开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
phpmailer.phpmailer.php
资源名称：com_comprofiler.zip　[点击查看]
上传用户：stephen_wu
上传日期：2008-07-05
资源大小：1757k
文件大小：51k
源码类别：

网络

开发平台：

Unix_Linux

phpmailer.phpmailer.php：源码内容
  1. <?php
  2. /*~ class.phpmailer.php
  3. .---------------------------------------------------------------------------.
  4. |  Software: PHPMailer - PHP email class                                    |
  5. |   Version: 2.0.0 rc3                                                      |
  6. |   Contact: via sourceforge.net support pages (also www.codeworxtech.com)  |
  7. |      Info: http://phpmailer.sourceforge.net                               |
  8. |   Support: http://sourceforge.net/projects/phpmailer/                     |
  9. | ------------------------------------------------------------------------- |
  10. |    Author: Andy Prevost (project admininistrator)                         |
  11. |    Author: Brent R. Matzelle (original founder)                           |
  12. | Copyright (c) 2004-2007, Andy Prevost. All Rights Reserved.               |
  13. | Copyright (c) 2001-2003, Brent R. Matzelle                                |
  14. | ------------------------------------------------------------------------- |
  15. |   License: Distributed under the Lesser General Public License (LGPL)     |
  16. |            http://www.gnu.org/copyleft/lesser.html                        |
  17. | This program is distributed in the hope that it will be useful - WITHOUT  |
  18. | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |
  19. | FITNESS FOR A PARTICULAR PURPOSE.                                         |
  20. | ------------------------------------------------------------------------- |
  21. | We offer a number of paid services (www.codeworxtech.com):                |
  22. | - Web Hosting on highly optimized fast and secure servers                 |
  23. | - Technology Consulting                                                   |
  24. | - Oursourcing (highly qualified programmers and graphic designers)        |
  25. '---------------------------------------------------------------------------'
  26. // Changes for CB: search for //BB.
  27. */
  28. /**
  29.  * PHPMailer - PHP email transport class
  30.  * @package PHPMailer
  31.  * @author Andy Prevost
  32.  * @copyright 2004 - 2007 Andy Prevost
  33.  * @license LGPL v2 at time of publishing.
  34.  */
  35. class CBPHPMailer { //BB: Line changed for CB library structure.
  37.   /////////////////////////////////////////////////
  38.   // PROPERTIES, PUBLIC
  39.   /////////////////////////////////////////////////
  41.   /**
  42.    * Email priority (1 = High, 3 = Normal, 5 = low).
  43.    * @var int
  44.    */
  45.   var $Priority          = 3;
  47.   /**
  48.    * Sets the CharSet of the message.
  49.    * @var string
  50.    */
  51.   var $CharSet           = 'iso-8859-1';
  53.   /**
  54.    * Sets the Content-type of the message.
  55.    * @var string
  56.    */
  57.   var $ContentType        = 'text/plain';
  59.   /**
  60.    * Sets the Encoding of the message. Options for this are "8bit",
  61.    * "7bit", "binary", "base64", and "quoted-printable".
  62.    * @var string
  63.    */
  64.   var $Encoding          = '8bit';
  66.   /**
  67.    * Holds the most recent mailer error message.
  68.    * @var string
  69.    */
  70.   var $ErrorInfo         = '';
  72.   /**
  73.    * Sets the From email address for the message.
  74.    * @var string
  75.    */
  76.   var $From              = 'root@localhost';
  78.   /**
  79.    * Sets the From name of the message.
  80.    * @var string
  81.    */
  82.   var $FromName          = 'Root User';
  84.   /**
  85.    * Sets the Sender email (Return-Path) of the message.  If not empty,
  86.    * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
  87.    * @var string
  88.    */
  89.   var $Sender            = '';
  91.   /**
  92.    * Sets the Subject of the message.
  93.    * @var string
  94.    */
  95.   var $Subject           = '';
  97.   /**
  98.    * Sets the Body of the message.  This can be either an HTML or text body.
  99.    * If HTML then run IsHTML(true).
  100.    * @var string
  101.    */
  102.   var $Body              = '';
  104.   /**
  105.    * Sets the text-only body of the message.  This automatically sets the
  106.    * email to multipart/alternative.  This body can be read by mail
  107.    * clients that do not have HTML email capability such as mutt. Clients
  108.    * that can read HTML will view the normal Body.
  109.    * @var string
  110.    */
  111.   var $AltBody           = '';
  113.   /**
  114.    * Sets word wrapping on the body of the message to a given number of
  115.    * characters.
  116.    * @var int
  117.    */
  118.   var $WordWrap          = 0;
  120.   /**
  121.    * Method to send mail: ("mail", "sendmail", or "smtp").
  122.    * @var string
  123.    */
  124.   var $Mailer            = 'mail';
  126.   /**
  127.    * Sets the path of the sendmail program.
  128.    * @var string
  129.    */
  130.   var $Sendmail          = '/usr/sbin/sendmail';
  132.   /**
  133.    * Path to PHPMailer plugins.  This is now only useful if the SMTP class
  134.    * is in a different directory than the PHP include path.
  135.    * @var string
  136.    */
  137.   var $PluginDir         = '';
  139.   /**
  140.    * Holds PHPMailer version.
  141.    * @var string
  142.    */
  143.   var $Version           = "2.0.0 rc3";
  145.   /**
  146.    * Sets the email address that a reading confirmation will be sent.
  147.    * @var string
  148.    */
  149.   var $ConfirmReadingTo  = '';
  151.   /**
  152.    * Sets the hostname to use in Message-Id and Received headers
  153.    * and as default HELO string. If empty, the value returned
  154.    * by SERVER_NAME is used or 'localhost.localdomain'.
  155.    * @var string
  156.    */
  157.   var $Hostname          = '';
  159.   /////////////////////////////////////////////////
  160.   // PROPERTIES FOR SMTP
  161.   /////////////////////////////////////////////////
  163.   /**
  164.    * Sets the SMTP hosts.  All hosts must be separated by a
  165.    * semicolon.  You can also specify a different port
  166.    * for each host by using this format: [hostname:port]
  167.    * (e.g. "smtp1.example.com:25;smtp2.example.com").
  168.    * Hosts will be tried in order.
  169.    * @var string
  170.    */
  171.   var $Host        = 'localhost';
  173.   /**
  174.    * Sets the default SMTP server port.
  175.    * @var int
  176.    */
  177.   var $Port        = 25;
  179.   /**
  180.    * Sets the SMTP HELO of the message (Default is $Hostname).
  181.    * @var string
  182.    */
  183.   var $Helo        = '';
  185.   /**
  186.    * Sets connection prefix.
  187.    * Options are "", "ssl" or "tls"
  188.    * @var string
  189.    */
  190.   var $SMTPSecure = "";
  192.   /**
  193.    * Sets SMTP authentication. Utilizes the Username and Password variables.
  194.    * @var bool
  195.    */
  196.   var $SMTPAuth     = false;
  198.   /**
  199.    * Sets SMTP username.
  200.    * @var string
  201.    */
  202.   var $Username     = '';
  204.   /**
  205.    * Sets SMTP password.
  206.    * @var string
  207.    */
  208.   var $Password     = '';
  210.   /**
  211.    * Sets the SMTP server timeout in seconds. This function will not
  212.    * work with the win32 version.
  213.    * @var int
  214.    */
  215.   var $Timeout      = 10;
  217.   /**
  218.    * Sets SMTP class debugging on or off.
  219.    * @var bool
  220.    */
  221.   var $SMTPDebug    = false;
  223.   /**
  224.    * Prevents the SMTP connection from being closed after each mail
  225.    * sending.  If this is set to true then to close the connection
  226.    * requires an explicit call to SmtpClose().
  227.    * @var bool
  228.    */
  229.   var $SMTPKeepAlive = false;
  231.   /**
  232.    * Provides the ability to have the TO field process individual
  233.    * emails, instead of sending to entire TO addresses
  234.    * @var bool
  235.    */
  236.   var $SingleTo = false;
  238.   /////////////////////////////////////////////////
  239.   // PROPERTIES, PRIVATE
  240.   /////////////////////////////////////////////////
  242.   /**
  243.    * smtp object
  244.    * @var CBSMTP
  245.    */
  246.   var $smtp            = NULL;
  247.   var $to              = array();
  248.   var $cc              = array();
  249.   var $bcc             = array();
  250.   var $ReplyTo         = array();
  251.   var $attachment      = array();
  252.   var $CustomHeader    = array();
  253.   var $message_type    = '';
  254.   var $boundary        = array();
  255.   var $language        = array();
  256.   var $error_count     = 0;
  257.   var $LE              = "n";
  259.   /////////////////////////////////////////////////
  260.   // METHODS, VARIABLES
  261.   /////////////////////////////////////////////////
  263.   /**
  264.    * Sets message type to HTML.
  265.    * @param bool $bool
  266.    * @return void
  267.    */
  268.   function IsHTML($bool) {
  269.     if($bool == true) {
  270.       $this->ContentType = 'text/html';
  271.     } else {
  272.       $this->ContentType = 'text/plain';
  273.     }
  274.   }
  276.   /**
  277.    * Sets Mailer to send message using SMTP.
  278.    * @return void
  279.    */
  280.   function IsSMTP() {
  281.     $this->Mailer = 'smtp';
  282.   }
  284.   /**
  285.    * Sets Mailer to send message using PHP mail() function.
  286.    * @return void
  287.    */
  288.   function IsMail() {
  289.     $this->Mailer = 'mail';
  290.   }
  292.   /**
  293.    * Sets Mailer to send message using the $Sendmail program.
  294.    * @return void
  295.    */
  296.   function IsSendmail() {
  297.     $this->Mailer = 'sendmail';
  298.   }
  300.   /**
  301.    * Sets Mailer to send message using the qmail MTA.
  302.    * @return void
  303.    */
  304.   function IsQmail() {
  305.     $this->Sendmail = '/var/qmail/bin/sendmail';
  306.     $this->Mailer = 'sendmail';
  307.   }
  309.   /////////////////////////////////////////////////
  310.   // METHODS, RECIPIENTS
  311.   /////////////////////////////////////////////////
  313.   /**
  314.    * Adds a "To" address.
  315.    * @param string $address
  316.    * @param string $name
  317.    * @return void
  318.    */
  319.   function AddAddress($address, $name = '') {
  320.     $cur = count($this->to);
  321.     $this->to[$cur][0] = trim($address);
  322.     $this->to[$cur][1] = $name;
  323.   }
  325.   /**
  326.    * Adds a "Cc" address. Note: this function works
  327.    * with the SMTP mailer on win32, not with the "mail"
  328.    * mailer.
  329.    * @param string $address
  330.    * @param string $name
  331.    * @return void
  332.    */
  333.   function AddCC($address, $name = '') {
  334.     $cur = count($this->cc);
  335.     $this->cc[$cur][0] = trim($address);
  336.     $this->cc[$cur][1] = $name;
  337.   }
  339.   /**
  340.    * Adds a "Bcc" address. Note: this function works
  341.    * with the SMTP mailer on win32, not with the "mail"
  342.    * mailer.
  343.    * @param string $address
  344.    * @param string $name
  345.    * @return void
  346.    */
  347.   function AddBCC($address, $name = '') {
  348.     $cur = count($this->bcc);
  349.     $this->bcc[$cur][0] = trim($address);
  350.     $this->bcc[$cur][1] = $name;
  351.   }
  353.   /**
  354.    * Adds a "Reply-To" address.
  355.    * @param string $address
  356.    * @param string $name
  357.    * @return void
  358.    */
  359.   function AddReplyTo($address, $name = '') {
  360.     $cur = count($this->ReplyTo);
  361.     $this->ReplyTo[$cur][0] = trim($address);
  362.     $this->ReplyTo[$cur][1] = $name;
  363.   }
  365.   /////////////////////////////////////////////////
  366.   // METHODS, MAIL SENDING
  367.   /////////////////////////////////////////////////
  369.   /**
  370.    * Creates message and assigns Mailer. If the message is
  371.    * not sent successfully then it returns false.  Use the ErrorInfo
  372.    * variable to view description of the error.
  373.    * @return bool
  374.    */
  375.   function Send() {
  376.     $header = '';
  377.     $body = '';
  378.     $result = true;
  380.     if((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
  381.       $this->SetError($this->Lang('provide_address'));
  382.       return false;
  383.     }
  385.     /* Set whether the message is multipart/alternative */
  386.     if(!empty($this->AltBody)) {
  387.       $this->ContentType = 'multipart/alternative';
  388.     }
  390.     $this->error_count = 0; // reset errors
  391.     $this->SetMessageType();
  392.     $header .= $this->CreateHeader();
  393.     $body = $this->CreateBody();
  395.     if($body == '') {
  396.       return false;
  397.     }
  399.     /* Choose the mailer */
  400.     switch($this->Mailer) {
  401.       case 'sendmail':
  402.         $result = $this->SendmailSend($header, $body);
  403.         break;
  404.       case 'smtp':
  405.         $result = $this->SmtpSend($header, $body);
  406.         break;
  407.       case 'mail':
  408.         $result = $this->MailSend($header, $body);
  409.         break;
  410.       default:
  411.         $result = $this->MailSend($header, $body);
  412.         break;
  413.         //$this->SetError($this->Mailer . $this->Lang('mailer_not_supported'));
  414.         //$result = false;
  415.         //break;
  416.     }
  418.     return $result;
  419.   }
  421.   /**
  422.    * Sends mail using the $Sendmail program.
  423.    * @access private
  424.    * @return bool
  425.    */
  426.   function SendmailSend($header, $body) {
  427.     if ($this->Sender != '') {
  428.       $sendmail = sprintf("%s -oi -f %s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
  429.     } else {
  430.       $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));
  431.     }
  433.     if(!@$mail = popen($sendmail, 'w')) {
  434.       $this->SetError($this->Lang('execute') . $this->Sendmail);
  435.       return false;
  436.     }
  438.     fputs($mail, $header);
  439.     fputs($mail, $body);
  441.     $result = pclose($mail) >> 8 & 0xFF;
  442.     if($result != 0) {
  443.       $this->SetError($this->Lang('execute') . $this->Sendmail);
  444.       return false;
  445.     }
  447.     return true;
  448.   }
  450.   /**
  451.    * Sends mail using the PHP mail() function.
  452.    * @access private
  453.    * @return bool
  454.    */
  455.   function MailSend($header, $body) {
  457.     $to = '';
  458.     for($i = 0; $i < count($this->to); $i++) {
  459.       if($i != 0) { $to .= ', '; }
  460.       $to .= $this->AddrFormat($this->to[$i]);
  461.     }
  463.     $toArr = split(',', $to);
  465.     if ($this->Sender != '' && strlen(ini_get('safe_mode'))< 1) {
  466.       $old_from = ini_get('sendmail_from');
  467.       ini_set('sendmail_from', $this->Sender);
  468.       $params = sprintf("-oi -f %s", $this->Sender);
  469.       if ($this->SingleTo === true && count($toArr) > 1) {
  470.         foreach ($toArr as $key => $val) {
  471.           $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
  472.         }
  473.       } else {
  474.         $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
  475.       }
  476.     } else {
  477.       if ($this->SingleTo === true && count($toArr) > 1) {
  478.         foreach ($toArr as $key => $val) {
  479.           $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
  480.         }
  481.       } else {
  482.         $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header);
  483.       }
  484.     }
  486.     if (isset($old_from)) {
  487.       ini_set('sendmail_from', $old_from);
  488.     }
  490.     if(!$rt) {
  491.       $this->SetError($this->Lang('instantiate'));
  492.       return false;
  493.     }
  495.     return true;
  496.   }
  498.   /**
  499.    * Sends mail via SMTP using PhpSMTP (Author:
  500.    * Chris Ryan).  Returns bool.  Returns false if there is a
  501.    * bad MAIL FROM, RCPT, or DATA input.
  502.    * @access private
  503.    * @return bool
  504.    */
  505.   function SmtpSend($header, $body) {
  506.     include_once($this->PluginDir . 'phpmailer.smtp.php'); //BB: Line changed for CB library structure.
  507.     $error = '';
  508.     $bad_rcpt = array();
  510.     if(!$this->SmtpConnect()) {
  511.       return false;
  512.     }
  514.     $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
  515.     if(!$this->smtp->Mail($smtp_from)) {
  516.       $error = $this->Lang('from_failed') . $smtp_from;
  517.       $this->SetError($error);
  518.       $this->smtp->Reset();
  519.       return false;
  520.     }
  522.     /* Attempt to send attach all recipients */
  523.     for($i = 0; $i < count($this->to); $i++) {
  524.       if(!$this->smtp->Recipient($this->to[$i][0])) {
  525.         $bad_rcpt[] = $this->to[$i][0];
  526.       }
  527.     }
  528.     for($i = 0; $i < count($this->cc); $i++) {
  529.       if(!$this->smtp->Recipient($this->cc[$i][0])) {
  530.         $bad_rcpt[] = $this->cc[$i][0];
  531.       }
  532.     }
  533.     for($i = 0; $i < count($this->bcc); $i++) {
  534.       if(!$this->smtp->Recipient($this->bcc[$i][0])) {
  535.         $bad_rcpt[] = $this->bcc[$i][0];
  536.       }
  537.     }
  539.     if(count($bad_rcpt) > 0) { // Create error message
  540.       for($i = 0; $i < count($bad_rcpt); $i++) {
  541.         if($i != 0) {
  542.           $error .= ', ';
  543.         }
  544.         $error .= $bad_rcpt[$i];
  545.       }
  546.       $error = $this->Lang('recipients_failed') . $error;
  547.       $this->SetError($error);
  548.       $this->smtp->Reset();
  549.       return false;
  550.     }
  552.     if(!$this->smtp->Data($header . $body)) {
  553.       $this->SetError($this->Lang('data_not_accepted'));
  554.       $this->smtp->Reset();
  555.       return false;
  556.     }
  557.     if($this->SMTPKeepAlive == true) {
  558.       $this->smtp->Reset();
  559.     } else {
  560.       $this->SmtpClose();
  561.     }
  563.     return true;
  564.   }
  566.   /**
  567.    * Initiates a connection to an SMTP server.  Returns false if the
  568.    * operation failed.
  569.    * @access private
  570.    * @return bool
  571.    */
  572.   function SmtpConnect() {
  573.     if($this->smtp == NULL) {
  574.       $this->smtp = new CBSMTP();
  575.     }
  577.     $this->smtp->do_debug = $this->SMTPDebug;
  578.     $hosts = explode(';', $this->Host);
  579.     $index = 0;
  580.     $connection = ($this->smtp->Connected());
  582.     /* Retry while there is no connection */
  583.     while($index < count($hosts) && $connection == false) {
  584.       $hostinfo = array();
  585.       if(preg_match('/^(.+):([0-9]+)$/', $hosts[$index], $hostinfo)) { //BB changed to preg
  586.         $host = $hostinfo[1];
  587.         $port = $hostinfo[2];
  588.       } else {
  589.         $host = $hosts[$index];
  590.         $port = $this->Port;
  591.       }
  593.       if($this->smtp->Connect(((!empty($this->SMTPSecure))?$this->SMTPSecure.'://':'').$host, $port, $this->Timeout)) {
  594.         if ($this->Helo != '') {
  595.           $this->smtp->Hello($this->Helo);
  596.         } else {
  597.           $this->smtp->Hello($this->ServerHostname());
  598.         }
  600.         $connection = true;
  601.         if($this->SMTPAuth) {
  602.           if(!$this->smtp->Authenticate($this->Username, $this->Password)) {
  603.             $this->SetError($this->Lang('authenticate'));
  604.             $this->smtp->Reset();
  605.             $connection = false;
  606.           }
  607.         }
  608.       }
  609.       $index++;
  610.     }
  611.     if(!$connection) {
  612.       $this->SetError($this->Lang('connect_host'));
  613.     }
  615.     return $connection;
  616.   }
  618.   /**
  619.    * Closes the active SMTP session if one exists.
  620.    * @return void
  621.    */
  622.   function SmtpClose() {
  623.     if($this->smtp != NULL) {
  624.       if($this->smtp->Connected()) {
  625.         $this->smtp->Quit();
  626.         $this->smtp->Close();
  627.       }
  628.     }
  629.   }
  631.   /**
  632.    * Sets the language for all class error messages.  Returns false
  633.    * if it cannot load the language file.  The default language type
  634.    * is English.
  635.    * @param string $lang_type Type of language (e.g. Portuguese: "br")
  636.    * @param string $lang_path Path to the language file directory
  637.    * @access public
  638.    * @return bool
  639.    */
  640.   function SetLanguage($lang_type, $lang_path = 'language/') {
  641.     if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php')) {
  642.       include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
  643.     } elseif (file_exists($lang_path.'phpmailer.lang-en.php')) {
  644.       include($lang_path.'phpmailer.lang-en.php');
  645.     } else {
  646.       $this->SetError('Could not load language file');
  647.       return false;
  648.     }
  649.     $this->language = $PHPMAILER_LANG;
  651.     return true;
  652.   }
  654.   /////////////////////////////////////////////////
  655.   // METHODS, MESSAGE CREATION
  656.   /////////////////////////////////////////////////
  658.   /**
  659.    * Creates recipient headers.
  660.    * @access private
  661.    * @return string
  662.    */
  663.   function AddrAppend($type, $addr) {
  664.     $addr_str = $type . ': ';
  665.     $addr_str .= $this->AddrFormat($addr[0]);
  666.     if(count($addr) > 1) {
  667.       for($i = 1; $i < count($addr); $i++) {
  668.         $addr_str .= ', ' . $this->AddrFormat($addr[$i]);
  669.       }
  670.     }
  671.     $addr_str .= $this->LE;
  673.     return $addr_str;
  674.   }
  676.   /**
  677.    * Formats an address correctly.
  678.    * @access private
  679.    * @return string
  680.    */
  681.   function AddrFormat($addr) {
  682.     if(empty($addr[1])) {
  683.       $formatted = $this->SecureHeader($addr[0]);
  684.     } else {
  685.       $formatted = $this->EncodeHeader($this->SecureHeader($addr[1]), 'phrase') . " <" . $this->SecureHeader($addr[0]) . ">";
  686.     }
  688.     return $formatted;
  689.   }
  691.   /**
  692.    * Wraps message for use with mailers that do not
  693.    * automatically perform wrapping and for quoted-printable.
  694.    * Original written by philippe.
  695.    * @access private
  696.    * @return string
  697.    */
  698.   function WrapText($message, $length, $qp_mode = false) {
  699.     $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
  701.     $message = $this->FixEOL($message);
  702.     if (substr($message, -1) == $this->LE) {
  703.       $message = substr($message, 0, -1);
  704.     }
  706.     $line = explode($this->LE, $message);
  707.     $message = '';
  708.     for ($i=0 ;$i < count($line); $i++) {
  709.       $line_part = explode(' ', $line[$i]);
  710.       $buf = '';
  711.       for ($e = 0; $e<count($line_part); $e++) {
  712.         $word = $line_part[$e];
  713.         if ($qp_mode and (strlen($word) > $length)) {
  714.           $space_left = $length - strlen($buf) - 1;
  715.           if ($e != 0) {
  716.             if ($space_left > 20) {
  717.               $len = $space_left;
  718.               if (substr($word, $len - 1, 1) == '=') {
  719.                 $len--;
  720.               } elseif (substr($word, $len - 2, 1) == '=') {
  721.                 $len -= 2;
  722.               }
  723.               $part = substr($word, 0, $len);
  724.               $word = substr($word, $len);
  725.               $buf .= ' ' . $part;
  726.               $message .= $buf . sprintf("=%s", $this->LE);
  727.             } else {
  728.               $message .= $buf . $soft_break;
  729.             }
  730.             $buf = '';
  731.           }
  732.           while (strlen($word) > 0) {
  733.             $len = $length;
  734.             if (substr($word, $len - 1, 1) == '=') {
  735.               $len--;
  736.             } elseif (substr($word, $len - 2, 1) == '=') {
  737.               $len -= 2;
  738.             }
  739.             $part = substr($word, 0, $len);
  740.             $word = substr($word, $len);
  742.             if (strlen($word) > 0) {
  743.               $message .= $part . sprintf("=%s", $this->LE);
  744.             } else {
  745.               $buf = $part;
  746.             }
  747.           }
  748.         } else {
  749.           $buf_o = $buf;
  750.           $buf .= ($e == 0) ? $word : (' ' . $word);
  752.           if (strlen($buf) > $length and $buf_o != '') {
  753.             $message .= $buf_o . $soft_break;
  754.             $buf = $word;
  755.           }
  756.         }
  757.       }
  758.       $message .= $buf . $this->LE;
  759.     }
  761.     return $message;
  762.   }
  764.   /**
  765.    * Set the body wrapping.
  766.    * @access private
  767.    * @return void
  768.    */
  769.   function SetWordWrap() {
  770.     if($this->WordWrap < 1) {
  771.       return;
  772.     }
  774.     switch($this->message_type) {
  775.       case 'alt':
  776.         /* fall through */
  777.       case 'alt_attachments':
  778.         $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
  779.         break;
  780.       default:
  781.         $this->Body = $this->WrapText($this->Body, $this->WordWrap);
  782.         break;
  783.     }
  784.   }
  786.   /**
  787.    * Assembles message header.
  788.    * @access private
  789.    * @return string
  790.    */
  791.   function CreateHeader() {
  792.     $result = '';
  794.     /* Set the boundaries */
  795.     $uniq_id = md5(uniqid(time()));
  796.     $this->boundary[1] = 'b1_' . $uniq_id;
  797.     $this->boundary[2] = 'b2_' . $uniq_id;
  799.     $result .= $this->HeaderLine('Date', $this->RFCDate());
  800.     if($this->Sender == '') {
  801.       $result .= $this->HeaderLine('Return-Path', trim($this->From));
  802.     } else {
  803.       $result .= $this->HeaderLine('Return-Path', trim($this->Sender));
  804.     }
  806.     /* To be created automatically by mail() */
  807.     if($this->Mailer != 'mail') {
  808.       if(count($this->to) > 0) {
  809.         $result .= $this->AddrAppend('To', $this->to);
  810.       } elseif (count($this->cc) == 0) {
  811.         $result .= $this->HeaderLine('To', 'undisclosed-recipients:;');
  812.       }
  813.       if(count($this->cc) > 0) {
  814.         $result .= $this->AddrAppend('Cc', $this->cc);
  815.       }
  816.     }
  818.     $from = array();
  819.     $from[0][0] = trim($this->From);
  820.     $from[0][1] = $this->FromName;
  821.     $result .= $this->AddrAppend('From', $from);
  823.     /* sendmail and mail() extract Cc from the header before sending */
  824.     if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->cc) > 0)) {
  825.       $result .= $this->AddrAppend('Cc', $this->cc);
  826.     }
  828.     /* sendmail and mail() extract Bcc from the header before sending */
  829.     if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->bcc) > 0)) {
  830.       $result .= $this->AddrAppend('Bcc', $this->bcc);
  831.     }
  833.     if(count($this->ReplyTo) > 0) {
  834.       $result .= $this->AddrAppend('Reply-To', $this->ReplyTo);
  835.     }
  837.     /* mail() sets the subject itself */
  838.     if($this->Mailer != 'mail') {
  839.       $result .= $this->HeaderLine('Subject', $this->EncodeHeader($this->SecureHeader($this->Subject)));
  840.     }
  842.     $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
  843.     $result .= $this->HeaderLine('X-Priority', $this->Priority);
  844.     $result .= $this->HeaderLine('X-Mailer', 'PHPMailer (phpmailer.sourceforge.net) [version ' . $this->Version . ']');
  846.     if($this->ConfirmReadingTo != '') {
  847.       $result .= $this->HeaderLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');
  848.     }
  850.     // Add custom headers
  851.     for($index = 0; $index < count($this->CustomHeader); $index++) {
  852.       $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
  853.     }
  854.     $result .= $this->HeaderLine('MIME-Version', '1.0');
  856.     switch($this->message_type) {
  857.       case 'plain':
  858.         $result .= $this->HeaderLine('Content-Transfer-Encoding', $this->Encoding);
  859.         $result .= sprintf("Content-Type: %s; charset="%s"", $this->ContentType, $this->CharSet);
  860.         break;
  861.       case 'attachments':
  862.         /* fall through */
  863.       case 'alt_attachments':
  864.         if($this->InlineImageExists()){
  865.           $result .= sprintf("Content-Type: %s;%sttype="text/html";%stboundary="%s"%s", 'multipart/related', $this->LE, $this->LE, $this->boundary[1], $this->LE);
  866.         } else {
  867.           $result .= $this->HeaderLine('Content-Type', 'multipart/mixed;');
  868.           $result .= $this->TextLine("tboundary="" . $this->boundary[1] . '"');
  869.         }
  870.         break;
  871.       case 'alt':
  872.         $result .= $this->HeaderLine('Content-Type', 'multipart/alternative;');
  873.         $result .= $this->TextLine("tboundary="" . $this->boundary[1] . '"');
  874.         break;
  875.     }
  877.     if($this->Mailer != 'mail') {
  878.       $result .= $this->LE.$this->LE;
  879.     }
  881.     return $result;
  882.   }
  884.   /**
  885.    * Assembles the message body.  Returns an empty string on failure.
  886.    * @access private
  887.    * @return string
  888.    */
  889.   function CreateBody() {
  890.     $result = '';
  892.     $this->SetWordWrap();
  894.     switch($this->message_type) {
  895.       case 'alt':
  896.         $result .= $this->GetBoundary($this->boundary[1], '', 'text/plain', '');
  897.         $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  898.         $result .= $this->LE.$this->LE;
  899.         $result .= $this->GetBoundary($this->boundary[1], '', 'text/html', '');
  900.         $result .= $this->EncodeString($this->Body, $this->Encoding);
  901.         $result .= $this->LE.$this->LE;
  902.         $result .= $this->EndBoundary($this->boundary[1]);
  903.         break;
  904.       case 'plain':
  905.         $result .= $this->EncodeString($this->Body, $this->Encoding);
  906.         break;
  907.       case 'attachments':
  908.         $result .= $this->GetBoundary($this->boundary[1], '', '', '');
  909.         $result .= $this->EncodeString($this->Body, $this->Encoding);
  910.         $result .= $this->LE;
  911.         $result .= $this->AttachAll();
  912.         break;
  913.       case 'alt_attachments':
  914.         $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
  915.         $result .= sprintf("Content-Type: %s;%s" . "tboundary="%s"%s", 'multipart/alternative', $this->LE, $this->boundary[2], $this->LE.$this->LE);
  916.         $result .= $this->GetBoundary($this->boundary[2], '', 'text/plain', '') . $this->LE; // Create text body
  917.         $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  918.         $result .= $this->LE.$this->LE;
  919.         $result .= $this->GetBoundary($this->boundary[2], '', 'text/html', '') . $this->LE; // Create the HTML body
  920.         $result .= $this->EncodeString($this->Body, $this->Encoding);
  921.         $result .= $this->LE.$this->LE;
  922.         $result .= $this->EndBoundary($this->boundary[2]);
  923.         $result .= $this->AttachAll();
  924.         break;
  925.     }
  926.     if($this->IsError()) {
  927.       $result = '';
  928.     }
  930.     return $result;
  931.   }
  933.   /**
  934.    * Returns the start of a message boundary.
  935.    * @access private
  936.    */
  937.   function GetBoundary($boundary, $charSet, $contentType, $encoding) {
  938.     $result = '';
  939.     if($charSet == '') {
  940.       $charSet = $this->CharSet;
  941.     }
  942.     if($contentType == '') {
  943.       $contentType = $this->ContentType;
  944.     }
  945.     if($encoding == '') {
  946.       $encoding = $this->Encoding;
  947.     }
  948.     $result .= $this->TextLine('--' . $boundary);
  949.     $result .= sprintf("Content-Type: %s; charset = "%s"", $contentType, $charSet);
  950.     $result .= $this->LE;
  951.     $result .= $this->HeaderLine('Content-Transfer-Encoding', $encoding);
  952.     $result .= $this->LE;
  954.     return $result;
  955.   }
  957.   /**
  958.    * Returns the end of a message boundary.
  959.    * @access private
  960.    */
  961.   function EndBoundary($boundary) {
  962.     return $this->LE . '--' . $boundary . '--' . $this->LE;
  963.   }
  965.   /**
  966.    * Sets the message type.
  967.    * @access private
  968.    * @return void
  969.    */
  970.   function SetMessageType() {
  971.     if(count($this->attachment) < 1 && strlen($this->AltBody) < 1) {
  972.       $this->message_type = 'plain';
  973.     } else {
  974.       if(count($this->attachment) > 0) {
  975.         $this->message_type = 'attachments';
  976.       }
  977.       if(strlen($this->AltBody) > 0 && count($this->attachment) < 1) {
  978.         $this->message_type = 'alt';
  979.       }
  980.       if(strlen($this->AltBody) > 0 && count($this->attachment) > 0) {
  981.         $this->message_type = 'alt_attachments';
  982.       }
  983.     }
  984.   }
  986.   /* Returns a formatted header line.
  987.    * @access private
  988.    * @return string
  989.    */
  990.   function HeaderLine($name, $value) {
  991.     return $name . ': ' . $value . $this->LE;
  992.   }
  994.   /**
  995.    * Returns a formatted mail line.
  996.    * @access private
  997.    * @return string
  998.    */
  999.   function TextLine($value) {
  1000.     return $value . $this->LE;
  1001.   }
  1003.   /////////////////////////////////////////////////
  1004.   // CLASS METHODS, ATTACHMENTS
  1005.   /////////////////////////////////////////////////
  1007.   /**
  1008.    * Adds an attachment from a path on the filesystem.
  1009.    * Returns false if the file could not be found
  1010.    * or accessed.
  1011.    * @param string $path Path to the attachment.
  1012.    * @param string $name Overrides the attachment name.
  1013.    * @param string $encoding File encoding (see $Encoding).
  1014.    * @param string $type File extension (MIME) type.
  1015.    * @return bool
  1016.    */
  1017.   function AddAttachment($path, $name = '', $encoding = 'base64', $type = 'application/octet-stream') {
  1018.     if(!@is_file($path)) {
  1019.       $this->SetError($this->Lang('file_access') . $path);
  1020.       return false;
  1021.     }
  1023.     $filename = basename($path);
  1024.     if($name == '') {
  1025.       $name = $filename;
  1026.     }
  1028.     $cur = count($this->attachment);
  1029.     $this->attachment[$cur][0] = $path;
  1030.     $this->attachment[$cur][1] = $filename;
  1031.     $this->attachment[$cur][2] = $name;
  1032.     $this->attachment[$cur][3] = $encoding;
  1033.     $this->attachment[$cur][4] = $type;
  1034.     $this->attachment[$cur][5] = false; // isStringAttachment
  1035.     $this->attachment[$cur][6] = 'attachment';
  1036.     $this->attachment[$cur][7] = 0;
  1038.     return true;
  1039.   }
  1041.   /**
  1042.    * Attaches all fs, string, and binary attachments to the message.
  1043.    * Returns an empty string on failure.
  1044.    * @access private
  1045.    * @return string
  1046.    */
  1047.   function AttachAll() {
  1048.     /* Return text of body */
  1049.     $mime = array();
  1051.     /* Add all attachments */
  1052.     for($i = 0; $i < count($this->attachment); $i++) {
  1053.       /* Check for string attachment */
  1054.       $bString = $this->attachment[$i][5];
  1055.       if ($bString) {
  1056.         $string = $this->attachment[$i][0];
  1057.       } else {
  1058.         $path = $this->attachment[$i][0];
  1059.       }
  1061.       $filename    = $this->attachment[$i][1];
  1062.       $name        = $this->attachment[$i][2];
  1063.       $encoding    = $this->attachment[$i][3];
  1064.       $type        = $this->attachment[$i][4];
  1065.       $disposition = $this->attachment[$i][6];
  1066.       $cid         = $this->attachment[$i][7];
  1068.       $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
  1069.       $mime[] = sprintf("Content-Type: %s; name="%s"%s", $type, $name, $this->LE);
  1070.       $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
  1072.       if($disposition == 'inline') {
  1073.         $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
  1074.       }
  1076.       $mime[] = sprintf("Content-Disposition: %s; filename="%s"%s", $disposition, $name, $this->LE.$this->LE);
  1078.       /* Encode as string attachment */
  1079.       if($bString) {
  1080.         $mime[] = $this->EncodeString($string, $encoding);
  1081.         if($this->IsError()) {
  1082.           return '';
  1083.         }
  1084.         $mime[] = $this->LE.$this->LE;
  1085.       } else {
  1086.         $mime[] = $this->EncodeFile($path, $encoding);
  1087.         if($this->IsError()) {
  1088.           return '';
  1089.         }
  1090.         $mime[] = $this->LE.$this->LE;
  1091.       }
  1092.     }
  1094.     $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
  1096.     return join('', $mime);
  1097.   }
  1099.   /**
  1100.    * Encodes attachment in requested format.  Returns an
  1101.    * empty string on failure.
  1102.    * @access private
  1103.    * @return string
  1104.    */
  1105.   function EncodeFile ($path, $encoding = 'base64') {
  1106.     if(!@$fd = fopen($path, 'rb')) {
  1107.       $this->SetError($this->Lang('file_open') . $path);
  1108.       return '';
  1109.     }
  1110.     $magic_quotes = get_magic_quotes_runtime();
  1111.     set_magic_quotes_runtime(0);
  1112.     $file_buffer = fread($fd, filesize($path));
  1113.     $file_buffer = $this->EncodeString($file_buffer, $encoding);
  1114.     fclose($fd);
  1115.     set_magic_quotes_runtime($magic_quotes);
  1117.     return $file_buffer;
  1118.   }
  1120.   /**
  1121.    * Encodes string to requested format. Returns an
  1122.    * empty string on failure.
  1123.    * @access private
  1124.    * @return string
  1125.    */
  1126.   function EncodeString ($str, $encoding = 'base64') {
  1127.     $encoded = '';
  1128.     switch(strtolower($encoding)) {
  1129.       case 'base64':
  1130.         /* chunk_split is found in PHP >= 3.0.6 */
  1131.         $encoded = chunk_split(base64_encode($str), 76, $this->LE);
  1132.         break;
  1133.       case '7bit':
  1134.       case '8bit':
  1135.         $encoded = $this->FixEOL($str);
  1136.         if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1137.           $encoded .= $this->LE;
  1138.         break;
  1139.       case 'binary':
  1140.         $encoded = $str;
  1141.         break;
  1142.       case 'quoted-printable':
  1143.         $encoded = $this->EncodeQP($str);
  1144.         break;
  1145.       default:
  1146.         $this->SetError($this->Lang('encoding') . $encoding);
  1147.         break;
  1148.     }
  1149.     return $encoded;
  1150.   }
  1152.   /**
  1153.    * Encode a header string to best of Q, B, quoted or none.
  1154.    * @access private
  1155.    * @return string
  1156.    */
  1157.   function EncodeHeader ($str, $position = 'text') {
  1158.     $x = 0;
  1160.     switch (strtolower($position)) {
  1161.       case 'phrase':
  1162.         if (!preg_match('/[200-377]/', $str)) {
  1163.           /* Can't use addslashes as we don't know what value has magic_quotes_sybase. */
  1164.           $encoded = addcslashes($str, "..37177\"");
  1165.           if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&'*+/=?^_`{|}~ -]/', $str)) {
  1166.             return ($encoded);
  1167.           } else {
  1168.             return (""$encoded"");
  1169.           }
  1170.         }
  1171.         $x = preg_match_all('/[^404143-133135-176]/', $str, $matches);
  1172.         break;
  1173.       case 'comment':
  1174.         $x = preg_match_all('/[()"]/', $str, $matches);
  1175.         /* Fall-through */
  1176.       case 'text':
  1177.       default:
  1178.         $x += preg_match_all('/[00-10131416-37177-377]/', $str, $matches);
  1179.         break;
  1180.     }
  1182.     if ($x == 0) {
  1183.       return ($str);
  1184.     }
  1186.     $maxlen = 75 - 7 - strlen($this->CharSet);
  1187.     /* Try to select the encoding which should produce the shortest output */
  1188.     if (strlen($str)/3 < $x) {
  1189.       $encoding = 'B';
  1190.       $encoded = base64_encode($str);
  1191.       $maxlen -= $maxlen % 4;
  1192.       $encoded = trim(chunk_split($encoded, $maxlen, "n"));
  1193.     } else {
  1194.       $encoding = 'Q';
  1195.       $encoded = $this->EncodeQ($str, $position);
  1196.       $encoded = $this->WrapText($encoded, $maxlen, true);
  1197.       $encoded = str_replace('='.$this->LE, "n", trim($encoded));
  1198.     }
  1200.     $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\1?=", $encoded);
  1201.     $encoded = trim(str_replace("n", $this->LE, $encoded));
  1203.     return $encoded;
  1204.   }
  1206.   /**
  1207.    * Encode string to quoted-printable.
  1208.    * @access private
  1209.    * @return string
  1210.    */
  1211.   function EncodeQP( $input = '', $line_max = 76, $space_conv = false ) {
  1212.     $hex = array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
  1213.     $lines = preg_split('/(?:rn|r|n)/', $input);
  1214.     $eol = "rn";
  1215.     $escape = '=';
  1216.     $output = '';
  1217.     while( list(, $line) = each($lines) ) {
  1218.       $linlen = strlen($line);
  1219.       $newline = '';
  1220.       for($i = 0; $i < $linlen; $i++) {
  1221.         $c = substr( $line, $i, 1 );
  1222.         $dec = ord( $c );
  1223.         if ( ( $i == 0 ) && ( $dec == 46 ) ) { // convert first point in the line into =2E
  1224.           $c = '=2E';
  1225.         }
  1226.         if ( $dec == 32 ) {
  1227.           if ( $i == ( $linlen - 1 ) ) { // convert space at eol only
  1228.             $c = '=20';
  1229.           } else if ( $space_conv ) {
  1230.             $c = '=20';
  1231.           }
  1232.         } elseif ( ($dec == 61) || ($dec < 32 ) || ($dec > 126) ) { // always encode "t", which is *not* required
  1233.           $h2 = floor($dec/16);
  1234.           $h1 = floor($dec%16);
  1235.           $c = $escape.$hex[$h2].$hex[$h1];
  1236.         }
  1237.         if ( (strlen($newline) + strlen($c)) >= $line_max ) { // CRLF is not counted
  1238.           $output .= $newline.$escape.$eol; //  soft line break; " =rn" is okay
  1239.           $newline = '';
  1240.           // check if newline first character will be point or not
  1241.           if ( $dec == 46 ) {
  1242.             $c = '=2E';
  1243.           }
  1244.         }
  1245.         $newline .= $c;
  1246.       } // end of for
  1247.       $output .= $newline.$eol;
  1248.     } // end of while
  1249.     return trim($output);
  1250.   }
  1252.   /**
  1253.    * Encode string to q encoding.
  1254.    * @access private
  1255.    * @return string
  1256.    */
  1257.   function EncodeQ ($str, $position = 'text') {
  1258.     /* There should not be any EOL in the string */
  1259.     $encoded = preg_replace("[rn]", '', $str);
  1261.     switch (strtolower($position)) {
  1262.       case 'phrase':
  1263.         $encoded = preg_replace("/([^A-Za-z0-9!*+/ -])/e", "'='.sprintf('%02X', ord('\1'))", $encoded);
  1264.         break;
  1265.       case 'comment':
  1266.         $encoded = preg_replace("/([()"])/e", "'='.sprintf('%02X', ord('\1'))", $encoded);
  1267.       case 'text':
  1268.       default:
  1269.         /* Replace every high ascii, control =, ? and _ characters */
  1270.         $encoded = preg_replace('/([00-11131416-377577137177-377])/e',
  1271.               "'='.sprintf('%02X', ord('\1'))", $encoded);
  1272.         break;
  1273.     }
  1275.     /* Replace every spaces to _ (more readable than =20) */
  1276.     $encoded = str_replace(' ', '_', $encoded);
  1278.     return $encoded;
  1279.   }
  1281.   /**
  1282.    * Adds a string or binary attachment (non-filesystem) to the list.
  1283.    * This method can be used to attach ascii or binary data,
  1284.    * such as a BLOB record from a database.
  1285.    * @param string $string String attachment data.
  1286.    * @param string $filename Name of the attachment.
  1287.    * @param string $encoding File encoding (see $Encoding).
  1288.    * @param string $type File extension (MIME) type.
  1289.    * @return void
  1290.    */
  1291.   function AddStringAttachment($string, $filename, $encoding = 'base64', $type = 'application/octet-stream') {
  1292.     /* Append to $attachment array */
  1293.     $cur = count($this->attachment);
  1294.     $this->attachment[$cur][0] = $string;
  1295.     $this->attachment[$cur][1] = $filename;
  1296.     $this->attachment[$cur][2] = $filename;
  1297.     $this->attachment[$cur][3] = $encoding;
  1298.     $this->attachment[$cur][4] = $type;
  1299.     $this->attachment[$cur][5] = true; // isString
  1300.     $this->attachment[$cur][6] = 'attachment';
  1301.     $this->attachment[$cur][7] = 0;
  1302.   }
  1304.   /**
  1305.    * Adds an embedded attachment.  This can include images, sounds, and
  1306.    * just about any other document.  Make sure to set the $type to an
  1307.    * image type.  For JPEG images use "image/jpeg" and for GIF images
  1308.    * use "image/gif".
  1309.    * @param string $path Path to the attachment.
  1310.    * @param string $cid Content ID of the attachment.  Use this to identify
  1311.    *        the Id for accessing the image in an HTML form.
  1312.    * @param string $name Overrides the attachment name.
  1313.    * @param string $encoding File encoding (see $Encoding).
  1314.    * @param string $type File extension (MIME) type.
  1315.    * @return bool
  1316.    */
  1317.   function AddEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = 'application/octet-stream') {
  1319.     if(!@is_file($path)) {
  1320.       $this->SetError($this->Lang('file_access') . $path);
  1321.       return false;
  1322.     }
  1324.     $filename = basename($path);
  1325.     if($name == '') {
  1326.       $name = $filename;
  1327.     }
  1329.     /* Append to $attachment array */
  1330.     $cur = count($this->attachment);
  1331.     $this->attachment[$cur][0] = $path;
  1332.     $this->attachment[$cur][1] = $filename;
  1333.     $this->attachment[$cur][2] = $name;
  1334.     $this->attachment[$cur][3] = $encoding;
  1335.     $this->attachment[$cur][4] = $type;
  1336.     $this->attachment[$cur][5] = false;
  1337.     $this->attachment[$cur][6] = 'inline';
  1338.     $this->attachment[$cur][7] = $cid;
  1340.     return true;
  1341.   }
  1343.   /**
  1344.    * Returns true if an inline attachment is present.
  1345.    * @access private
  1346.    * @return bool
  1347.    */
  1348.   function InlineImageExists() {
  1349.     $result = false;
  1350.     for($i = 0; $i < count($this->attachment); $i++) {
  1351.       if($this->attachment[$i][6] == 'inline') {
  1352.         $result = true;
  1353.         break;
  1354.       }
  1355.     }
  1357.     return $result;
  1358.   }
  1360.   /////////////////////////////////////////////////
  1361.   // CLASS METHODS, MESSAGE RESET
  1362.   /////////////////////////////////////////////////
  1364.   /**
  1365.    * Clears all recipients assigned in the TO array.  Returns void.
  1366.    * @return void
  1367.    */
  1368.   function ClearAddresses() {
  1369.     $this->to = array();
  1370.   }
  1372.   /**
  1373.    * Clears all recipients assigned in the CC array.  Returns void.
  1374.    * @return void
  1375.    */
  1376.   function ClearCCs() {
  1377.     $this->cc = array();
  1378.   }
  1380.   /**
  1381.    * Clears all recipients assigned in the BCC array.  Returns void.
  1382.    * @return void
  1383.    */
  1384.   function ClearBCCs() {
  1385.     $this->bcc = array();
  1386.   }
  1388.   /**
  1389.    * Clears all recipients assigned in the ReplyTo array.  Returns void.
  1390.    * @return void
  1391.    */
  1392.   function ClearReplyTos() {
  1393.     $this->ReplyTo = array();
  1394.   }
  1396.   /**
  1397.    * Clears all recipients assigned in the TO, CC and BCC
  1398.    * array.  Returns void.
  1399.    * @return void
  1400.    */
  1401.   function ClearAllRecipients() {
  1402.     $this->to = array();
  1403.     $this->cc = array();
  1404.     $this->bcc = array();
  1405.   }
  1407.   /**
  1408.    * Clears all previously set filesystem, string, and binary
  1409.    * attachments.  Returns void.
  1410.    * @return void
  1411.    */
  1412.   function ClearAttachments() {
  1413.     $this->attachment = array();
  1414.   }
  1416.   /**
  1417.    * Clears all custom headers.  Returns void.
  1418.    * @return void
  1419.    */
  1420.   function ClearCustomHeaders() {
  1421.     $this->CustomHeader = array();
  1422.   }
  1424.   /////////////////////////////////////////////////
  1425.   // CLASS METHODS, MISCELLANEOUS
  1426.   /////////////////////////////////////////////////
  1428.   /**
  1429.    * Adds the error message to the error container.
  1430.    * Returns void.
  1431.    * @access private
  1432.    * @return void
  1433.    */
  1434.   function SetError($msg) {
  1435.     $this->error_count++;
  1436.     $this->ErrorInfo = $msg;
  1437.   }
  1439.   /**
  1440.    * Returns the proper RFC 822 formatted date.
  1441.    * @access private
  1442.    * @return string
  1443.    */
  1444.   function RFCDate() {
  1445.     $tz = date('Z');
  1446.     $tzs = ($tz < 0) ? '-' : '+';
  1447.     $tz = abs($tz);
  1448.     $tz = (int)($tz/3600)*100 + ($tz%3600)/60;
  1449.     $result = sprintf("%s %s%04d", date('D, j M Y H:i:s'), $tzs, $tz);
  1451.     return $result;
  1452.   }
  1454.   /**
  1455.    * Returns the appropriate server variable.  Should work with both
  1456.    * PHP 4.1.0+ as well as older versions.  Returns an empty string
  1457.    * if nothing is found.
  1458.    * @access private
  1459.    * @return mixed
  1460.    */
  1461.   function ServerVar($varName) {
  1462.     global $HTTP_SERVER_VARS;
  1463.     global $HTTP_ENV_VARS;
  1465.     if(!isset($_SERVER)) {
  1466.       $_SERVER = $HTTP_SERVER_VARS;
  1467.       if(!isset($_SERVER['REMOTE_ADDR'])) {
  1468.         $_SERVER = $HTTP_ENV_VARS; // must be Apache
  1469.       }
  1470.     }
  1472.     if(isset($_SERVER[$varName])) {
  1473.       return $_SERVER[$varName];
  1474.     } else {
  1475.       return '';
  1476.     }
  1477.   }
  1479.   /**
  1480.    * Returns the server hostname or 'localhost.localdomain' if unknown.
  1481.    * @access private
  1482.    * @return string
  1483.    */
  1484.   function ServerHostname() {
  1485.     if ($this->Hostname != '') {
  1486.       $result = $this->Hostname;
  1487.     } elseif ($this->ServerVar('SERVER_NAME') != '') {
  1488.       $result = $this->ServerVar('SERVER_NAME');
  1489.     } else {
  1490.       $result = 'localhost.localdomain';
  1491.     }
  1493.     return $result;
  1494.   }
  1496.   /**
  1497.    * Returns a message in the appropriate language.
  1498.    * @access private
  1499.    * @return string
  1500.    */
  1501.   function Lang($key) {
  1502.     if(count($this->language) < 1) {
  1503.       $this->SetLanguage('en'); // set the default language
  1504.     }
  1506.     if(isset($this->language[$key])) {
  1507.       return $this->language[$key];
  1508.     } else {
  1509.       return 'Language string failed to load: ' . $key;
  1510.     }
  1511.   }
  1513.   /**
  1514.    * Returns true if an error occurred.
  1515.    * @return bool
  1516.    */
  1517.   function IsError() {
  1518.     return ($this->error_count > 0);
  1519.   }
  1521.   /**
  1522.    * Changes every end of line from CR or LF to CRLF.
  1523.    * @access private
  1524.    * @return string
  1525.    */
  1526.   function FixEOL($str) {
  1527.     $str = str_replace("rn", "n", $str);
  1528.     $str = str_replace("r", "n", $str);
  1529.     $str = str_replace("n", $this->LE, $str);
  1530.     return $str;
  1531.   }
  1533.   /**
  1534.    * Adds a custom header.
  1535.    * @return void
  1536.    */
  1537.   function AddCustomHeader($custom_header) {
  1538.     $this->CustomHeader[] = explode(':', $custom_header, 2);
  1539.   }
  1541.   /**
  1542.    * Evaluates the message and returns modifications for inline images and backgrounds
  1543.    * @access public
  1544.    * @return $message
  1545.    */
  1546.   function MsgHTML($message) {
  1547.     preg_match_all("/(src|background)="(.*)"/Ui", $message, $images);
  1548.     if(isset($images[2])) {
  1549.       foreach($images[2] as $i => $url) {
  1550.         $filename  = basename($url);
  1551.         $directory = dirname($url);
  1552.         $cid       = 'cid:' . md5($filename);
  1553.         $fileParts = split(".", $filename);
  1554.         $ext       = $fileParts[1];
  1555.         $mimeType  = $this->_mime_types($ext);
  1556.         $message = preg_replace("/".$images[1][$i]."="".preg_quote($url, '/').""/Ui", $images[1][$i]."="".$cid.""", $message);
  1557.         $this->AddEmbeddedImage($url, md5($filename), $filename, 'base64', $mimeType);
  1558.       }
  1559.     }
  1560.     $this->IsHTML(true);
  1561.     $this->Body = $message;
  1562.     $textMsg = trim(strip_tags($message));
  1563.     if ( !empty($textMsg) && empty($this->AltBody) ) {
  1564.       $this->AltBody = $textMsg;
  1565.     }
  1566.     if ( empty($this->AltBody) ) {
  1567.       $this->AltBody = 'To view this email message, open the email in with HTML compatibility!' . "nn";
  1568.     }
  1569.   }
  1571.   /**
  1572.    * Gets the mime type of the embedded or inline image
  1573.    * @access private
  1574.    * @return mime type of ext
  1575.    */
  1576.   function _mime_types($ext = '') {
  1577.     $mimes = array(
  1578.       'hqx'  =>  'application/mac-binhex40',
  1579.       'cpt'   =>  'application/mac-compactpro',
  1580.       'doc'   =>  'application/msword',
  1581.       'bin'   =>  'application/macbinary',
  1582.       'dms'   =>  'application/octet-stream',
  1583.       'lha'   =>  'application/octet-stream',
  1584.       'lzh'   =>  'application/octet-stream',
  1585.       'exe'   =>  'application/octet-stream',
  1586.       'class' =>  'application/octet-stream',
  1587.       'psd'   =>  'application/octet-stream',
  1588.       'so'    =>  'application/octet-stream',
  1589.       'sea'   =>  'application/octet-stream',
  1590.       'dll'   =>  'application/octet-stream',
  1591.       'oda'   =>  'application/oda',
  1592.       'pdf'   =>  'application/pdf',
  1593.       'ai'    =>  'application/postscript',
  1594.       'eps'   =>  'application/postscript',
  1595.       'ps'    =>  'application/postscript',
  1596.       'smi'   =>  'application/smil',
  1597.       'smil'  =>  'application/smil',
  1598.       'mif'   =>  'application/vnd.mif',
  1599.       'xls'   =>  'application/vnd.ms-excel',
  1600.       'ppt'   =>  'application/vnd.ms-powerpoint',
  1601.       'wbxml' =>  'application/vnd.wap.wbxml',
  1602.       'wmlc'  =>  'application/vnd.wap.wmlc',
  1603.       'dcr'   =>  'application/x-director',
  1604.       'dir'   =>  'application/x-director',
  1605.       'dxr'   =>  'application/x-director',
  1606.       'dvi'   =>  'application/x-dvi',
  1607.       'gtar'  =>  'application/x-gtar',
  1608.       'php'   =>  'application/x-httpd-php',
  1609.       'php4'  =>  'application/x-httpd-php',
  1610.       'php3'  =>  'application/x-httpd-php',
  1611.       'phtml' =>  'application/x-httpd-php',
  1612.       'phps'  =>  'application/x-httpd-php-source',
  1613.       'js'    =>  'application/x-javascript',
  1614.       'swf'   =>  'application/x-shockwave-flash',
  1615.       'sit'   =>  'application/x-stuffit',
  1616.       'tar'   =>  'application/x-tar',
  1617.       'tgz'   =>  'application/x-tar',
  1618.       'xhtml' =>  'application/xhtml+xml',
  1619.       'xht'   =>  'application/xhtml+xml',
  1620.       'zip'   =>  'application/zip',
  1621.       'mid'   =>  'audio/midi',
  1622.       'midi'  =>  'audio/midi',
  1623.       'mpga'  =>  'audio/mpeg',
  1624.       'mp2'   =>  'audio/mpeg',
  1625.       'mp3'   =>  'audio/mpeg',
  1626.       'aif'   =>  'audio/x-aiff',
  1627.       'aiff'  =>  'audio/x-aiff',
  1628.       'aifc'  =>  'audio/x-aiff',
  1629.       'ram'   =>  'audio/x-pn-realaudio',
  1630.       'rm'    =>  'audio/x-pn-realaudio',
  1631.       'rpm'   =>  'audio/x-pn-realaudio-plugin',
  1632.       'ra'    =>  'audio/x-realaudio',
  1633.       'rv'    =>  'video/vnd.rn-realvideo',
  1634.       'wav'   =>  'audio/x-wav',
  1635.       'bmp'   =>  'image/bmp',
  1636.       'gif'   =>  'image/gif',
  1637.       'jpeg'  =>  'image/jpeg',
  1638.       'jpg'   =>  'image/jpeg',
  1639.       'jpe'   =>  'image/jpeg',
  1640.       'png'   =>  'image/png',
  1641.       'tiff'  =>  'image/tiff',
  1642.       'tif'   =>  'image/tiff',
  1643.       'css'   =>  'text/css',
  1644.       'html'  =>  'text/html',
  1645.       'htm'   =>  'text/html',
  1646.       'shtml' =>  'text/html',
  1647.       'txt'   =>  'text/plain',
  1648.       'text'  =>  'text/plain',
  1649.       'log'   =>  'text/plain',
  1650.       'rtx'   =>  'text/richtext',
  1651.       'rtf'   =>  'text/rtf',
  1652.       'xml'   =>  'text/xml',
  1653.       'xsl'   =>  'text/xml',
  1654.       'mpeg'  =>  'video/mpeg',
  1655.       'mpg'   =>  'video/mpeg',
  1656.       'mpe'   =>  'video/mpeg',
  1657.       'qt'    =>  'video/quicktime',
  1658.       'mov'   =>  'video/quicktime',
  1659.       'avi'   =>  'video/x-msvideo',
  1660.       'movie' =>  'video/x-sgi-movie',
  1661.       'doc'   =>  'application/msword',
  1662.       'word'  =>  'application/msword',
  1663.       'xl'    =>  'application/excel',
  1664.       'eml'   =>  'message/rfc822'
  1665.     );
  1666.     return ( ! isset($mimes[strtolower($ext)])) ? 'application/x-unknown-content-type' : $mimes[strtolower($ext)];
  1667.   }
  1669.   /**
  1670.    * Set (or reset) Class Objects (variables)
  1671.    *
  1672.    * Usage Example:
  1673.    * $page->set('X-Priority', '3');
  1674.    *
  1675.    * @access public
  1676.    * @param string $name Parameter Name
  1677.    * @param mixed $value Parameter Value
  1678.    * NOTE: will not work with arrays, there are no arrays to set/reset
  1679.    */
  1680.   function set ( $name, $value = '' ) {
  1681.     if ( isset($this->$name) ) {
  1682.       $this->$name = $value;
  1683.     } else {
  1684.       $this->SetError('Cannot set or reset variable ' . $name);
  1685.       return false;
  1686.     }
  1687.   }
  1689.   /**
  1690.    * Read a file from a supplied filename and return it.
  1691.    *
  1692.    * @access public
  1693.    * @param string $filename Parameter File Name
  1694.    */
  1695.   function getFile($filename) {
  1696.     $return = '';
  1697.     if ($fp = fopen($filename, 'rb')) {
  1698.       while (!feof($fp)) {
  1699.         $return .= fread($fp, 1024);
  1700.       }
  1701.       fclose($fp);
  1702.       return $return;
  1703.     } else {
  1704.       return false;
  1705.     }
  1706.   }
  1708.   /**
  1709.    * Strips newlines to prevent header injection.
  1710.    * @access private
  1711.    * @param string $str String
  1712.    * @return string
  1713.    */
  1714.   function SecureHeader($str) {
  1715.     $str = trim($str);
  1716.     $str = str_replace("r", "", $str);
  1717.     $str = str_replace("n", "", $str);
  1718.     return $str;
  1719.   }
  1721. }
  1723. ?>