1NAME
2 MIME::Lite - low-calorie MIME generator
3
4WAIT!
5 MIME::Lite is not recommended by its current maintainer. There are a
6 number of alternatives, like Email::MIME or MIME::Entity and
7 Email::Sender, which you should probably use instead. MIME::Lite
8 continues to accrue weird bug reports, and it is not receiving a large
9 amount of refactoring due to the availability of better alternatives.
10 Please consider using something else.
11
12SYNOPSIS
13 Create and send using the default send method for your OS a single-part
14 message:
15
16 use MIME::Lite;
17 ### Create a new single-part message, to send a GIF file:
18 $msg = MIME::Lite->new(
19 From => 'me@myhost.com',
20 To => 'you@yourhost.com',
21 Cc => 'some@other.com, some@more.com',
22 Subject => 'Helloooooo, nurse!',
23 Type => 'image/gif',
24 Encoding => 'base64',
25 Path => 'hellonurse.gif'
26 );
27 $msg->send; # send via default
28
29 Create a multipart message (i.e., one with attachments) and send it SMTP
30
31 ### Create a new multipart message:
32 $msg = MIME::Lite->new(
33 From => 'me@myhost.com',
34 To => 'you@yourhost.com',
35 Cc => 'some@other.com, some@more.com',
36 Subject => 'A message with 2 parts...',
37 Type => 'multipart/mixed'
38 );
39
40 ### Add parts (each "attach" has same arguments as "new"):
41 $msg->attach(
42 Type => 'TEXT',
43 Data => "Here's the GIF file you wanted"
44 );
45 $msg->attach(
46 Type => 'image/gif',
47 Path => 'aaa000123.gif',
48 Filename => 'logo.gif',
49 Disposition => 'attachment'
50 );
51 ### use Net:SMTP to do the sending
52 $msg->send('smtp','some.host', Debug=>1 );
53
54 Output a message:
55
56 ### Format as a string:
57 $str = $msg->as_string;
58
59 ### Print to a filehandle (say, a "sendmail" stream):
60 $msg->print(\*SENDMAIL);
61
62 Send a message:
63
64 ### Send in the "best" way (the default is to use "sendmail"):
65 $msg->send;
66 ### Send a specific way:
67 $msg->send('type',@args);
68
69 Specify default send method:
70
71 MIME::Lite->send('smtp','some.host',Debug=>0);
72
73 with authentication
74
75 MIME::Lite->send('smtp','some.host', AuthUser=>$user, AuthPass=>$pass);
76
77DESCRIPTION
78 In the never-ending quest for great taste with fewer calories, we
79 proudly present: *MIME::Lite*.
80
81 MIME::Lite is intended as a simple, standalone module for generating
82 (not parsing!) MIME messages... specifically, it allows you to output a
83 simple, decent single- or multi-part message with text or binary
84 attachments. It does not require that you have the Mail:: or MIME::
85 modules installed, but will work with them if they are.
86
87 You can specify each message part as either the literal data itself (in
88 a scalar or array), or as a string which can be given to open() to get a
89 readable filehandle (e.g., "<filename" or "somecommand|").
90
91 You don't need to worry about encoding your message data: this module
92 will do that for you. It handles the 5 standard MIME encodings.
93
94EXAMPLES
95 Create a simple message containing just text
96 $msg = MIME::Lite->new(
97 From =>'me@myhost.com',
98 To =>'you@yourhost.com',
99 Cc =>'some@other.com, some@more.com',
100 Subject =>'Helloooooo, nurse!',
101 Data =>"How's it goin', eh?"
102 );
103
104 Create a simple message containing just an image
105 $msg = MIME::Lite->new(
106 From =>'me@myhost.com',
107 To =>'you@yourhost.com',
108 Cc =>'some@other.com, some@more.com',
109 Subject =>'Helloooooo, nurse!',
110 Type =>'image/gif',
111 Encoding =>'base64',
112 Path =>'hellonurse.gif'
113 );
114
115 Create a multipart message
116 ### Create the multipart "container":
117 $msg = MIME::Lite->new(
118 From =>'me@myhost.com',
119 To =>'you@yourhost.com',
120 Cc =>'some@other.com, some@more.com',
121 Subject =>'A message with 2 parts...',
122 Type =>'multipart/mixed'
123 );
124
125 ### Add the text message part:
126 ### (Note that "attach" has same arguments as "new"):
127 $msg->attach(
128 Type =>'TEXT',
129 Data =>"Here's the GIF file you wanted"
130 );
131
132 ### Add the image part:
133 $msg->attach(
134 Type =>'image/gif',
135 Path =>'aaa000123.gif',
136 Filename =>'logo.gif',
137 Disposition => 'attachment'
138 );
139
140 Attach a GIF to a text message
141 This will create a multipart message exactly as above, but using the
142 "attach to singlepart" hack:
143
144 ### Start with a simple text message:
145 $msg = MIME::Lite->new(
146 From =>'me@myhost.com',
147 To =>'you@yourhost.com',
148 Cc =>'some@other.com, some@more.com',
149 Subject =>'A message with 2 parts...',
150 Type =>'TEXT',
151 Data =>"Here's the GIF file you wanted"
152 );
153
154 ### Attach a part... the make the message a multipart automatically:
155 $msg->attach(
156 Type =>'image/gif',
157 Path =>'aaa000123.gif',
158 Filename =>'logo.gif'
159 );
160
161 Attach a pre-prepared part to a message
162 ### Create a standalone part:
163 $part = MIME::Lite->new(
164 Top => 0,
165 Type =>'text/html',
166 Data =>'<H1>Hello</H1>',
167 );
168 $part->attr('content-type.charset' => 'UTF-8');
169 $part->add('X-Comment' => 'A message for you');
170
171 ### Attach it to any message:
172 $msg->attach($part);
173
174 Print a message to a filehandle
175 ### Write it to a filehandle:
176 $msg->print(\*STDOUT);
177
178 ### Write just the header:
179 $msg->print_header(\*STDOUT);
180
181 ### Write just the encoded body:
182 $msg->print_body(\*STDOUT);
183
184 Print a message into a string
185 ### Get entire message as a string:
186 $str = $msg->as_string;
187
188 ### Get just the header:
189 $str = $msg->header_as_string;
190
191 ### Get just the encoded body:
192 $str = $msg->body_as_string;
193
194 Send a message
195 ### Send in the "best" way (the default is to use "sendmail"):
196 $msg->send;
197
198 Send an HTML document... with images included!
199 $msg = MIME::Lite->new(
200 To =>'you@yourhost.com',
201 Subject =>'HTML with in-line images!',
202 Type =>'multipart/related'
203 );
204 $msg->attach(
205 Type => 'text/html',
206 Data => qq{
207 <body>
208 Here's <i>my</i> image:
209 <img src="cid:myimage.gif">
210 </body>
211 },
212 );
213 $msg->attach(
214 Type => 'image/gif',
215 Id => 'myimage.gif',
216 Path => '/path/to/somefile.gif',
217 );
218 $msg->send();
219
220 Change how messages are sent
221 ### Do something like this in your 'main':
222 if ($I_DONT_HAVE_SENDMAIL) {
223 MIME::Lite->send('smtp', $host, Timeout=>60,
224 AuthUser=>$user, AuthPass=>$pass);
225 }
226
227 ### Now this will do the right thing:
228 $msg->send; ### will now use Net::SMTP as shown above
229
230PUBLIC INTERFACE
231 Global configuration
232 To alter the way the entire module behaves, you have the following
233 methods/options:
234
235 MIME::Lite->field_order()
236 When used as a classmethod, this changes the default order in which
237 headers are output for *all* messages. However, please consider
238 using the instance method variant instead, so you won't stomp on
239 other message senders in the same application.
240
241 MIME::Lite->quiet()
242 This classmethod can be used to suppress/unsuppress all warnings
243 coming from this module.
244
245 MIME::Lite->send()
246 When used as a classmethod, this can be used to specify a different
247 default mechanism for sending message. The initial default is:
248
249 MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem");
250
251 However, you should consider the similar but smarter and taint-safe
252 variant:
253
254 MIME::Lite->send("sendmail");
255
256 Or, for non-Unix users:
257
258 MIME::Lite->send("smtp");
259
260 $MIME::Lite::AUTO_CC
261 If true, automatically send to the Cc/Bcc addresses for
262 send_by_smtp(). Default is true.
263
264 $MIME::Lite::AUTO_CONTENT_TYPE
265 If true, try to automatically choose the content type from the file
266 name in "new()"/"build()". In other words, setting this true changes
267 the default "Type" from "TEXT" to "AUTO".
268
269 Default is false, since we must maintain backwards-compatibility
270 with prior behavior. Please consider keeping it false, and just
271 using Type 'AUTO' when you build() or attach().
272
273 $MIME::Lite::AUTO_ENCODE
274 If true, automatically choose the encoding from the content type.
275 Default is true.
276
277 $MIME::Lite::AUTO_VERIFY
278 If true, check paths to attachments right before printing, raising
279 an exception if any path is unreadable. Default is true.
280
281 $MIME::Lite::PARANOID
282 If true, we won't attempt to use MIME::Base64, MIME::QuotedPrint, or
283 MIME::Types, even if they're available. Default is false. Please
284 consider keeping it false, and trusting these other packages to do
285 the right thing.
286
287 Construction
288 new [PARAMHASH]
289 *Class method, constructor.* Create a new message object.
290
291 If any arguments are given, they are passed into "build()";
292 otherwise, just the empty object is created.
293
294 attach PART
295 attach PARAMHASH...
296 *Instance method.* Add a new part to this message, and return the
297 new part.
298
299 If you supply a single PART argument, it will be regarded as a
300 MIME::Lite object to be attached. Otherwise, this method assumes
301 that you are giving in the pairs of a PARAMHASH which will be sent
302 into "new()" to create the new part.
303
304 One of the possibly-quite-useful hacks thrown into this is the
305 "attach-to-singlepart" hack: if you attempt to attach a part (let's
306 call it "part 1") to a message that doesn't have a content-type of
307 "multipart" or "message", the following happens:
308
309 * A new part (call it "part 0") is made.
310
311 * The MIME attributes and data (but *not* the other headers) are
312 cut from the "self" message, and pasted into "part 0".
313
314 * The "self" is turned into a "multipart/mixed" message.
315
316 * The new "part 0" is added to the "self", and *then* "part 1" is
317 added.
318
319 One of the nice side-effects is that you can create a text message
320 and then add zero or more attachments to it, much in the same way
321 that a user agent like Netscape allows you to do.
322
323 build [PARAMHASH]
324 *Class/instance method, initializer.* Create (or initialize) a MIME
325 message object. Normally, you'll use the following keys in
326 PARAMHASH:
327
328 * Data, FH, or Path (either one of these, or none if multipart)
329 * Type (e.g., "image/jpeg")
330 * From, To, and Subject (if this is the "top level" of a message)
331
332 The PARAMHASH can contain the following keys:
333
334 (fieldname)
335 Any field you want placed in the message header, taken from the
336 standard list of header fields (you don't need to worry about
337 case):
338
339 Approved Encrypted Received Sender
340 Bcc From References Subject
341 Cc Keywords Reply-To To
342 Comments Message-ID Resent-* X-*
343 Content-* MIME-Version Return-Path
344 Date Organization
345
346 To give experienced users some veto power, these fields will be
347 set *after* the ones I set... so be careful: *don't set any MIME
348 fields* (like "Content-type") unless you know what you're doing!
349
350 To specify a fieldname that's *not* in the above list, even one
351 that's identical to an option below, just give it with a
352 trailing ":", like "My-field:". When in doubt, that *always*
353 signals a mail field (and it sort of looks like one too).
354
355 Data
356 *Alternative to "Path" or "FH".* The actual message data. This
357 may be a scalar or a ref to an array of strings; if the latter,
358 the message consists of a simple concatenation of all the
359 strings in the array.
360
361 Datestamp
362 *Optional.* If given true (or omitted), we force the creation of
363 a "Date:" field stamped with the current date/time if this is a
364 top-level message. You may want this if using send_by_smtp(). If
365 you don't want this to be done, either provide your own Date or
366 explicitly set this to false.
367
368 Disposition
369 *Optional.* The content disposition, "inline" or "attachment".
370 The default is "inline".
371
372 Encoding
373 *Optional.* The content transfer encoding that should be used to
374 encode your data:
375
376 Use encoding: | If your message contains:
377 ------------------------------------------------------------
378 7bit | Only 7-bit text, all lines <1000 characters
379 8bit | 8-bit text, all lines <1000 characters
380 quoted-printable | 8-bit text or long lines (more reliable than "8bit")
381 base64 | Largely non-textual data: a GIF, a tar file, etc.
382
383 The default is taken from the Type; generally it is "binary" (no
384 encoding) for text/*, message/*, and multipart/*, and "base64"
385 for everything else. A value of "binary" is generally *not*
386 suitable for sending anything but ASCII text files with lines
387 under 1000 characters, so consider using one of the other values
388 instead.
389
390 In the case of "7bit"/"8bit", long lines are automatically
391 chopped to legal length; in the case of "7bit", all 8-bit
392 characters are automatically *removed*. This may not be what you
393 want, so pick your encoding well! For more info, see "A MIME
394 PRIMER".
395
396 FH *Alternative to "Data" or "Path".* Filehandle containing the
397 data, opened for reading. See "ReadNow" also.
398
399 Filename
400 *Optional.* The name of the attachment. You can use this to
401 supply a recommended filename for the end-user who is saving the
402 attachment to disk. You only need this if the filename at the
403 end of the "Path" is inadequate, or if you're using "Data"
404 instead of "Path". You should *not* put path information in here
405 (e.g., no "/" or "\" or ":" characters should be used).
406
407 Id *Optional.* Same as setting "content-id".
408
409 Length
410 *Optional.* Set the content length explicitly. Normally, this
411 header is automatically computed, but only under certain
412 circumstances (see "Benign limitations").
413
414 Path
415 *Alternative to "Data" or "FH".* Path to a file containing the
416 data... actually, it can be any open()able expression. If it
417 looks like a path, the last element will automatically be
418 treated as the filename. See "ReadNow" also.
419
420 ReadNow
421 *Optional, for use with "Path".* If true, will open the path and
422 slurp the contents into core now. This is useful if the Path
423 points to a command and you don't want to run the command over
424 and over if outputting the message several times. Fatal
425 exception raised if the open fails.
426
427 Top *Optional.* If defined, indicates whether or not this is a
428 "top-level" MIME message. The parts of a multipart message are
429 *not* top-level. Default is true.
430
431 Type
432 *Optional.* The MIME content type, or one of these special
433 values (case-sensitive):
434
435 "TEXT" means "text/plain"
436 "BINARY" means "application/octet-stream"
437 "AUTO" means attempt to guess from the filename, falling back
438 to 'application/octet-stream'. This is good if you have
439 MIME::Types on your system and you have no idea what
440 file might be used for the attachment.
441
442 The default is "TEXT", but it will be "AUTO" if you set
443 $AUTO_CONTENT_TYPE to true (sorry, but you have to enable it
444 explicitly, since we don't want to break code which depends on
445 the old behavior).
446
447 A picture being worth 1000 words (which is of course 2000 bytes, so
448 it's probably more of an "icon" than a "picture", but I digress...),
449 here are some examples:
450
451 $msg = MIME::Lite->build(
452 From => 'yelling@inter.com',
453 To => 'stocking@fish.net',
454 Subject => "Hi there!",
455 Type => 'TEXT',
456 Encoding => '7bit',
457 Data => "Just a quick note to say hi!"
458 );
459
460 $msg = MIME::Lite->build(
461 From => 'dorothy@emerald-city.oz',
462 To => 'gesundheit@edu.edu.edu',
463 Subject => "A gif for U"
464 Type => 'image/gif',
465 Path => "/home/httpd/logo.gif"
466 );
467
468 $msg = MIME::Lite->build(
469 From => 'laughing@all.of.us',
470 To => 'scarlett@fiddle.dee.de',
471 Subject => "A gzipp'ed tar file",
472 Type => 'x-gzip',
473 Path => "gzip < /usr/inc/somefile.tar |",
474 ReadNow => 1,
475 Filename => "somefile.tgz"
476 );
477
478 To show you what's really going on, that last example could also
479 have been written:
480
481 $msg = new MIME::Lite;
482 $msg->build(
483 Type => 'x-gzip',
484 Path => "gzip < /usr/inc/somefile.tar |",
485 ReadNow => 1,
486 Filename => "somefile.tgz"
487 );
488 $msg->add(From => "laughing@all.of.us");
489 $msg->add(To => "scarlett@fiddle.dee.de");
490 $msg->add(Subject => "A gzipp'ed tar file");
491
492 Setting/getting headers and attributes
493 add TAG,VALUE
494 *Instance method.* Add field TAG with the given VALUE to the end of
495 the header. The TAG will be converted to all-lowercase, and the
496 VALUE will be made "safe" (returns will be given a trailing space).
497
498 Beware: any MIME fields you "add" will override any MIME attributes
499 I have when it comes time to output those fields. Normally, you will
500 use this method to add *non-MIME* fields:
501
502 $msg->add("Subject" => "Hi there!");
503
504 Giving VALUE as an arrayref will cause all those values to be added.
505 This is only useful for special multiple-valued fields like
506 "Received":
507
508 $msg->add("Received" => ["here", "there", "everywhere"]
509
510 Giving VALUE as the empty string adds an invisible placeholder to
511 the header, which can be used to suppress the output of the
512 "Content-*" fields or the special "MIME-Version" field. When
513 suppressing fields, you should use replace() instead of add():
514
515 $msg->replace("Content-disposition" => "");
516
517 *Note:* add() is probably going to be more efficient than
518 "replace()", so you're better off using it for most applications if
519 you are certain that you don't need to delete() the field first.
520
521 *Note:* the name comes from Mail::Header.
522
523 attr ATTR,[VALUE]
524 *Instance method.* Set MIME attribute ATTR to the string VALUE. ATTR
525 is converted to all-lowercase. This method is normally used to
526 set/get MIME attributes:
527
528 $msg->attr("content-type" => "text/html");
529 $msg->attr("content-type.charset" => "US-ASCII");
530 $msg->attr("content-type.name" => "homepage.html");
531
532 This would cause the final output to look something like this:
533
534 Content-type: text/html; charset=US-ASCII; name="homepage.html"
535
536 Note that the special empty sub-field tag indicates the anonymous
537 first sub-field.
538
539 Giving VALUE as undefined will cause the contents of the named
540 subfield to be deleted.
541
542 Supplying no VALUE argument just returns the attribute's value:
543
544 $type = $msg->attr("content-type"); ### returns "text/html"
545 $name = $msg->attr("content-type.name"); ### returns "homepage.html"
546
547 delete TAG
548 *Instance method.* Delete field TAG with the given VALUE to the end
549 of the header. The TAG will be converted to all-lowercase.
550
551 $msg->delete("Subject");
552
553 *Note:* the name comes from Mail::Header.
554
555 field_order FIELD,...FIELD
556 *Class/instance method.* Change the order in which header fields are
557 output for this object:
558
559 $msg->field_order('from', 'to', 'content-type', 'subject');
560
561 When used as a class method, changes the default settings for all
562 objects:
563
564 MIME::Lite->field_order('from', 'to', 'content-type', 'subject');
565
566 Case does not matter: all field names will be coerced to lowercase.
567 In either case, supply the empty array to restore the default
568 ordering.
569
570 fields
571 *Instance method.* Return the full header for the object, as a ref
572 to an array of "[TAG, VALUE]" pairs, where each TAG is
573 all-lowercase. Note that any fields the user has explicitly set will
574 override the corresponding MIME fields that we would otherwise
575 generate. So, don't say...
576
577 $msg->set("Content-type" => "text/html; charset=US-ASCII");
578
579 unless you want the above value to override the "Content-type" MIME
580 field that we would normally generate.
581
582 *Note:* I called this "fields" because the header() method of
583 Mail::Header returns something different, but similar enough to be
584 confusing.
585
586 You can change the order of the fields: see "field_order". You
587 really shouldn't need to do this, but some people have to deal with
588 broken mailers.
589
590 filename [FILENAME]
591 *Instance method.* Set the filename which this data will be reported
592 as. This actually sets both "standard" attributes.
593
594 With no argument, returns the filename as dictated by the
595 content-disposition.
596
597 get TAG,[INDEX]
598 *Instance method.* Get the contents of field TAG, which might have
599 been set with set() or replace(). Returns the text of the field.
600
601 $ml->get('Subject', 0);
602
603 If the optional 0-based INDEX is given, then we return the INDEX'th
604 occurrence of field TAG. Otherwise, we look at the context: In a
605 scalar context, only the first (0th) occurrence of the field is
606 returned; in an array context, *all* occurrences are returned.
607
608 *Warning:* this should only be used with non-MIME fields. Behavior
609 with MIME fields is TBD, and will raise an exception for now.
610
611 get_length
612 *Instance method.* Recompute the content length for the message *if
613 the process is trivial*, setting the "content-length" attribute as a
614 side-effect:
615
616 $msg->get_length;
617
618 Returns the length, or undefined if not set.
619
620 *Note:* the content length can be difficult to compute, since it
621 involves assembling the entire encoded body and taking the length of
622 it (which, in the case of multipart messages, means freezing all the
623 sub-parts, etc.).
624
625 This method only sets the content length to a defined value if the
626 message is a singlepart with "binary" encoding, *and* the body is
627 available either in-core or as a simple file. Otherwise, the content
628 length is set to the undefined value.
629
630 Since content-length is not a standard MIME field anyway (that's
631 right, kids: it's not in the MIME RFCs, it's an HTTP thing), this
632 seems pretty fair.
633
634 parts
635 *Instance method.* Return the parts of this entity, and this entity
636 only. Returns empty array if this entity has no parts.
637
638 This is not recursive! Parts can have sub-parts; use parts_DFS() to
639 get everything.
640
641 parts_DFS
642 *Instance method.* Return the list of all MIME::Lite objects
643 included in the entity, starting with the entity itself, in
644 depth-first-search order. If this object has no parts, it alone will
645 be returned.
646
647 preamble [TEXT]
648 *Instance method.* Get/set the preamble string, assuming that this
649 object has subparts. Set it to undef for the default string.
650
651 replace TAG,VALUE
652 *Instance method.* Delete all occurrences of fields named TAG, and
653 add a new field with the given VALUE. TAG is converted to
654 all-lowercase.
655
656 Beware the special MIME fields (MIME-version, Content-*): if you
657 "replace" a MIME field, the replacement text will override the
658 *actual* MIME attributes when it comes time to output that field. So
659 normally you use attr() to change MIME fields and add()/replace() to
660 change *non-MIME* fields:
661
662 $msg->replace("Subject" => "Hi there!");
663
664 Giving VALUE as the *empty string* will effectively *prevent* that
665 field from being output. This is the correct way to suppress the
666 special MIME fields:
667
668 $msg->replace("Content-disposition" => "");
669
670 Giving VALUE as *undefined* will just cause all explicit values for
671 TAG to be deleted, without having any new values added.
672
673 *Note:* the name of this method comes from Mail::Header.
674
675 scrub
676 *Instance method.* This is Alpha code. If you use it, please let me
677 know how it goes. Recursively goes through the "parts" tree of this
678 message and tries to find MIME attributes that can be removed. With
679 an array argument, removes exactly those attributes; e.g.:
680
681 $msg->scrub(['content-disposition', 'content-length']);
682
683 Is the same as recursively doing:
684
685 $msg->replace('Content-disposition' => '');
686 $msg->replace('Content-length' => '');
687
688 Setting/getting message data
689 binmode [OVERRIDE]
690 *Instance method.* With no argument, returns whether or not it
691 thinks that the data (as given by the "Path" argument of "build()")
692 should be read using binmode() (for example, when "read_now()" is
693 invoked).
694
695 The default behavior is that any content type other than "text/*" or
696 "message/*" is binmode'd; this should in general work fine.
697
698 With a defined argument, this method sets an explicit "override"
699 value. An undefined argument unsets the override. The new current
700 value is returned.
701
702 data [DATA]
703 *Instance method.* Get/set the literal DATA of the message. The DATA
704 may be either a scalar, or a reference to an array of scalars (which
705 will simply be joined).
706
707 *Warning:* setting the data causes the "content-length" attribute to
708 be recomputed (possibly to nothing).
709
710 fh [FILEHANDLE]
711 *Instance method.* Get/set the FILEHANDLE which contains the message
712 data.
713
714 Takes a filehandle as an input and stores it in the object. This
715 routine is similar to path(); one important difference is that no
716 attempt is made to set the content length.
717
718 path [PATH]
719 *Instance method.* Get/set the PATH to the message data.
720
721 *Warning:* setting the path recomputes any existing "content-length"
722 field, and re-sets the "filename" (to the last element of the path
723 if it looks like a simple path, and to nothing if not).
724
725 resetfh [FILEHANDLE]
726 *Instance method.* Set the current position of the filehandle back
727 to the beginning. Only applies if you used "FH" in build() or
728 attach() for this message.
729
730 Returns false if unable to reset the filehandle (since not all
731 filehandles are seekable).
732
733 read_now
734 *Instance method.* Forces data from the path/filehandle (as
735 specified by "build()") to be read into core immediately, just as
736 though you had given it literally with the "Data" keyword.
737
738 Note that the in-core data will always be used if available.
739
740 Be aware that everything is slurped into a giant scalar: you may not
741 want to use this if sending tar files! The benefit of *not* reading
742 in the data is that very large files can be handled by this module
743 if left on disk until the message is output via "print()" or
744 "print_body()".
745
746 sign PARAMHASH
747 *Instance method.* Sign the message. This forces the message to be
748 read into core, after which the signature is appended to it.
749
750 Data
751 As in "build()": the literal signature data. Can be either a
752 scalar or a ref to an array of scalars.
753
754 Path
755 As in "build()": the path to the file.
756
757 If no arguments are given, the default is:
758
759 Path => "$ENV{HOME}/.signature"
760
761 The content-length is recomputed.
762
763 verify_data
764 *Instance method.* Verify that all "paths" to attached data exist,
765 recursively. It might be a good idea for you to do this before a
766 print(), to prevent accidental partial output if a file might be
767 missing. Raises exception if any path is not readable.
768
769 Output
770 print [OUTHANDLE]
771 *Instance method.* Print the message to the given output handle, or
772 to the currently-selected filehandle if none was given.
773
774 All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
775 any object that responds to a print() message.
776
777 print_body [OUTHANDLE] [IS_SMTP]
778 *Instance method.* Print the body of a message to the given output
779 handle, or to the currently-selected filehandle if none was given.
780
781 All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
782 any object that responds to a print() message.
783
784 Fatal exception raised if unable to open any of the input files, or
785 if a part contains no data, or if an unsupported encoding is
786 encountered.
787
788 IS_SMPT is a special option to handle SMTP mails a little more
789 intelligently than other send mechanisms may require. Specifically
790 this ensures that the last byte sent is NOT '\n' (octal \012) if the
791 last two bytes are not '\r\n' (\015\012) as this will cause some
792 SMTP servers to hang.
793
794 print_header [OUTHANDLE]
795 *Instance method.* Print the header of the message to the given
796 output handle, or to the currently-selected filehandle if none was
797 given.
798
799 All OUTHANDLE has to be is a filehandle (possibly a glob ref), or
800 any object that responds to a print() message.
801
802 as_string
803 *Instance method.* Return the entire message as a string, with a
804 header and an encoded body.
805
806 body_as_string
807 *Instance method.* Return the encoded body as a string. This is the
808 portion after the header and the blank line.
809
810 *Note:* actually prepares the body by "printing" to a scalar. Proof
811 that you can hand the "print*()" methods any blessed object that
812 responds to a "print()" message.
813
814 header_as_string
815 *Instance method.* Return the header as a string.
816
817 Sending
818 send
819 send HOW, HOWARGS...
820 *Class/instance method.* This is the principal method for sending
821 mail, and for configuring how mail will be sent.
822
823 *As a class method* with a HOW argument and optional HOWARGS, it
824 sets the default sending mechanism that the no-argument instance
825 method will use. The HOW is a facility name (see below), and the
826 HOWARGS is interpreted by the facility. The class method returns the
827 previous HOW and HOWARGS as an array.
828
829 MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe");
830 ...
831 $msg = MIME::Lite->new(...);
832 $msg->send;
833
834 *As an instance method with arguments* (a HOW argument and optional
835 HOWARGS), sends the message in the requested manner; e.g.:
836
837 $msg->send('sendmail', "d:\\programs\\sendmail.exe");
838
839 *As an instance method with no arguments,* sends the message by the
840 default mechanism set up by the class method. Returns whatever the
841 mail-handling routine returns: this should be true on success,
842 false/exception on error:
843
844 $msg = MIME::Lite->new(From=>...);
845 $msg->send || die "you DON'T have mail!";
846
847 On Unix systems (or rather non-Win32 systems), the default setting
848 is equivalent to:
849
850 MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem");
851
852 On Win32 systems the default setting is equivalent to:
853
854 MIME::Lite->send("smtp");
855
856 The assumption is that on Win32 your site/lib/Net/libnet.cfg file
857 will be preconfigured to use the appropriate SMTP server. See below
858 for configuring for authentication.
859
860 There are three facilities:
861
862 "sendmail", ARGS...
863 Send a message by piping it into the "sendmail" command. Uses
864 the send_by_sendmail() method, giving it the ARGS. This usage
865 implements (and deprecates) the "sendmail()" method.
866
867 "smtp", [HOSTNAME, [NAMEDPARMS] ]
868 Send a message by SMTP, using optional HOSTNAME as SMTP-sending
869 host. Net::SMTP will be required. Uses the send_by_smtp()
870 method. Any additional arguments passed in will also be passed
871 through to send_by_smtp. This is useful for things like mail
872 servers requiring authentication where you can say something
873 like the following
874
875 MIME::Lite->send('smtp', $host, AuthUser=>$user, AuthPass=>$pass);
876
877 which will configure things so future uses of
878
879 $msg->send();
880
881 do the right thing.
882
883 "sub", \&SUBREF, ARGS...
884 Sends a message MSG by invoking the subroutine SUBREF of your
885 choosing, with MSG as the first argument, and ARGS following.
886
887 *For example:* let's say you're on an OS which lacks the usual Unix
888 "sendmail" facility, but you've installed something a lot like it,
889 and you need to configure your Perl script to use this
890 "sendmail.exe" program. Do this following in your script's setup:
891
892 MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe");
893
894 Then, whenever you need to send a message $msg, just say:
895
896 $msg->send;
897
898 That's it. Now, if you ever move your script to a Unix box, all you
899 need to do is change that line in the setup and you're done. All of
900 your $msg->send invocations will work as expected.
901
902 After sending, the method last_send_successful() can be used to
903 determine if the send was successful or not.
904
905 send_by_sendmail SENDMAILCMD
906 send_by_sendmail PARAM=>VALUE, ARRAY, HASH...
907 *Instance method.* Send message via an external "sendmail" program
908 (this will probably only work out-of-the-box on Unix systems).
909
910 Returns true on success, false or exception on error.
911
912 You can specify the program and all its arguments by giving a single
913 string, SENDMAILCMD. Nothing fancy is done; the message is simply
914 piped in.
915
916 However, if your needs are a little more advanced, you can specify
917 zero or more of the following PARAM/VALUE pairs (or a reference to
918 hash or array of such arguments as well as any combination thereof);
919 a Unix-style, taint-safe "sendmail" command will be constructed for
920 you:
921
922 Sendmail
923 Full path to the program to use. Default is "/usr/lib/sendmail".
924
925 BaseArgs
926 Ref to the basic array of arguments we start with. Default is
927 "["-t", "-oi", "-oem"]".
928
929 SetSender
930 Unless this is *explicitly* given as false, we attempt to
931 automatically set the "-f" argument to the first address that
932 can be extracted from the "From:" field of the message (if there
933 is one).
934
935 *What is the -f, and why do we use it?* Suppose we did *not* use
936 "-f", and you gave an explicit "From:" field in your message: in
937 this case, the sendmail "envelope" would indicate the *real*
938 user your process was running under, as a way of preventing mail
939 forgery. Using the "-f" switch causes the sender to be set in
940 the envelope as well.
941
942 *So when would I NOT want to use it?* If sendmail doesn't regard
943 you as a "trusted" user, it will permit the "-f" but also add an
944 "X-Authentication-Warning" header to the message to indicate a
945 forged envelope. To avoid this, you can either (1) have
946 SetSender be false, or (2) make yourself a trusted user by
947 adding a "T" configuration command to your *sendmail.cf* file
948 (e.g.: "Teryq" if the script is running as user "eryq").
949
950 FromSender
951 If defined, this is identical to setting SetSender to true,
952 except that instead of looking at the "From:" field we use the
953 address given by this option. Thus:
954
955 FromSender => 'me@myhost.com'
956
957 After sending, the method last_send_successful() can be used to
958 determine if the send was successful or not.
959
960 send_by_smtp HOST, ARGS...
961 send_by_smtp REF, HOST, ARGS
962 *Instance method.* Send message via SMTP, using Net::SMTP -- which
963 will be required for this feature.
964
965 HOST is the name of SMTP server to connect to, or undef to have
966 Net::SMTP use the defaults in Libnet.cfg.
967
968 ARGS are a list of key value pairs which may be selected from the
969 list below. Many of these are just passed through to specific
970 Net::SMTP commands and you should review that module for details.
971
972 Please see Good-vs-bad email addresses with send_by_smtp()
973
974 Hello
975 LocalAddr
976 LocalPort
977 Timeout
978 Port
979 ExactAddresses
980 Debug
981 See Net::SMTP::new() for details.
982
983 Size
984 Return
985 Bits
986 Transaction
987 Envelope
988 See Net::SMTP::mail() for details.
989
990 SkipBad
991 If true doesn't throw an error when multiple email addresses are
992 provided and some are not valid. See Net::SMTP::recipient() for
993 details.
994
995 AuthUser
996 Authenticate with Net::SMTP::auth() using this username.
997
998 AuthPass
999 Authenticate with Net::SMTP::auth() using this password.
1000
1001 NoAuth
1002 Normally if AuthUser and AuthPass are defined MIME::Lite will
1003 attempt to use them with the Net::SMTP::auth() command to
1004 authenticate the connection, however if this value is true then
1005 no authentication occurs.
1006
1007 To Sets the addresses to send to. Can be a string or a reference to
1008 an array of strings. Normally this is extracted from the To:
1009 (and Cc: and Bcc: fields if $AUTO_CC is true).
1010
1011 This value overrides that.
1012
1013 From
1014 Sets the email address to send from. Normally this value is
1015 extracted from the Return-Path: or From: field of the mail
1016 itself (in that order).
1017
1018 This value overrides that.
1019
1020 *Returns:* True on success, croaks with an error message on failure.
1021
1022 After sending, the method last_send_successful() can be used to
1023 determine if the send was successful or not.
1024
1025 send_by_testfile FILENAME
1026 *Instance method.* Print message to a file (namely FILENAME), which
1027 will default to mailer.testfile If file exists, message will be
1028 appended.
1029
1030 last_send_successful
1031 This method will return TRUE if the last send() or send_by_XXX()
1032 method call was successful. It will return defined but false if it
1033 was not successful, and undefined if the object had not been used to
1034 send yet.
1035
1036 sendmail COMMAND...
1037 *Class method, DEPRECATED.* Declare the sender to be "sendmail", and
1038 set up the "sendmail" command. *You should use send() instead.*
1039
1040 Miscellaneous
1041 quiet ONOFF
1042 *Class method.* Suppress/unsuppress all warnings coming from this
1043 module.
1044
1045 MIME::Lite->quiet(1); ### I know what I'm doing
1046
1047 I recommend that you include that comment as well. And while you
1048 type it, say it out loud: if it doesn't feel right, then maybe you
1049 should reconsider the whole line. ";-)"
1050
1051NOTES
1052 How do I prevent "Content" headers from showing up in my mail reader?
1053 Apparently, some people are using mail readers which display the MIME
1054 headers like "Content-disposition", and they want MIME::Lite not to
1055 generate them "because they look ugly".
1056
1057 Sigh.
1058
1059 Y'know, kids, those headers aren't just there for cosmetic purposes.
1060 They help ensure that the message is *understood* correctly by mail
1061 readers. But okay, you asked for it, you got it... here's how you can
1062 suppress the standard MIME headers. Before you send the message, do
1063 this:
1064
1065 $msg->scrub;
1066
1067 You can scrub() any part of a multipart message independently; just be
1068 aware that it works recursively. Before you scrub, note the rules that I
1069 follow:
1070
1071 Content-type
1072 You can safely scrub the "content-type" attribute if, and only if,
1073 the part is of type "text/plain" with charset "us-ascii".
1074
1075 Content-transfer-encoding
1076 You can safely scrub the "content-transfer-encoding" attribute if,
1077 and only if, the part uses "7bit", "8bit", or "binary" encoding. You
1078 are far better off doing this if your lines are under 1000
1079 characters. Generally, that means you *can* scrub it for plain text,
1080 and you can *not* scrub this for images, etc.
1081
1082 Content-disposition
1083 You can safely scrub the "content-disposition" attribute if you
1084 trust the mail reader to do the right thing when it decides whether
1085 to show an attachment inline or as a link. Be aware that scrubbing
1086 both the content-disposition and the content-type means that there
1087 is no way to "recommend" a filename for the attachment!
1088
1089 Note: there are reports of brain-dead MUAs out there that do the
1090 wrong thing if you *provide* the content-disposition. If your
1091 attachments keep showing up inline or vice-versa, try scrubbing this
1092 attribute.
1093
1094 Content-length
1095 You can always scrub "content-length" safely.
1096
1097 How do I give my attachment a [different] recommended filename?
1098 By using the Filename option (which is different from Path!):
1099
1100 $msg->attach(Type => "image/gif",
1101 Path => "/here/is/the/real/file.GIF",
1102 Filename => "logo.gif");
1103
1104 You should *not* put path information in the Filename.
1105
1106 Benign limitations
1107 This is "lite", after all...
1108
1109 * There's no parsing. Get MIME-tools if you need to parse MIME
1110 messages.
1111
1112 * MIME::Lite messages are currently *not* interchangeable with either
1113 Mail::Internet or MIME::Entity objects. This is a completely
1114 separate module.
1115
1116 * A content-length field is only inserted if the encoding is binary,
1117 the message is a singlepart, and all the document data is available
1118 at "build()" time by virtue of residing in a simple path, or
1119 in-core. Since content-length is not a standard MIME field anyway
1120 (that's right, kids: it's not in the MIME RFCs, it's an HTTP thing),
1121 this seems pretty fair.
1122
1123 * MIME::Lite alone cannot help you lose weight. You must supplement
1124 your use of MIME::Lite with a healthy diet and exercise.
1125
1126 Cheap and easy mailing
1127 I thought putting in a default "sendmail" invocation wasn't too bad an
1128 idea, since a lot of Perlers are on UNIX systems. (As of version 3.02
1129 this is default only on Non-Win32 boxen. On Win32 boxen the default is
1130 to use SMTP and the defaults specified in the site/lib/Net/libnet.cfg)
1131
1132 The out-of-the-box configuration is:
1133
1134 MIME::Lite->send('sendmail', "/usr/lib/sendmail -t -oi -oem");
1135
1136 By the way, these arguments to sendmail are:
1137
1138 -t Scan message for To:, Cc:, Bcc:, etc.
1139
1140 -oi Do NOT treat a single "." on a line as a message terminator.
1141 As in, "-oi vey, it truncated my message... why?!"
1142
1143 -oem On error, mail back the message (I assume to the
1144 appropriate address, given in the header).
1145 When mail returns, circle is complete. Jai Guru Deva -oem.
1146
1147 Note that these are the same arguments you get if you configure to use
1148 the smarter, taint-safe mailing:
1149
1150 MIME::Lite->send('sendmail');
1151
1152 If you get "X-Authentication-Warning" headers from this, you can forgo
1153 diddling with the envelope by instead specifying:
1154
1155 MIME::Lite->send('sendmail', SetSender=>0);
1156
1157 And, if you're not on a Unix system, or if you'd just rather send mail
1158 some other way, there's always SMTP, which these days probably requires
1159 authentication so you probably need to say
1160
1161 MIME::Lite->send('smtp', "smtp.myisp.net",
1162 AuthUser=>"YourName",AuthPass=>"YourPass" );
1163
1164 Or you can set up your own subroutine to call. In any case, check out
1165 the send() method.
1166
1167WARNINGS
1168 Good-vs-bad email addresses with send_by_smtp()
1169 If using send_by_smtp(), be aware that unless you explicitly provide the
1170 email addresses to send to and from you will be forcing MIME::Lite to
1171 extract email addresses out of a possible list provided in the "To:",
1172 "Cc:", and "Bcc:" fields. This is tricky stuff, and as such only the
1173 following sorts of addresses will work reliably:
1174
1175 username
1176 full.name@some.host.com
1177 "Name, Full" <full.name@some.host.com>
1178
1179 Disclaimer: MIME::Lite was never intended to be a Mail User Agent, so
1180 please don't expect a full implementation of RFC-822. Restrict yourself
1181 to the common forms of Internet addresses described herein, and you
1182 should be fine. If this is not feasible, then consider using MIME::Lite
1183 to *prepare* your message only, and using Net::SMTP explicitly to *send*
1184 your message.
1185
1186 Note: As of MIME::Lite v3.02 the mail name extraction routines have been
1187 beefed up considerably. Furthermore if Mail::Address if provided then
1188 name extraction is done using that. Accordingly the above advice is now
1189 less true than it once was. Funky email names *should* work properly
1190 now. However the disclaimer remains. Patches welcome. :-)
1191
1192 Formatting of headers delayed until print()
1193 This class treats a MIME header in the most abstract sense, as being a
1194 collection of high-level attributes. The actual RFC-822-style header
1195 fields are not constructed until it's time to actually print the darn
1196 thing.
1197
1198 Encoding of data delayed until print()
1199 When you specify message bodies (in build() or attach()) -- whether by
1200 FH, Data, or Path -- be warned that we don't attempt to open files, read
1201 filehandles, or encode the data until print() is invoked.
1202
1203 In the past, this created some confusion for users of sendmail who gave
1204 the wrong path to an attachment body, since enough of the print() would
1205 succeed to get the initial part of the message out. Nowadays,
1206 $AUTO_VERIFY is used to spot-check the Paths given before the mail
1207 facility is employed. A whisker slower, but tons safer.
1208
1209 Note that if you give a message body via FH, and try to print() a
1210 message twice, the second print() will not do the right thing unless you
1211 explicitly rewind the filehandle.
1212
1213 You can get past these difficulties by using the ReadNow option,
1214 provided that you have enough memory to handle your messages.
1215
1216 MIME attributes are separate from header fields!
1217 Important: the MIME attributes are stored and manipulated separately
1218 from the message header fields; when it comes time to print the header
1219 out, *any explicitly-given header fields override the ones that would be
1220 created from the MIME attributes.* That means that this:
1221
1222 ### DANGER ### DANGER ### DANGER ### DANGER ### DANGER ###
1223 $msg->add("Content-type", "text/html; charset=US-ASCII");
1224
1225 will set the exact "Content-type" field in the header I write,
1226 *regardless of what the actual MIME attributes are.*
1227
1228 *This feature is for experienced users only,* as an escape hatch in case
1229 the code that normally formats MIME header fields isn't doing what you
1230 need. And, like any escape hatch, it's got an alarm on it: MIME::Lite
1231 will warn you if you attempt to "set()" or "replace()" any MIME header
1232 field. Use "attr()" instead.
1233
1234 Beware of lines consisting of a single dot
1235 Julian Haight noted that MIME::Lite allows you to compose messages with
1236 lines in the body consisting of a single ".". This is true: it should be
1237 completely harmless so long as "sendmail" is used with the -oi option
1238 (see "Cheap and easy mailing").
1239
1240 However, I don't know if using Net::SMTP to transfer such a message is
1241 equally safe. Feedback is welcomed.
1242
1243 My perspective: I don't want to magically diddle with a user's message
1244 unless absolutely positively necessary. Some users may want to send
1245 files with "." alone on a line; my well-meaning tinkering could
1246 seriously harm them.
1247
1248 Infinite loops may mean tainted data!
1249 Stefan Sautter noticed a bug in 2.106 where a m//gc match was failing
1250 due to tainted data, leading to an infinite loop inside MIME::Lite.
1251
1252 I am attempting to correct for this, but be advised that my fix will
1253 silently untaint the data (given the context in which the problem
1254 occurs, this should be benign: I've labelled the source code with
1255 UNTAINT comments for the curious).
1256
1257 So: don't depend on taint-checking to save you from outputting tainted
1258 data in a message.
1259
1260 Don't tweak the global configuration
1261 Global configuration variables are bad, and should go away. Until they
1262 do, please follow the hints with each setting on how *not* to change it.
1263
1264A MIME PRIMER
1265 Content types
1266 The "Type" parameter of "build()" is a *content type*. This is the
1267 actual type of data you are sending. Generally this is a string of the
1268 form "majortype/minortype".
1269
1270 Here are the major MIME types. A more-comprehensive listing may be found
1271 in RFC-2046.
1272
1273 application
1274 Data which does not fit in any of the other categories, particularly
1275 data to be processed by some type of application program.
1276 "application/octet-stream", "application/gzip",
1277 "application/postscript"...
1278
1279 audio
1280 Audio data. "audio/basic"...
1281
1282 image
1283 Graphics data. "image/gif", "image/jpeg"...
1284
1285 message
1286 A message, usually another mail or MIME message. "message/rfc822"...
1287
1288 multipart
1289 A message containing other messages. "multipart/mixed",
1290 "multipart/alternative"...
1291
1292 text
1293 Textual data, meant for humans to read. "text/plain", "text/html"...
1294
1295 video
1296 Video or video+audio data. "video/mpeg"...
1297
1298 Content transfer encodings
1299 The "Encoding" parameter of "build()". This is how the message body is
1300 packaged up for safe transit.
1301
1302 Here are the 5 major MIME encodings. A more-comprehensive listing may be
1303 found in RFC-2045.
1304
1305 7bit
1306 Basically, no *real* encoding is done. However, this label
1307 guarantees that no 8-bit characters are present, and that lines do
1308 not exceed 1000 characters in length.
1309
1310 8bit
1311 Basically, no *real* encoding is done. The message might contain
1312 8-bit characters, but this encoding guarantees that lines do not
1313 exceed 1000 characters in length.
1314
1315 binary
1316 No encoding is done at all. Message might contain 8-bit characters,
1317 and lines might be longer than 1000 characters long.
1318
1319 The most liberal, and the least likely to get through mail gateways.
1320 Use sparingly, or (better yet) not at all.
1321
1322 base64
1323 Like "uuencode", but very well-defined. This is how you should send
1324 essentially binary information (tar files, GIFs, JPEGs, etc.).
1325
1326 quoted-printable
1327 Useful for encoding messages which are textual in nature, yet which
1328 contain non-ASCII characters (e.g., Latin-1, Latin-2, or any other
1329 8-bit alphabet).
1330
1331HELPER MODULES
1332 MIME::Lite works nicely with other certain other modules if they are
1333 present. Good to have installed are the latest MIME::Types,
1334 Mail::Address, MIME::Base64, MIME::QuotedPrint, and Net::SMTP.
1335 Email::Date::Format is strictly required.
1336
1337 If they aren't present then some functionality won't work, and other
1338 features wont be as efficient or up to date as they could be.
1339 Nevertheless they are optional extras.
1340
1341BUNDLED GOODIES
1342 MIME::Lite comes with a number of extra files in the distribution
1343 bundle. This includes examples, and utility modules that you can use to
1344 get yourself started with the module.
1345
1346 The ./examples directory contains a number of snippets in prepared form,
1347 generally they are documented, but they should be easy to understand.
1348
1349 The ./contrib directory contains a companion/tool modules that come
1350 bundled with MIME::Lite, they don't get installed by default. Please
1351 review the POD they come with.
1352
1353BUGS
1354 The whole reason that version 3.0 was released was to ensure that
1355 MIME::Lite is up to date and patched. If you find an issue please report
1356 it.
1357
1358 As far as I know MIME::Lite doesn't currently have any serious bugs, but
1359 my usage is hardly comprehensive.
1360
1361 Having said that there are a number of open issues for me, mostly caused
1362 by the progress in the community as whole since Eryq last released. The
1363 tests are based around an interesting but non standard test framework.
1364 I'd like to change it over to using Test::More.
1365
1366 Should tests fail please review the ./testout directory, and in any bug
1367 reports please include the output of the relevant file. This is the only
1368 redeeming feature of not using Test::More that I can see.
1369
1370 Bug fixes / Patches / Contribution are welcome, however I probably won't
1371 apply them unless they also have an associated test. This means that if
1372 I don't have the time to write the test the patch wont get applied, so
1373 please, include tests for any patches you provide.
1374
1375VERSION
1376 Version: 3.033
1377
1378CHANGE LOG
1379 Moved to ./changes.pod
1380
1381 NOTE: Users of the "advanced features" of 3.01_0x smtp sending should
1382 take care: These features have been REMOVED as they never really fit the
1383 purpose of the module. Redundant SMTP delivery is a task that should be
1384 handled by another module.
1385
1386TERMS AND CONDITIONS
1387 Copyright (c) 1997 by Eryq.
1388 Copyright (c) 1998 by ZeeGee Software Inc.
1389 Copyright (c) 2003,2005 Yves Orton. (demerphq)
1390
1391 All rights reserved. This program is free software; you can redistribute
1392 it and/or modify it under the same terms as Perl itself.
1393
1394 This software comes with NO WARRANTY of any kind. See the COPYING file
1395 in the distribution for details.
1396
1397NUTRITIONAL INFORMATION
1398 For some reason, the US FDA says that this is now required by law on any
1399 products that bear the name "Lite"...
1400
1401 Version 3.0 is now new and improved! The distribution is now 30%
1402 smaller!
1403
1404 MIME::Lite |
1405 ------------------------------------------------------------
1406 Serving size: | 1 module
1407 Servings per container: | 1
1408 Calories: | 0
1409 Fat: | 0g
1410 Saturated Fat: | 0g
1411
1412 Warning: for consumption by hardware only! May produce indigestion in
1413 humans if taken internally.
1414
1415AUTHOR
1416 Eryq (eryq@zeegee.com). President, ZeeGee Software Inc.
1417 (http://www.zeegee.com).
1418
1419 Go to http://www.cpan.org for the latest downloads and on-line
1420 documentation for this module. Enjoy.
1421
1422 Patches And Maintenance by Yves Orton and many others. Consult
1423 ./changes.pod
1424
1425