1MIME::Lite(3)         User Contributed Perl Documentation        MIME::Lite(3)
2
3
4

NAME

6       MIME::Lite - low-calorie MIME generator
7

WAIT!

9       MIME::Lite is not recommended by its current maintainer.  There are a
10       number of alternatives, like Email::MIME or MIME::Entity and
11       Email::Sender, which you should probably use instead.  MIME::Lite
12       continues to accrue weird bug reports, and it is not receiving a large
13       amount of refactoring due to the availability of better alternatives.
14       Please consider using something else.
15

SYNOPSIS

17       Create and send using the default send method for your OS a single-part
18       message:
19
20           use MIME::Lite;
21           ### Create a new single-part message, to send a GIF file:
22           $msg = MIME::Lite->new(
23               From     => 'me@myhost.com',
24               To       => 'you@yourhost.com',
25               Cc       => 'some@other.com, some@more.com',
26               Subject  => 'Helloooooo, nurse!',
27               Type     => 'image/gif',
28               Encoding => 'base64',
29               Path     => 'hellonurse.gif'
30           );
31           $msg->send; # send via default
32
33       Create a multipart message (i.e., one with attachments) and send it
34       SMTP
35
36           ### Create a new multipart message:
37           $msg = MIME::Lite->new(
38               From    => 'me@myhost.com',
39               To      => 'you@yourhost.com',
40               Cc      => 'some@other.com, some@more.com',
41               Subject => 'A message with 2 parts...',
42               Type    => 'multipart/mixed'
43           );
44
45           ### Add parts (each "attach" has same arguments as "new"):
46           $msg->attach(
47               Type     => 'TEXT',
48               Data     => "Here's the GIF file you wanted"
49           );
50           $msg->attach(
51               Type     => 'image/gif',
52               Path     => 'aaa000123.gif',
53               Filename => 'logo.gif',
54               Disposition => 'attachment'
55           );
56           ### use Net:SMTP to do the sending
57           $msg->send('smtp','some.host', Debug=>1 );
58
59       Output a message:
60
61           ### Format as a string:
62           $str = $msg->as_string;
63
64           ### Print to a filehandle (say, a "sendmail" stream):
65           $msg->print(\*SENDMAIL);
66
67       Send a message:
68
69           ### Send in the "best" way (the default is to use "sendmail"):
70           $msg->send;
71           ### Send a specific way:
72           $msg->send('type',@args);
73
74       Specify default send method:
75
76           MIME::Lite->send('smtp','some.host',Debug=>0);
77
78       with authentication
79
80           MIME::Lite->send('smtp','some.host', AuthUser=>$user, AuthPass=>$pass);
81

DESCRIPTION

83       In the never-ending quest for great taste with fewer calories, we
84       proudly present: MIME::Lite.
85
86       MIME::Lite is intended as a simple, standalone module for generating
87       (not parsing!) MIME messages... specifically, it allows you to output a
88       simple, decent single- or multi-part message with text or binary
89       attachments.  It does not require that you have the Mail:: or MIME::
90       modules installed, but will work with them if they are.
91
92       You can specify each message part as either the literal data itself (in
93       a scalar or array), or as a string which can be given to open() to get
94       a readable filehandle (e.g., "<filename" or "somecommand|").
95
96       You don't need to worry about encoding your message data: this module
97       will do that for you.  It handles the 5 standard MIME encodings.
98

EXAMPLES

100   Create a simple message containing just text
101           $msg = MIME::Lite->new(
102               From     =>'me@myhost.com',
103               To       =>'you@yourhost.com',
104               Cc       =>'some@other.com, some@more.com',
105               Subject  =>'Helloooooo, nurse!',
106               Data     =>"How's it goin', eh?"
107           );
108
109   Create a simple message containing just an image
110           $msg = MIME::Lite->new(
111               From     =>'me@myhost.com',
112               To       =>'you@yourhost.com',
113               Cc       =>'some@other.com, some@more.com',
114               Subject  =>'Helloooooo, nurse!',
115               Type     =>'image/gif',
116               Encoding =>'base64',
117               Path     =>'hellonurse.gif'
118           );
119
120   Create a multipart message
121           ### Create the multipart "container":
122           $msg = MIME::Lite->new(
123               From    =>'me@myhost.com',
124               To      =>'you@yourhost.com',
125               Cc      =>'some@other.com, some@more.com',
126               Subject =>'A message with 2 parts...',
127               Type    =>'multipart/mixed'
128           );
129
130           ### Add the text message part:
131           ### (Note that "attach" has same arguments as "new"):
132           $msg->attach(
133               Type     =>'TEXT',
134               Data     =>"Here's the GIF file you wanted"
135           );
136
137           ### Add the image part:
138           $msg->attach(
139               Type        =>'image/gif',
140               Path        =>'aaa000123.gif',
141               Filename    =>'logo.gif',
142               Disposition => 'attachment'
143           );
144
145   Attach a GIF to a text message
146       This will create a multipart message exactly as above, but using the
147       "attach to singlepart" hack:
148
149           ### Start with a simple text message:
150           $msg = MIME::Lite->new(
151               From    =>'me@myhost.com',
152               To      =>'you@yourhost.com',
153               Cc      =>'some@other.com, some@more.com',
154               Subject =>'A message with 2 parts...',
155               Type    =>'TEXT',
156               Data    =>"Here's the GIF file you wanted"
157           );
158
159           ### Attach a part... the make the message a multipart automatically:
160           $msg->attach(
161               Type     =>'image/gif',
162               Path     =>'aaa000123.gif',
163               Filename =>'logo.gif'
164           );
165
166   Attach a pre-prepared part to a message
167           ### Create a standalone part:
168           $part = MIME::Lite->new(
169               Top      => 0,
170               Type     =>'text/html',
171               Data     =>'<H1>Hello</H1>',
172           );
173           $part->attr('content-type.charset' => 'UTF-8');
174           $part->add('X-Comment' => 'A message for you');
175
176           ### Attach it to any message:
177           $msg->attach($part);
178
179   Print a message to a filehandle
180           ### Write it to a filehandle:
181           $msg->print(\*STDOUT);
182
183           ### Write just the header:
184           $msg->print_header(\*STDOUT);
185
186           ### Write just the encoded body:
187           $msg->print_body(\*STDOUT);
188
189   Print a message into a string
190           ### Get entire message as a string:
191           $str = $msg->as_string;
192
193           ### Get just the header:
194           $str = $msg->header_as_string;
195
196           ### Get just the encoded body:
197           $str = $msg->body_as_string;
198
199   Send a message
200           ### Send in the "best" way (the default is to use "sendmail"):
201           $msg->send;
202
203   Send an HTML document... with images included!
204           $msg = MIME::Lite->new(
205                To      =>'you@yourhost.com',
206                Subject =>'HTML with in-line images!',
207                Type    =>'multipart/related'
208           );
209           $msg->attach(
210               Type => 'text/html',
211               Data => qq{
212                   <body>
213                       Here's <i>my</i> image:
214                       <img src="cid:myimage.gif">
215                   </body>
216               },
217           );
218           $msg->attach(
219               Type => 'image/gif',
220               Id   => 'myimage.gif',
221               Path => '/path/to/somefile.gif',
222           );
223           $msg->send();
224
225   Change how messages are sent
226           ### Do something like this in your 'main':
227           if ($I_DONT_HAVE_SENDMAIL) {
228              MIME::Lite->send('smtp', $host, Timeout=>60,
229                  AuthUser=>$user, AuthPass=>$pass);
230           }
231
232           ### Now this will do the right thing:
233           $msg->send;         ### will now use Net::SMTP as shown above
234

PUBLIC INTERFACE

236   Global configuration
237       To alter the way the entire module behaves, you have the following
238       methods/options:
239
240       MIME::Lite->field_order()
241           When used as a classmethod, this changes the default order in which
242           headers are output for all messages.  However, please consider
243           using the instance method variant instead, so you won't stomp on
244           other message senders in the same application.
245
246       MIME::Lite->quiet()
247           This classmethod can be used to suppress/unsuppress all warnings
248           coming from this module.
249
250       MIME::Lite->send()
251           When used as a classmethod, this can be used to specify a different
252           default mechanism for sending message.  The initial default is:
253
254               MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem");
255
256           However, you should consider the similar but smarter and taint-safe
257           variant:
258
259               MIME::Lite->send("sendmail");
260
261           Or, for non-Unix users:
262
263               MIME::Lite->send("smtp");
264
265       $MIME::Lite::AUTO_CC
266           If true, automatically send to the Cc/Bcc addresses for
267           send_by_smtp().  Default is true.
268
269       $MIME::Lite::AUTO_CONTENT_TYPE
270           If true, try to automatically choose the content type from the file
271           name in "new()"/"build()".  In other words, setting this true
272           changes the default "Type" from "TEXT" to "AUTO".
273
274           Default is false, since we must maintain backwards-compatibility
275           with prior behavior.  Please consider keeping it false, and just
276           using Type 'AUTO' when you build() or attach().
277
278       $MIME::Lite::AUTO_ENCODE
279           If true, automatically choose the encoding from the content type.
280           Default is true.
281
282       $MIME::Lite::AUTO_VERIFY
283           If true, check paths to attachments right before printing, raising
284           an exception if any path is unreadable.  Default is true.
285
286       $MIME::Lite::PARANOID
287           If true, we won't attempt to use MIME::Base64, MIME::QuotedPrint,
288           or MIME::Types, even if they're available.  Default is false.
289           Please consider keeping it false, and trusting these other packages
290           to do the right thing.
291
292   Construction
293       new [PARAMHASH]
294           Class method, constructor.  Create a new message object.
295
296           If any arguments are given, they are passed into "build()";
297           otherwise, just the empty object is created.
298
299       attach PART
300       attach PARAMHASH...
301           Instance method.  Add a new part to this message, and return the
302           new part.
303
304           If you supply a single PART argument, it will be regarded as a
305           MIME::Lite object to be attached.  Otherwise, this method assumes
306           that you are giving in the pairs of a PARAMHASH which will be sent
307           into "new()" to create the new part.
308
309           One of the possibly-quite-useful hacks thrown into this is the
310           "attach-to-singlepart" hack: if you attempt to attach a part (let's
311           call it "part 1") to a message that doesn't have a content-type of
312           "multipart" or "message", the following happens:
313
314           ·   A new part (call it "part 0") is made.
315
316           ·   The MIME attributes and data (but not the other headers) are
317               cut from the "self" message, and pasted into "part 0".
318
319           ·   The "self" is turned into a "multipart/mixed" message.
320
321           ·   The new "part 0" is added to the "self", and then "part 1" is
322               added.
323
324           One of the nice side-effects is that you can create a text message
325           and then add zero or more attachments to it, much in the same way
326           that a user agent like Netscape allows you to do.
327
328       build [PARAMHASH]
329           Class/instance method, initializer.  Create (or initialize) a MIME
330           message object.  Normally, you'll use the following keys in
331           PARAMHASH:
332
333              * Data, FH, or Path      (either one of these, or none if multipart)
334              * Type                   (e.g., "image/jpeg")
335              * From, To, and Subject  (if this is the "top level" of a message)
336
337           The PARAMHASH can contain the following keys:
338
339           (fieldname)
340               Any field you want placed in the message header, taken from the
341               standard list of header fields (you don't need to worry about
342               case):
343
344                   Approved      Encrypted     Received      Sender
345                   Bcc           From          References    Subject
346                   Cc            Keywords      Reply-To      To
347                   Comments      Message-ID    Resent-*      X-*
348                   Content-*     MIME-Version  Return-Path
349                   Date                        Organization
350
351               To give experienced users some veto power, these fields will be
352               set after the ones I set... so be careful: don't set any MIME
353               fields (like "Content-type") unless you know what you're doing!
354
355               To specify a fieldname that's not in the above list, even one
356               that's identical to an option below, just give it with a
357               trailing ":", like "My-field:".  When in doubt, that always
358               signals a mail field (and it sort of looks like one too).
359
360           Data
361               Alternative to "Path" or "FH".  The actual message data.  This
362               may be a scalar or a ref to an array of strings; if the latter,
363               the message consists of a simple concatenation of all the
364               strings in the array.
365
366           Datestamp
367               Optional.  If given true (or omitted), we force the creation of
368               a "Date:" field stamped with the current date/time if this is a
369               top-level message.  You may want this if using send_by_smtp().
370               If you don't want this to be done, either provide your own Date
371               or explicitly set this to false.
372
373           Disposition
374               Optional.  The content disposition, "inline" or "attachment".
375               The default is "inline".
376
377           Encoding
378               Optional.  The content transfer encoding that should be used to
379               encode your data:
380
381                  Use encoding:     | If your message contains:
382                  ------------------------------------------------------------
383                  7bit              | Only 7-bit text, all lines <1000 characters
384                  8bit              | 8-bit text, all lines <1000 characters
385                  quoted-printable  | 8-bit text or long lines (more reliable than "8bit")
386                  base64            | Largely non-textual data: a GIF, a tar file, etc.
387
388               The default is taken from the Type; generally it is "binary"
389               (no encoding) for text/*, message/*, and multipart/*, and
390               "base64" for everything else.  A value of "binary" is generally
391               not suitable for sending anything but ASCII text files with
392               lines under 1000 characters, so consider using one of the other
393               values instead.
394
395               In the case of "7bit"/"8bit", long lines are automatically
396               chopped to legal length; in the case of "7bit", all 8-bit
397               characters are automatically removed.  This may not be what you
398               want, so pick your encoding well!  For more info, see "A MIME
399               PRIMER".
400
401           FH  Alternative to "Data" or "Path".  Filehandle containing the
402               data, opened for reading.  See "ReadNow" also.
403
404           Filename
405               Optional.  The name of the attachment.  You can use this to
406               supply a recommended filename for the end-user who is saving
407               the attachment to disk.  You only need this if the filename at
408               the end of the "Path" is inadequate, or if you're using "Data"
409               instead of "Path".  You should not put path information in here
410               (e.g., no "/" or "\" or ":" characters should be used).
411
412           Id  Optional.  Same as setting "content-id".
413
414           Length
415               Optional.  Set the content length explicitly.  Normally, this
416               header is automatically computed, but only under certain
417               circumstances (see "Benign limitations").
418
419           Path
420               Alternative to "Data" or "FH".  Path to a file containing the
421               data... actually, it can be any open()able expression.  If it
422               looks like a path, the last element will automatically be
423               treated as the filename.  See "ReadNow" also.
424
425           ReadNow
426               Optional, for use with "Path".  If true, will open the path and
427               slurp the contents into core now.  This is useful if the Path
428               points to a command and you don't want to run the command over
429               and over if outputting the message several times.  Fatal
430               exception raised if the open fails.
431
432           Top Optional.  If defined, indicates whether or not this is a "top-
433               level" MIME message.  The parts of a multipart message are not
434               top-level.  Default is true.
435
436           Type
437               Optional.  The MIME content type, or one of these special
438               values (case-sensitive):
439
440                    "TEXT"   means "text/plain"
441                    "BINARY" means "application/octet-stream"
442                    "AUTO"   means attempt to guess from the filename, falling back
443                             to 'application/octet-stream'.  This is good if you have
444                             MIME::Types on your system and you have no idea what
445                             file might be used for the attachment.
446
447               The default is "TEXT", but it will be "AUTO" if you set
448               $AUTO_CONTENT_TYPE to true (sorry, but you have to enable it
449               explicitly, since we don't want to break code which depends on
450               the old behavior).
451
452           A picture being worth 1000 words (which is of course 2000 bytes, so
453           it's probably more of an "icon" than a "picture", but I
454           digress...), here are some examples:
455
456               $msg = MIME::Lite->build(
457                   From     => 'yelling@inter.com',
458                   To       => 'stocking@fish.net',
459                   Subject  => "Hi there!",
460                   Type     => 'TEXT',
461                   Encoding => '7bit',
462                   Data     => "Just a quick note to say hi!"
463               );
464
465               $msg = MIME::Lite->build(
466                   From     => 'dorothy@emerald-city.oz',
467                   To       => 'gesundheit@edu.edu.edu',
468                   Subject  => "A gif for U"
469                   Type     => 'image/gif',
470                   Path     => "/home/httpd/logo.gif"
471               );
472
473               $msg = MIME::Lite->build(
474                   From     => 'laughing@all.of.us',
475                   To       => 'scarlett@fiddle.dee.de',
476                   Subject  => "A gzipp'ed tar file",
477                   Type     => 'x-gzip',
478                   Path     => "gzip < /usr/inc/somefile.tar |",
479                   ReadNow  => 1,
480                   Filename => "somefile.tgz"
481               );
482
483           To show you what's really going on, that last example could also
484           have been written:
485
486               $msg = new MIME::Lite;
487               $msg->build(
488                   Type     => 'x-gzip',
489                   Path     => "gzip < /usr/inc/somefile.tar |",
490                   ReadNow  => 1,
491                   Filename => "somefile.tgz"
492               );
493               $msg->add(From    => "laughing@all.of.us");
494               $msg->add(To      => "scarlett@fiddle.dee.de");
495               $msg->add(Subject => "A gzipp'ed tar file");
496
497   Setting/getting headers and attributes
498       add TAG,VALUE
499           Instance method.  Add field TAG with the given VALUE to the end of
500           the header.  The TAG will be converted to all-lowercase, and the
501           VALUE will be made "safe" (returns will be given a trailing space).
502
503           Beware: any MIME fields you "add" will override any MIME attributes
504           I have when it comes time to output those fields.  Normally, you
505           will use this method to add non-MIME fields:
506
507               $msg->add("Subject" => "Hi there!");
508
509           Giving VALUE as an arrayref will cause all those values to be
510           added.  This is only useful for special multiple-valued fields like
511           "Received":
512
513               $msg->add("Received" => ["here", "there", "everywhere"]
514
515           Giving VALUE as the empty string adds an invisible placeholder to
516           the header, which can be used to suppress the output of the
517           "Content-*" fields or the special  "MIME-Version" field.  When
518           suppressing fields, you should use replace() instead of add():
519
520               $msg->replace("Content-disposition" => "");
521
522           Note: add() is probably going to be more efficient than
523           "replace()", so you're better off using it for most applications if
524           you are certain that you don't need to delete() the field first.
525
526           Note: the name comes from Mail::Header.
527
528       attr ATTR,[VALUE]
529           Instance method.  Set MIME attribute ATTR to the string VALUE.
530           ATTR is converted to all-lowercase.  This method is normally used
531           to set/get MIME attributes:
532
533               $msg->attr("content-type"         => "text/html");
534               $msg->attr("content-type.charset" => "US-ASCII");
535               $msg->attr("content-type.name"    => "homepage.html");
536
537           This would cause the final output to look something like this:
538
539               Content-type: text/html; charset=US-ASCII; name="homepage.html"
540
541           Note that the special empty sub-field tag indicates the anonymous
542           first sub-field.
543
544           Giving VALUE as undefined will cause the contents of the named
545           subfield to be deleted.
546
547           Supplying no VALUE argument just returns the attribute's value:
548
549               $type = $msg->attr("content-type");        ### returns "text/html"
550               $name = $msg->attr("content-type.name");   ### returns "homepage.html"
551
552       delete TAG
553           Instance method.  Delete field TAG with the given VALUE to the end
554           of the header.  The TAG will be converted to all-lowercase.
555
556               $msg->delete("Subject");
557
558           Note: the name comes from Mail::Header.
559
560       field_order FIELD,...FIELD
561           Class/instance method.  Change the order in which header fields are
562           output for this object:
563
564               $msg->field_order('from', 'to', 'content-type', 'subject');
565
566           When used as a class method, changes the default settings for all
567           objects:
568
569               MIME::Lite->field_order('from', 'to', 'content-type', 'subject');
570
571           Case does not matter: all field names will be coerced to lowercase.
572           In either case, supply the empty array to restore the default
573           ordering.
574
575       fields
576           Instance method.  Return the full header for the object, as a ref
577           to an array of "[TAG, VALUE]" pairs, where each TAG is all-
578           lowercase.  Note that any fields the user has explicitly set will
579           override the corresponding MIME fields that we would otherwise
580           generate.  So, don't say...
581
582               $msg->set("Content-type" => "text/html; charset=US-ASCII");
583
584           unless you want the above value to override the "Content-type" MIME
585           field that we would normally generate.
586
587           Note: I called this "fields" because the header() method of
588           Mail::Header returns something different, but similar enough to be
589           confusing.
590
591           You can change the order of the fields: see "field_order".  You
592           really shouldn't need to do this, but some people have to deal with
593           broken mailers.
594
595       filename [FILENAME]
596           Instance method.  Set the filename which this data will be reported
597           as.  This actually sets both "standard" attributes.
598
599           With no argument, returns the filename as dictated by the content-
600           disposition.
601
602       get TAG,[INDEX]
603           Instance method.  Get the contents of field TAG, which might have
604           been set with set() or replace().  Returns the text of the field.
605
606               $ml->get('Subject', 0);
607
608           If the optional 0-based INDEX is given, then we return the INDEX'th
609           occurrence of field TAG.  Otherwise, we look at the context: In a
610           scalar context, only the first (0th) occurrence of the field is
611           returned; in an array context, all occurrences are returned.
612
613           Warning: this should only be used with non-MIME fields.  Behavior
614           with MIME fields is TBD, and will raise an exception for now.
615
616       get_length
617           Instance method.  Recompute the content length for the message if
618           the process is trivial, setting the "content-length" attribute as a
619           side-effect:
620
621               $msg->get_length;
622
623           Returns the length, or undefined if not set.
624
625           Note: the content length can be difficult to compute, since it
626           involves assembling the entire encoded body and taking the length
627           of it (which, in the case of multipart messages, means freezing all
628           the sub-parts, etc.).
629
630           This method only sets the content length to a defined value if the
631           message is a singlepart with "binary" encoding, and the body is
632           available either in-core or as a simple file.  Otherwise, the
633           content length is set to the undefined value.
634
635           Since content-length is not a standard MIME field anyway (that's
636           right, kids: it's not in the MIME RFCs, it's an HTTP thing), this
637           seems pretty fair.
638
639       parts
640           Instance method.  Return the parts of this entity, and this entity
641           only.  Returns empty array if this entity has no parts.
642
643           This is not recursive!  Parts can have sub-parts; use parts_DFS()
644           to get everything.
645
646       parts_DFS
647           Instance method.  Return the list of all MIME::Lite objects
648           included in the entity, starting with the entity itself, in depth-
649           first-search order.  If this object has no parts, it alone will be
650           returned.
651
652       preamble [TEXT]
653           Instance method.  Get/set the preamble string, assuming that this
654           object has subparts.  Set it to undef for the default string.
655
656       replace TAG,VALUE
657           Instance method.  Delete all occurrences of fields named TAG, and
658           add a new field with the given VALUE.  TAG is converted to all-
659           lowercase.
660
661           Beware the special MIME fields (MIME-version, Content-*): if you
662           "replace" a MIME field, the replacement text will override the
663           actual MIME attributes when it comes time to output that field.  So
664           normally you use attr() to change MIME fields and add()/replace()
665           to change non-MIME fields:
666
667               $msg->replace("Subject" => "Hi there!");
668
669           Giving VALUE as the empty string will effectively prevent that
670           field from being output.  This is the correct way to suppress the
671           special MIME fields:
672
673               $msg->replace("Content-disposition" => "");
674
675           Giving VALUE as undefined will just cause all explicit values for
676           TAG to be deleted, without having any new values added.
677
678           Note: the name of this method  comes from Mail::Header.
679
680       scrub
681           Instance method.  This is Alpha code.  If you use it, please let me
682           know how it goes.  Recursively goes through the "parts" tree of
683           this message and tries to find MIME attributes that can be removed.
684           With an array argument, removes exactly those attributes; e.g.:
685
686               $msg->scrub(['content-disposition', 'content-length']);
687
688           Is the same as recursively doing:
689
690               $msg->replace('Content-disposition' => '');
691               $msg->replace('Content-length'      => '');
692
693   Setting/getting message data
694       binmode [OVERRIDE]
695           Instance method.  With no argument, returns whether or not it
696           thinks that the data (as given by the "Path" argument of "build()")
697           should be read using binmode() (for example, when "read_now()" is
698           invoked).
699
700           The default behavior is that any content type other than "text/*"
701           or "message/*" is binmode'd; this should in general work fine.
702
703           With a defined argument, this method sets an explicit "override"
704           value.  An undefined argument unsets the override.  The new current
705           value is returned.
706
707       data [DATA]
708           Instance method.  Get/set the literal DATA of the message.  The
709           DATA may be either a scalar, or a reference to an array of scalars
710           (which will simply be joined).
711
712           Warning: setting the data causes the "content-length" attribute to
713           be recomputed (possibly to nothing).
714
715       fh [FILEHANDLE]
716           Instance method.  Get/set the FILEHANDLE which contains the message
717           data.
718
719           Takes a filehandle as an input and stores it in the object.  This
720           routine is similar to path(); one important difference is that no
721           attempt is made to set the content length.
722
723       path [PATH]
724           Instance method.  Get/set the PATH to the message data.
725
726           Warning: setting the path recomputes any existing "content-length"
727           field, and re-sets the "filename" (to the last element of the path
728           if it looks like a simple path, and to nothing if not).
729
730       resetfh [FILEHANDLE]
731           Instance method.  Set the current position of the filehandle back
732           to the beginning.  Only applies if you used "FH" in build() or
733           attach() for this message.
734
735           Returns false if unable to reset the filehandle (since not all
736           filehandles are seekable).
737
738       read_now
739           Instance method.  Forces data from the path/filehandle (as
740           specified by "build()") to be read into core immediately, just as
741           though you had given it literally with the "Data" keyword.
742
743           Note that the in-core data will always be used if available.
744
745           Be aware that everything is slurped into a giant scalar: you may
746           not want to use this if sending tar files!  The benefit of not
747           reading in the data is that very large files can be handled by this
748           module if left on disk until the message is output via "print()" or
749           "print_body()".
750
751       sign PARAMHASH
752           Instance method.  Sign the message.  This forces the message to be
753           read into core, after which the signature is appended to it.
754
755           Data
756               As in "build()": the literal signature data.  Can be either a
757               scalar or a ref to an array of scalars.
758
759           Path
760               As in "build()": the path to the file.
761
762           If no arguments are given, the default is:
763
764               Path => "$ENV{HOME}/.signature"
765
766           The content-length is recomputed.
767
768       verify_data
769           Instance method.  Verify that all "paths" to attached data exist,
770           recursively.  It might be a good idea for you to do this before a
771           print(), to prevent accidental partial output if a file might be
772           missing.  Raises exception if any path is not readable.
773
774   Output
775       print [OUTHANDLE]
776           Instance method.  Print the message to the given output handle, or
777           to the currently-selected filehandle if none was given.
778
779           All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
780           any object that responds to a print() message.
781
782       print_body [OUTHANDLE] [IS_SMTP]
783           Instance method.  Print the body of a message to the given output
784           handle, or to the currently-selected filehandle if none was given.
785
786           All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
787           any object that responds to a print() message.
788
789           Fatal exception raised if unable to open any of the input files, or
790           if a part contains no data, or if an unsupported encoding is
791           encountered.
792
793           IS_SMPT is a special option to handle SMTP mails a little more
794           intelligently than other send mechanisms may require. Specifically
795           this ensures that the last byte sent is NOT '\n' (octal \012) if
796           the last two bytes are not '\r\n' (\015\012) as this will cause
797           some SMTP servers to hang.
798
799       print_header [OUTHANDLE]
800           Instance method.  Print the header of the message to the given
801           output handle, or to the currently-selected filehandle if none was
802           given.
803
804           All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
805           any object that responds to a print() message.
806
807       as_string
808           Instance method.  Return the entire message as a string, with a
809           header and an encoded body.
810
811       body_as_string
812           Instance method.  Return the encoded body as a string.  This is the
813           portion after the header and the blank line.
814
815           Note: actually prepares the body by "printing" to a scalar.  Proof
816           that you can hand the "print*()" methods any blessed object that
817           responds to a "print()" message.
818
819       header_as_string
820           Instance method.  Return the header as a string.
821
822   Sending
823       send
824       send HOW, HOWARGS...
825           Class/instance method.  This is the principal method for sending
826           mail, and for configuring how mail will be sent.
827
828           As a class method with a HOW argument and optional HOWARGS, it sets
829           the default sending mechanism that the no-argument instance method
830           will use.  The HOW is a facility name (see below), and the HOWARGS
831           is interpreted by the facility.  The class method returns the
832           previous HOW and HOWARGS as an array.
833
834               MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe");
835               ...
836               $msg = MIME::Lite->new(...);
837               $msg->send;
838
839           As an instance method with arguments (a HOW argument and optional
840           HOWARGS), sends the message in the requested manner; e.g.:
841
842               $msg->send('sendmail', "d:\\programs\\sendmail.exe");
843
844           As an instance method with no arguments, sends the message by the
845           default mechanism set up by the class method.  Returns whatever the
846           mail-handling routine returns: this should be true on success,
847           false/exception on error:
848
849               $msg = MIME::Lite->new(From=>...);
850               $msg->send || die "you DON'T have mail!";
851
852           On Unix systems (or rather non-Win32 systems), the default setting
853           is equivalent to:
854
855               MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem");
856
857           On Win32 systems the default setting is equivalent to:
858
859               MIME::Lite->send("smtp");
860
861           The assumption is that on Win32 your site/lib/Net/libnet.cfg file
862           will be preconfigured to use the appropriate SMTP server. See below
863           for configuring for authentication.
864
865           There are three facilities:
866
867           "sendmail", ARGS...
868               Send a message by piping it into the "sendmail" command.  Uses
869               the send_by_sendmail() method, giving it the ARGS.  This usage
870               implements (and deprecates) the "sendmail()" method.
871
872           "smtp", [HOSTNAME, [NAMEDPARMS] ]
873               Send a message by SMTP, using optional HOSTNAME as SMTP-sending
874               host.  Net::SMTP will be required.  Uses the send_by_smtp()
875               method. Any additional arguments passed in will also be passed
876               through to send_by_smtp.  This is useful for things like mail
877               servers requiring authentication where you can say something
878               like the following
879
880                 MIME::Lite->send('smtp', $host, AuthUser=>$user, AuthPass=>$pass);
881
882               which will configure things so future uses of
883
884                 $msg->send();
885
886               do the right thing.
887
888           "sub", \&SUBREF, ARGS...
889               Sends a message MSG by invoking the subroutine SUBREF of your
890               choosing, with MSG as the first argument, and ARGS following.
891
892           For example: let's say you're on an OS which lacks the usual Unix
893           "sendmail" facility, but you've installed something a lot like it,
894           and you need to configure your Perl script to use this
895           "sendmail.exe" program.  Do this following in your script's setup:
896
897               MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe");
898
899           Then, whenever you need to send a message $msg, just say:
900
901               $msg->send;
902
903           That's it.  Now, if you ever move your script to a Unix box, all
904           you need to do is change that line in the setup and you're done.
905           All of your $msg->send invocations will work as expected.
906
907           After sending, the method last_send_successful() can be used to
908           determine if the send was successful or not.
909
910       send_by_sendmail SENDMAILCMD
911       send_by_sendmail PARAM=>VALUE, ARRAY, HASH...
912           Instance method.  Send message via an external "sendmail" program
913           (this will probably only work out-of-the-box on Unix systems).
914
915           Returns true on success, false or exception on error.
916
917           You can specify the program and all its arguments by giving a
918           single string, SENDMAILCMD.  Nothing fancy is done; the message is
919           simply piped in.
920
921           However, if your needs are a little more advanced, you can specify
922           zero or more of the following PARAM/VALUE pairs (or a reference to
923           hash or array of such arguments as well as any combination
924           thereof); a Unix-style, taint-safe "sendmail" command will be
925           constructed for you:
926
927           Sendmail
928               Full path to the program to use.  Default is
929               "/usr/lib/sendmail".
930
931           BaseArgs
932               Ref to the basic array of arguments we start with.  Default is
933               "["-t", "-oi", "-oem"]".
934
935           SetSender
936               Unless this is explicitly given as false, we attempt to
937               automatically set the "-f" argument to the first address that
938               can be extracted from the "From:" field of the message (if
939               there is one).
940
941               What is the -f, and why do we use it?  Suppose we did not use
942               "-f", and you gave an explicit "From:" field in your message:
943               in this case, the sendmail "envelope" would indicate the real
944               user your process was running under, as a way of preventing
945               mail forgery.  Using the "-f" switch causes the sender to be
946               set in the envelope as well.
947
948               So when would I NOT want to use it?  If sendmail doesn't regard
949               you as a "trusted" user, it will permit the "-f" but also add
950               an "X-Authentication-Warning" header to the message to indicate
951               a forged envelope.  To avoid this, you can either (1) have
952               SetSender be false, or (2) make yourself a trusted user by
953               adding a "T" configuration
954                   command to your sendmail.cf file
955                   (e.g.: "Teryq" if the script is running as user "eryq").
956
957           FromSender
958               If defined, this is identical to setting SetSender to true,
959               except that instead of looking at the "From:" field we use the
960               address given by this option.  Thus:
961
962                   FromSender => 'me@myhost.com'
963
964           After sending, the method last_send_successful() can be used to
965           determine if the send was successful or not.
966
967       send_by_smtp HOST, ARGS...
968       send_by_smtp REF, HOST, ARGS
969           Instance method.  Send message via SMTP, using Net::SMTP -- which
970           will be required for this feature.
971
972           HOST is the name of SMTP server to connect to, or undef to have
973           Net::SMTP use the defaults in Libnet.cfg.
974
975           ARGS are a list of key value pairs which may be selected from the
976           list below. Many of these are just passed through to specific
977           Net::SMTP commands and you should review that module for details.
978
979           Please see Good-vs-bad email addresses with send_by_smtp()
980
981           Hello
982           LocalAddr
983           LocalPort
984           Timeout
985           Port
986           ExactAddresses
987           Debug
988               See Net::SMTP::new() for details.
989
990           Size
991           Return
992           Bits
993           Transaction
994           Envelope
995               See Net::SMTP::mail() for details.
996
997           SkipBad
998               If true doesn't throw an error when multiple email addresses
999               are provided and some are not valid. See Net::SMTP::recipient()
1000               for details.
1001
1002           AuthUser
1003               Authenticate with Net::SMTP::auth() using this username.
1004
1005           AuthPass
1006               Authenticate with Net::SMTP::auth() using this password.
1007
1008           NoAuth
1009               Normally if AuthUser and AuthPass are defined MIME::Lite will
1010               attempt to use them with the Net::SMTP::auth() command to
1011               authenticate the connection, however if this value is true then
1012               no authentication occurs.
1013
1014           To  Sets the addresses to send to. Can be a string or a reference
1015               to an array of strings. Normally this is extracted from the To:
1016               (and Cc: and Bcc: fields if $AUTO_CC is true).
1017
1018               This value overrides that.
1019
1020           From
1021               Sets the email address to send from. Normally this value is
1022               extracted from the Return-Path: or From: field of the mail
1023               itself (in that order).
1024
1025               This value overrides that.
1026
1027           Returns: True on success, croaks with an error message on failure.
1028
1029           After sending, the method last_send_successful() can be used to
1030           determine if the send was successful or not.
1031
1032       send_by_testfile FILENAME
1033           Instance method.  Print message to a file (namely FILENAME), which
1034           will default to mailer.testfile If file exists, message will be
1035           appended.
1036
1037       last_send_successful
1038           This method will return TRUE if the last send() or send_by_XXX()
1039           method call was successful. It will return defined but false if it
1040           was not successful, and undefined if the object had not been used
1041           to send yet.
1042
1043       sendmail COMMAND...
1044           Class method, DEPRECATED.  Declare the sender to be "sendmail", and
1045           set up the "sendmail" command.  You should use send() instead.
1046
1047   Miscellaneous
1048       quiet ONOFF
1049           Class method.  Suppress/unsuppress all warnings coming from this
1050           module.
1051
1052               MIME::Lite->quiet(1);       ### I know what I'm doing
1053
1054           I recommend that you include that comment as well.  And while you
1055           type it, say it out loud: if it doesn't feel right, then maybe you
1056           should reconsider the whole line.  ";-)"
1057

NOTES

1059   How do I prevent "Content" headers from showing up in my mail reader?
1060       Apparently, some people are using mail readers which display the MIME
1061       headers like "Content-disposition", and they want MIME::Lite not to
1062       generate them "because they look ugly".
1063
1064       Sigh.
1065
1066       Y'know, kids, those headers aren't just there for cosmetic purposes.
1067       They help ensure that the message is understood correctly by mail
1068       readers.  But okay, you asked for it, you got it...  here's how you can
1069       suppress the standard MIME headers.  Before you send the message, do
1070       this:
1071
1072           $msg->scrub;
1073
1074       You can scrub() any part of a multipart message independently; just be
1075       aware that it works recursively.  Before you scrub, note the rules that
1076       I follow:
1077
1078       Content-type
1079           You can safely scrub the "content-type" attribute if, and only if,
1080           the part is of type "text/plain" with charset "us-ascii".
1081
1082       Content-transfer-encoding
1083           You can safely scrub the "content-transfer-encoding" attribute if,
1084           and only if, the part uses "7bit", "8bit", or "binary" encoding.
1085           You are far better off doing this if your lines are under 1000
1086           characters.  Generally, that means you can scrub it for plain text,
1087           and you can not scrub this for images, etc.
1088
1089       Content-disposition
1090           You can safely scrub the "content-disposition" attribute if you
1091           trust the mail reader to do the right thing when it decides whether
1092           to show an attachment inline or as a link.  Be aware that scrubbing
1093           both the content-disposition and the content-type means that there
1094           is no way to "recommend" a filename for the attachment!
1095
1096           Note: there are reports of brain-dead MUAs out there that do the
1097           wrong thing if you provide the content-disposition.  If your
1098           attachments keep showing up inline or vice-versa, try scrubbing
1099           this attribute.
1100
1101       Content-length
1102           You can always scrub "content-length" safely.
1103
1104   How do I give my attachment a [different] recommended filename?
1105       By using the Filename option (which is different from Path!):
1106
1107           $msg->attach(Type => "image/gif",
1108                        Path => "/here/is/the/real/file.GIF",
1109                        Filename => "logo.gif");
1110
1111       You should not put path information in the Filename.
1112
1113   Benign limitations
1114       This is "lite", after all...
1115
1116       ·   There's no parsing.  Get MIME-tools if you need to parse MIME
1117           messages.
1118
1119       ·   MIME::Lite messages are currently not interchangeable with either
1120           Mail::Internet or MIME::Entity objects.  This is a completely
1121           separate module.
1122
1123       ·   A content-length field is only inserted if the encoding is binary,
1124           the message is a singlepart, and all the document data is available
1125           at "build()" time by virtue of residing in a simple path, or in-
1126           core.  Since content-length is not a standard MIME field anyway
1127           (that's right, kids: it's not in the MIME RFCs, it's an HTTP
1128           thing), this seems pretty fair.
1129
1130       ·   MIME::Lite alone cannot help you lose weight.  You must supplement
1131           your use of MIME::Lite with a healthy diet and exercise.
1132
1133   Cheap and easy mailing
1134       I thought putting in a default "sendmail" invocation wasn't too bad an
1135       idea, since a lot of Perlers are on UNIX systems. (As of version 3.02
1136       this is default only on Non-Win32 boxen. On Win32 boxen the default is
1137       to use SMTP and the defaults specified in the site/lib/Net/libnet.cfg)
1138
1139       The out-of-the-box configuration is:
1140
1141            MIME::Lite->send('sendmail', "/usr/lib/sendmail -t -oi -oem");
1142
1143       By the way, these arguments to sendmail are:
1144
1145            -t      Scan message for To:, Cc:, Bcc:, etc.
1146
1147            -oi     Do NOT treat a single "." on a line as a message terminator.
1148                    As in, "-oi vey, it truncated my message... why?!"
1149
1150            -oem    On error, mail back the message (I assume to the
1151                    appropriate address, given in the header).
1152                    When mail returns, circle is complete.  Jai Guru Deva -oem.
1153
1154       Note that these are the same arguments you get if you configure to use
1155       the smarter, taint-safe mailing:
1156
1157            MIME::Lite->send('sendmail');
1158
1159       If you get "X-Authentication-Warning" headers from this, you can forgo
1160       diddling with the envelope by instead specifying:
1161
1162            MIME::Lite->send('sendmail', SetSender=>0);
1163
1164       And, if you're not on a Unix system, or if you'd just rather send mail
1165       some other way, there's always SMTP, which these days probably requires
1166       authentication so you probably need to say
1167
1168            MIME::Lite->send('smtp', "smtp.myisp.net",
1169               AuthUser=>"YourName",AuthPass=>"YourPass" );
1170
1171       Or you can set up your own subroutine to call.  In any case, check out
1172       the send() method.
1173

WARNINGS

1175   Good-vs-bad email addresses with send_by_smtp()
1176       If using send_by_smtp(), be aware that unless you explicitly provide
1177       the email addresses to send to and from you will be forcing MIME::Lite
1178       to extract email addresses out of a possible list provided in the
1179       "To:", "Cc:", and "Bcc:" fields.  This is tricky stuff, and as such
1180       only the following sorts of addresses will work reliably:
1181
1182           username
1183           full.name@some.host.com
1184           "Name, Full" <full.name@some.host.com>
1185
1186       Disclaimer: MIME::Lite was never intended to be a Mail User Agent, so
1187       please don't expect a full implementation of RFC-822.  Restrict
1188       yourself to the common forms of Internet addresses described herein,
1189       and you should be fine.  If this is not feasible, then consider using
1190       MIME::Lite to prepare your message only, and using Net::SMTP explicitly
1191       to send your message.
1192
1193       Note: As of MIME::Lite v3.02 the mail name extraction routines have
1194       been beefed up considerably. Furthermore if Mail::Address if provided
1195       then name extraction is done using that. Accordingly the above advice
1196       is now less true than it once was. Funky email names should work
1197       properly now. However the disclaimer remains. Patches welcome. :-)
1198
1199   Formatting of headers delayed until print()
1200       This class treats a MIME header in the most abstract sense, as being a
1201       collection of high-level attributes.  The actual RFC-822-style header
1202       fields are not constructed until it's time to actually print the darn
1203       thing.
1204
1205   Encoding of data delayed until print()
1206       When you specify message bodies (in build() or attach()) -- whether by
1207       FH, Data, or Path -- be warned that we don't attempt to open files,
1208       read filehandles, or encode the data until print() is invoked.
1209
1210       In the past, this created some confusion for users of sendmail who gave
1211       the wrong path to an attachment body, since enough of the print() would
1212       succeed to get the initial part of the message out.  Nowadays,
1213       $AUTO_VERIFY is used to spot-check the Paths given before the mail
1214       facility is employed.  A whisker slower, but tons safer.
1215
1216       Note that if you give a message body via FH, and try to print() a
1217       message twice, the second print() will not do the right thing unless
1218       you  explicitly rewind the filehandle.
1219
1220       You can get past these difficulties by using the ReadNow option,
1221       provided that you have enough memory to handle your messages.
1222
1223   MIME attributes are separate from header fields!
1224       Important: the MIME attributes are stored and manipulated separately
1225       from the message header fields; when it comes time to print the header
1226       out, any explicitly-given header fields override the ones that would be
1227       created from the MIME attributes.  That means that this:
1228
1229           ### DANGER ### DANGER ### DANGER ### DANGER ### DANGER ###
1230           $msg->add("Content-type", "text/html; charset=US-ASCII");
1231
1232       will set the exact "Content-type" field in the header I write,
1233       regardless of what the actual MIME attributes are.
1234
1235       This feature is for experienced users only, as an escape hatch in case
1236       the code that normally formats MIME header fields isn't doing what you
1237       need.  And, like any escape hatch, it's got an alarm on it: MIME::Lite
1238       will warn you if you attempt to "set()" or "replace()" any MIME header
1239       field.  Use "attr()" instead.
1240
1241   Beware of lines consisting of a single dot
1242       Julian Haight noted that MIME::Lite allows you to compose messages with
1243       lines in the body consisting of a single ".".  This is true: it should
1244       be completely harmless so long as "sendmail" is used with the -oi
1245       option (see "Cheap and easy mailing").
1246
1247       However, I don't know if using Net::SMTP to transfer such a message is
1248       equally safe.  Feedback is welcomed.
1249
1250       My perspective: I don't want to magically diddle with a user's message
1251       unless absolutely positively necessary.  Some users may want to send
1252       files with "." alone on a line; my well-meaning tinkering could
1253       seriously harm them.
1254
1255   Infinite loops may mean tainted data!
1256       Stefan Sautter noticed a bug in 2.106 where a m//gc match was failing
1257       due to tainted data, leading to an infinite loop inside MIME::Lite.
1258
1259       I am attempting to correct for this, but be advised that my fix will
1260       silently untaint the data (given the context in which the problem
1261       occurs, this should be benign: I've labelled the source code with
1262       UNTAINT comments for the curious).
1263
1264       So: don't depend on taint-checking to save you from outputting tainted
1265       data in a message.
1266
1267   Don't tweak the global configuration
1268       Global configuration variables are bad, and should go away.  Until they
1269       do, please follow the hints with each setting on how not to change it.
1270

A MIME PRIMER

1272   Content types
1273       The "Type" parameter of "build()" is a content type.  This is the
1274       actual type of data you are sending.  Generally this is a string of the
1275       form "majortype/minortype".
1276
1277       Here are the major MIME types.  A more-comprehensive listing may be
1278       found in RFC-2046.
1279
1280       application
1281           Data which does not fit in any of the other categories,
1282           particularly data to be processed by some type of application
1283           program.  "application/octet-stream", "application/gzip",
1284           "application/postscript"...
1285
1286       audio
1287           Audio data.  "audio/basic"...
1288
1289       image
1290           Graphics data.  "image/gif", "image/jpeg"...
1291
1292       message
1293           A message, usually another mail or MIME message.
1294           "message/rfc822"...
1295
1296       multipart
1297           A message containing other messages.  "multipart/mixed",
1298           "multipart/alternative"...
1299
1300       text
1301           Textual data, meant for humans to read.  "text/plain",
1302           "text/html"...
1303
1304       video
1305           Video or video+audio data.  "video/mpeg"...
1306
1307   Content transfer encodings
1308       The "Encoding" parameter of "build()".  This is how the message body is
1309       packaged up for safe transit.
1310
1311       Here are the 5 major MIME encodings.  A more-comprehensive listing may
1312       be found in RFC-2045.
1313
1314       7bit
1315           Basically, no real encoding is done.  However, this label
1316           guarantees that no 8-bit characters are present, and that lines do
1317           not exceed 1000 characters in length.
1318
1319       8bit
1320           Basically, no real encoding is done.  The message might contain
1321           8-bit characters, but this encoding guarantees that lines do not
1322           exceed 1000 characters in length.
1323
1324       binary
1325           No encoding is done at all.  Message might contain 8-bit
1326           characters, and lines might be longer than 1000 characters long.
1327
1328           The most liberal, and the least likely to get through mail
1329           gateways.  Use sparingly, or (better yet) not at all.
1330
1331       base64
1332           Like "uuencode", but very well-defined.  This is how you should
1333           send essentially binary information (tar files, GIFs, JPEGs, etc.).
1334
1335       quoted-printable
1336           Useful for encoding messages which are textual in nature, yet which
1337           contain non-ASCII characters (e.g., Latin-1, Latin-2, or any other
1338           8-bit alphabet).
1339

HELPER MODULES

1341       MIME::Lite works nicely with other certain other modules if they are
1342       present.  Good to have installed are the latest MIME::Types,
1343       Mail::Address, MIME::Base64, MIME::QuotedPrint, and Net::SMTP.
1344       Email::Date::Format is strictly required.
1345
1346       If they aren't present then some functionality won't work, and other
1347       features wont be as efficient or up to date as they could be.
1348       Nevertheless they are optional extras.
1349

BUNDLED GOODIES

1351       MIME::Lite comes with a number of extra files in the distribution
1352       bundle.  This includes examples, and utility modules that you can use
1353       to get yourself started with the module.
1354
1355       The ./examples directory contains a number of snippets in prepared
1356       form, generally they are documented, but they should be easy to
1357       understand.
1358
1359       The ./contrib directory contains a companion/tool modules that come
1360       bundled with MIME::Lite, they don't get installed by default. Please
1361       review the POD they come with.
1362

BUGS

1364       The whole reason that version 3.0 was released was to ensure that
1365       MIME::Lite is up to date and patched. If you find an issue please
1366       report it.
1367
1368       As far as I know MIME::Lite doesn't currently have any serious bugs,
1369       but my usage is hardly comprehensive.
1370
1371       Having said that there are a number of open issues for me, mostly
1372       caused by the progress in the community as whole since Eryq last
1373       released. The tests are based around an interesting but non standard
1374       test framework. I'd like to change it over to using Test::More.
1375
1376       Should tests fail please review the ./testout directory, and in any bug
1377       reports please include the output of the relevant file. This is the
1378       only redeeming feature of not using Test::More that I can see.
1379
1380       Bug fixes / Patches / Contribution are welcome, however I probably
1381       won't apply them unless they also have an associated test. This means
1382       that if I don't have the time to write the test the patch wont get
1383       applied, so please, include tests for any patches you provide.
1384

VERSION

1386       Version: 3.030
1387

CHANGE LOG

1389       Moved to ./changes.pod
1390
1391       NOTE: Users of the "advanced features" of 3.01_0x smtp sending should
1392       take care: These features have been REMOVED as they never really fit
1393       the purpose of the module. Redundant SMTP delivery is a task that
1394       should be handled by another module.
1395

TERMS AND CONDITIONS

1397         Copyright (c) 1997 by Eryq.
1398         Copyright (c) 1998 by ZeeGee Software Inc.
1399         Copyright (c) 2003,2005 Yves Orton. (demerphq)
1400
1401       All rights reserved.  This program is free software; you can
1402       redistribute it and/or modify it under the same terms as Perl itself.
1403
1404       This software comes with NO WARRANTY of any kind.  See the COPYING file
1405       in the distribution for details.
1406

NUTRITIONAL INFORMATION

1408       For some reason, the US FDA says that this is now required by law on
1409       any products that bear the name "Lite"...
1410
1411       Version 3.0 is now new and improved! The distribution is now 30%
1412       smaller!
1413
1414           MIME::Lite                |
1415           ------------------------------------------------------------
1416           Serving size:             | 1 module
1417           Servings per container:   | 1
1418           Calories:                 | 0
1419           Fat:                      | 0g
1420             Saturated Fat:          | 0g
1421
1422       Warning: for consumption by hardware only!  May produce indigestion in
1423       humans if taken internally.
1424

AUTHOR

1426       Eryq (eryq@zeegee.com).  President, ZeeGee Software Inc.
1427       (http://www.zeegee.com).
1428
1429       Go to http://www.cpan.org for the latest downloads and on-line
1430       documentation for this module.  Enjoy.
1431
1432       Patches And Maintenance by Yves Orton and many others.  Consult
1433       ./changes.pod
1434
1435
1436
1437perl v5.28.1                      2013-11-04                     MIME::Lite(3)
Impressum