MIME-Lite-3.030/000755 000766 000766 00000000000 12235601706 012240 5ustar00rjbs000000 000000 MIME-Lite-3.030/changes.pod000644 000766 000766 00000040141 12235601373 014354 0ustar00rjbs000000 000000 =head1 CHANGE LOG =over 4 =item Version 3.030 Make send_by_sendmail set sender like documentation says it does (thanks, Michael Schout!) =item Version 3.029 Allow the MIME-Version header to be replaced (thanks, Florian!) =item Version 3.028 Various documentation fixes =item Version 3.027 Add send_to_testfile method (Thanks, AlexanderBecker) =item Version 3.026 Fix tests to pass with MIME::Types 1.28 =item Version 3.025 Added back support for providing a non-default SMTP port (#21156, #48783, thanks John Bokma!). =item Version 3.024 add git repo link to metadata =item Version 3.023 Correct erroneous changelog entry Fix typo in perldoc: utf-8, not utf8 =item Version 3.022 Behave on Cygwin as on Win32 with regard to defaulting to SMTP sending. Respect crazy people who put multiple Cc or Bcc headers in message (#30574, thanks Pavel V. Rochnyack!) We no longer rewrite array and hash refs in the send_by_sendmail args so aggressively. Cope with missing local sendmail (thanks to Debian for patching for this, and for putting up with me (rjbs) being an insufferable jerk!) Fix weird unicode-in-$1 bug (thanks SREZIC!) Other minor bug fixes. =item Version 3.021 Replace Email::Date with Email::Date::Format to limit prereqs (Email::Date::Format produced just for this!) Begin the process of removing use of ExtUtils::TBone for testing =item Version 3.020 Optimized code for speedup of creation of two-part messages. The internal structure of the object has changes, but that won't matter if you were using the published interface. (Sam Tregar) Removed the "advanced features", ie auto-fallback delivery, from send_by_smtp. They didn't belong there in the first place. =item Version 3.01_06 (2007/07/29) First release from Perl Email Project. Updated packaging. =item Version 3.01_04 (2004/05/05) Reworked the new send_by_smtp stuff. Documentation modifications. =item Version 3.01_02 (2003/08/28) Well, it seems 3.01_01 failed tests on Win32 due to me accidentally changing the line ending format to DOSish. Also the way that email extraction for SMTP with or without Mail::Address was different (from 2.117 even). So ive fixed that. Anybody depending on the undocumented extract_addrs() is in for a suprise. I suggest you look at using Mail::Address. =item Version 3.01_01 (2003/04/25 - 2003/08/21) (This version is a test release, if its ok then I'll re-release it as 3.02) Patched the pod to use correct entities Thanks to Ed Avis for the patch. Added better support for funky names in the from field when sending via SMTP, thanks to prodding by Darren Hemphill and Ollie Gallardo. (Actually I kind of messed this up orginally and no doubt Darren wasn't impressed. I ended up using something pretty close to his solution. My bad for not paying more attention. Sorry mate.) 08/21: Apparently I never uploaded my changes for this version to CPAN. Sigh. *** Win32 CHANGES *** Up until this release the default send() method for all OS'es has been to invoke sendmail and pipe the mail to it. This behaviour has now changed on Win32 to default to using SMTP. This means that if your /site/lib/Net/libnet.cfg file is properly configured then you can use SMTP without specifying a send method explicitly. This seemed a rational decision as most Win32 users who send mails are using an SMTP server and not a tool like sendmail. *** SMTP CHANGES *** Jonathan Eunice pointed out an interesting bug in the interaction between MIME::Lite and Net::SMTP/Net::CMD. This was that sending a mail ending in "\n\n" without additional encoding would cause Net::CMD to send an incorrect end of mail signal to the SMTP server which would result in A) The mail failing to be sent due to a timeout, and B) MIME::Lite to report that all was well. This has been fixed by checking to make sure that if the last character sent was \n, but the last two chars were not \r\n then the \n is turned into an \r, which Net::CMD then adds an \n to and then sends the normal ".\r\n" to terminate the message. Weird error, that im not entirely sure has been resolved properly. Please inform me if this screws anything up that it shouldn't. As stated earlier send_by_smtp wasnt extracting the _real_ email address from the overall fancy once specified in the From: field. This is resolved now, fancy display names are now possible while using SMTP. *** Content-Id *** It was pointed out by alex via CPAN RT that Content-Id needs to have angle brackets around it or HTML mails dont show up properly in many mail clients, furthermore the RFC mandates it (to be honest im taking his word on this, please feel free to yell at me if this causes trouble), so as he suggested I am automatically adding them in they arent provided. *** sendmail path *** Dom pointed out via CPAN RT that despite some effort going in to trying to discover the correct location of sendmail, that it was still using a bad default. Fixed. *** Date Stamping *** Kurt reported via RT that datestamps were not being correctly formatted. His patch has been incorporated with only one change, a comment where Perl was spelled PERL :-) *** Quoted printable fix *** Klaus Rusch noted a bug in how quoted-printable handled weird \r\n combinations. Fixed now. =item Version 3.01 (2003/04/25) Eryq has reappeared long enough to graciously hand over the maintaince of the module to me. Thanks. =item Version 3.00 (2003/04/24) Eryq has disappeared. His web site remains but he doesnt answer emails. I have taken it onto myself to take over maintenance until he returns to reclaim his excellent work. I don't intend to develop this in an serious way. I'll patch it if people have a patch and generally keep it ticking over, but dont expect new features. This release has code that actually works with MIME::Lite now. As well as a few other minor additions (like a test for this functionailty) For stuff that could be done, a first place would be to rewrite and extend the test suite. It should use Test::More or Test::Builder at the very least. I also might rip out the preformatted doc pages. It makes the distro way fatter than it needs to be. I reckon the package contains the POD in at least three forms. A wee tad overkill I think. :-) =item Version 2.117 (2001/08/20) The terms-of-use have been placed in the distribution file "COPYING". Also, small documentation tweaks were made. =item Version 2.116 (2001/08/17) Added long-overdue patch which makes the instance method form of send() do the right thing when given HOW... arguments. I =item Version 2.114 (2001/08/16) New special 'AUTO' content type in new()/build() tells MIME::Lite to try and guess the type from file extension. To make use of this, you'll want to install B. The "AUTO" setting can be made the default default (instead of "TEXT") if you set C<$AUTO_CONTENT_TYPE = 1, $PARANOID = 0>. I Ville SkyttE<228> I File::Basename is used if it is available. I Ville SkyttE<228> I SMTP failures (in send_by_smtp) now add the $smtp-Emessage to the croak'ed exception, so if things go wrong, you get a better idea of what and why. I Made a subtle change to C which supposedly fixes a failed MIME data.t test with Perl 5.004_04 on NT 4 sp6. The problem might only exist in this old perl, but as the patch author says, not everyone has climbed higher on the Perl ladder. I Added C directory, with F. I Improved HTML documentation (notice the links to the individual methods in the top menu). Corrected some mis-docs. =item Version 2.111 (2001/04/03) Added long-overdue C and C methods. No instance method For accessing the subparts? That can't be right. D'OH! Added long-overdue auto-verify logic to C method. Added long-overdue C method for getting/setting the preamble text. I =item Version 2.108 (2001/03/30) New C allows you to set the header order, both on a per-message basis, and package-wide. I Added code to try and divine "sendmail" path more intelligently. I =item Version 2.107 (2001/03/27) Fixed serious bug where tainted data with quoted-printable encoding was causing infinite loops. The "fix" untaints the data in question, which is not optimal, but it's probably benign in this case. I I "Doctor, O doctor: it's painful when I do *this* --" "Simple: don't *do* that." Fixed bugs where a non-local C<$_> was being modified... again! Will I never learn? I Dollar-underscore can poison distant waters; 'local' must it be. Fixed buglet in C where all value references were being treated as arrayrefs, instead of as possibly-self-stringifying object refs. Now you can send in an object ref as the 2nd argument. I That ref is a string? Operator overload has ruined my day. Added "Approved" as an acceptable header field for C, as per RFC1036. I Small improvements to docs to make different uses of attach() and various arguments clearer. I =item Version 2.106 (2000/11/21) Added Alpha version of scrub() to make it easy for people to suppress the printing of unwanted MIME attributes (like Content-length). I Headers with empty-strings for their values are no longer printed. This seems sensible, and helps us implement scrub(). =item Version 2.105 (2000/10/14) The regression-test failure was identified, and it was my fault. Apparently some of the \-quoting in my "autoloaded" code was making Perl 5.6 unhappy. For this nesting-related idiocy, a nesting kaiku. I In a pattern, my backslash-s dwells peacefully, unambiguous -- but I embed it in a double-quoted string doubling the backslash -- interpolating that same double-quoted string in other patterns -- and, worlds within worlds, I single-quote the function to autoload it -- changing the meaning of the backslash and the 's'; and Five-Point-Six growls. =item Version 2.104 (2000/09/28) Now attempts to load and use Mail::Address for parsing email addresses I falling back to our own method. I Parsing addresses is too damn hard. One last hope: Let Graham Barr do it! For the curious, the version of Mail::Address appears as the "A" number in the X-Mailer: X-Mailer: MIME::Lite 2.104 (A1.15; B2.09; Q2.03) Added B option to send_by_sendmail(). I =item Version 2.101 (2000/06/06) Major revision to print_body() and body_as_string() so that "body" really means "the part after the header", which is what most people would want in this context. This is B how it was used 1.x, where "body" only meant "the body of a simple singlepart". Hopefully, this change will solve many problems and create very few ones. Added support for attaching a part to a "message/rfc822", treating the "message" type as a multipart-like container. Now takes care not to include "Bcc:" in header when using send_by_smtp, as a safety precaution against qmail's behavior. I Improved efficiency of many stringifying operations by using string-arrays which are joined, instead of doing multiple appends to a scalar. Cleaned up the "examples" directory. =item Version 1.147 (2000/06/02) Fixed buglet where lack of Cc:/Bcc: was causing extract_addrs to emit "undefined variable" warnings. Also, lack of a "To:" field now causes a croak. I =item Version 1.146 (2000/05/18) Fixed bug in parsing of addresses; please read the WARNINGS section which describes recommended address formats for "To:", "Cc:", etc. Also added automatic inclusion of a UT "Date:" at top level unless explicitly told not to. I =item Version 1.145 (2000/05/06) Fixed bug in encode_7bit(): a lingering C modifier was removed. I =item Version 1.142 (2000/05/02) Added new, taint-safe invocation of "sendmail", one which also sets up the C<-f> option. Unfortunately, I couldn't make this automatic: the change could have broken a lot of code out there which used send_by_sendmail() with unusual "sendmail" variants. So you'll have to configure "send" to use the new mechanism: MIME::Lite->send('sendmail'); ### no args! I =item Version 1.140 (2000/04/27) Fixed bug in support for "To", "Cc", and "Bcc" in send_by_smtp(): multiple (comma-separated) addresses should now work fine. We try real hard to extract addresses from the flat text strings. I Added automatic verification that attached data files exist, done immediately before the "send" action is invoked. To turn this off, set $MIME::Lite::AUTO_VERIFY to false. =item Version 1.137 (2000/03/22) Added support for "Cc" and "Bcc" in send_by_smtp(). To turn this off, set $MIME::Lite::AUTO_CC to false. I Chooses a better default content-transfer-encoding if the content-type is "image/*", "audio/*", etc. To turn this off, set $MIME::Lite::AUTO_ENCODE to false. I Fixed bug in QP-encoding where a non-local C<$_> was being modified. I Removed references to C<$`>, C<$'>, and C<$&> (bad variables which slow things down). Added an example of how to send HTML files with enclosed in-line images, per popular demand. =item Version 1.133 (1999/04/17) Fixed bug in "Data" handling: arrayrefs were not being handled properly. =item Version 1.130 (1998/12/14) Added much larger and more-flexible send() facility. I Added get() method for extracting basic attributes. New... "t" tests! =item Version 1.124 (1998/11/13) Folded in filehandle (FH) support in build/attach. I =item Version 1.122 (1998/01/19) MIME::Base64 and MIME::QuotedPrint are used if available. The 7bit encoding no longer does "escapes"; it merely strips 8-bit characters. =item Version 1.121 (1997/04/08) Filename attribute is now no longer ignored by build(). I =item Version 1.120 (1997/03/29) Efficiency hack to speed up MIME::Lite::IO_Scalar. I =item Version 1.116 (1997/03/19) Small bug in our private copy of encode_base64() was patched. I New, prettier way of specifying mail message headers in C. New quiet method to turn off warnings. Changed "stringify" methods to more-standard "as_string" methods. =item Version 1.112 (1997/03/06) Added C, and C method for our non-Unix-using brethren: file data is now read using binmode() if appropriate. I =item Version 1.110 (1997/03/06) Fixed bug in opening the data filehandle. =item Version 1.102 (1997/03/01) Initial release. =item Version 1.101 (1997/03/01) Baseline code. Originally created: 11 December 1996. Ho ho ho. =back MIME-Lite-3.030/contrib/000755 000766 000766 00000000000 12235601705 013677 5ustar00rjbs000000 000000 MIME-Lite-3.030/COPYING000644 000766 000766 00000003656 11111624774 013307 0ustar00rjbs000000 000000 The "MIME-Lite" Perl5 toolkit. Copyright (c) 1996 by Eryq. All rights reserved. Copyright (c) 1999 by ZeeGee Software Inc. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. You should have received a copy of the Perl license along with Perl; see the file README in Perl distribution. You should have received a copy of the GNU General Public License along with Perl; see the file Copying. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You should have received a copy of the Artistic License along with Perl; see the file Artistic. NO WARRANTY BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS MIME-Lite-3.030/examples/000755 000766 000766 00000000000 12235601705 014055 5ustar00rjbs000000 000000 MIME-Lite-3.030/INSTALLING000644 000766 000766 00000001362 11111624774 013633 0ustar00rjbs000000 000000 ------------------------------------------------------------ STANDARD INSTALLATION On most systems, just do this from the command line: perl Makefile.PL make test make install Please note that you'll need permission to write to the standard installation directories; under Unix-like systems, this often means that you must be logged in as "root". If you're on a non-Unix platform, you might be using 'dmake' instead of 'make'. ------------------------------------------------------------ NON-STANDARD INSTALLATION To install to a non-standard place else (e.g., "/home/me/lib"), see the manual page for ExtUtils::MakeMaker, or try this: perl Makefile.PL LIB=/home/me/lib make test make install MIME-Lite-3.030/lib/000755 000766 000766 00000000000 12235601705 013005 5ustar00rjbs000000 000000 MIME-Lite-3.030/LICENSE000644 000766 000766 00000047371 11111624774 013263 0ustar00rjbs000000 000000 Terms of Perl itself a) the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version, or b) the "Artistic License" ---------------------------------------------------------------------------- The General Public License (GPL) Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS ---------------------------------------------------------------------------- The Artistic License Preamble The intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications. Definitions: - "Package" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification. - "Standard Version" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder. - "Copyright Holder" is whoever is named in the copyright or copyrights for the package. - "You" is you, if you're thinking about copying or distributing this Package. - "Reasonable copying fee" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.) - "Freely Available" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it. 1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version. 3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following: a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package. b) use the modified Package only within your corporation or organization. c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version. d) make other distribution arrangements with the Copyright Holder. 4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following: a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version. b) accompany the distribution with the machine-readable source of the Package with your modifications. c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version. d) make other distribution arrangements with the Copyright Holder. 5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. 6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package. 7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package. 8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission. 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End MIME-Lite-3.030/Makefile.PL000644 000766 000766 00000003454 12235600300 014205 0ustar00rjbs000000 000000 #!/usr/bin/perl use strict; use ExtUtils::MakeMaker; #------------------------------------------------------------ # Makefile: #------------------------------------------------------------ my %extra_prereq = ( 'Mail::Address' => 1.62, 'MIME::Types' => 1.28, 'MIME::Base64' => undef, 'MIME::QuotedPrint' => undef, ); for my $module (sort keys %extra_prereq) { local $@; my $ok = eval "require $module; \$extra_prereq{\$module} && \$module->VERSION(\$extra_prereq{\$module}); 1"; delete $extra_prereq{ $module } if $ok; } my %prereq = ( 'File::Spec' => 0, 'File::Basename' => 0, 'Email::Date::Format' => '1.000', # first release ); if (%extra_prereq) { print "MIME::Lite is designed to take advantage of a variety of external modules\n", "if they are not present then MIME::Lite will attempt to do its best\n", "but its strongly recommend that you install them.\n\n", "These modules are:\n", (map {; "\t$_\n" } sort keys %extra_prereq), "I can add these modules to the prereq list which will cause the files to be\n", "automatically installed if they aren't already present\n"; if (prompt("Add prereqs?",'Yes')=~/y/i) { %prereq = (%prereq, %extra_prereq); } } # Write the Makefile: WriteMakefile( NAME => 'MIME::Lite', (eval { ExtUtils::MakeMaker->VERSION(6.21) } ? (LICENSE => 'perl') : ()), VERSION_FROM => "lib/MIME/Lite.pm", DISTNAME => "MIME-Lite", 'dist' => { #PREOP => 'cvu_perl_preop -m MIME::Lite -f',#demerphq COMPRESS => 'gzip', SUFFIX => 'gz', }, (eval { ExtUtils::MakeMaker->VERSION(6.46) } ? (META_MERGE => { resources => { repository => 'http://github.com/rjbs/MIME-Lite' } }) : () ), 'PREREQ_PM' => \%prereq, ); MIME-Lite-3.030/MANIFEST000644 000766 000766 00000001122 12235601706 013365 0ustar00rjbs000000 000000 COPYING INSTALLING LICENSE MANIFEST Makefile.PL README contrib/MailTool.pm contrib/README examples/mime_fwd examples/mime_gif examples/mime_hack examples/mime_longlines examples/mime_postcard examples/nodisp lib/MIME/Lite.pm t/ExtUtils/TBone.pm t/Utils.pm t/addrs.t t/data.t t/head.t t/mime-version.t t/parts.t t/pod.t t/pod-coverage.t t/sendmail.t t/verify.t t/types.t testin/README testin/hello testin/test.html changes.pod META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) MIME-Lite-3.030/META.json000644 000766 000766 00000001770 12235601706 013666 0ustar00rjbs000000 000000 { "abstract" : "unknown", "author" : [ "unknown" ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter version 2.132830", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "MIME-Lite", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Email::Date::Format" : "1.000", "File::Basename" : "0", "File::Spec" : "0" } } }, "release_status" : "stable", "resources" : { "repository" : { "url" : "http://github.com/rjbs/MIME-Lite" } }, "version" : "3.030" } MIME-Lite-3.030/META.yml000644 000766 000766 00000001036 12235601706 013511 0ustar00rjbs000000 000000 --- abstract: unknown author: - unknown build_requires: ExtUtils::MakeMaker: 0 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter version 2.132830' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: MIME-Lite no_index: directory: - t - inc requires: Email::Date::Format: 1.000 File::Basename: 0 File::Spec: 0 resources: repository: http://github.com/rjbs/MIME-Lite version: 3.030 MIME-Lite-3.030/README000644 000766 000766 00000160170 12235601540 013121 0ustar00rjbs000000 000000 NAME MIME::Lite - low-calorie MIME generator WAIT! MIME::Lite is not recommended by its current maintainer. There are a number of alternatives, like Email::MIME or MIME::Entity and Email::Sender, which you should probably use instead. MIME::Lite continues to accrue weird bug reports, and it is not receiving a large amount of refactoring due to the availability of better alternatives. Please consider using something else. SYNOPSIS Create and send using the default send method for your OS a single-part message: use MIME::Lite; ### Create a new single-part message, to send a GIF file: $msg = MIME::Lite->new( From => 'me@myhost.com', To => 'you@yourhost.com', Cc => 'some@other.com, some@more.com', Subject => 'Helloooooo, nurse!', Type => 'image/gif', Encoding => 'base64', Path => 'hellonurse.gif' ); $msg->send; # send via default Create a multipart message (i.e., one with attachments) and send it SMTP ### Create a new multipart message: $msg = MIME::Lite->new( From => 'me@myhost.com', To => 'you@yourhost.com', Cc => 'some@other.com, some@more.com', Subject => 'A message with 2 parts...', Type => 'multipart/mixed' ); ### Add parts (each "attach" has same arguments as "new"): $msg->attach( Type => 'TEXT', Data => "Here's the GIF file you wanted" ); $msg->attach( Type => 'image/gif', Path => 'aaa000123.gif', Filename => 'logo.gif', Disposition => 'attachment' ); ### use Net:SMTP to do the sending $msg->send('smtp','some.host', Debug=>1 ); Output a message: ### Format as a string: $str = $msg->as_string; ### Print to a filehandle (say, a "sendmail" stream): $msg->print(\*SENDMAIL); Send a message: ### Send in the "best" way (the default is to use "sendmail"): $msg->send; ### Send a specific way: $msg->send('type',@args); Specify default send method: MIME::Lite->send('smtp','some.host',Debug=>0); with authentication MIME::Lite->send('smtp','some.host', AuthUser=>$user, AuthPass=>$pass); DESCRIPTION In the never-ending quest for great taste with fewer calories, we proudly present: *MIME::Lite*. MIME::Lite is intended as a simple, standalone module for generating (not parsing!) MIME messages... specifically, it allows you to output a simple, decent single- or multi-part message with text or binary attachments. It does not require that you have the Mail:: or MIME:: modules installed, but will work with them if they are. You can specify each message part as either the literal data itself (in a scalar or array), or as a string which can be given to open() to get a readable filehandle (e.g., "new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'Helloooooo, nurse!', Data =>"How's it goin', eh?" ); Create a simple message containing just an image $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'Helloooooo, nurse!', Type =>'image/gif', Encoding =>'base64', Path =>'hellonurse.gif' ); Create a multipart message ### Create the multipart "container": $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'A message with 2 parts...', Type =>'multipart/mixed' ); ### Add the text message part: ### (Note that "attach" has same arguments as "new"): $msg->attach( Type =>'TEXT', Data =>"Here's the GIF file you wanted" ); ### Add the image part: $msg->attach( Type =>'image/gif', Path =>'aaa000123.gif', Filename =>'logo.gif', Disposition => 'attachment' ); Attach a GIF to a text message This will create a multipart message exactly as above, but using the "attach to singlepart" hack: ### Start with a simple text message: $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'A message with 2 parts...', Type =>'TEXT', Data =>"Here's the GIF file you wanted" ); ### Attach a part... the make the message a multipart automatically: $msg->attach( Type =>'image/gif', Path =>'aaa000123.gif', Filename =>'logo.gif' ); Attach a pre-prepared part to a message ### Create a standalone part: $part = MIME::Lite->new( Top => 0, Type =>'text/html', Data =>'

Hello

', ); $part->attr('content-type.charset' => 'UTF-8'); $part->add('X-Comment' => 'A message for you'); ### Attach it to any message: $msg->attach($part); Print a message to a filehandle ### Write it to a filehandle: $msg->print(\*STDOUT); ### Write just the header: $msg->print_header(\*STDOUT); ### Write just the encoded body: $msg->print_body(\*STDOUT); Print a message into a string ### Get entire message as a string: $str = $msg->as_string; ### Get just the header: $str = $msg->header_as_string; ### Get just the encoded body: $str = $msg->body_as_string; Send a message ### Send in the "best" way (the default is to use "sendmail"): $msg->send; Send an HTML document... with images included! $msg = MIME::Lite->new( To =>'you@yourhost.com', Subject =>'HTML with in-line images!', Type =>'multipart/related' ); $msg->attach( Type => 'text/html', Data => qq{ Here's my image: }, ); $msg->attach( Type => 'image/gif', Id => 'myimage.gif', Path => '/path/to/somefile.gif', ); $msg->send(); Change how messages are sent ### Do something like this in your 'main': if ($I_DONT_HAVE_SENDMAIL) { MIME::Lite->send('smtp', $host, Timeout=>60, AuthUser=>$user, AuthPass=>$pass); } ### Now this will do the right thing: $msg->send; ### will now use Net::SMTP as shown above PUBLIC INTERFACE Global configuration To alter the way the entire module behaves, you have the following methods/options: MIME::Lite->field_order() When used as a classmethod, this changes the default order in which headers are output for *all* messages. However, please consider using the instance method variant instead, so you won't stomp on other message senders in the same application. MIME::Lite->quiet() This classmethod can be used to suppress/unsuppress all warnings coming from this module. MIME::Lite->send() When used as a classmethod, this can be used to specify a different default mechanism for sending message. The initial default is: MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem"); However, you should consider the similar but smarter and taint-safe variant: MIME::Lite->send("sendmail"); Or, for non-Unix users: MIME::Lite->send("smtp"); $MIME::Lite::AUTO_CC If true, automatically send to the Cc/Bcc addresses for send_by_smtp(). Default is true. $MIME::Lite::AUTO_CONTENT_TYPE If true, try to automatically choose the content type from the file name in "new()"/"build()". In other words, setting this true changes the default "Type" from "TEXT" to "AUTO". Default is false, since we must maintain backwards-compatibility with prior behavior. Please consider keeping it false, and just using Type 'AUTO' when you build() or attach(). $MIME::Lite::AUTO_ENCODE If true, automatically choose the encoding from the content type. Default is true. $MIME::Lite::AUTO_VERIFY If true, check paths to attachments right before printing, raising an exception if any path is unreadable. Default is true. $MIME::Lite::PARANOID If true, we won't attempt to use MIME::Base64, MIME::QuotedPrint, or MIME::Types, even if they're available. Default is false. Please consider keeping it false, and trusting these other packages to do the right thing. Construction new [PARAMHASH] *Class method, constructor.* Create a new message object. If any arguments are given, they are passed into "build()"; otherwise, just the empty object is created. attach PART attach PARAMHASH... *Instance method.* Add a new part to this message, and return the new part. If you supply a single PART argument, it will be regarded as a MIME::Lite object to be attached. Otherwise, this method assumes that you are giving in the pairs of a PARAMHASH which will be sent into "new()" to create the new part. One of the possibly-quite-useful hacks thrown into this is the "attach-to-singlepart" hack: if you attempt to attach a part (let's call it "part 1") to a message that doesn't have a content-type of "multipart" or "message", the following happens: * A new part (call it "part 0") is made. * The MIME attributes and data (but *not* the other headers) are cut from the "self" message, and pasted into "part 0". * The "self" is turned into a "multipart/mixed" message. * The new "part 0" is added to the "self", and *then* "part 1" is added. One of the nice side-effects is that you can create a text message and then add zero or more attachments to it, much in the same way that a user agent like Netscape allows you to do. build [PARAMHASH] *Class/instance method, initializer.* Create (or initialize) a MIME message object. Normally, you'll use the following keys in PARAMHASH: * Data, FH, or Path (either one of these, or none if multipart) * Type (e.g., "image/jpeg") * From, To, and Subject (if this is the "top level" of a message) The PARAMHASH can contain the following keys: (fieldname) Any field you want placed in the message header, taken from the standard list of header fields (you don't need to worry about case): Approved Encrypted Received Sender Bcc From References Subject Cc Keywords Reply-To To Comments Message-ID Resent-* X-* Content-* MIME-Version Return-Path Date Organization To give experienced users some veto power, these fields will be set *after* the ones I set... so be careful: *don't set any MIME fields* (like "Content-type") unless you know what you're doing! To specify a fieldname that's *not* in the above list, even one that's identical to an option below, just give it with a trailing ":", like "My-field:". When in doubt, that *always* signals a mail field (and it sort of looks like one too). Data *Alternative to "Path" or "FH".* The actual message data. This may be a scalar or a ref to an array of strings; if the latter, the message consists of a simple concatenation of all the strings in the array. Datestamp *Optional.* If given true (or omitted), we force the creation of a "Date:" field stamped with the current date/time if this is a top-level message. You may want this if using send_by_smtp(). If you don't want this to be done, either provide your own Date or explicitly set this to false. Disposition *Optional.* The content disposition, "inline" or "attachment". The default is "inline". Encoding *Optional.* The content transfer encoding that should be used to encode your data: Use encoding: | If your message contains: ------------------------------------------------------------ 7bit | Only 7-bit text, all lines <1000 characters 8bit | 8-bit text, all lines <1000 characters quoted-printable | 8-bit text or long lines (more reliable than "8bit") base64 | Largely non-textual data: a GIF, a tar file, etc. The default is taken from the Type; generally it is "binary" (no encoding) for text/*, message/*, and multipart/*, and "base64" for everything else. A value of "binary" is generally *not* suitable for sending anything but ASCII text files with lines under 1000 characters, so consider using one of the other values instead. In the case of "7bit"/"8bit", long lines are automatically chopped to legal length; in the case of "7bit", all 8-bit characters are automatically *removed*. This may not be what you want, so pick your encoding well! For more info, see "A MIME PRIMER". FH *Alternative to "Data" or "Path".* Filehandle containing the data, opened for reading. See "ReadNow" also. Filename *Optional.* The name of the attachment. You can use this to supply a recommended filename for the end-user who is saving the attachment to disk. You only need this if the filename at the end of the "Path" is inadequate, or if you're using "Data" instead of "Path". You should *not* put path information in here (e.g., no "/" or "\" or ":" characters should be used). Id *Optional.* Same as setting "content-id". Length *Optional.* Set the content length explicitly. Normally, this header is automatically computed, but only under certain circumstances (see "Benign limitations"). Path *Alternative to "Data" or "FH".* Path to a file containing the data... actually, it can be any open()able expression. If it looks like a path, the last element will automatically be treated as the filename. See "ReadNow" also. ReadNow *Optional, for use with "Path".* If true, will open the path and slurp the contents into core now. This is useful if the Path points to a command and you don't want to run the command over and over if outputting the message several times. Fatal exception raised if the open fails. Top *Optional.* If defined, indicates whether or not this is a "top-level" MIME message. The parts of a multipart message are *not* top-level. Default is true. Type *Optional.* The MIME content type, or one of these special values (case-sensitive): "TEXT" means "text/plain" "BINARY" means "application/octet-stream" "AUTO" means attempt to guess from the filename, falling back to 'application/octet-stream'. This is good if you have MIME::Types on your system and you have no idea what file might be used for the attachment. The default is "TEXT", but it will be "AUTO" if you set $AUTO_CONTENT_TYPE to true (sorry, but you have to enable it explicitly, since we don't want to break code which depends on the old behavior). A picture being worth 1000 words (which is of course 2000 bytes, so it's probably more of an "icon" than a "picture", but I digress...), here are some examples: $msg = MIME::Lite->build( From => 'yelling@inter.com', To => 'stocking@fish.net', Subject => "Hi there!", Type => 'TEXT', Encoding => '7bit', Data => "Just a quick note to say hi!" ); $msg = MIME::Lite->build( From => 'dorothy@emerald-city.oz', To => 'gesundheit@edu.edu.edu', Subject => "A gif for U" Type => 'image/gif', Path => "/home/httpd/logo.gif" ); $msg = MIME::Lite->build( From => 'laughing@all.of.us', To => 'scarlett@fiddle.dee.de', Subject => "A gzipp'ed tar file", Type => 'x-gzip', Path => "gzip < /usr/inc/somefile.tar |", ReadNow => 1, Filename => "somefile.tgz" ); To show you what's really going on, that last example could also have been written: $msg = new MIME::Lite; $msg->build( Type => 'x-gzip', Path => "gzip < /usr/inc/somefile.tar |", ReadNow => 1, Filename => "somefile.tgz" ); $msg->add(From => "laughing@all.of.us"); $msg->add(To => "scarlett@fiddle.dee.de"); $msg->add(Subject => "A gzipp'ed tar file"); Setting/getting headers and attributes add TAG,VALUE *Instance method.* Add field TAG with the given VALUE to the end of the header. The TAG will be converted to all-lowercase, and the VALUE will be made "safe" (returns will be given a trailing space). Beware: any MIME fields you "add" will override any MIME attributes I have when it comes time to output those fields. Normally, you will use this method to add *non-MIME* fields: $msg->add("Subject" => "Hi there!"); Giving VALUE as an arrayref will cause all those values to be added. This is only useful for special multiple-valued fields like "Received": $msg->add("Received" => ["here", "there", "everywhere"] Giving VALUE as the empty string adds an invisible placeholder to the header, which can be used to suppress the output of the "Content-*" fields or the special "MIME-Version" field. When suppressing fields, you should use replace() instead of add(): $msg->replace("Content-disposition" => ""); *Note:* add() is probably going to be more efficient than "replace()", so you're better off using it for most applications if you are certain that you don't need to delete() the field first. *Note:* the name comes from Mail::Header. attr ATTR,[VALUE] *Instance method.* Set MIME attribute ATTR to the string VALUE. ATTR is converted to all-lowercase. This method is normally used to set/get MIME attributes: $msg->attr("content-type" => "text/html"); $msg->attr("content-type.charset" => "US-ASCII"); $msg->attr("content-type.name" => "homepage.html"); This would cause the final output to look something like this: Content-type: text/html; charset=US-ASCII; name="homepage.html" Note that the special empty sub-field tag indicates the anonymous first sub-field. Giving VALUE as undefined will cause the contents of the named subfield to be deleted. Supplying no VALUE argument just returns the attribute's value: $type = $msg->attr("content-type"); ### returns "text/html" $name = $msg->attr("content-type.name"); ### returns "homepage.html" delete TAG *Instance method.* Delete field TAG with the given VALUE to the end of the header. The TAG will be converted to all-lowercase. $msg->delete("Subject"); *Note:* the name comes from Mail::Header. field_order FIELD,...FIELD *Class/instance method.* Change the order in which header fields are output for this object: $msg->field_order('from', 'to', 'content-type', 'subject'); When used as a class method, changes the default settings for all objects: MIME::Lite->field_order('from', 'to', 'content-type', 'subject'); Case does not matter: all field names will be coerced to lowercase. In either case, supply the empty array to restore the default ordering. fields *Instance method.* Return the full header for the object, as a ref to an array of "[TAG, VALUE]" pairs, where each TAG is all-lowercase. Note that any fields the user has explicitly set will override the corresponding MIME fields that we would otherwise generate. So, don't say... $msg->set("Content-type" => "text/html; charset=US-ASCII"); unless you want the above value to override the "Content-type" MIME field that we would normally generate. *Note:* I called this "fields" because the header() method of Mail::Header returns something different, but similar enough to be confusing. You can change the order of the fields: see "field_order". You really shouldn't need to do this, but some people have to deal with broken mailers. filename [FILENAME] *Instance method.* Set the filename which this data will be reported as. This actually sets both "standard" attributes. With no argument, returns the filename as dictated by the content-disposition. get TAG,[INDEX] *Instance method.* Get the contents of field TAG, which might have been set with set() or replace(). Returns the text of the field. $ml->get('Subject', 0); If the optional 0-based INDEX is given, then we return the INDEX'th occurrence of field TAG. Otherwise, we look at the context: In a scalar context, only the first (0th) occurrence of the field is returned; in an array context, *all* occurrences are returned. *Warning:* this should only be used with non-MIME fields. Behavior with MIME fields is TBD, and will raise an exception for now. get_length *Instance method.* Recompute the content length for the message *if the process is trivial*, setting the "content-length" attribute as a side-effect: $msg->get_length; Returns the length, or undefined if not set. *Note:* the content length can be difficult to compute, since it involves assembling the entire encoded body and taking the length of it (which, in the case of multipart messages, means freezing all the sub-parts, etc.). This method only sets the content length to a defined value if the message is a singlepart with "binary" encoding, *and* the body is available either in-core or as a simple file. Otherwise, the content length is set to the undefined value. Since content-length is not a standard MIME field anyway (that's right, kids: it's not in the MIME RFCs, it's an HTTP thing), this seems pretty fair. parts *Instance method.* Return the parts of this entity, and this entity only. Returns empty array if this entity has no parts. This is not recursive! Parts can have sub-parts; use parts_DFS() to get everything. parts_DFS *Instance method.* Return the list of all MIME::Lite objects included in the entity, starting with the entity itself, in depth-first-search order. If this object has no parts, it alone will be returned. preamble [TEXT] *Instance method.* Get/set the preamble string, assuming that this object has subparts. Set it to undef for the default string. replace TAG,VALUE *Instance method.* Delete all occurrences of fields named TAG, and add a new field with the given VALUE. TAG is converted to all-lowercase. Beware the special MIME fields (MIME-version, Content-*): if you "replace" a MIME field, the replacement text will override the *actual* MIME attributes when it comes time to output that field. So normally you use attr() to change MIME fields and add()/replace() to change *non-MIME* fields: $msg->replace("Subject" => "Hi there!"); Giving VALUE as the *empty string* will effectively *prevent* that field from being output. This is the correct way to suppress the special MIME fields: $msg->replace("Content-disposition" => ""); Giving VALUE as *undefined* will just cause all explicit values for TAG to be deleted, without having any new values added. *Note:* the name of this method comes from Mail::Header. scrub *Instance method.* This is Alpha code. If you use it, please let me know how it goes. Recursively goes through the "parts" tree of this message and tries to find MIME attributes that can be removed. With an array argument, removes exactly those attributes; e.g.: $msg->scrub(['content-disposition', 'content-length']); Is the same as recursively doing: $msg->replace('Content-disposition' => ''); $msg->replace('Content-length' => ''); Setting/getting message data binmode [OVERRIDE] *Instance method.* With no argument, returns whether or not it thinks that the data (as given by the "Path" argument of "build()") should be read using binmode() (for example, when "read_now()" is invoked). The default behavior is that any content type other than "text/*" or "message/*" is binmode'd; this should in general work fine. With a defined argument, this method sets an explicit "override" value. An undefined argument unsets the override. The new current value is returned. data [DATA] *Instance method.* Get/set the literal DATA of the message. The DATA may be either a scalar, or a reference to an array of scalars (which will simply be joined). *Warning:* setting the data causes the "content-length" attribute to be recomputed (possibly to nothing). fh [FILEHANDLE] *Instance method.* Get/set the FILEHANDLE which contains the message data. Takes a filehandle as an input and stores it in the object. This routine is similar to path(); one important difference is that no attempt is made to set the content length. path [PATH] *Instance method.* Get/set the PATH to the message data. *Warning:* setting the path recomputes any existing "content-length" field, and re-sets the "filename" (to the last element of the path if it looks like a simple path, and to nothing if not). resetfh [FILEHANDLE] *Instance method.* Set the current position of the filehandle back to the beginning. Only applies if you used "FH" in build() or attach() for this message. Returns false if unable to reset the filehandle (since not all filehandles are seekable). read_now *Instance method.* Forces data from the path/filehandle (as specified by "build()") to be read into core immediately, just as though you had given it literally with the "Data" keyword. Note that the in-core data will always be used if available. Be aware that everything is slurped into a giant scalar: you may not want to use this if sending tar files! The benefit of *not* reading in the data is that very large files can be handled by this module if left on disk until the message is output via "print()" or "print_body()". sign PARAMHASH *Instance method.* Sign the message. This forces the message to be read into core, after which the signature is appended to it. Data As in "build()": the literal signature data. Can be either a scalar or a ref to an array of scalars. Path As in "build()": the path to the file. If no arguments are given, the default is: Path => "$ENV{HOME}/.signature" The content-length is recomputed. verify_data *Instance method.* Verify that all "paths" to attached data exist, recursively. It might be a good idea for you to do this before a print(), to prevent accidental partial output if a file might be missing. Raises exception if any path is not readable. Output print [OUTHANDLE] *Instance method.* Print the message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. print_body [OUTHANDLE] [IS_SMTP] *Instance method.* Print the body of a message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. Fatal exception raised if unable to open any of the input files, or if a part contains no data, or if an unsupported encoding is encountered. IS_SMPT is a special option to handle SMTP mails a little more intelligently than other send mechanisms may require. Specifically this ensures that the last byte sent is NOT '\n' (octal \012) if the last two bytes are not '\r\n' (\015\012) as this will cause some SMTP servers to hang. print_header [OUTHANDLE] *Instance method.* Print the header of the message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. as_string *Instance method.* Return the entire message as a string, with a header and an encoded body. body_as_string *Instance method.* Return the encoded body as a string. This is the portion after the header and the blank line. *Note:* actually prepares the body by "printing" to a scalar. Proof that you can hand the "print*()" methods any blessed object that responds to a "print()" message. header_as_string *Instance method.* Return the header as a string. Sending send send HOW, HOWARGS... *Class/instance method.* This is the principal method for sending mail, and for configuring how mail will be sent. *As a class method* with a HOW argument and optional HOWARGS, it sets the default sending mechanism that the no-argument instance method will use. The HOW is a facility name (see below), and the HOWARGS is interpreted by the facility. The class method returns the previous HOW and HOWARGS as an array. MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe"); ... $msg = MIME::Lite->new(...); $msg->send; *As an instance method with arguments* (a HOW argument and optional HOWARGS), sends the message in the requested manner; e.g.: $msg->send('sendmail', "d:\\programs\\sendmail.exe"); *As an instance method with no arguments,* sends the message by the default mechanism set up by the class method. Returns whatever the mail-handling routine returns: this should be true on success, false/exception on error: $msg = MIME::Lite->new(From=>...); $msg->send || die "you DON'T have mail!"; On Unix systems (or rather non-Win32 systems), the default setting is equivalent to: MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem"); On Win32 systems the default setting is equivalent to: MIME::Lite->send("smtp"); The assumption is that on Win32 your site/lib/Net/libnet.cfg file will be preconfigured to use the appropriate SMTP server. See below for configuring for authentication. There are three facilities: "sendmail", ARGS... Send a message by piping it into the "sendmail" command. Uses the send_by_sendmail() method, giving it the ARGS. This usage implements (and deprecates) the "sendmail()" method. "smtp", [HOSTNAME, [NAMEDPARMS] ] Send a message by SMTP, using optional HOSTNAME as SMTP-sending host. Net::SMTP will be required. Uses the send_by_smtp() method. Any additional arguments passed in will also be passed through to send_by_smtp. This is useful for things like mail servers requiring authentication where you can say something like the following MIME::Lite->send('smtp', $host, AuthUser=>$user, AuthPass=>$pass); which will configure things so future uses of $msg->send(); do the right thing. "sub", \&SUBREF, ARGS... Sends a message MSG by invoking the subroutine SUBREF of your choosing, with MSG as the first argument, and ARGS following. *For example:* let's say you're on an OS which lacks the usual Unix "sendmail" facility, but you've installed something a lot like it, and you need to configure your Perl script to use this "sendmail.exe" program. Do this following in your script's setup: MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe"); Then, whenever you need to send a message $msg, just say: $msg->send; That's it. Now, if you ever move your script to a Unix box, all you need to do is change that line in the setup and you're done. All of your $msg->send invocations will work as expected. After sending, the method last_send_successful() can be used to determine if the send was successful or not. send_by_sendmail SENDMAILCMD send_by_sendmail PARAM=>VALUE, ARRAY, HASH... *Instance method.* Send message via an external "sendmail" program (this will probably only work out-of-the-box on Unix systems). Returns true on success, false or exception on error. You can specify the program and all its arguments by giving a single string, SENDMAILCMD. Nothing fancy is done; the message is simply piped in. However, if your needs are a little more advanced, you can specify zero or more of the following PARAM/VALUE pairs (or a reference to hash or array of such arguments as well as any combination thereof); a Unix-style, taint-safe "sendmail" command will be constructed for you: Sendmail Full path to the program to use. Default is "/usr/lib/sendmail". BaseArgs Ref to the basic array of arguments we start with. Default is "["-t", "-oi", "-oem"]". SetSender Unless this is *explicitly* given as false, we attempt to automatically set the "-f" argument to the first address that can be extracted from the "From:" field of the message (if there is one). *What is the -f, and why do we use it?* Suppose we did *not* use "-f", and you gave an explicit "From:" field in your message: in this case, the sendmail "envelope" would indicate the *real* user your process was running under, as a way of preventing mail forgery. Using the "-f" switch causes the sender to be set in the envelope as well. *So when would I NOT want to use it?* If sendmail doesn't regard you as a "trusted" user, it will permit the "-f" but also add an "X-Authentication-Warning" header to the message to indicate a forged envelope. To avoid this, you can either (1) have SetSender be false, or (2) make yourself a trusted user by adding a "T" configuration command to your *sendmail.cf* file (e.g.: "Teryq" if the script is running as user "eryq"). FromSender If defined, this is identical to setting SetSender to true, except that instead of looking at the "From:" field we use the address given by this option. Thus: FromSender => 'me@myhost.com' After sending, the method last_send_successful() can be used to determine if the send was successful or not. send_by_smtp HOST, ARGS... send_by_smtp REF, HOST, ARGS *Instance method.* Send message via SMTP, using Net::SMTP -- which will be required for this feature. HOST is the name of SMTP server to connect to, or undef to have Net::SMTP use the defaults in Libnet.cfg. ARGS are a list of key value pairs which may be selected from the list below. Many of these are just passed through to specific Net::SMTP commands and you should review that module for details. Please see Good-vs-bad email addresses with send_by_smtp() Hello LocalAddr LocalPort Timeout Port ExactAddresses Debug See Net::SMTP::new() for details. Size Return Bits Transaction Envelope See Net::SMTP::mail() for details. SkipBad If true doesn't throw an error when multiple email addresses are provided and some are not valid. See Net::SMTP::recipient() for details. AuthUser Authenticate with Net::SMTP::auth() using this username. AuthPass Authenticate with Net::SMTP::auth() using this password. NoAuth Normally if AuthUser and AuthPass are defined MIME::Lite will attempt to use them with the Net::SMTP::auth() command to authenticate the connection, however if this value is true then no authentication occurs. To Sets the addresses to send to. Can be a string or a reference to an array of strings. Normally this is extracted from the To: (and Cc: and Bcc: fields if $AUTO_CC is true). This value overrides that. From Sets the email address to send from. Normally this value is extracted from the Return-Path: or From: field of the mail itself (in that order). This value overrides that. *Returns:* True on success, croaks with an error message on failure. After sending, the method last_send_successful() can be used to determine if the send was successful or not. send_by_testfile FILENAME *Instance method.* Print message to a file (namely FILENAME), which will default to mailer.testfile If file exists, message will be appended. last_send_successful This method will return TRUE if the last send() or send_by_XXX() method call was successful. It will return defined but false if it was not successful, and undefined if the object had not been used to send yet. sendmail COMMAND... *Class method, DEPRECATED.* Declare the sender to be "sendmail", and set up the "sendmail" command. *You should use send() instead.* Miscellaneous quiet ONOFF *Class method.* Suppress/unsuppress all warnings coming from this module. MIME::Lite->quiet(1); ### I know what I'm doing I recommend that you include that comment as well. And while you type it, say it out loud: if it doesn't feel right, then maybe you should reconsider the whole line. ";-)" NOTES How do I prevent "Content" headers from showing up in my mail reader? Apparently, some people are using mail readers which display the MIME headers like "Content-disposition", and they want MIME::Lite not to generate them "because they look ugly". Sigh. Y'know, kids, those headers aren't just there for cosmetic purposes. They help ensure that the message is *understood* correctly by mail readers. But okay, you asked for it, you got it... here's how you can suppress the standard MIME headers. Before you send the message, do this: $msg->scrub; You can scrub() any part of a multipart message independently; just be aware that it works recursively. Before you scrub, note the rules that I follow: Content-type You can safely scrub the "content-type" attribute if, and only if, the part is of type "text/plain" with charset "us-ascii". Content-transfer-encoding You can safely scrub the "content-transfer-encoding" attribute if, and only if, the part uses "7bit", "8bit", or "binary" encoding. You are far better off doing this if your lines are under 1000 characters. Generally, that means you *can* scrub it for plain text, and you can *not* scrub this for images, etc. Content-disposition You can safely scrub the "content-disposition" attribute if you trust the mail reader to do the right thing when it decides whether to show an attachment inline or as a link. Be aware that scrubbing both the content-disposition and the content-type means that there is no way to "recommend" a filename for the attachment! Note: there are reports of brain-dead MUAs out there that do the wrong thing if you *provide* the content-disposition. If your attachments keep showing up inline or vice-versa, try scrubbing this attribute. Content-length You can always scrub "content-length" safely. How do I give my attachment a [different] recommended filename? By using the Filename option (which is different from Path!): $msg->attach(Type => "image/gif", Path => "/here/is/the/real/file.GIF", Filename => "logo.gif"); You should *not* put path information in the Filename. Benign limitations This is "lite", after all... * There's no parsing. Get MIME-tools if you need to parse MIME messages. * MIME::Lite messages are currently *not* interchangeable with either Mail::Internet or MIME::Entity objects. This is a completely separate module. * A content-length field is only inserted if the encoding is binary, the message is a singlepart, and all the document data is available at "build()" time by virtue of residing in a simple path, or in-core. Since content-length is not a standard MIME field anyway (that's right, kids: it's not in the MIME RFCs, it's an HTTP thing), this seems pretty fair. * MIME::Lite alone cannot help you lose weight. You must supplement your use of MIME::Lite with a healthy diet and exercise. Cheap and easy mailing I thought putting in a default "sendmail" invocation wasn't too bad an idea, since a lot of Perlers are on UNIX systems. (As of version 3.02 this is default only on Non-Win32 boxen. On Win32 boxen the default is to use SMTP and the defaults specified in the site/lib/Net/libnet.cfg) The out-of-the-box configuration is: MIME::Lite->send('sendmail', "/usr/lib/sendmail -t -oi -oem"); By the way, these arguments to sendmail are: -t Scan message for To:, Cc:, Bcc:, etc. -oi Do NOT treat a single "." on a line as a message terminator. As in, "-oi vey, it truncated my message... why?!" -oem On error, mail back the message (I assume to the appropriate address, given in the header). When mail returns, circle is complete. Jai Guru Deva -oem. Note that these are the same arguments you get if you configure to use the smarter, taint-safe mailing: MIME::Lite->send('sendmail'); If you get "X-Authentication-Warning" headers from this, you can forgo diddling with the envelope by instead specifying: MIME::Lite->send('sendmail', SetSender=>0); And, if you're not on a Unix system, or if you'd just rather send mail some other way, there's always SMTP, which these days probably requires authentication so you probably need to say MIME::Lite->send('smtp', "smtp.myisp.net", AuthUser=>"YourName",AuthPass=>"YourPass" ); Or you can set up your own subroutine to call. In any case, check out the send() method. WARNINGS Good-vs-bad email addresses with send_by_smtp() If using send_by_smtp(), be aware that unless you explicitly provide the email addresses to send to and from you will be forcing MIME::Lite to extract email addresses out of a possible list provided in the "To:", "Cc:", and "Bcc:" fields. This is tricky stuff, and as such only the following sorts of addresses will work reliably: username full.name@some.host.com "Name, Full" Disclaimer: MIME::Lite was never intended to be a Mail User Agent, so please don't expect a full implementation of RFC-822. Restrict yourself to the common forms of Internet addresses described herein, and you should be fine. If this is not feasible, then consider using MIME::Lite to *prepare* your message only, and using Net::SMTP explicitly to *send* your message. Note: As of MIME::Lite v3.02 the mail name extraction routines have been beefed up considerably. Furthermore if Mail::Address if provided then name extraction is done using that. Accordingly the above advice is now less true than it once was. Funky email names *should* work properly now. However the disclaimer remains. Patches welcome. :-) Formatting of headers delayed until print() This class treats a MIME header in the most abstract sense, as being a collection of high-level attributes. The actual RFC-822-style header fields are not constructed until it's time to actually print the darn thing. Encoding of data delayed until print() When you specify message bodies (in build() or attach()) -- whether by FH, Data, or Path -- be warned that we don't attempt to open files, read filehandles, or encode the data until print() is invoked. In the past, this created some confusion for users of sendmail who gave the wrong path to an attachment body, since enough of the print() would succeed to get the initial part of the message out. Nowadays, $AUTO_VERIFY is used to spot-check the Paths given before the mail facility is employed. A whisker slower, but tons safer. Note that if you give a message body via FH, and try to print() a message twice, the second print() will not do the right thing unless you explicitly rewind the filehandle. You can get past these difficulties by using the ReadNow option, provided that you have enough memory to handle your messages. MIME attributes are separate from header fields! Important: the MIME attributes are stored and manipulated separately from the message header fields; when it comes time to print the header out, *any explicitly-given header fields override the ones that would be created from the MIME attributes.* That means that this: ### DANGER ### DANGER ### DANGER ### DANGER ### DANGER ### $msg->add("Content-type", "text/html; charset=US-ASCII"); will set the exact "Content-type" field in the header I write, *regardless of what the actual MIME attributes are.* *This feature is for experienced users only,* as an escape hatch in case the code that normally formats MIME header fields isn't doing what you need. And, like any escape hatch, it's got an alarm on it: MIME::Lite will warn you if you attempt to "set()" or "replace()" any MIME header field. Use "attr()" instead. Beware of lines consisting of a single dot Julian Haight noted that MIME::Lite allows you to compose messages with lines in the body consisting of a single ".". This is true: it should be completely harmless so long as "sendmail" is used with the -oi option (see "Cheap and easy mailing"). However, I don't know if using Net::SMTP to transfer such a message is equally safe. Feedback is welcomed. My perspective: I don't want to magically diddle with a user's message unless absolutely positively necessary. Some users may want to send files with "." alone on a line; my well-meaning tinkering could seriously harm them. Infinite loops may mean tainted data! Stefan Sautter noticed a bug in 2.106 where a m//gc match was failing due to tainted data, leading to an infinite loop inside MIME::Lite. I am attempting to correct for this, but be advised that my fix will silently untaint the data (given the context in which the problem occurs, this should be benign: I've labelled the source code with UNTAINT comments for the curious). So: don't depend on taint-checking to save you from outputting tainted data in a message. Don't tweak the global configuration Global configuration variables are bad, and should go away. Until they do, please follow the hints with each setting on how *not* to change it. A MIME PRIMER Content types The "Type" parameter of "build()" is a *content type*. This is the actual type of data you are sending. Generally this is a string of the form "majortype/minortype". Here are the major MIME types. A more-comprehensive listing may be found in RFC-2046. application Data which does not fit in any of the other categories, particularly data to be processed by some type of application program. "application/octet-stream", "application/gzip", "application/postscript"... audio Audio data. "audio/basic"... image Graphics data. "image/gif", "image/jpeg"... message A message, usually another mail or MIME message. "message/rfc822"... multipart A message containing other messages. "multipart/mixed", "multipart/alternative"... text Textual data, meant for humans to read. "text/plain", "text/html"... video Video or video+audio data. "video/mpeg"... Content transfer encodings The "Encoding" parameter of "build()". This is how the message body is packaged up for safe transit. Here are the 5 major MIME encodings. A more-comprehensive listing may be found in RFC-2045. 7bit Basically, no *real* encoding is done. However, this label guarantees that no 8-bit characters are present, and that lines do not exceed 1000 characters in length. 8bit Basically, no *real* encoding is done. The message might contain 8-bit characters, but this encoding guarantees that lines do not exceed 1000 characters in length. binary No encoding is done at all. Message might contain 8-bit characters, and lines might be longer than 1000 characters long. The most liberal, and the least likely to get through mail gateways. Use sparingly, or (better yet) not at all. base64 Like "uuencode", but very well-defined. This is how you should send essentially binary information (tar files, GIFs, JPEGs, etc.). quoted-printable Useful for encoding messages which are textual in nature, yet which contain non-ASCII characters (e.g., Latin-1, Latin-2, or any other 8-bit alphabet). HELPER MODULES MIME::Lite works nicely with other certain other modules if they are present. Good to have installed are the latest MIME::Types, Mail::Address, MIME::Base64, MIME::QuotedPrint, and Net::SMTP. Email::Date::Format is strictly required. If they aren't present then some functionality won't work, and other features wont be as efficient or up to date as they could be. Nevertheless they are optional extras. BUNDLED GOODIES MIME::Lite comes with a number of extra files in the distribution bundle. This includes examples, and utility modules that you can use to get yourself started with the module. The ./examples directory contains a number of snippets in prepared form, generally they are documented, but they should be easy to understand. The ./contrib directory contains a companion/tool modules that come bundled with MIME::Lite, they don't get installed by default. Please review the POD they come with. BUGS The whole reason that version 3.0 was released was to ensure that MIME::Lite is up to date and patched. If you find an issue please report it. As far as I know MIME::Lite doesn't currently have any serious bugs, but my usage is hardly comprehensive. Having said that there are a number of open issues for me, mostly caused by the progress in the community as whole since Eryq last released. The tests are based around an interesting but non standard test framework. I'd like to change it over to using Test::More. Should tests fail please review the ./testout directory, and in any bug reports please include the output of the relevant file. This is the only redeeming feature of not using Test::More that I can see. Bug fixes / Patches / Contribution are welcome, however I probably won't apply them unless they also have an associated test. This means that if I don't have the time to write the test the patch wont get applied, so please, include tests for any patches you provide. VERSION Version: 3.030 CHANGE LOG Moved to ./changes.pod NOTE: Users of the "advanced features" of 3.01_0x smtp sending should take care: These features have been REMOVED as they never really fit the purpose of the module. Redundant SMTP delivery is a task that should be handled by another module. TERMS AND CONDITIONS Copyright (c) 1997 by Eryq. Copyright (c) 1998 by ZeeGee Software Inc. Copyright (c) 2003,2005 Yves Orton. (demerphq) All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. This software comes with NO WARRANTY of any kind. See the COPYING file in the distribution for details. NUTRITIONAL INFORMATION For some reason, the US FDA says that this is now required by law on any products that bear the name "Lite"... Version 3.0 is now new and improved! The distribution is now 30% smaller! MIME::Lite | ------------------------------------------------------------ Serving size: | 1 module Servings per container: | 1 Calories: | 0 Fat: | 0g Saturated Fat: | 0g Warning: for consumption by hardware only! May produce indigestion in humans if taken internally. AUTHOR Eryq (eryq@zeegee.com). President, ZeeGee Software Inc. (http://www.zeegee.com). Go to http://www.cpan.org for the latest downloads and on-line documentation for this module. Enjoy. Patches And Maintenance by Yves Orton and many others. Consult ./changes.pod MIME-Lite-3.030/t/000755 000766 000766 00000000000 12235601705 012502 5ustar00rjbs000000 000000 MIME-Lite-3.030/testin/000755 000766 000766 00000000000 12235601705 013545 5ustar00rjbs000000 000000 MIME-Lite-3.030/testin/hello000644 000766 000766 00000000016 11111624774 014573 0ustar00rjbs000000 000000 Hello World MIME-Lite-3.030/testin/README000644 000766 000766 00000000026 11111624774 014426 0ustar00rjbs000000 000000 Test input directory MIME-Lite-3.030/testin/test.html000755 000766 000766 00000000100 11525563071 015410 0ustar00rjbs000000 000000 This isn't really html. We are only checking the filename silly.MIME-Lite-3.030/t/addrs.t000644 000766 000766 00000002507 11111624774 013773 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use Test::More; use Utils; $MIME::Lite::VANILLA = 1; $MIME::Lite::PARANOID = 1; # Pairs: my @pairs = ( [' me@myhost.com ', 1, ''], [' mylogin ', 1, ''], [' "Me, Jr." < me@myhost.com > ', 1, ''], [' Me ', 1, ''], ['"Me, Jr." ', 1, ''], ['"Me@somewhere.com, Jr." ', 1, ''], ['me@myhost.com,you@yourhost.com', 2, ' '], ['"Me" , "You"', 2, ' '], ['"Me" , you@yourhost.com, "And also" ', 3, ' '], ['"Me" , mylogin ,yourlogin , She ', 4, ' '] ); plan tests => 2 * @pairs; # New: foreach my $pair (@pairs) { my ($to, $count, $result) = @$pair; my @addrs = MIME::Lite::extract_only_addrs($to); is(@addrs, $count, "as many addrs as expected"); is( join(' ', map {"<$_>"} @addrs), $result, "addrs stringify together as expected", ); } MIME-Lite-3.030/t/data.t000644 000766 000766 00000002243 11111624774 013604 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use ExtUtils::TBone; use Utils; # Make a tester... here are 3 different alternatives: my $T = typical ExtUtils::TBone; # standard log $MIME::Lite::VANILLA = 1; $MIME::Lite::PARANOID = 1; # Begin testing: $T->begin(4); my ($me, $str); #------------------------------ $me = MIME::Lite->build(Type => 'text/plain', Data => "Hello\nWorld\n"); $str = $me->as_string; $T->ok(($str =~ m{Hello\nWorld\n}), $from, "Data string"); #------------------------------ $me = MIME::Lite->build(Type => 'text/plain', Data => ["Hel", "lo\n", "World\n"]); $str = $me->as_string; $T->ok(($str =~ m{Hello\nWorld\n}), $from, "Data array 1"); #------------------------------ $me = MIME::Lite->build(Type => 'text/plain', Data => ["Hel", "lo", "\n", "", "World", "", "","\n"]); $str = $me->as_string; $T->ok(($str =~ m{Hello\nWorld\n}), $from, "Data array 2"); #------------------------------ $me = MIME::Lite->build(Type => 'text/plain', Path => "./testin/hello"); $str = $me->as_string; $T->ok(($str =~ m{Hello\r?\nWorld\r?\n}), $from, "Data file"); $T->end; MIME-Lite-3.030/t/ExtUtils/000755 000766 000766 00000000000 12235601705 014263 5ustar00rjbs000000 000000 MIME-Lite-3.030/t/head.t000644 000766 000766 00000004332 11111624774 013575 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use ExtUtils::TBone; use Utils; # Make a tester... here are 3 different alternatives: my $T = typical ExtUtils::TBone; # standard log $MIME::Lite::VANILLA = 1; $MIME::Lite::PARANOID = 1; # Begin testing: $T->begin(14); # New: my $from = 'me@myhost.com'; my $me = MIME::Lite->build(From => $from, To => 'you@yourhost.com', Subject => 'Me!', Type => 'text/plain', Data => "Hello!\n"); # Test "get" [4 tests]: $T->ok_eq(scalar($me->get('From')), $from, "get: simple get of 'From'"); $T->ok_eq($me->get('From',0), $from, "get: indexed get(0) of 'From' gets first"); $T->ok_eq($me->get('From',-1), $from, "get: indexed get(-1) of 'From' gets first"); $T->ok_eq($me->get('FROM',0), $from, "get: indexed get(0) of 'FROM' gets From"); # Test "add": add one, then two [6 tests]: $me->add('Received', 'sined'); $me->add('Received', ['seeled', 'delivered']); $T->ok_eq(scalar($me->get('Received')), 'sined', "add: scalar context get of 'Received'"); $T->ok_eq($me->get('Received',0), 'sined', "add: scalar context get(0) of 'Received'"); $T->ok_eq($me->get('Received',1), 'seeled', "add: scalar context get(1) of 'Received'"); $T->ok_eq($me->get('Received',2), 'delivered', "add: scalar context get(2) of 'Received'"); $T->ok_eq($me->get('Received',-1), 'delivered', "add: scalar context get(-1) of 'Received'"); $T->ok_eq(($me->get('Received'))[1], 'seeled', "add: array context get of 'Received', indexed to 1'th elem"); # Test "delete" [1 test]: $me->delete('RECEIVED'); $T->ok(!defined($me->get('Received')), "delete: deletion of RECEIVED worked"); # Test "replace" [1 test]: $me->replace('subject', "Hellooooo, nurse!"); $T->ok_eq($me->get('SUBJECT'), "Hellooooo, nurse!", "replace: replace of SUBJECT worked"); # Test "attr" [2 tests]: $me->attr('content-type.charset', 'US-ASCII'); $T->ok_eq($me->attr('content-type.charset'), 'US-ASCII', "attr: replace of charset worked"); # my ($ct) = map {($_->[0] eq 'content-type') ? $_->[1] : ()} @{$me->fields}; $T->ok_eq($ct, 'text/plain; charset="US-ASCII"', "attr: replace of charset worked on whole line"); $T->end; MIME-Lite-3.030/t/mime-version.t000644 000766 000766 00000000761 12013454200 015273 0ustar00rjbs000000 000000 #!/usr/bin/perl use strict; use warnings; use MIME::Lite; use Test::More tests => 3; my $msg = MIME::Lite->new( Type => "multipart/digest" ); $msg->attr( 'MIME-Version' => 'qqq' ); my $str = $msg->as_string; like( $str, qr/MIME-Version: qqq/, '"MIME-Version" header has been set to qqq' ); unlike( $str, qr/MIME-Version: 1\.0/, 'default header "MIME-Version: 1.0" is no longer found' ); is( $str =~ s/MIME-Version: /counted/g, 1, 'only one MIME-Version header present', ); MIME-Lite-3.030/t/parts.t000644 000766 000766 00000001446 11111624774 014030 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use ExtUtils::TBone; use Utils; # Make a tester... here are 3 different alternatives: my $T = typical ExtUtils::TBone; # standard log $MIME::Lite::VANILLA = 1; $MIME::Lite::PARANOID = 1; # Begin testing: $T->begin(2); my $msg; $msg = MIME::Lite->new(From=>"me", To=>"you", Data=>"original text"); $msg->attach(Data => "attachment 1"); $msg->attach(Data => "attachment 2"); my $part = $msg->attach(Data => "attachment 3"); $part->attach(Data => "attachment 4"); $part->attach(Data => "attachment 5"); $T->msg("The message:\n".$msg->stringify); $T->ok_eqnum(int($msg->parts), 4, "Does parts() work?"); $T->ok_eqnum(int($msg->parts_DFS), 7, "Does parts_DFS() work?"); $T->end; MIME-Lite-3.030/t/pod-coverage.t000644 000766 000766 00000001516 11656357042 015255 0ustar00rjbs000000 000000 #!perl -T use Test::More; eval "use Test::Pod::Coverage 1.08"; plan skip_all => "Test::Pod::Coverage 1.08 required for testing POD coverage" if $@; plan skip_all => "set RELEASE_TESTING to run this test" unless $ENV{RELEASE_TESTING}; TODO: { local $TODO = "need to hash out what's what"; all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::CountParents', also_private => [ qr/^encode_/ ], trustme => [ qw( extract_full_addrs extract_only_addrs fields_as_string fold gen_boundary is_mime_field my_extract_full_addrs my_extract_only_addrs print_for_smtp print_simple_body send_by_smtp_simple send_by_sub stringify stringify_body stringify_header suggest_encoding suggest_type top_level ) ], }); } MIME-Lite-3.030/t/pod.t000644 000766 000766 00000000344 11656357050 013461 0ustar00rjbs000000 000000 #!perl -T use Test::More; eval "use Test::Pod 1.14"; plan skip_all => "Test::Pod 1.14 required for testing POD" if $@; plan skip_all => "set RELEASE_TESTING to run this test" unless $ENV{RELEASE_TESTING}; all_pod_files_ok(); MIME-Lite-3.030/t/sendmail.t000644 000766 000766 00000000600 12235601235 014455 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use Test::More tests => 2; use_ok('MIME::Lite') or exit 1; # set up dummy sendmail args. MIME::Lite->send('sendmail', '/foo/bar/sendmail -x -y -z'); # retrieve the settings. my @prev = MIME::Lite->send(sendmail => '/foo/bar/sendmail'); is_deeply \@prev, ['sendmail', '/foo/bar/sendmail -x -y -z'], 'sendmail args updated'; MIME-Lite-3.030/t/types.t000644 000766 000766 00000003033 11525563071 014036 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use Test::More; use Utils; if (eval { require MIME::Types; MIME::Types->VERSION(1.28); 1 }) { plan tests => 1; } else { plan skip_all => "MIME::Types >= 1.28 not available"; } $MIME::Lite::VANILLA = 1; # warn "#\n#Testing MIME::Types interaction\n"; my $msg = MIME::Lite->new( From => 'me@myhost.com', To => 'you@yourhost.com', Cc => 'some@other.com, some@more.com', Subject => 'Helloooooo, nurse!', Data => "How's it goin', eh?" ); # this test requires output in a particular order, so specify it $msg->field_order(qw( Content-Transfer-Encoding Content-Type MIME-Version From To Cc Subject )); $msg->attach( Type => 'AUTO', Path => "./testin/test.html", ReadNow => 1, Filename => "test.html", ); (my $ret=$msg->stringify)=~s/^Date:.*\n//m; my $expect=<<'EOFEXPECT'; Content-Transfer-Encoding: 7bit Content-Type: multipart/mixed; boundary="_----------=_0" MIME-Version: 1.0 From: me@myhost.com To: you@yourhost.com Cc: some@other.com, some@more.com Subject: Helloooooo, nurse! This is a multi-part message in MIME format. --_----------=_0 Content-Disposition: inline Content-Transfer-Encoding: 8bit Content-Type: text/plain How's it goin', eh? --_----------=_0 Content-Disposition: inline; filename="test.html" Content-Transfer-Encoding: 8bit Content-Type: text/html; name="test.html" This isn't really html. We are only checking the filename silly. --_----------=_0-- EOFEXPECT is($ret, $expect, "we got the message we expected"); MIME-Lite-3.030/t/Utils.pm000644 000766 000766 00000000606 11111624774 014145 0ustar00rjbs000000 000000 package Utils; @ISA = qw(Exporter); @EXPORT = qw(slurp spew cmp); sub slurp { my $path = shift; open IN, "<$path"; my $data = join('',); close IN; $data; } sub spew { my ($path, $data) = @_; open OUT, ">$path"; print OUT $data; close OUT; } sub cmp { my ($a, $b) = @_; $a =~ s/\r//g; $b =~ s/\r//g; return ($a eq $b); } 1; MIME-Lite-3.030/t/verify.t000644 000766 000766 00000001071 11111624774 014175 0ustar00rjbs000000 000000 #!/usr/bin/perl use lib "lib", "t"; use MIME::Lite; use Test::More tests => 2; use Utils; $MIME::Lite::VANILLA = 1; $MIME::Lite::PARANOID = 1; my $msg; $msg = MIME::Lite->new(From => "me", To => "you"); $msg->attach(Path => "boguscmd |"); $msg->attach(Data => "Hello"); $msg->attach(Path => "verify_data }; like($@, qr/path\.to\.missing\.file/, "we detected a missing file"); $msg = MIME::Lite->new(From=>"me", To=>"you"); $msg->attach(Data => "Hello"); eval { $msg->verify_data }; ok(!$@, "we detected NO missing file"); MIME-Lite-3.030/t/ExtUtils/TBone.pm000644 000766 000766 00000031606 11545235252 015641 0ustar00rjbs000000 000000 package ExtUtils::TBone; =head1 NAME ExtUtils::TBone - a "skeleton" for writing "t/*.t" test files. =head1 SYNOPSIS Include a copy of this module in your t directory (as t/ExtUtils/TBone.pm), and then write your t/*.t files like this: use lib "./t"; # to pick up a ExtUtils::TBone use ExtUtils::TBone; # Make a tester... here are 3 different alternatives: my $T = typical ExtUtils::TBone; # standard log my $T = new ExtUtils::TBone; # no log my $T = new ExtUtils::TBone "testout/Foo.tlog"; # explicit log # Begin testing, and expect 3 tests in all: $T->begin(3); # expect 3 tests $T->msg("Something for the log file"); # message for the log # Run some tests: $T->ok($this); # test 1: no real info logged $T->ok($that, # test 2: logs a comment "Is that ok, or isn't it?"); $T->ok(($this eq $that), # test 3: logs comment + vars "Do they match?", This => $this, That => $that); # That last one could have also been written... $T->ok_eq($this, $that); # does 'eq' and logs operands $T->ok_eqnum($this, $that); # does '==' and logs operands # End testing: $T->end; =head1 DESCRIPTION This module is intended for folks who release CPAN modules with "t/*.t" tests. It makes it easy for you to output syntactically correct test-output while at the same time logging all test activity to a log file. Hopefully, bug reports which include the contents of this file will be easier for you to investigate. =head1 OUTPUT =head2 Standard output Pretty much as described by C, with a special "# END" comment placed at the very end: 1..3 ok 1 not ok 2 ok 3 # END =head1 Log file A typical log file output by this module looks like this: 1..3 ** A message logged with msg(). ** Another one. 1: My first test, using test(): how'd I do? 1: ok 1 ** Yet another message. 2: My second test, using test_eq()... 2: A: The first string 2: B: The second string 2: not ok 2 3: My third test. 3: ok 3 # END Each test() is logged with the test name and results, and the test-number prefixes each line. This allows you to scan a large file easily with "grep" (or, ahem, "perl"). A blank line follows each test's record, for clarity. =head1 PUBLIC INTERFACE =cut # Globals: use strict; use vars qw($VERSION); use FileHandle; use File::Basename; # The package version, both in 1.23 style *and* usable by MakeMaker: $VERSION = substr q$Revision: 1.124 $, 10; #------------------------------ =head2 Construction =over 4 =cut #------------------------------ =item new [ARGS...] I Create a new tester. Any arguments are sent to log_open(). =cut sub new { my $self = bless { OUT =>\*STDOUT, Begin=>0, End =>0, Count=>0, }, shift; $self->log_open(@_) if @_; $self; } #------------------------------ =item typical I Create a typical tester. Use this instead of new() for most applicaitons. The directory "testout" is created for you automatically, to hold the output log file, and log_warnings() is invoked. =cut sub typical { my $class = shift; my ($tfile) = basename $0; unless (-d "testout") { mkdir "testout", 0755 or die "Couldn't create a 'testout' subdirectory: $!\n"; ### warn "$class: created 'testout' directory\n"; } my $self = $class->new($class->catfile('.', 'testout', "${tfile}log")); $self->log_warnings; $self; } #------------------------------ # DESTROY #------------------------------ # Class method, destructor. # Automatically closes the log. # sub DESTROY { $_[0]->log_close; } #------------------------------ =back =head2 Doing tests =over 4 =cut #------------------------------ =item begin NUMTESTS I Start testing. This outputs the 1..NUMTESTS line to the standard output. =cut sub begin { my ($self, $n) = @_; return if $self->{Begin}++; $self->l_print("1..$n\n\n"); print {$self->{OUT}} "1..$n\n"; } #------------------------------ =item end I Indicate the end of testing. This outputs a "# END" line to the standard output. =cut sub end { my ($self) = @_; return if $self->{End}++; $self->l_print("# END\n"); print {$self->{OUT}} "# END\n"; } #------------------------------ =item ok BOOL, [TESTNAME], [PARAMHASH...] I Do a test, and log some information connected with it. This outputs the test result lines to the standard output: ok 12 not ok 13 Use it like this: $T->ok(-e $dotforward); Or better yet, like this: $T->ok((-e $dotforward), "Does the user have a .forward file?"); Or even better, like this: $T->ok((-e $dotforward), "Does the user have a .forward file?", User => $ENV{USER}, Path => $dotforward, Fwd => $ENV{FWD}); That last one, if it were test #3, would be logged as: 3: Does the user have a .forward file? 3: User: "alice" 3: Path: "/home/alice/.forward" 3: Fwd: undef 3: ok You get the idea. Note that defined quantities are logged with delimiters and with all nongraphical characters suitably escaped, so you can see evidence of unexpected whitespace and other badnasties. Had "Fwd" been the string "this\nand\nthat", you'd have seen: 3: Fwd: "this\nand\nthat" And unblessed array refs like ["this", "and", "that"] are treated as multiple values: 3: Fwd: "this" 3: Fwd: "and" 3: Fwd: "that" =cut sub ok { my ($self, $ok, $test, @ps) = @_; ++($self->{Count}); # next test # Report to harness: my $status = ($ok ? "ok " : "not ok ") . $self->{Count}; print {$self->{OUT}} $status, "\n"; # Log: $self->ln_print($test, "\n") if $test; while (@ps) { my ($k, $v) = (shift @ps, shift @ps); my @vs = ((ref($v) and (ref($v) eq 'ARRAY'))? @$v : ($v)); foreach (@vs) { if (!defined($_)) { # value not defined: output keyword $self->ln_print(qq{ $k: undef\n}); } else { # value defined: output quoted, encoded form s{([\n\t\x00-\x1F\x7F-\xFF\\\"])} {'\\'.sprintf("%02X",ord($1)) }exg; s{\\0A}{\\n}g; $self->ln_print(qq{ $k: "$_"\n}); } } } $self->ln_print($status, "\n"); $self->l_print("\n"); 1; } #------------------------------ =item ok_eq ASTRING, BSTRING, [TESTNAME], [PARAMHASH...] I Convenience front end to ok(): test whether C, and logs the operands as 'A' and 'B'. =cut sub ok_eq { my ($self, $this, $that, $test, @ps) = @_; $self->ok(($this eq $that), ($test || "(Is 'A' string-equal to 'B'?)"), A => $this, B => $that, @ps); } #------------------------------ =item ok_eqnum ANUM, BNUM, [TESTNAME], [PARAMHASH...] I Convenience front end to ok(): test whether C, and logs the operands as 'A' and 'B'. =cut sub ok_eqnum { my ($self, $this, $that, $test, @ps) = @_; $self->ok(($this == $that), ($test || "(Is 'A' numerically-equal to 'B'?)"), A => $this, B => $that, @ps); } #------------------------------ =back =head2 Logging messages =over 4 =cut #------------------------------ =item log_open PATH I Open a log file for messages to be output to. This is invoked for you automatically by C and C. =cut sub log_open { my ($self, $path) = @_; $self->{LogPath} = $path; $self->{LOG} = FileHandle->new(">$path") || die "open $path: $!"; $self; } #------------------------------ =item log_close I Close the log file and stop logging. You shouldn't need to invoke this directly; the destructor does it. =cut sub log_close { my $self = shift; close(delete $self->{LOG}) if $self->{LOG}; } #------------------------------ =item log_warnings I Invoking this redefines $SIG{__WARN__} to log to STDERR and to the tester's log. This is automatically invoked when using the C constructor. =cut sub log_warnings { my ($self) = @_; $SIG{__WARN__} = sub { print STDERR $_[0]; $self->log("warning: ", $_[0]); }; } #------------------------------ =item log MESSAGE... I Log a message to the log file. No alterations are made on the text of the message. See msg() for an alternative. =cut sub log { my $self = shift; print {$self->{LOG}} @_ if $self->{LOG}; } #------------------------------ =item msg MESSAGE... I Log a message to the log file. Lines are prefixed with "** " for clarity, and a terminating newline is forced. =cut sub msg { my $self = shift; my $text = join '', @_; chomp $text; $text =~ s{^}{** }gm; $self->l_print($text, "\n"); } #------------------------------ # # l_print MESSAGE... # # Instance method, private. # Print to the log file if there is one. # sub l_print { my $self = shift; print { $self->{LOG} } @_ if $self->{LOG}; } #------------------------------ # # ln_print MESSAGE... # # Instance method, private. # Print to the log file, prefixed by message number. # sub ln_print { my $self = shift; foreach (split /\n/, join('', @_)) { $self->l_print("$self->{Count}: $_\n"); } } #------------------------------ =back =head2 Utilities =over 4 =cut #------------------------------ =item catdir DIR, ..., DIR I Concatenate several directories into a path ending in a directory. Lightweight version of the one in C; this method dates back to a more-innocent time when File::Spec was younger and less ubiquitous. Paths are assumed to be absolute. To signify a relative path, the first DIR must be ".", which is processed specially. On Mac, the path I end in a ':'. On Unix, the path I end in a '/'. =cut sub catdir { my $self = shift; my $relative = shift @_ if ($_[0] eq '.'); if ($^O eq 'Mac') { return ($relative ? ':' : '') . (join ':', @_) . ':'; } else { return ($relative ? './' : '/') . join '/', @_; } } #------------------------------ =item catfile DIR, ..., DIR, FILE I Like catdir(), but last element is assumed to be a file. Note that, at a minimum, you must supply at least a single DIR. =cut sub catfile { my $self = shift; my $file = pop; if ($^O eq 'Mac') { return $self->catdir(@_) . $file; } else { return $self->catdir(@_) . "/$file"; } } #------------------------------ =back =head1 VERSION $Id: TBone.pm,v 1.124 2001/08/20 20:30:07 eryq Exp $ =head1 CHANGE LOG =over 4 =item Version 1.124 (2001/08/20) The terms-of-use have been placed in the distribution file "COPYING". Also, small documentation tweaks were made. =item Version 1.122 (2001/08/20) Changed output of C<"END"> to C<"# END">; apparently, "END" is not a directive. Maybe it never was. I The storyteller need not say "the end" aloud; Silence is enough. Automatically invoke C when constructing via C. =item Version 1.120 (2001/08/17) Added log_warnings() to support the logging of SIG{__WARN__} messages to the log file (if any). =item Version 1.116 (2000/03/23) Cosmetic improvements only. =item Version 1.112 (1999/05/12) Added lightweight catdir() and catfile() (a la File::Spec) to enhance portability to Mac environment. =item Version 1.111 (1999/04/18) Now uses File::Basename to create "typical" logfile name, for portability. =item Version 1.110 (1999/04/17) Fixed bug in constructor that surfaced if no log was being used. =back Created: Friday-the-13th of February, 1998. =head1 AUTHOR Eryq (F). President, ZeeGee Software Inc. (F). Go to F for the latest downloads and on-line documentation for this module. Enjoy. Yell if it breaks. =cut #------------------------------ 1; __END__ my $T = new ExtUtils::TBone "testout/foo.tlog"; $T->begin(3); $T->msg("before 1\nor 2"); $T->ok(1, "one"); $T->ok(2, "Two"); $T->ok(3, "Three", Roman=>'III', Arabic=>[3, '03'], Misc=>"3\nor 3"); $T->end; 1; MIME-Lite-3.030/lib/MIME/000755 000766 000766 00000000000 12235601705 013534 5ustar00rjbs000000 000000 MIME-Lite-3.030/lib/MIME/Lite.pm000644 000766 000766 00000315235 12235601403 014773 0ustar00rjbs000000 000000 package MIME::Lite; use strict; require 5.004; ### for /c modifier in m/\G.../gc modifier =head1 NAME MIME::Lite - low-calorie MIME generator =head1 WAIT! MIME::Lite is not recommended by its current maintainer. There are a number of alternatives, like Email::MIME or MIME::Entity and Email::Sender, which you should probably use instead. MIME::Lite continues to accrue weird bug reports, and it is not receiving a large amount of refactoring due to the availability of better alternatives. Please consider using something else. =head1 SYNOPSIS Create and send using the default send method for your OS a single-part message: use MIME::Lite; ### Create a new single-part message, to send a GIF file: $msg = MIME::Lite->new( From => 'me@myhost.com', To => 'you@yourhost.com', Cc => 'some@other.com, some@more.com', Subject => 'Helloooooo, nurse!', Type => 'image/gif', Encoding => 'base64', Path => 'hellonurse.gif' ); $msg->send; # send via default Create a multipart message (i.e., one with attachments) and send it SMTP ### Create a new multipart message: $msg = MIME::Lite->new( From => 'me@myhost.com', To => 'you@yourhost.com', Cc => 'some@other.com, some@more.com', Subject => 'A message with 2 parts...', Type => 'multipart/mixed' ); ### Add parts (each "attach" has same arguments as "new"): $msg->attach( Type => 'TEXT', Data => "Here's the GIF file you wanted" ); $msg->attach( Type => 'image/gif', Path => 'aaa000123.gif', Filename => 'logo.gif', Disposition => 'attachment' ); ### use Net:SMTP to do the sending $msg->send('smtp','some.host', Debug=>1 ); Output a message: ### Format as a string: $str = $msg->as_string; ### Print to a filehandle (say, a "sendmail" stream): $msg->print(\*SENDMAIL); Send a message: ### Send in the "best" way (the default is to use "sendmail"): $msg->send; ### Send a specific way: $msg->send('type',@args); Specify default send method: MIME::Lite->send('smtp','some.host',Debug=>0); with authentication MIME::Lite->send('smtp','some.host', AuthUser=>$user, AuthPass=>$pass); =head1 DESCRIPTION In the never-ending quest for great taste with fewer calories, we proudly present: I. MIME::Lite is intended as a simple, standalone module for generating (not parsing!) MIME messages... specifically, it allows you to output a simple, decent single- or multi-part message with text or binary attachments. It does not require that you have the Mail:: or MIME:: modules installed, but will work with them if they are. You can specify each message part as either the literal data itself (in a scalar or array), or as a string which can be given to open() to get a readable filehandle (e.g., "new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'Helloooooo, nurse!', Data =>"How's it goin', eh?" ); =head2 Create a simple message containing just an image $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'Helloooooo, nurse!', Type =>'image/gif', Encoding =>'base64', Path =>'hellonurse.gif' ); =head2 Create a multipart message ### Create the multipart "container": $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'A message with 2 parts...', Type =>'multipart/mixed' ); ### Add the text message part: ### (Note that "attach" has same arguments as "new"): $msg->attach( Type =>'TEXT', Data =>"Here's the GIF file you wanted" ); ### Add the image part: $msg->attach( Type =>'image/gif', Path =>'aaa000123.gif', Filename =>'logo.gif', Disposition => 'attachment' ); =head2 Attach a GIF to a text message This will create a multipart message exactly as above, but using the "attach to singlepart" hack: ### Start with a simple text message: $msg = MIME::Lite->new( From =>'me@myhost.com', To =>'you@yourhost.com', Cc =>'some@other.com, some@more.com', Subject =>'A message with 2 parts...', Type =>'TEXT', Data =>"Here's the GIF file you wanted" ); ### Attach a part... the make the message a multipart automatically: $msg->attach( Type =>'image/gif', Path =>'aaa000123.gif', Filename =>'logo.gif' ); =head2 Attach a pre-prepared part to a message ### Create a standalone part: $part = MIME::Lite->new( Top => 0, Type =>'text/html', Data =>'

Hello

', ); $part->attr('content-type.charset' => 'UTF-8'); $part->add('X-Comment' => 'A message for you'); ### Attach it to any message: $msg->attach($part); =head2 Print a message to a filehandle ### Write it to a filehandle: $msg->print(\*STDOUT); ### Write just the header: $msg->print_header(\*STDOUT); ### Write just the encoded body: $msg->print_body(\*STDOUT); =head2 Print a message into a string ### Get entire message as a string: $str = $msg->as_string; ### Get just the header: $str = $msg->header_as_string; ### Get just the encoded body: $str = $msg->body_as_string; =head2 Send a message ### Send in the "best" way (the default is to use "sendmail"): $msg->send; =head2 Send an HTML document... with images included! $msg = MIME::Lite->new( To =>'you@yourhost.com', Subject =>'HTML with in-line images!', Type =>'multipart/related' ); $msg->attach( Type => 'text/html', Data => qq{ Here's my image: }, ); $msg->attach( Type => 'image/gif', Id => 'myimage.gif', Path => '/path/to/somefile.gif', ); $msg->send(); =head2 Change how messages are sent ### Do something like this in your 'main': if ($I_DONT_HAVE_SENDMAIL) { MIME::Lite->send('smtp', $host, Timeout=>60, AuthUser=>$user, AuthPass=>$pass); } ### Now this will do the right thing: $msg->send; ### will now use Net::SMTP as shown above =head1 PUBLIC INTERFACE =head2 Global configuration To alter the way the entire module behaves, you have the following methods/options: =over 4 =item MIME::Lite->field_order() When used as a L, this changes the default order in which headers are output for I messages. However, please consider using the instance method variant instead, so you won't stomp on other message senders in the same application. =item MIME::Lite->quiet() This L can be used to suppress/unsuppress all warnings coming from this module. =item MIME::Lite->send() When used as a L, this can be used to specify a different default mechanism for sending message. The initial default is: MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem"); However, you should consider the similar but smarter and taint-safe variant: MIME::Lite->send("sendmail"); Or, for non-Unix users: MIME::Lite->send("smtp"); =item $MIME::Lite::AUTO_CC If true, automatically send to the Cc/Bcc addresses for send_by_smtp(). Default is B. =item $MIME::Lite::AUTO_CONTENT_TYPE If true, try to automatically choose the content type from the file name in C/C. In other words, setting this true changes the default C from C<"TEXT"> to C<"AUTO">. Default is B, since we must maintain backwards-compatibility with prior behavior. B consider keeping it false, and just using Type 'AUTO' when you build() or attach(). =item $MIME::Lite::AUTO_ENCODE If true, automatically choose the encoding from the content type. Default is B. =item $MIME::Lite::AUTO_VERIFY If true, check paths to attachments right before printing, raising an exception if any path is unreadable. Default is B. =item $MIME::Lite::PARANOID If true, we won't attempt to use MIME::Base64, MIME::QuotedPrint, or MIME::Types, even if they're available. Default is B. Please consider keeping it false, and trusting these other packages to do the right thing. =back =cut use Carp (); use FileHandle; use vars qw( $AUTO_CC $AUTO_CONTENT_TYPE $AUTO_ENCODE $AUTO_VERIFY $PARANOID $QUIET $VANILLA $VERSION $DEBUG ); # GLOBALS, EXTERNAL/CONFIGURATION... $VERSION = '3.030'; ### Automatically interpret CC/BCC for SMTP: $AUTO_CC = 1; ### Automatically choose content type from file name: $AUTO_CONTENT_TYPE = 0; ### Automatically choose encoding from content type: $AUTO_ENCODE = 1; ### Check paths right before printing: $AUTO_VERIFY = 1; ### Set this true if you don't want to use MIME::Base64/QuotedPrint/Types: $PARANOID = 0; ### Don't warn me about dangerous activities: $QUIET = undef; ### Unsupported (for tester use): don't qualify boundary with time/pid: $VANILLA = 0; $MIME::Lite::DEBUG = 0; #============================== #============================== # # GLOBALS, INTERNAL... my $Sender = ""; my $SENDMAIL = ""; if ( $^O =~ /win32|cygwin/i ) { $Sender = "smtp"; } else { ### Find sendmail: $Sender = "sendmail"; $SENDMAIL = "/usr/lib/sendmail"; ( -x $SENDMAIL ) or ( $SENDMAIL = "/usr/sbin/sendmail" ); ( -x $SENDMAIL ) or ( $SENDMAIL = "sendmail" ); unless (-x $SENDMAIL) { require File::Spec; for my $dir (File::Spec->path) { if ( -x "$dir/sendmail" ) { $SENDMAIL = "$dir/sendmail"; last; } } } unless (-x $SENDMAIL) { undef $SENDMAIL; } } ### Our sending facilities: my %SenderArgs = ( sendmail => [], smtp => [], sub => [], ); ### Boundary counter: my $BCount = 0; ### Known Mail/MIME fields... these, plus some general forms like ### "x-*", are recognized by build(): my %KnownField = map { $_ => 1 } qw( bcc cc comments date encrypted from keywords message-id mime-version organization received references reply-to return-path sender subject to approved ); ### What external packages do we use for encoding? my @Uses; ### Header order: my @FieldOrder; ### See if we have File::Basename my $HaveFileBasename = 0; if ( eval "require File::Basename" ) { # not affected by $PARANOID, core Perl $HaveFileBasename = 1; push @Uses, "F$File::Basename::VERSION"; } ### See if we have/want MIME::Types my $HaveMimeTypes = 0; if ( !$PARANOID and eval "require MIME::Types; MIME::Types->VERSION(1.28);" ) { $HaveMimeTypes = 1; push @Uses, "T$MIME::Types::VERSION"; } #============================== #============================== # # PRIVATE UTILITY FUNCTIONS... #------------------------------ # # fold STRING # # Make STRING safe as a field value. Remove leading/trailing whitespace, # and make sure newlines are represented as newline+space sub fold { my $str = shift; $str =~ s/^\s*|\s*$//g; ### trim $str =~ s/\n/\n /g; $str; } #------------------------------ # # gen_boundary # # Generate a new boundary to use. # The unsupported $VANILLA is for test purposes only. sub gen_boundary { return ( "_----------=_" . ( $VANILLA ? '' : int(time) . $$ ) . $BCount++ ); } #------------------------------ # # is_mime_field FIELDNAME # # Is this a field I manage? sub is_mime_field { $_[0] =~ /^(mime\-|content\-)/i; } #------------------------------ # # extract_full_addrs STRING # extract_only_addrs STRING # # Split STRING into an array of email addresses: somewhat of a KLUDGE. # # Unless paranoid, we try to load the real code before supplying our own. BEGIN { my $ATOM = '[^ \000-\037()<>@,;:\134"\056\133\135]+'; my $QSTR = '".*?"'; my $WORD = '(?:' . $QSTR . '|' . $ATOM . ')'; my $DOMAIN = '(?:' . $ATOM . '(?:' . '\\.' . $ATOM . ')*' . ')'; my $LOCALPART = '(?:' . $WORD . '(?:' . '\\.' . $WORD . ')*' . ')'; my $ADDR = '(?:' . $LOCALPART . '@' . $DOMAIN . ')'; my $PHRASE = '(?:' . $WORD . ')+'; my $SEP = "(?:^\\s*|\\s*,\\s*)"; ### before elems in a list sub my_extract_full_addrs { my $str = shift; return unless $str; my @addrs; $str =~ s/\s/ /g; ### collapse whitespace pos($str) = 0; while ( $str !~ m{\G\s*\Z}gco ) { ### print STDERR "TACKLING: ".substr($str, pos($str))."\n"; if ( $str =~ m{\G$SEP($PHRASE)\s*<\s*($ADDR)\s*>}gco ) { push @addrs, "$1 <$2>"; } elsif ( $str =~ m{\G$SEP($ADDR)}gco or $str =~ m{\G$SEP($ATOM)}gco ) { push @addrs, $1; } else { my $problem = substr( $str, pos($str) ); die "can't extract address at <$problem> in <$str>\n"; } } return wantarray ? @addrs : $addrs[0]; } sub my_extract_only_addrs { my @ret = map { /<([^>]+)>/ ? $1 : $_ } my_extract_full_addrs(@_); return wantarray ? @ret : $ret[0]; } } #------------------------------ if ( !$PARANOID and eval "require Mail::Address" ) { push @Uses, "A$Mail::Address::VERSION"; eval q{ sub extract_full_addrs { my @ret=map { $_->format } Mail::Address->parse($_[0]); return wantarray ? @ret : $ret[0] } sub extract_only_addrs { my @ret=map { $_->address } Mail::Address->parse($_[0]); return wantarray ? @ret : $ret[0] } }; ### q } else { eval q{ *extract_full_addrs=*my_extract_full_addrs; *extract_only_addrs=*my_extract_only_addrs; }; ### q } ### if #============================== #============================== # # PRIVATE ENCODING FUNCTIONS... #------------------------------ # # encode_base64 STRING # # Encode the given string using BASE64. # Unless paranoid, we try to load the real code before supplying our own. if ( !$PARANOID and eval "require MIME::Base64" ) { import MIME::Base64 qw(encode_base64); push @Uses, "B$MIME::Base64::VERSION"; } else { eval q{ sub encode_base64 { my $res = ""; my $eol = "\n"; pos($_[0]) = 0; ### thanks, Andreas! while ($_[0] =~ /(.{1,45})/gs) { $res .= substr(pack('u', $1), 1); chop($res); } $res =~ tr|` -_|AA-Za-z0-9+/|; ### Fix padding at the end: my $padding = (3 - length($_[0]) % 3) % 3; $res =~ s/.{$padding}$/'=' x $padding/e if $padding; ### Break encoded string into lines of no more than 76 characters each: $res =~ s/(.{1,76})/$1$eol/g if (length $eol); return $res; } ### sub } ### q } ### if #------------------------------ # # encode_qp STRING # # Encode the given string, LINE BY LINE, using QUOTED-PRINTABLE. # Stolen from MIME::QuotedPrint by Gisle Aas, with a slight bug fix: we # break lines earlier. Notice that this seems not to work unless # encoding line by line. # # Unless paranoid, we try to load the real code before supplying our own. if ( !$PARANOID and eval "require MIME::QuotedPrint" ) { import MIME::QuotedPrint qw(encode_qp); push @Uses, "Q$MIME::QuotedPrint::VERSION"; } else { eval q{ sub encode_qp { my $res = shift; local($_); $res =~ s/([^ \t\n!-<>-~])/sprintf("=%02X", ord($1))/eg; ### rule #2,#3 $res =~ s/([ \t]+)$/ join('', map { sprintf("=%02X", ord($_)) } split('', $1) )/egm; ### rule #3 (encode whitespace at eol) ### rule #5 (lines shorter than 76 chars, but can't break =XX escapes: my $brokenlines = ""; $brokenlines .= "$1=\n" while $res =~ s/^(.{70}([^=]{2})?)//; ### 70 was 74 $brokenlines =~ s/=\n$// unless length $res; "$brokenlines$res"; } ### sub } ### q } ### if #------------------------------ # # encode_8bit STRING # # Encode the given string using 8BIT. # This breaks long lines into shorter ones. sub encode_8bit { my $str = shift; $str =~ s/^(.{990})/$1\n/mg; $str; } #------------------------------ # # encode_7bit STRING # # Encode the given string using 7BIT. # This NO LONGER protects people through encoding. sub encode_7bit { my $str = shift; $str =~ s/[\x80-\xFF]//g; $str =~ s/^(.{990})/$1\n/mg; $str; } #============================== #============================== =head2 Construction =over 4 =cut #------------------------------ =item new [PARAMHASH] I Create a new message object. If any arguments are given, they are passed into C; otherwise, just the empty object is created. =cut sub new { my $class = shift; ### Create basic object: my $self = { Attrs => {}, ### MIME attributes SubAttrs => {}, ### MIME sub-attributes Header => [], ### explicit message headers Parts => [], ### array of parts }; bless $self, $class; ### Build, if needed: return ( @_ ? $self->build(@_) : $self ); } #------------------------------ =item attach PART =item attach PARAMHASH... I Add a new part to this message, and return the new part. If you supply a single PART argument, it will be regarded as a MIME::Lite object to be attached. Otherwise, this method assumes that you are giving in the pairs of a PARAMHASH which will be sent into C to create the new part. One of the possibly-quite-useful hacks thrown into this is the "attach-to-singlepart" hack: if you attempt to attach a part (let's call it "part 1") to a message that doesn't have a content-type of "multipart" or "message", the following happens: =over 4 =item * A new part (call it "part 0") is made. =item * The MIME attributes and data (but I the other headers) are cut from the "self" message, and pasted into "part 0". =item * The "self" is turned into a "multipart/mixed" message. =item * The new "part 0" is added to the "self", and I "part 1" is added. =back One of the nice side-effects is that you can create a text message and then add zero or more attachments to it, much in the same way that a user agent like Netscape allows you to do. =cut sub attach { my $self = shift; my $attrs = $self->{Attrs}; my $sub_attrs = $self->{SubAttrs}; ### Create new part, if necessary: my $part1 = ( ( @_ == 1 ) ? shift: ref($self)->new( Top => 0, @_ ) ); ### Do the "attach-to-singlepart" hack: if ( $attrs->{'content-type'} !~ m{^(multipart|message)/}i ) { ### Create part zero: my $part0 = ref($self)->new; ### Cut MIME stuff from self, and paste into part zero: foreach (qw(SubAttrs Attrs Data Path FH)) { $part0->{$_} = $self->{$_}; delete( $self->{$_} ); } $part0->top_level(0); ### clear top-level attributes ### Make self a top-level multipart: $attrs = $self->{Attrs} ||= {}; ### reset (sam: bug? this doesn't reset anything since Attrs is already a hash-ref) $sub_attrs = $self->{SubAttrs} ||= {}; ### reset $attrs->{'content-type'} = 'multipart/mixed'; $sub_attrs->{'content-type'}{'boundary'} = gen_boundary(); $attrs->{'content-transfer-encoding'} = '7bit'; $self->top_level(1); ### activate top-level attributes ### Add part 0: push @{ $self->{Parts} }, $part0; } ### Add the new part: push @{ $self->{Parts} }, $part1; $part1; } #------------------------------ =item build [PARAMHASH] I Create (or initialize) a MIME message object. Normally, you'll use the following keys in PARAMHASH: * Data, FH, or Path (either one of these, or none if multipart) * Type (e.g., "image/jpeg") * From, To, and Subject (if this is the "top level" of a message) The PARAMHASH can contain the following keys: =over 4 =item (fieldname) Any field you want placed in the message header, taken from the standard list of header fields (you don't need to worry about case): Approved Encrypted Received Sender Bcc From References Subject Cc Keywords Reply-To To Comments Message-ID Resent-* X-* Content-* MIME-Version Return-Path Date Organization To give experienced users some veto power, these fields will be set I the ones I set... so be careful: I (like C) unless you know what you're doing! To specify a fieldname that's I in the above list, even one that's identical to an option below, just give it with a trailing C<":">, like C<"My-field:">. When in doubt, that I signals a mail field (and it sort of looks like one too). =item Data I The actual message data. This may be a scalar or a ref to an array of strings; if the latter, the message consists of a simple concatenation of all the strings in the array. =item Datestamp I If given true (or omitted), we force the creation of a C field stamped with the current date/time if this is a top-level message. You may want this if using L. If you don't want this to be done, either provide your own Date or explicitly set this to false. =item Disposition I The content disposition, C<"inline"> or C<"attachment">. The default is C<"inline">. =item Encoding I The content transfer encoding that should be used to encode your data: Use encoding: | If your message contains: ------------------------------------------------------------ 7bit | Only 7-bit text, all lines <1000 characters 8bit | 8-bit text, all lines <1000 characters quoted-printable | 8-bit text or long lines (more reliable than "8bit") base64 | Largely non-textual data: a GIF, a tar file, etc. The default is taken from the Type; generally it is "binary" (no encoding) for text/*, message/*, and multipart/*, and "base64" for everything else. A value of C<"binary"> is generally I suitable for sending anything but ASCII text files with lines under 1000 characters, so consider using one of the other values instead. In the case of "7bit"/"8bit", long lines are automatically chopped to legal length; in the case of "7bit", all 8-bit characters are automatically I. This may not be what you want, so pick your encoding well! For more info, see L<"A MIME PRIMER">. =item FH I Filehandle containing the data, opened for reading. See "ReadNow" also. =item Filename I The name of the attachment. You can use this to supply a recommended filename for the end-user who is saving the attachment to disk. You only need this if the filename at the end of the "Path" is inadequate, or if you're using "Data" instead of "Path". You should I put path information in here (e.g., no "/" or "\" or ":" characters should be used). =item Id I Same as setting "content-id". =item Length I Set the content length explicitly. Normally, this header is automatically computed, but only under certain circumstances (see L<"Benign limitations">). =item Path I Path to a file containing the data... actually, it can be any open()able expression. If it looks like a path, the last element will automatically be treated as the filename. See "ReadNow" also. =item ReadNow I If true, will open the path and slurp the contents into core now. This is useful if the Path points to a command and you don't want to run the command over and over if outputting the message several times. B raised if the open fails. =item Top I If defined, indicates whether or not this is a "top-level" MIME message. The parts of a multipart message are I top-level. Default is true. =item Type I The MIME content type, or one of these special values (case-sensitive): "TEXT" means "text/plain" "BINARY" means "application/octet-stream" "AUTO" means attempt to guess from the filename, falling back to 'application/octet-stream'. This is good if you have MIME::Types on your system and you have no idea what file might be used for the attachment. The default is C<"TEXT">, but it will be C<"AUTO"> if you set $AUTO_CONTENT_TYPE to true (sorry, but you have to enable it explicitly, since we don't want to break code which depends on the old behavior). =back A picture being worth 1000 words (which is of course 2000 bytes, so it's probably more of an "icon" than a "picture", but I digress...), here are some examples: $msg = MIME::Lite->build( From => 'yelling@inter.com', To => 'stocking@fish.net', Subject => "Hi there!", Type => 'TEXT', Encoding => '7bit', Data => "Just a quick note to say hi!" ); $msg = MIME::Lite->build( From => 'dorothy@emerald-city.oz', To => 'gesundheit@edu.edu.edu', Subject => "A gif for U" Type => 'image/gif', Path => "/home/httpd/logo.gif" ); $msg = MIME::Lite->build( From => 'laughing@all.of.us', To => 'scarlett@fiddle.dee.de', Subject => "A gzipp'ed tar file", Type => 'x-gzip', Path => "gzip < /usr/inc/somefile.tar |", ReadNow => 1, Filename => "somefile.tgz" ); To show you what's really going on, that last example could also have been written: $msg = new MIME::Lite; $msg->build( Type => 'x-gzip', Path => "gzip < /usr/inc/somefile.tar |", ReadNow => 1, Filename => "somefile.tgz" ); $msg->add(From => "laughing@all.of.us"); $msg->add(To => "scarlett@fiddle.dee.de"); $msg->add(Subject => "A gzipp'ed tar file"); =cut sub build { my $self = shift; my %params = @_; my @params = @_; my $key; ### Miko's note: reorganized to check for exactly one of Data, Path, or FH ( defined( $params{Data} ) + defined( $params{Path} ) + defined( $params{FH} ) <= 1 ) or Carp::croak "supply exactly zero or one of (Data|Path|FH).\n"; ### Create new instance, if necessary: ref($self) or $self = $self->new; ### CONTENT-TYPE.... ### ### Get content-type or content-type-macro: my $type = ( $params{Type} || ( $AUTO_CONTENT_TYPE ? 'AUTO' : 'TEXT' ) ); ### Interpret content-type-macros: if ( $type eq 'TEXT' ) { $type = 'text/plain'; } elsif ( $type eq 'HTML' ) { $type = 'text/html'; } elsif ( $type eq 'BINARY' ) { $type = 'application/octet-stream' } elsif ( $type eq 'AUTO' ) { $type = $self->suggest_type( $params{Path} ); } ### We now have a content-type; set it: $type = lc($type); my $attrs = $self->{Attrs}; my $sub_attrs = $self->{SubAttrs}; $attrs->{'content-type'} = $type; ### Get some basic attributes from the content type: my $is_multipart = ( $type =~ m{^(multipart)/}i ); ### Add in the multipart boundary: if ($is_multipart) { my $boundary = gen_boundary(); $sub_attrs->{'content-type'}{'boundary'} = $boundary; } ### CONTENT-ID... ### if ( defined $params{Id} ) { my $id = $params{Id}; $id = "<$id>" unless $id =~ /\A\s*<.*>\s*\z/; $attrs->{'content-id'} = $id; } ### DATA OR PATH... ### Note that we must do this *after* we get the content type, ### in case read_now() is invoked, since it needs the binmode(). ### Get data, as... ### ...either literal data: if ( defined( $params{Data} ) ) { $self->data( $params{Data} ); } ### ...or a path to data: elsif ( defined( $params{Path} ) ) { $self->path( $params{Path} ); ### also sets filename $self->read_now if $params{ReadNow}; } ### ...or a filehandle to data: ### Miko's note: this part works much like the path routine just above, elsif ( defined( $params{FH} ) ) { $self->fh( $params{FH} ); $self->read_now if $params{ReadNow}; ### implement later } ### FILENAME... (added by Ian Smith on 8/4/97) ### Need this to make sure the filename is added. The Filename ### attribute is ignored, otherwise. if ( defined( $params{Filename} ) ) { $self->filename( $params{Filename} ); } ### CONTENT-TRANSFER-ENCODING... ### ### Get it: my $enc = ( $params{Encoding} || ( $AUTO_ENCODE and $self->suggest_encoding($type) ) || 'binary' ); $attrs->{'content-transfer-encoding'} = lc($enc); ### Sanity check: if ( $type =~ m{^(multipart|message)/} ) { ( $enc =~ m{^(7bit|8bit|binary)\Z} ) or Carp::croak( "illegal MIME: " . "can't have encoding $enc with type $type\n" ); } ### CONTENT-DISPOSITION... ### Default is inline for single, none for multis: ### my $disp = ( $params{Disposition} or ( $is_multipart ? undef: 'inline' ) ); $attrs->{'content-disposition'} = $disp; ### CONTENT-LENGTH... ### my $length; if ( exists( $params{Length} ) ) { ### given by caller: $attrs->{'content-length'} = $params{Length}; } else { ### compute it ourselves $self->get_length; } ### Init the top-level fields: my $is_top = defined( $params{Top} ) ? $params{Top} : 1; $self->top_level($is_top); ### Datestamp if desired: my $ds_wanted = $params{Datestamp}; my $ds_defaulted = ( $is_top and !exists( $params{Datestamp} ) ); if ( ( $ds_wanted or $ds_defaulted ) and !exists( $params{Date} ) ) { require Email::Date::Format; $self->add( "date", Email::Date::Format::email_date() ); } ### Set message headers: my @paramz = @params; my $field; while (@paramz) { my ( $tag, $value ) = ( shift(@paramz), shift(@paramz) ); my $lc_tag = lc($tag); ### Get tag, if a tag: if ( $lc_tag =~ /^-(.*)/ ) { ### old style, backwards-compatibility $field = $1; } elsif ( $lc_tag =~ /^(.*):$/ ) { ### new style $field = $1; } elsif ( $KnownField{$lc_tag} or $lc_tag =~ m{^(content|resent|x)-.} ){ $field = $lc_tag; } else { ### not a field: next; } ### Add it: $self->add( $field, $value ); } ### Done! $self; } =back =cut #============================== #============================== =head2 Setting/getting headers and attributes =over 4 =cut #------------------------------ # # top_level ONOFF # # Set/unset the top-level attributes and headers. # This affects "MIME-Version" and "X-Mailer". sub top_level { my ( $self, $onoff ) = @_; my $attrs = $self->{Attrs}; if ($onoff) { $attrs->{'mime-version'} = '1.0'; my $uses = ( @Uses ? ( "(" . join( "; ", @Uses ) . ")" ) : '' ); $self->replace( 'X-Mailer' => "MIME::Lite $VERSION $uses" ) unless $VANILLA; } else { delete $attrs->{'mime-version'}; $self->delete('X-Mailer'); } } #------------------------------ =item add TAG,VALUE I Add field TAG with the given VALUE to the end of the header. The TAG will be converted to all-lowercase, and the VALUE will be made "safe" (returns will be given a trailing space). B any MIME fields you "add" will override any MIME attributes I have when it comes time to output those fields. Normally, you will use this method to add I fields: $msg->add("Subject" => "Hi there!"); Giving VALUE as an arrayref will cause all those values to be added. This is only useful for special multiple-valued fields like "Received": $msg->add("Received" => ["here", "there", "everywhere"] Giving VALUE as the empty string adds an invisible placeholder to the header, which can be used to suppress the output of the "Content-*" fields or the special "MIME-Version" field. When suppressing fields, you should use replace() instead of add(): $msg->replace("Content-disposition" => ""); I add() is probably going to be more efficient than C, so you're better off using it for most applications if you are certain that you don't need to delete() the field first. I the name comes from Mail::Header. =cut sub add { my $self = shift; my $tag = lc(shift); my $value = shift; ### If a dangerous option, warn them: Carp::carp "Explicitly setting a MIME header field ($tag) is dangerous:\n" . "use the attr() method instead.\n" if ( is_mime_field($tag) && !$QUIET ); ### Get array of clean values: my @vals = ( ( ref($value) and ( ref($value) eq 'ARRAY' ) ) ? @{$value} : ( $value . '' ) ); map { s/\n/\n /g } @vals; ### Add them: foreach (@vals) { push @{ $self->{Header} }, [ $tag, $_ ]; } } #------------------------------ =item attr ATTR,[VALUE] I Set MIME attribute ATTR to the string VALUE. ATTR is converted to all-lowercase. This method is normally used to set/get MIME attributes: $msg->attr("content-type" => "text/html"); $msg->attr("content-type.charset" => "US-ASCII"); $msg->attr("content-type.name" => "homepage.html"); This would cause the final output to look something like this: Content-type: text/html; charset=US-ASCII; name="homepage.html" Note that the special empty sub-field tag indicates the anonymous first sub-field. Giving VALUE as undefined will cause the contents of the named subfield to be deleted. Supplying no VALUE argument just returns the attribute's value: $type = $msg->attr("content-type"); ### returns "text/html" $name = $msg->attr("content-type.name"); ### returns "homepage.html" =cut sub attr { my ( $self, $attr, $value ) = @_; my $attrs = $self->{Attrs}; $attr = lc($attr); ### Break attribute name up: my ( $tag, $subtag ) = split /\./, $attr; if (defined($subtag)) { $attrs = $self->{SubAttrs}{$tag} ||= {}; $tag = $subtag; } ### Set or get? if ( @_ > 2 ) { ### set: if ( defined($value) ) { $attrs->{$tag} = $value; } else { delete $attrs->{$tag}; } } ### Return current value: $attrs->{$tag}; } sub _safe_attr { my ( $self, $attr ) = @_; return defined $self->{Attrs}{$attr} ? $self->{Attrs}{$attr} : ''; } #------------------------------ =item delete TAG I Delete field TAG with the given VALUE to the end of the header. The TAG will be converted to all-lowercase. $msg->delete("Subject"); I the name comes from Mail::Header. =cut sub delete { my $self = shift; my $tag = lc(shift); ### Delete from the header: my $hdr = []; my $field; foreach $field ( @{ $self->{Header} } ) { push @$hdr, $field if ( $field->[0] ne $tag ); } $self->{Header} = $hdr; $self; } #------------------------------ =item field_order FIELD,...FIELD I Change the order in which header fields are output for this object: $msg->field_order('from', 'to', 'content-type', 'subject'); When used as a class method, changes the default settings for all objects: MIME::Lite->field_order('from', 'to', 'content-type', 'subject'); Case does not matter: all field names will be coerced to lowercase. In either case, supply the empty array to restore the default ordering. =cut sub field_order { my $self = shift; if ( ref($self) ) { $self->{FieldOrder} = [ map { lc($_) } @_ ]; } else { @FieldOrder = map { lc($_) } @_; } } #------------------------------ =item fields I Return the full header for the object, as a ref to an array of C<[TAG, VALUE]> pairs, where each TAG is all-lowercase. Note that any fields the user has explicitly set will override the corresponding MIME fields that we would otherwise generate. So, don't say... $msg->set("Content-type" => "text/html; charset=US-ASCII"); unless you want the above value to override the "Content-type" MIME field that we would normally generate. I I called this "fields" because the header() method of Mail::Header returns something different, but similar enough to be confusing. You can change the order of the fields: see L. You really shouldn't need to do this, but some people have to deal with broken mailers. =cut sub fields { my $self = shift; my @fields; my $attrs = $self->{Attrs}; my $sub_attrs = $self->{SubAttrs}; ### Get a lookup-hash of all *explicitly-given* fields: my %explicit = map { $_->[0] => 1 } @{ $self->{Header} }; ### Start with any MIME attributes not given explicitly: my $tag; foreach $tag ( sort keys %{ $self->{Attrs} } ) { ### Skip if explicit: next if ( $explicit{$tag} ); # get base attr value or skip if not available my $value = $attrs->{$tag}; defined $value or next; ### handle sub-attrs if available if (my $subs = $sub_attrs->{$tag}) { $value .= '; ' . join('; ', map { qq{$_="$subs->{$_}"} } sort keys %$subs); } # handle stripping \r\n now since we're not doing it in attr() # anymore $value =~ tr/\r\n//; ### Add to running fields; push @fields, [ $tag, $value ]; } ### Add remaining fields (note that we duplicate the array for safety): foreach ( @{ $self->{Header} } ) { push @fields, [ @{$_} ]; } ### Final step: ### If a suggested ordering was given, we "sort" by that ordering. ### The idea is that we give each field a numeric rank, which is ### (1000 * order(field)) + origposition. my @order = @{ $self->{FieldOrder} || [] }; ### object-specific @order or @order = @FieldOrder; ### no? maybe generic if (@order) { ### either? ### Create hash mapping field names to 1-based rank: my %rank = map { $order[$_] => ( 1 + $_ ) } ( 0 .. $#order ); ### Create parallel array to @fields, called @ranked. ### It contains fields tagged with numbers like 2003, where the ### 3 is the original 0-based position, and 2000 indicates that ### we wanted this type of field to go second. my @ranked = map { [ ( $_ + 1000 * ( $rank{ lc( $fields[$_][0] ) } || ( 2 + $#order ) ) ), $fields[$_] ] } ( 0 .. $#fields ); # foreach (@ranked) { # print STDERR "RANKED: $_->[0] $_->[1][0] $_->[1][1]\n"; # } ### That was half the Schwartzian transform. Here's the rest: @fields = map { $_->[1] } sort { $a->[0] <=> $b->[0] } @ranked; } ### Done! return \@fields; } #------------------------------ =item filename [FILENAME] I Set the filename which this data will be reported as. This actually sets both "standard" attributes. With no argument, returns the filename as dictated by the content-disposition. =cut sub filename { my ( $self, $filename ) = @_; my $sub_attrs = $self->{SubAttrs}; if ( @_ > 1 ) { $sub_attrs->{'content-type'}{'name'} = $filename; $sub_attrs->{'content-disposition'}{'filename'} = $filename; } return $sub_attrs->{'content-disposition'}{'filename'}; } #------------------------------ =item get TAG,[INDEX] I Get the contents of field TAG, which might have been set with set() or replace(). Returns the text of the field. $ml->get('Subject', 0); If the optional 0-based INDEX is given, then we return the INDEX'th occurrence of field TAG. Otherwise, we look at the context: In a scalar context, only the first (0th) occurrence of the field is returned; in an array context, I occurrences are returned. I this should only be used with non-MIME fields. Behavior with MIME fields is TBD, and will raise an exception for now. =cut sub get { my ( $self, $tag, $index ) = @_; $tag = lc($tag); Carp::croak "get: can't be used with MIME fields\n" if is_mime_field($tag); my @all = map { ( $_->[0] eq $tag ) ? $_->[1] : () } @{ $self->{Header} }; ( defined($index) ? $all[$index] : ( wantarray ? @all : $all[0] ) ); } #------------------------------ =item get_length I Recompute the content length for the message I, setting the "content-length" attribute as a side-effect: $msg->get_length; Returns the length, or undefined if not set. I the content length can be difficult to compute, since it involves assembling the entire encoded body and taking the length of it (which, in the case of multipart messages, means freezing all the sub-parts, etc.). This method only sets the content length to a defined value if the message is a singlepart with C<"binary"> encoding, I the body is available either in-core or as a simple file. Otherwise, the content length is set to the undefined value. Since content-length is not a standard MIME field anyway (that's right, kids: it's not in the MIME RFCs, it's an HTTP thing), this seems pretty fair. =cut #---- # Miko's note: I wasn't quite sure how to handle this, so I waited to hear # what you think. Given that the content-length isn't always required, # and given the performance cost of calculating it from a file handle, # I thought it might make more sense to add some sort of computelength # property. If computelength is false, then the length simply isn't # computed. What do you think? # # Eryq's reply: I agree; for now, we can silently leave out the content-type. sub get_length { my $self = shift; my $attrs = $self->{Attrs}; my $is_multipart = ( $attrs->{'content-type'} =~ m{^multipart/}i ); my $enc = lc( $attrs->{'content-transfer-encoding'} || 'binary' ); my $length; if ( !$is_multipart && ( $enc eq "binary" ) ) { ### might figure it out cheap: if ( defined( $self->{Data} ) ) { ### it's in core $length = length( $self->{Data} ); } elsif ( defined( $self->{FH} ) ) { ### it's in a filehandle ### no-op: it's expensive, so don't bother } elsif ( defined( $self->{Path} ) ) { ### it's a simple file! $length = ( -s $self->{Path} ) if ( -e $self->{Path} ); } } $attrs->{'content-length'} = $length; return $length; } #------------------------------ =item parts I Return the parts of this entity, and this entity only. Returns empty array if this entity has no parts. This is B recursive! Parts can have sub-parts; use parts_DFS() to get everything. =cut sub parts { my $self = shift; @{ $self->{Parts} || [] }; } #------------------------------ =item parts_DFS I Return the list of all MIME::Lite objects included in the entity, starting with the entity itself, in depth-first-search order. If this object has no parts, it alone will be returned. =cut sub parts_DFS { my $self = shift; return ( $self, map { $_->parts_DFS } $self->parts ); } #------------------------------ =item preamble [TEXT] I Get/set the preamble string, assuming that this object has subparts. Set it to undef for the default string. =cut sub preamble { my $self = shift; $self->{Preamble} = shift if @_; $self->{Preamble}; } #------------------------------ =item replace TAG,VALUE I Delete all occurrences of fields named TAG, and add a new field with the given VALUE. TAG is converted to all-lowercase. B the special MIME fields (MIME-version, Content-*): if you "replace" a MIME field, the replacement text will override the I MIME attributes when it comes time to output that field. So normally you use attr() to change MIME fields and add()/replace() to change I fields: $msg->replace("Subject" => "Hi there!"); Giving VALUE as the I will effectively I that field from being output. This is the correct way to suppress the special MIME fields: $msg->replace("Content-disposition" => ""); Giving VALUE as I will just cause all explicit values for TAG to be deleted, without having any new values added. I the name of this method comes from Mail::Header. =cut sub replace { my ( $self, $tag, $value ) = @_; $self->delete($tag); $self->add( $tag, $value ) if defined($value); } #------------------------------ =item scrub I B Recursively goes through the "parts" tree of this message and tries to find MIME attributes that can be removed. With an array argument, removes exactly those attributes; e.g.: $msg->scrub(['content-disposition', 'content-length']); Is the same as recursively doing: $msg->replace('Content-disposition' => ''); $msg->replace('Content-length' => ''); =cut sub scrub { my ( $self, @a ) = @_; my ($expl) = @a; local $QUIET = 1; ### Scrub me: if ( !@a ) { ### guess ### Scrub length always: $self->replace( 'content-length', '' ); ### Scrub disposition if no filename, or if content-type has same info: if ( !$self->_safe_attr('content-disposition.filename') || $self->_safe_attr('content-type.name') ) { $self->replace( 'content-disposition', '' ); } ### Scrub encoding if effectively unencoded: if ( $self->_safe_attr('content-transfer-encoding') =~ /^(7bit|8bit|binary)$/i ) { $self->replace( 'content-transfer-encoding', '' ); } ### Scrub charset if US-ASCII: if ( $self->_safe_attr('content-type.charset') =~ /^(us-ascii)/i ) { $self->attr( 'content-type.charset' => undef ); } ### TBD: this is not really right for message/digest: if ( ( keys %{ $self->{Attrs}{'content-type'} } == 1 ) and ( $self->_safe_attr('content-type') eq 'text/plain' ) ) { $self->replace( 'content-type', '' ); } } elsif ( $expl and ( ref($expl) eq 'ARRAY' ) ) { foreach ( @{$expl} ) { $self->replace( $_, '' ); } } ### Scrub my kids: foreach ( @{ $self->{Parts} } ) { $_->scrub(@a); } } =back =cut #============================== #============================== =head2 Setting/getting message data =over 4 =cut #------------------------------ =item binmode [OVERRIDE] I With no argument, returns whether or not it thinks that the data (as given by the "Path" argument of C) should be read using binmode() (for example, when C is invoked). The default behavior is that any content type other than C or C is binmode'd; this should in general work fine. With a defined argument, this method sets an explicit "override" value. An undefined argument unsets the override. The new current value is returned. =cut sub binmode { my $self = shift; $self->{Binmode} = shift if (@_); ### argument? set override return ( defined( $self->{Binmode} ) ? $self->{Binmode} : ( $self->{Attrs}{"content-type"} !~ m{^(text|message)/}i ) ); } #------------------------------ =item data [DATA] I Get/set the literal DATA of the message. The DATA may be either a scalar, or a reference to an array of scalars (which will simply be joined). I setting the data causes the "content-length" attribute to be recomputed (possibly to nothing). =cut sub data { my $self = shift; if (@_) { $self->{Data} = ( ( ref( $_[0] ) eq 'ARRAY' ) ? join( '', @{ $_[0] } ) : $_[0] ); $self->get_length; } $self->{Data}; } #------------------------------ =item fh [FILEHANDLE] I Get/set the FILEHANDLE which contains the message data. Takes a filehandle as an input and stores it in the object. This routine is similar to path(); one important difference is that no attempt is made to set the content length. =cut sub fh { my $self = shift; $self->{FH} = shift if @_; $self->{FH}; } #------------------------------ =item path [PATH] I Get/set the PATH to the message data. I setting the path recomputes any existing "content-length" field, and re-sets the "filename" (to the last element of the path if it looks like a simple path, and to nothing if not). =cut sub path { my $self = shift; if (@_) { ### Set the path, and invalidate the content length: $self->{Path} = shift; ### Re-set filename, extracting it from path if possible: my $filename; if ( $self->{Path} and ( $self->{Path} !~ /\|$/ ) ) { ### non-shell path: ( $filename = $self->{Path} ) =~ s/^filename($filename); ### Reset the length: $self->get_length; } $self->{Path}; } #------------------------------ =item resetfh [FILEHANDLE] I Set the current position of the filehandle back to the beginning. Only applies if you used "FH" in build() or attach() for this message. Returns false if unable to reset the filehandle (since not all filehandles are seekable). =cut #---- # Miko's note: With the Data and Path, the same data could theoretically # be reused. However, file handles need to be reset to be reused, # so I added this routine. # # Eryq reply: beware... not all filehandles are seekable (think about STDIN)! sub resetfh { my $self = shift; seek( $self->{FH}, 0, 0 ); } #------------------------------ =item read_now I Forces data from the path/filehandle (as specified by C) to be read into core immediately, just as though you had given it literally with the C keyword. Note that the in-core data will always be used if available. Be aware that everything is slurped into a giant scalar: you may not want to use this if sending tar files! The benefit of I reading in the data is that very large files can be handled by this module if left on disk until the message is output via C or C. =cut sub read_now { my $self = shift; local $/ = undef; if ( $self->{FH} ) { ### data from a filehandle: my $chunk; my @chunks; CORE::binmode( $self->{FH} ) if $self->binmode; while ( read( $self->{FH}, $chunk, 1024 ) ) { push @chunks, $chunk; } $self->{Data} = join '', @chunks; } elsif ( $self->{Path} ) { ### data from a path: open SLURP, $self->{Path} or Carp::croak "open $self->{Path}: $!\n"; CORE::binmode(SLURP) if $self->binmode; $self->{Data} = ; ### sssssssssssssslurp... close SLURP; ### ...aaaaaaaaahhh! } } #------------------------------ =item sign PARAMHASH I Sign the message. This forces the message to be read into core, after which the signature is appended to it. =over 4 =item Data As in C: the literal signature data. Can be either a scalar or a ref to an array of scalars. =item Path As in C: the path to the file. =back If no arguments are given, the default is: Path => "$ENV{HOME}/.signature" The content-length is recomputed. =cut sub sign { my $self = shift; my %params = @_; ### Default: @_ or $params{Path} = "$ENV{HOME}/.signature"; ### Force message in-core: defined( $self->{Data} ) or $self->read_now; ### Load signature: my $sig; if ( !defined( $sig = $params{Data} ) ) { ### not given explicitly: local $/ = undef; open SIG, $params{Path} or Carp::croak "open sig $params{Path}: $!\n"; $sig = ; ### sssssssssssssslurp... close SIG; ### ...aaaaaaaaahhh! } $sig = join( '', @$sig ) if ( ref($sig) and ( ref($sig) eq 'ARRAY' ) ); ### Append, following Internet conventions: $self->{Data} .= "\n-- \n$sig"; ### Re-compute length: $self->get_length; 1; } #------------------------------ # # =item suggest_encoding CONTENTTYPE # # I # Based on the CONTENTTYPE, return a good suggested encoding. # C and C types have their bodies scanned line-by-line # for 8-bit characters and long lines; lack of either means that the # message is 7bit-ok. Other types are chosen independent of their body: # # Major type: 7bit ok? Suggested encoding: # ------------------------------------------------------------ # text yes 7bit # no quoted-printable # unknown binary # # message yes 7bit # no binary # unknown binary # # multipart n/a binary (in case some parts are not ok) # # (other) n/a base64 # #=cut sub suggest_encoding { my ( $self, $ctype ) = @_; $ctype = lc($ctype); ### Consult MIME::Types, maybe: if ($HaveMimeTypes) { ### Mappings contain [suffix,mimetype,encoding] my @mappings = MIME::Types::by_mediatype($ctype); if ( scalar(@mappings) ) { ### Just pick the first one: my ( $suffix, $mimetype, $encoding ) = @{ $mappings[0] }; if ( $encoding && $encoding =~ /^(base64|binary|[78]bit|quoted-printable)$/i ) { return lc($encoding); ### sanity check } } } ### If we got here, then MIME::Types was no help. ### Extract major type: my ($type) = split '/', $ctype; if ( ( $type eq 'text' ) || ( $type eq 'message' ) ) { ### scan message body? return 'binary'; } else { return ( $type eq 'multipart' ) ? 'binary' : 'base64'; } } #------------------------------ # # =item suggest_type PATH # # I # Suggest the content-type for this attached path. # We always fall back to "application/octet-stream" if no good guess # can be made, so don't use this if you don't mean it! # sub suggest_type { my ( $self, $path ) = @_; ### If there's no path, bail: $path or return 'application/octet-stream'; ### Consult MIME::Types, maybe: if ($HaveMimeTypes) { # Mappings contain [mimetype,encoding]: my ( $mimetype, $encoding ) = MIME::Types::by_suffix($path); return $mimetype if ( $mimetype && $mimetype =~ /^\S+\/\S+$/ ); ### sanity check } ### If we got here, then MIME::Types was no help. ### The correct thing to fall back to is the most-generic content type: return 'application/octet-stream'; } #------------------------------ =item verify_data I Verify that all "paths" to attached data exist, recursively. It might be a good idea for you to do this before a print(), to prevent accidental partial output if a file might be missing. Raises exception if any path is not readable. =cut sub verify_data { my $self = shift; ### Verify self: my $path = $self->{Path}; if ( $path and ( $path !~ /\|$/ ) ) { ### non-shell path: $path =~ s/^{Parts} } ) { $part->verify_data } 1; } =back =cut #============================== #============================== =head2 Output =over 4 =cut #------------------------------ =item print [OUTHANDLE] I Print the message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. =cut sub print { my ( $self, $out ) = @_; ### Coerce into a printable output handle: $out = MIME::Lite::IO_Handle->wrap($out); ### Output head, separator, and body: $self->verify_data if $AUTO_VERIFY; ### prevents missing parts! $out->print( $self->header_as_string, "\n" ); $self->print_body($out); } #------------------------------ # # print_for_smtp # # Instance method, private. # Print, but filter out the topmost "Bcc" field. # This is because qmail apparently doesn't do this for us! # sub print_for_smtp { my ( $self, $out ) = @_; ### Coerce into a printable output handle: $out = MIME::Lite::IO_Handle->wrap($out); ### Create a safe head: my @fields = grep { $_->[0] ne 'bcc' } @{ $self->fields }; my $header = $self->fields_as_string( \@fields ); ### Output head, separator, and body: $out->print( $header, "\n" ); $self->print_body( $out, '1' ); } #------------------------------ =item print_body [OUTHANDLE] [IS_SMTP] I Print the body of a message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. B raised if unable to open any of the input files, or if a part contains no data, or if an unsupported encoding is encountered. IS_SMPT is a special option to handle SMTP mails a little more intelligently than other send mechanisms may require. Specifically this ensures that the last byte sent is NOT '\n' (octal \012) if the last two bytes are not '\r\n' (\015\012) as this will cause some SMTP servers to hang. =cut sub print_body { my ( $self, $out, $is_smtp ) = @_; my $attrs = $self->{Attrs}; my $sub_attrs = $self->{SubAttrs}; ### Coerce into a printable output handle: $out = MIME::Lite::IO_Handle->wrap($out); ### Output either the body or the parts. ### Notice that we key off of the content-type! We expect fewer ### accidents that way, since the syntax will always match the MIME type. my $type = $attrs->{'content-type'}; if ( $type =~ m{^multipart/}i ) { my $boundary = $sub_attrs->{'content-type'}{'boundary'}; ### Preamble: $out->print( defined( $self->{Preamble} ) ? $self->{Preamble} : "This is a multi-part message in MIME format.\n" ); ### Parts: my $part; foreach $part ( @{ $self->{Parts} } ) { $out->print("\n--$boundary\n"); $part->print($out); } ### Epilogue: $out->print("\n--$boundary--\n\n"); } elsif ( $type =~ m{^message/} ) { my @parts = @{ $self->{Parts} }; ### It's a toss-up; try both data and parts: if ( @parts == 0 ) { $self->print_simple_body( $out, $is_smtp ) } elsif ( @parts == 1 ) { $parts[0]->print($out) } else { Carp::croak "can't handle message with >1 part\n"; } } else { $self->print_simple_body( $out, $is_smtp ); } 1; } #------------------------------ # # print_simple_body [OUTHANDLE] # # I # Print the body of a simple singlepart message to the given # output handle, or to the currently-selected filehandle if none # was given. # # Note that if you want to print "the portion after # the header", you don't want this method: you want # L. # # All OUTHANDLE has to be is a filehandle (possibly a glob ref), or # any object that responds to a print() message. # # B raised if unable to open any of the input files, # or if a part contains no data, or if an unsupported encoding is # encountered. # sub print_simple_body { my ( $self, $out, $is_smtp ) = @_; my $attrs = $self->{Attrs}; ### Coerce into a printable output handle: $out = MIME::Lite::IO_Handle->wrap($out); ### Get content-transfer-encoding: my $encoding = uc( $attrs->{'content-transfer-encoding'} ); warn "M::L >>> Encoding using $encoding, is_smtp=" . ( $is_smtp || 0 ) . "\n" if $MIME::Lite::DEBUG; ### Notice that we don't just attempt to slurp the data in from a file: ### by processing files piecemeal, we still enable ourselves to prepare ### very large MIME messages... ### Is the data in-core? If so, blit it out... if ( defined( $self->{Data} ) ) { DATA: { local $_ = $encoding; /^BINARY$/ and do { $is_smtp and $self->{Data} =~ s/(?!\r)\n\z/\r/; $out->print( $self->{Data} ); last DATA; }; /^8BIT$/ and do { $out->print( encode_8bit( $self->{Data} ) ); last DATA; }; /^7BIT$/ and do { $out->print( encode_7bit( $self->{Data} ) ); last DATA; }; /^QUOTED-PRINTABLE$/ and do { ### UNTAINT since m//mg on tainted data loops forever: my ($untainted) = ( $self->{Data} =~ m/\A(.*)\Z/s ); ### Encode it line by line: while ( $untainted =~ m{^(.*[\r\n]*)}smg ) { ### have to do it line by line... my $line = $1; # copy to avoid weird bug; rt 39334 $out->print( encode_qp($line) ); } last DATA; }; /^BASE64/ and do { $out->print( encode_base64( $self->{Data} ) ); last DATA; }; Carp::croak "unsupported encoding: `$_'\n"; } } ### Else, is the data in a file? If so, output piecemeal... ### Miko's note: this routine pretty much works the same with a path ### or a filehandle. the only difference in behaviour is that it does ### not attempt to open anything if it already has a filehandle elsif ( defined( $self->{Path} ) || defined( $self->{FH} ) ) { no strict 'refs'; ### in case FH is not an object my $DATA; ### Open file if necessary: if ( defined( $self->{Path} ) ) { $DATA = new FileHandle || Carp::croak "can't get new filehandle\n"; $DATA->open("$self->{Path}") or Carp::croak "open $self->{Path}: $!\n"; } else { $DATA = $self->{FH}; } CORE::binmode($DATA) if $self->binmode; ### Encode piece by piece: PATH: { local $_ = $encoding; /^BINARY$/ and do { my $last = ""; while ( read( $DATA, $_, 2048 ) ) { $out->print($last) if length $last; $last = $_; } if ( length $last ) { $is_smtp and $last =~ s/(?!\r)\n\z/\r/; $out->print($last); } last PATH; }; /^8BIT$/ and do { $out->print( encode_8bit($_) ) while (<$DATA>); last PATH; }; /^7BIT$/ and do { $out->print( encode_7bit($_) ) while (<$DATA>); last PATH; }; /^QUOTED-PRINTABLE$/ and do { $out->print( encode_qp($_) ) while (<$DATA>); last PATH; }; /^BASE64$/ and do { $out->print( encode_base64($_) ) while ( read( $DATA, $_, 45 ) ); last PATH; }; Carp::croak "unsupported encoding: `$_'\n"; } ### Close file: close $DATA if defined( $self->{Path} ); } else { Carp::croak "no data in this part\n"; } 1; } #------------------------------ =item print_header [OUTHANDLE] I Print the header of the message to the given output handle, or to the currently-selected filehandle if none was given. All OUTHANDLE has to be is a filehandle (possibly a glob ref), or any object that responds to a print() message. =cut sub print_header { my ( $self, $out ) = @_; ### Coerce into a printable output handle: $out = MIME::Lite::IO_Handle->wrap($out); ### Output the header: $out->print( $self->header_as_string ); 1; } #------------------------------ =item as_string I Return the entire message as a string, with a header and an encoded body. =cut sub as_string { my $self = shift; my $buf = ""; my $io = ( wrap MIME::Lite::IO_Scalar \$buf); $self->print($io); return $buf; } *stringify = \&as_string; ### backwards compatibility *stringify = \&as_string; ### ...twice to avoid warnings :) #------------------------------ =item body_as_string I Return the encoded body as a string. This is the portion after the header and the blank line. I actually prepares the body by "printing" to a scalar. Proof that you can hand the C methods any blessed object that responds to a C message. =cut sub body_as_string { my $self = shift; my $buf = ""; my $io = ( wrap MIME::Lite::IO_Scalar \$buf); $self->print_body($io); return $buf; } *stringify_body = \&body_as_string; ### backwards compatibility *stringify_body = \&body_as_string; ### ...twice to avoid warnings :) #------------------------------ # # fields_as_string FIELDS # # PRIVATE! Return a stringified version of the given header # fields, where FIELDS is an arrayref like that returned by fields(). # sub fields_as_string { my ( $self, $fields ) = @_; my $out = ""; foreach (@$fields) { my ( $tag, $value ) = @$_; next if ( $value eq '' ); ### skip empties $tag =~ s/\b([a-z])/uc($1)/ge; ### make pretty $tag =~ s/^mime-/MIME-/i; ### even prettier $out .= "$tag: $value\n"; } return $out; } #------------------------------ =item header_as_string I Return the header as a string. =cut sub header_as_string { my $self = shift; $self->fields_as_string( $self->fields ); } *stringify_header = \&header_as_string; ### backwards compatibility *stringify_header = \&header_as_string; ### ...twice to avoid warnings :) =back =cut #============================== #============================== =head2 Sending =over 4 =cut #------------------------------ =item send =item send HOW, HOWARGS... I This is the principal method for sending mail, and for configuring how mail will be sent. I with a HOW argument and optional HOWARGS, it sets the default sending mechanism that the no-argument instance method will use. The HOW is a facility name (B), and the HOWARGS is interpreted by the facility. The class method returns the previous HOW and HOWARGS as an array. MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe"); ... $msg = MIME::Lite->new(...); $msg->send; I (a HOW argument and optional HOWARGS), sends the message in the requested manner; e.g.: $msg->send('sendmail', "d:\\programs\\sendmail.exe"); I sends the message by the default mechanism set up by the class method. Returns whatever the mail-handling routine returns: this should be true on success, false/exception on error: $msg = MIME::Lite->new(From=>...); $msg->send || die "you DON'T have mail!"; On Unix systems (or rather non-Win32 systems), the default setting is equivalent to: MIME::Lite->send("sendmail", "/usr/lib/sendmail -t -oi -oem"); On Win32 systems the default setting is equivalent to: MIME::Lite->send("smtp"); The assumption is that on Win32 your site/lib/Net/libnet.cfg file will be preconfigured to use the appropriate SMTP server. See below for configuring for authentication. There are three facilities: =over 4 =item "sendmail", ARGS... Send a message by piping it into the "sendmail" command. Uses the L method, giving it the ARGS. This usage implements (and deprecates) the C method. =item "smtp", [HOSTNAME, [NAMEDPARMS] ] Send a message by SMTP, using optional HOSTNAME as SMTP-sending host. L will be required. Uses the L method. Any additional arguments passed in will also be passed through to send_by_smtp. This is useful for things like mail servers requiring authentication where you can say something like the following MIME::Lite->send('smtp', $host, AuthUser=>$user, AuthPass=>$pass); which will configure things so future uses of $msg->send(); do the right thing. =item "sub", \&SUBREF, ARGS... Sends a message MSG by invoking the subroutine SUBREF of your choosing, with MSG as the first argument, and ARGS following. =back I let's say you're on an OS which lacks the usual Unix "sendmail" facility, but you've installed something a lot like it, and you need to configure your Perl script to use this "sendmail.exe" program. Do this following in your script's setup: MIME::Lite->send('sendmail', "d:\\programs\\sendmail.exe"); Then, whenever you need to send a message $msg, just say: $msg->send; That's it. Now, if you ever move your script to a Unix box, all you need to do is change that line in the setup and you're done. All of your $msg-Esend invocations will work as expected. After sending, the method last_send_successful() can be used to determine if the send was successful or not. =cut sub send { my $self = shift; my $meth = shift; if ( ref($self) ) { ### instance method: my ( $method, @args ); if (@_) { ### args; use them just this once $method = 'send_by_' . $meth; @args = @_; } else { ### no args; use defaults $method = "send_by_$Sender"; @args = @{ $SenderArgs{$Sender} || [] }; } $self->verify_data if $AUTO_VERIFY; ### prevents missing parts! Carp::croak "Unknown send method '$meth'" unless $self->can($method); return $self->$method(@args); } else { ### class method: if (@_) { my @old = ( $Sender, @{ $SenderArgs{$Sender} } ); $Sender = $meth; $SenderArgs{$Sender} = [@_]; ### remaining args return @old; } else { Carp::croak "class method send must have HOW... arguments\n"; } } } #------------------------------ =item send_by_sendmail SENDMAILCMD =item send_by_sendmail PARAM=>VALUE, ARRAY, HASH... I Send message via an external "sendmail" program (this will probably only work out-of-the-box on Unix systems). Returns true on success, false or exception on error. You can specify the program and all its arguments by giving a single string, SENDMAILCMD. Nothing fancy is done; the message is simply piped in. However, if your needs are a little more advanced, you can specify zero or more of the following PARAM/VALUE pairs (or a reference to hash or array of such arguments as well as any combination thereof); a Unix-style, taint-safe "sendmail" command will be constructed for you: =over 4 =item Sendmail Full path to the program to use. Default is "/usr/lib/sendmail". =item BaseArgs Ref to the basic array of arguments we start with. Default is C<["-t", "-oi", "-oem"]>. =item SetSender Unless this is I given as false, we attempt to automatically set the C<-f> argument to the first address that can be extracted from the "From:" field of the message (if there is one). I Suppose we did I use C<-f>, and you gave an explicit "From:" field in your message: in this case, the sendmail "envelope" would indicate the I user your process was running under, as a way of preventing mail forgery. Using the C<-f> switch causes the sender to be set in the envelope as well. I If sendmail doesn't regard you as a "trusted" user, it will permit the C<-f> but also add an "X-Authentication-Warning" header to the message to indicate a forged envelope. To avoid this, you can either (1) have SetSender be false, or (2) make yourself a trusted user by adding a C configuration command to your I file (e.g.: C if the script is running as user "eryq"). =item FromSender If defined, this is identical to setting SetSender to true, except that instead of looking at the "From:" field we use the address given by this option. Thus: FromSender => 'me@myhost.com' =back After sending, the method last_send_successful() can be used to determine if the send was successful or not. =cut sub _unfold_stupid_params { my $self = shift; my %p; STUPID_PARAM: for (my $i = 0; $i < @_; $i++) { ## no critic Loop my $item = $_[$i]; if (not ref $item) { $p{ $item } = $_[ ++$i ]; } elsif (UNIVERSAL::isa($item, 'HASH')) { $p{ $_ } = $item->{ $_ } for keys %$item; } elsif (UNIVERSAL::isa($item, 'ARRAY')) { for (my $j = 0; $j < @$item; $j += 2) { $p{ $item->[ $j ] } = $item->[ $j + 1 ]; } } } return %p; } sub send_by_sendmail { my $self = shift; my $return; if ( @_ == 1 and !ref $_[0] ) { ### Use the given command... my $sendmailcmd = shift @_; Carp::croak "No sendmail command available" unless $sendmailcmd; ### Do it: local *SENDMAIL; open SENDMAIL, "|$sendmailcmd" or Carp::croak "open |$sendmailcmd: $!\n"; $self->print( \*SENDMAIL ); close SENDMAIL; $return = ( ( $? >> 8 ) ? undef: 1 ); } else { ### Build the command... my %p = $self->_unfold_stupid_params(@_); $p{Sendmail} = $SENDMAIL unless defined $p{Sendmail}; ### Start with the command and basic args: my @cmd = ( $p{Sendmail}, @{ $p{BaseArgs} || [ '-t', '-oi', '-oem' ] } ); # SetSender default is true $p{SetSender} = 1 unless defined $p{SetSender}; ### See if we are forcibly setting the sender: $p{SetSender} ||= defined( $p{FromSender} ); ### Add the -f argument, unless we're explicitly told NOT to: if ( $p{SetSender} ) { my $from = $p{FromSender} || ( $self->get('From') )[0]; if ($from) { my ($from_addr) = extract_full_addrs($from); push @cmd, "-f$from_addr" if $from_addr; } } ### Open the command in a taint-safe fashion: my $pid = open SENDMAIL, "|-"; defined($pid) or die "open of pipe failed: $!\n"; if ( !$pid ) { ### child exec(@cmd) or die "can't exec $p{Sendmail}: $!\n"; ### NOTREACHED } else { ### parent $self->print( \*SENDMAIL ); close SENDMAIL || die "error closing $p{Sendmail}: $! (exit $?)\n"; $return = 1; } } return $self->{last_send_successful} = $return; } #------------------------------ =item send_by_smtp HOST, ARGS... =item send_by_smtp REF, HOST, ARGS I Send message via SMTP, using Net::SMTP -- which will be required for this feature. HOST is the name of SMTP server to connect to, or undef to have L use the defaults in Libnet.cfg. ARGS are a list of key value pairs which may be selected from the list below. Many of these are just passed through to specific L commands and you should review that module for details. Please see L =over 4 =item Hello =item LocalAddr =item LocalPort =item Timeout =item Port =item ExactAddresses =item Debug See L for details. =item Size =item Return =item Bits =item Transaction =item Envelope See L for details. =item SkipBad If true doesn't throw an error when multiple email addresses are provided and some are not valid. See L for details. =item AuthUser Authenticate with L using this username. =item AuthPass Authenticate with L using this password. =item NoAuth Normally if AuthUser and AuthPass are defined MIME::Lite will attempt to use them with the L command to authenticate the connection, however if this value is true then no authentication occurs. =item To Sets the addresses to send to. Can be a string or a reference to an array of strings. Normally this is extracted from the To: (and Cc: and Bcc: fields if $AUTO_CC is true). This value overrides that. =item From Sets the email address to send from. Normally this value is extracted from the Return-Path: or From: field of the mail itself (in that order). This value overrides that. =back I True on success, croaks with an error message on failure. After sending, the method last_send_successful() can be used to determine if the send was successful or not. =cut # Derived from work by Andrew McRae. Version 0.2 anm 09Sep97 # Copyright 1997 Optimation New Zealand Ltd. # May be modified/redistributed under the same terms as Perl. # external opts my @_mail_opts = qw( Size Return Bits Transaction Envelope ); my @_recip_opts = qw( SkipBad ); my @_net_smtp_opts = qw( Hello LocalAddr LocalPort Timeout Port ExactAddresses Debug ); # internal: qw( NoAuth AuthUser AuthPass To From Host); sub __opts { my $args=shift; return map { exists $args->{$_} ? ( $_ => $args->{$_} ) : () } @_; } sub send_by_smtp { require Net::SMTP; my ($self,$hostname,%args) = @_; # We may need the "From:" and "To:" headers to pass to the # SMTP mailer also. $self->{last_send_successful}=0; my @hdr_to = extract_only_addrs( scalar $self->get('To') ); if ($AUTO_CC) { foreach my $field (qw(Cc Bcc)) { push @hdr_to, extract_only_addrs($_) for $self->get($field); } } Carp::croak "send_by_smtp: nobody to send to for host '$hostname'?!\n" unless @hdr_to; $args{To} ||= \@hdr_to; $args{From} ||= extract_only_addrs( scalar $self->get('Return-Path') ); $args{From} ||= extract_only_addrs( scalar $self->get('From') ) ; # Create SMTP client. # MIME::Lite::SMTP is just a wrapper giving a print method # to the SMTP object. my %opts = __opts(\%args, @_net_smtp_opts); my $smtp = MIME::Lite::SMTP->new( $hostname, %opts ) or Carp::croak "SMTP Failed to connect to mail server: $!\n"; # Possibly authenticate if ( defined $args{AuthUser} and defined $args{AuthPass} and !$args{NoAuth} ) { if ($smtp->supports('AUTH',500,["Command unknown: 'AUTH'"])) { $smtp->auth( $args{AuthUser}, $args{AuthPass} ) or die "SMTP auth() command failed: $!\n" . $smtp->message . "\n"; } else { die "SMTP auth() command not supported on $hostname\n"; } } # Send the mail command %opts = __opts( \%args, @_mail_opts); $smtp->mail( $args{From}, %opts ? \%opts : () ) or die "SMTP mail() command failed: $!\n" . $smtp->message . "\n"; # Send the recipients command %opts = __opts( \%args, @_recip_opts); $smtp->recipient( @{ $args{To} }, %opts ? \%opts : () ) or die "SMTP recipient() command failed: $!\n" . $smtp->message . "\n"; # Send the data $smtp->data() or die "SMTP data() command failed: $!\n" . $smtp->message . "\n"; $self->print_for_smtp($smtp); # Finish the mail $smtp->dataend() or Carp::croak "Net::CMD (Net::SMTP) DATAEND command failed.\n" . "Last server message was:" . $smtp->message . "This probably represents a problem with newline encoding "; # terminate the session $smtp->quit; return $self->{last_send_successful} = 1; } =item send_by_testfile FILENAME I Print message to a file (namely FILENAME), which will default to mailer.testfile If file exists, message will be appended. =cut sub send_by_testfile { my $self = shift; ### Use the default filename... my $filename = 'mailer.testfile'; if ( @_ == 1 and !ref $_[0] ) { ### Use the given filename if given... $filename = shift @_; Carp::croak "no filename given to send_by_testfile" unless $filename; } ### Do it: local *FILE; open FILE, ">> $filename" or Carp::croak "open $filename: $!\n"; $self->print( \*FILE ); close FILE; my $return = ( ( $? >> 8 ) ? undef: 1 ); return $self->{last_send_successful} = $return; } =item last_send_successful This method will return TRUE if the last send() or send_by_XXX() method call was successful. It will return defined but false if it was not successful, and undefined if the object had not been used to send yet. =cut sub last_send_successful { my $self = shift; return $self->{last_send_successful}; } ### Provided by Andrew McRae. Version 0.2 anm 09Sep97 ### Copyright 1997 Optimation New Zealand Ltd. ### May be modified/redistributed under the same terms as Perl. ### Aditional changes by Yves. ### Until 3.01_03 this was send_by_smtp() sub send_by_smtp_simple { my ( $self, @args ) = @_; $self->{last_send_successful} = 0; ### We need the "From:" and "To:" headers to pass to the SMTP mailer: my $hdr = $self->fields(); my $from_header = $self->get('From'); my ($from) = extract_only_addrs($from_header); warn "M::L>>> $from_header => $from" if $MIME::Lite::DEBUG; my $to = $self->get('To'); ### Sanity check: defined($to) or Carp::croak "send_by_smtp: missing 'To:' address\n"; ### Get the destinations as a simple array of addresses: my @to_all = extract_only_addrs($to); if ($AUTO_CC) { foreach my $field (qw(Cc Bcc)) { my $value = $self->get($field); push @to_all, extract_only_addrs($value) if defined($value); } } ### Create SMTP client: require Net::SMTP; my $smtp = MIME::Lite::SMTP->new(@args) or Carp::croak("Failed to connect to mail server: $!\n"); $smtp->mail($from) or Carp::croak( "SMTP MAIL command failed: $!\n" . $smtp->message . "\n" ); $smtp->to(@to_all) or Carp::croak( "SMTP RCPT command failed: $!\n" . $smtp->message . "\n" ); $smtp->data() or Carp::croak( "SMTP DATA command failed: $!\n" . $smtp->message . "\n" ); ### MIME::Lite can print() to anything with a print() method: $self->print_for_smtp($smtp); $smtp->dataend() or Carp::croak( "Net::CMD (Net::SMTP) DATAEND command failed.\n" . "Last server message was:" . $smtp->message . "This probably represents a problem with newline encoding " ); $smtp->quit; $self->{last_send_successful} = 1; 1; } #------------------------------ # # send_by_sub [\&SUBREF, [ARGS...]] # # I # Send the message via an anonymous subroutine. # sub send_by_sub { my ( $self, $subref, @args ) = @_; $self->{last_send_successful} = &$subref( $self, @args ); } #------------------------------ =item sendmail COMMAND... I Declare the sender to be "sendmail", and set up the "sendmail" command. I =cut sub sendmail { my $self = shift; $self->send( 'sendmail', join( ' ', @_ ) ); } =back =cut #============================== #============================== =head2 Miscellaneous =over 4 =cut #------------------------------ =item quiet ONOFF I Suppress/unsuppress all warnings coming from this module. MIME::Lite->quiet(1); ### I know what I'm doing I recommend that you include that comment as well. And while you type it, say it out loud: if it doesn't feel right, then maybe you should reconsider the whole line. C<;-)> =cut sub quiet { my $class = shift; $QUIET = shift if @_; $QUIET; } =back =cut #============================================================ package MIME::Lite::SMTP; #============================================================ # This class just adds a print() method to Net::SMTP. # Notice that we don't use/require it until it's needed! use strict; use vars qw( @ISA ); @ISA = qw(Net::SMTP); # some of the below is borrowed from Data::Dumper my %esc = ( "\a" => "\\a", "\b" => "\\b", "\t" => "\\t", "\n" => "\\n", "\f" => "\\f", "\r" => "\\r", "\e" => "\\e", ); sub _hexify { local $_ = shift; my @split = m/(.{1,16})/gs; foreach my $split (@split) { ( my $txt = $split ) =~ s/([\a\b\t\n\f\r\e])/$esc{$1}/sg; $split =~ s/(.)/sprintf("%02X ",ord($1))/sge; print STDERR "M::L >>> $split : $txt\n"; } } sub print { my $smtp = shift; $MIME::Lite::DEBUG and _hexify( join( "", @_ ) ); $smtp->datasend(@_) or Carp::croak( "Net::CMD (Net::SMTP) DATASEND command failed.\n" . "Last server message was:" . $smtp->message . "This probably represents a problem with newline encoding " ); } #============================================================ package MIME::Lite::IO_Handle; #============================================================ ### Wrap a non-object filehandle inside a blessed, printable interface: ### Does nothing if the given $fh is already a blessed object. sub wrap { my ( $class, $fh ) = @_; no strict 'refs'; ### Get default, if necessary: $fh or $fh = select; ### no filehandle means selected one ref($fh) or $fh = \*$fh; ### scalar becomes a globref ### Stop right away if already a printable object: return $fh if ( ref($fh) and ( ref($fh) ne 'GLOB' ) ); ### Get and return a printable interface: bless \$fh, $class; ### wrap it in a printable interface } ### Print: sub print { my $self = shift; print {$$self} @_; } #============================================================ package MIME::Lite::IO_Scalar; #============================================================ ### Wrap a scalar inside a blessed, printable interface: sub wrap { my ( $class, $scalarref ) = @_; defined($scalarref) or $scalarref = \""; bless $scalarref, $class; } ### Print: sub print { ${$_[0]} .= join( '', @_[1..$#_] ); 1; } #============================================================ package MIME::Lite::IO_ScalarArray; #============================================================ ### Wrap an array inside a blessed, printable interface: sub wrap { my ( $class, $arrayref ) = @_; defined($arrayref) or $arrayref = []; bless $arrayref, $class; } ### Print: sub print { my $self = shift; push @$self, @_; 1; } 1; __END__ #============================================================ =head1 NOTES =head2 How do I prevent "Content" headers from showing up in my mail reader? Apparently, some people are using mail readers which display the MIME headers like "Content-disposition", and they want MIME::Lite not to generate them "because they look ugly". Sigh. Y'know, kids, those headers aren't just there for cosmetic purposes. They help ensure that the message is I correctly by mail readers. But okay, you asked for it, you got it... here's how you can suppress the standard MIME headers. Before you send the message, do this: $msg->scrub; You can scrub() any part of a multipart message independently; just be aware that it works recursively. Before you scrub, note the rules that I follow: =over 4 =item Content-type You can safely scrub the "content-type" attribute if, and only if, the part is of type "text/plain" with charset "us-ascii". =item Content-transfer-encoding You can safely scrub the "content-transfer-encoding" attribute if, and only if, the part uses "7bit", "8bit", or "binary" encoding. You are far better off doing this if your lines are under 1000 characters. Generally, that means you I scrub it for plain text, and you can I scrub this for images, etc. =item Content-disposition You can safely scrub the "content-disposition" attribute if you trust the mail reader to do the right thing when it decides whether to show an attachment inline or as a link. Be aware that scrubbing both the content-disposition and the content-type means that there is no way to "recommend" a filename for the attachment! B there are reports of brain-dead MUAs out there that do the wrong thing if you I the content-disposition. If your attachments keep showing up inline or vice-versa, try scrubbing this attribute. =item Content-length You can always scrub "content-length" safely. =back =head2 How do I give my attachment a [different] recommended filename? By using the Filename option (which is different from Path!): $msg->attach(Type => "image/gif", Path => "/here/is/the/real/file.GIF", Filename => "logo.gif"); You should I put path information in the Filename. =head2 Benign limitations This is "lite", after all... =over 4 =item * There's no parsing. Get MIME-tools if you need to parse MIME messages. =item * MIME::Lite messages are currently I interchangeable with either Mail::Internet or MIME::Entity objects. This is a completely separate module. =item * A content-length field is only inserted if the encoding is binary, the message is a singlepart, and all the document data is available at C time by virtue of residing in a simple path, or in-core. Since content-length is not a standard MIME field anyway (that's right, kids: it's not in the MIME RFCs, it's an HTTP thing), this seems pretty fair. =item * MIME::Lite alone cannot help you lose weight. You must supplement your use of MIME::Lite with a healthy diet and exercise. =back =head2 Cheap and easy mailing I thought putting in a default "sendmail" invocation wasn't too bad an idea, since a lot of Perlers are on UNIX systems. (As of version 3.02 this is default only on Non-Win32 boxen. On Win32 boxen the default is to use SMTP and the defaults specified in the site/lib/Net/libnet.cfg) The out-of-the-box configuration is: MIME::Lite->send('sendmail', "/usr/lib/sendmail -t -oi -oem"); By the way, these arguments to sendmail are: -t Scan message for To:, Cc:, Bcc:, etc. -oi Do NOT treat a single "." on a line as a message terminator. As in, "-oi vey, it truncated my message... why?!" -oem On error, mail back the message (I assume to the appropriate address, given in the header). When mail returns, circle is complete. Jai Guru Deva -oem. Note that these are the same arguments you get if you configure to use the smarter, taint-safe mailing: MIME::Lite->send('sendmail'); If you get "X-Authentication-Warning" headers from this, you can forgo diddling with the envelope by instead specifying: MIME::Lite->send('sendmail', SetSender=>0); And, if you're not on a Unix system, or if you'd just rather send mail some other way, there's always SMTP, which these days probably requires authentication so you probably need to say MIME::Lite->send('smtp', "smtp.myisp.net", AuthUser=>"YourName",AuthPass=>"YourPass" ); Or you can set up your own subroutine to call. In any case, check out the L method. =head1 WARNINGS =head2 Good-vs-bad email addresses with send_by_smtp() If using L, be aware that unless you explicitly provide the email addresses to send to and from you will be forcing MIME::Lite to extract email addresses out of a possible list provided in the C, C, and C fields. This is tricky stuff, and as such only the following sorts of addresses will work reliably: username full.name@some.host.com "Name, Full" B MIME::Lite was never intended to be a Mail User Agent, so please don't expect a full implementation of RFC-822. Restrict yourself to the common forms of Internet addresses described herein, and you should be fine. If this is not feasible, then consider using MIME::Lite to I your message only, and using Net::SMTP explicitly to I your message. B As of MIME::Lite v3.02 the mail name extraction routines have been beefed up considerably. Furthermore if Mail::Address if provided then name extraction is done using that. Accordingly the above advice is now less true than it once was. Funky email names I work properly now. However the disclaimer remains. Patches welcome. :-) =head2 Formatting of headers delayed until print() This class treats a MIME header in the most abstract sense, as being a collection of high-level attributes. The actual RFC-822-style header fields are not constructed until it's time to actually print the darn thing. =head2 Encoding of data delayed until print() When you specify message bodies (in L or L) -- whether by B, B, or B -- be warned that we don't attempt to open files, read filehandles, or encode the data until L is invoked. In the past, this created some confusion for users of sendmail who gave the wrong path to an attachment body, since enough of the print() would succeed to get the initial part of the message out. Nowadays, $AUTO_VERIFY is used to spot-check the Paths given before the mail facility is employed. A whisker slower, but tons safer. Note that if you give a message body via FH, and try to print() a message twice, the second print() will not do the right thing unless you explicitly rewind the filehandle. You can get past these difficulties by using the B option, provided that you have enough memory to handle your messages. =head2 MIME attributes are separate from header fields! B the MIME attributes are stored and manipulated separately from the message header fields; when it comes time to print the header out, I That means that this: ### DANGER ### DANGER ### DANGER ### DANGER ### DANGER ### $msg->add("Content-type", "text/html; charset=US-ASCII"); will set the exact C<"Content-type"> field in the header I write, I I as an escape hatch in case the code that normally formats MIME header fields isn't doing what you need. And, like any escape hatch, it's got an alarm on it: MIME::Lite will warn you if you attempt to C or C any MIME header field. Use C instead. =head2 Beware of lines consisting of a single dot Julian Haight noted that MIME::Lite allows you to compose messages with lines in the body consisting of a single ".". This is true: it should be completely harmless so long as "sendmail" is used with the -oi option (see L<"Cheap and easy mailing">). However, I don't know if using Net::SMTP to transfer such a message is equally safe. Feedback is welcomed. My perspective: I don't want to magically diddle with a user's message unless absolutely positively necessary. Some users may want to send files with "." alone on a line; my well-meaning tinkering could seriously harm them. =head2 Infinite loops may mean tainted data! Stefan Sautter noticed a bug in 2.106 where a m//gc match was failing due to tainted data, leading to an infinite loop inside MIME::Lite. I am attempting to correct for this, but be advised that my fix will silently untaint the data (given the context in which the problem occurs, this should be benign: I've labelled the source code with UNTAINT comments for the curious). So: don't depend on taint-checking to save you from outputting tainted data in a message. =head2 Don't tweak the global configuration Global configuration variables are bad, and should go away. Until they do, please follow the hints with each setting on how I to change it. =head1 A MIME PRIMER =head2 Content types The "Type" parameter of C is a I. This is the actual type of data you are sending. Generally this is a string of the form C<"majortype/minortype">. Here are the major MIME types. A more-comprehensive listing may be found in RFC-2046. =over 4 =item application Data which does not fit in any of the other categories, particularly data to be processed by some type of application program. C, C, C... =item audio Audio data. C