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