Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: PHPMailer

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /phpmailer/phpmailer.php

Documentation is available at phpmailer.php

  1. <?php
  2. ////////////////////////////////////////////////////
  3. // PHPMailer - PHP email class
  4. //
  5. // Class for sending email using either
  6. // sendmail, PHP mail(), or SMTP.  Methods are
  7. // based upon the standard AspEmail(tm) classes.
  8. //
  9. // Copyright (C) 2001 - 2003  Brent R. Matzelle
  10. //
  11. // License: LGPL, see LICENSE
  12. ////////////////////////////////////////////////////
  13.  
  14. /**
  15.  * PHPMailer - PHP email transport class
  16.  * @package PHPMailer
  17.  * @author Brent R. Matzelle
  18.  * @copyright 2001 - 2003 Brent R. Matzelle
  19.  */
  20. class PHPMailer
  21. {
  22.     /////////////////////////////////////////////////
  23.     // PUBLIC VARIABLES
  24.     /////////////////////////////////////////////////
  25.  
  26.     
  27.     /**
  28.      * Email priority (1 = High, 3 = Normal, 5 = low).
  29.      * @var int 
  30.      */
  31.     var $Priority          = 3;
  32.  
  33.     /**
  34.      * Sets the CharSet of the message.
  35.      * @var string 
  36.      */
  37.     var $CharSet           = "iso-8859-1";
  38.  
  39.     /**
  40.      * Sets the Content-type of the message.
  41.      * @var string 
  42.      */
  43.     var $ContentType        = "text/plain";
  44.  
  45.     /**
  46.      * Sets the Encoding of the message. Options for this are "8bit",
  47.      * "7bit", "binary", "base64", and "quoted-printable".
  48.      * @var string 
  49.      */
  50.     var $Encoding          = "8bit";
  51.  
  52.     /**
  53.      * Holds the most recent mailer error message.
  54.      * @var string 
  55.      */
  56.     var $ErrorInfo         = "";
  57.  
  58.     /**
  59.      * Sets the From email address for the message.
  60.      * @var string 
  61.      */
  62.     var $From               = "root@localhost";
  63.  
  64.     /**
  65.      * Sets the From name of the message.
  66.      * @var string 
  67.      */
  68.     var $FromName           = "Root User";
  69.  
  70.     /**
  71.      * Sets the Sender email (Return-Path) of the message.  If not empty,
  72.      * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
  73.      * @var string 
  74.      */
  75.     var $Sender            = "";
  76.  
  77.     /**
  78.      * Sets the Subject of the message.
  79.      * @var string 
  80.      */
  81.     var $Subject           = "";
  82.  
  83.     /**
  84.      * Sets the Body of the message.  This can be either an HTML or text body.
  85.      * If HTML then run IsHTML(true).
  86.      * @var string 
  87.      */
  88.     var $Body               = "";
  89.  
  90.     /**
  91.      * Sets the text-only body of the message.  This automatically sets the
  92.      * email to multipart/alternative.  This body can be read by mail
  93.      * clients that do not have HTML email capability such as mutt. Clients
  94.      * that can read HTML will view the normal Body.
  95.      * @var string 
  96.      */
  97.     var $AltBody           = "";
  98.  
  99.     /**
  100.      * Sets word wrapping on the body of the message to a given number of
  101.      * characters.
  102.      * @var int 
  103.      */
  104.     var $WordWrap          = 0;
  105.  
  106.     /**
  107.      * Method to send mail: ("mail", "sendmail", or "smtp").
  108.      * @var string 
  109.      */
  110.     var $Mailer            = "mail";
  111.  
  112.     /**
  113.      * Sets the path of the sendmail program.
  114.      * @var string 
  115.      */
  116.     var $Sendmail          = "/usr/sbin/sendmail";
  117.     
  118.     /**
  119.      * Path to PHPMailer plugins.  This is now only useful if the SMTP class
  120.      * is in a different directory than the PHP include path.
  121.      * @var string 
  122.      */
  123.     var $PluginDir         = "";
  124.  
  125.     /**
  126.      *  Holds PHPMailer version.
  127.      *  @var string 
  128.      */
  129.     var $Version           = "1.73";
  130.  
  131.     /**
  132.      * Sets the email address that a reading confirmation will be sent.
  133.      * @var string 
  134.      */
  135.     var $ConfirmReadingTo  = "";
  136.  
  137.     /**
  138.      *  Sets the hostname to use in Message-Id and Received headers
  139.      *  and as default HELO string. If empty, the value returned
  140.      *  by SERVER_NAME is used or 'localhost.localdomain'.
  141.      *  @var string 
  142.      */
  143.     var $Hostname          = "";
  144.  
  145.     /////////////////////////////////////////////////
  146.     // SMTP VARIABLES
  147.     /////////////////////////////////////////////////
  148.  
  149.     
  150.     /**
  151.      *  Sets the SMTP hosts.  All hosts must be separated by a
  152.      *  semicolon.  You can also specify a different port
  153.      *  for each host by using this format: [hostname:port]
  154.      *  (e.g. "smtp1.example.com:25;smtp2.example.com").
  155.      *  Hosts will be tried in order.
  156.      *  @var string 
  157.      */
  158.     var $Host        = "localhost";
  159.  
  160.     /**
  161.      *  Sets the default SMTP server port.
  162.      *  @var int 
  163.      */
  164.     var $Port        = 25;
  165.  
  166.     /**
  167.      *  Sets the SMTP HELO of the message (Default is $Hostname).
  168.      *  @var string 
  169.      */
  170.     var $Helo        = "";
  171.  
  172.     /**
  173.      *  Sets SMTP authentication. Utilizes the Username and Password variables.
  174.      *  @var bool 
  175.      */
  176.     var $SMTPAuth     = false;
  177.  
  178.     /**
  179.      *  Sets SMTP username.
  180.      *  @var string 
  181.      */
  182.     var $Username     = "";
  183.  
  184.     /**
  185.      *  Sets SMTP password.
  186.      *  @var string 
  187.      */
  188.     var $Password     = "";
  189.  
  190.     /**
  191.      *  Sets the SMTP server timeout in seconds. This function will not
  192.      *  work with the win32 version.
  193.      *  @var int 
  194.      */
  195.     var $Timeout      = 10;
  196.  
  197.     /**
  198.      *  Sets SMTP class debugging on or off.
  199.      *  @var bool 
  200.      */
  201.     var $SMTPDebug    = false;
  202.  
  203.     /**
  204.      * Prevents the SMTP connection from being closed after each mail
  205.      * sending.  If this is set to true then to close the connection
  206.      * requires an explicit call to SmtpClose().
  207.      * @var bool 
  208.      */
  209.     var $SMTPKeepAlive = false;
  210.  
  211.     /**#@+
  212.      * @access private
  213.      */
  214.     var $smtp            = NULL;
  215.     var $to              = array();
  216.     var $cc              = array();
  217.     var $bcc             = array();
  218.     var $ReplyTo         = array();
  219.     var $attachment      = array();
  220.     var $CustomHeader    = array();
  221.     var $message_type    = "";
  222.     var $boundary        = array();
  223.     var $language        = array();
  224.     var $error_count     = 0;
  225.     var $LE              = "\n";
  226.     /**#@-*/
  227.     
  228.     /////////////////////////////////////////////////
  229.     // VARIABLE METHODS
  230.     /////////////////////////////////////////////////
  231.  
  232.     
  233.     /**
  234.      * Sets message type to HTML.
  235.      * @param bool $bool 
  236.      * @return void 
  237.      */
  238.     function IsHTML($bool) {
  239.         if($bool == true)
  240.             $this->ContentType = "text/html";
  241.         else
  242.             $this->ContentType = "text/plain";
  243.     }
  244.  
  245.     /**
  246.      * Sets Mailer to send message using SMTP.
  247.      * @return void 
  248.      */
  249.     function IsSMTP() {
  250.         $this->Mailer = "smtp";
  251.     }
  252.  
  253.     /**
  254.      * Sets Mailer to send message using PHP mail() function.
  255.      * @return void 
  256.      */
  257.     function IsMail() {
  258.         $this->Mailer = "mail";
  259.     }
  260.  
  261.     /**
  262.      * Sets Mailer to send message using the $Sendmail program.
  263.      * @return void 
  264.      */
  265.     function IsSendmail() {
  266.         $this->Mailer = "sendmail";
  267.     }
  268.  
  269.     /**
  270.      * Sets Mailer to send message using the qmail MTA.
  271.      * @return void 
  272.      */
  273.     function IsQmail() {
  274.         $this->Sendmail = "/var/qmail/bin/sendmail";
  275.         $this->Mailer = "sendmail";
  276.     }
  277.  
  278.  
  279.     /////////////////////////////////////////////////
  280.     // RECIPIENT METHODS
  281.     /////////////////////////////////////////////////
  282.  
  283.     
  284.     /**
  285.      * Adds a "To" address.
  286.      * @param string $address 
  287.      * @param string $name 
  288.      * @return void 
  289.      */
  290.     function AddAddress($address, $name = "") {
  291.         $cur = count($this->to);
  292.         $this->to[$cur][0] = trim($address);
  293.         $this->to[$cur][1] = $name;
  294.     }
  295.  
  296.     /**
  297.      * Adds a "Cc" address. Note: this function works
  298.      * with the SMTP mailer on win32, not with the "mail"
  299.      * mailer.
  300.      * @param string $address 
  301.      * @param string $name 
  302.      * @return void 
  303.     */
  304.     function AddCC($address, $name = "") {
  305.         $cur = count($this->cc);
  306.         $this->cc[$cur][0] = trim($address);
  307.         $this->cc[$cur][1] = $name;
  308.     }
  309.  
  310.     /**
  311.      * Adds a "Bcc" address. Note: this function works
  312.      * with the SMTP mailer on win32, not with the "mail"
  313.      * mailer.
  314.      * @param string $address 
  315.      * @param string $name 
  316.      * @return void 
  317.      */
  318.     function AddBCC($address, $name = "") {
  319.         $cur = count($this->bcc);
  320.         $this->bcc[$cur][0] = trim($address);
  321.         $this->bcc[$cur][1] = $name;
  322.     }
  323.  
  324.     /**
  325.      * Adds a "Reply-to" address.
  326.      * @param string $address 
  327.      * @param string $name 
  328.      * @return void 
  329.      */
  330.     function AddReplyTo($address, $name = "") {
  331.         $cur = count($this->ReplyTo);
  332.         $this->ReplyTo[$cur][0] = trim($address);
  333.         $this->ReplyTo[$cur][1] = $name;
  334.     }
  335.  
  336.  
  337.     /////////////////////////////////////////////////
  338.     // MAIL SENDING METHODS
  339.     /////////////////////////////////////////////////
  340.  
  341.     
  342.     /**
  343.      * Creates message and assigns Mailer. If the message is
  344.      * not sent successfully then it returns false.  Use the ErrorInfo
  345.      * variable to view description of the error.
  346.      * @return bool 
  347.      */
  348.     function Send() {
  349.         $header = "";
  350.         $body = "";
  351.         $result = true;
  352.  
  353.         if((count($this->to) + count($this->cc) + count($this->bcc)) < 1)
  354.         {
  355.             $this->SetError($this->Lang("provide_address"));
  356.             return false;
  357.         }
  358.  
  359.         // Set whether the message is multipart/alternative
  360.         if(!empty($this->AltBody))
  361.             $this->ContentType = "multipart/alternative";
  362.  
  363.         $this->error_count = 0; // reset errors
  364.         $this->SetMessageType();
  365.         $header .= $this->CreateHeader();
  366.         $body = $this->CreateBody();
  367.  
  368.         if($body == "") { return false; }
  369.  
  370.         // Choose the mailer
  371.         switch($this->Mailer)
  372.         {
  373.             case "sendmail":
  374.                 $result = $this->SendmailSend($header, $body);
  375.                 break;
  376.             case "mail":
  377.                 $result = $this->MailSend($header, $body);
  378.                 break;
  379.             case "smtp":
  380.                 $result = $this->SmtpSend($header, $body);
  381.                 break;
  382.             default:
  383.             $this->SetError($this->Mailer . $this->Lang("mailer_not_supported"));
  384.                 $result = false;
  385.                 break;
  386.         }
  387.  
  388.         return $result;
  389.     }
  390.     
  391.     /**
  392.      * Sends mail using the $Sendmail program.
  393.      * @access private
  394.      * @return bool 
  395.      */
  396.     function SendmailSend($header, $body) {
  397.         if ($this->Sender != "")
  398.             $sendmail = sprintf("%s -oi -f %s -t", $this->Sendmail, $this->Sender);
  399.         else
  400.             $sendmail = sprintf("%s -oi -t", $this->Sendmail);
  401.  
  402.         if(!@$mail = popen($sendmail, "w"))
  403.         {
  404.             $this->SetError($this->Lang("execute") . $this->Sendmail);
  405.             return false;
  406.         }
  407.  
  408.         fputs($mail, $header);
  409.         fputs($mail, $body);
  410.         
  411.         $result = pclose($mail) >> 8 & 0xFF;
  412.         if($result != 0)
  413.         {
  414.             $this->SetError($this->Lang("execute") . $this->Sendmail);
  415.             return false;
  416.         }
  417.  
  418.         return true;
  419.     }
  420.  
  421.     /**
  422.      * Sends mail using the PHP mail() function.
  423.      * @access private
  424.      * @return bool 
  425.      */
  426.     function MailSend($header, $body) {
  427.         $to = "";
  428.         for($i = 0; $i < count($this->to); $i++)
  429.         {
  430.             if($i != 0) { $to .= ", "; }
  431.             $to .= $this->to[$i][0];
  432.         }
  433.  
  434.         if ($this->Sender != "" && strlen(ini_get("safe_mode"))< 1)
  435.         {
  436.             $old_from = ini_get("sendmail_from");
  437.             ini_set("sendmail_from", $this->Sender);
  438.             $params = sprintf("-oi -f %s", $this->Sender);
  439.             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, 
  440.                         $header, $params);
  441.         }
  442.         else
  443.             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, $header);
  444.  
  445.         if (isset($old_from))
  446.             ini_set("sendmail_from", $old_from);
  447.  
  448.         if(!$rt)
  449.         {
  450.             $this->SetError($this->Lang("instantiate"));
  451.             return false;
  452.         }
  453.  
  454.         return true;
  455.     }
  456.  
  457.     /**
  458.      * Sends mail via SMTP using PhpSMTP (Author:
  459.      * Chris Ryan).  Returns bool.  Returns false if there is a
  460.      * bad MAIL FROM, RCPT, or DATA input.
  461.      * @access private
  462.      * @return bool 
  463.      */
  464.     function SmtpSend($header, $body) {
  465.         include_once($this->PluginDir . "smtp.php");
  466.         $error = "";
  467.         $bad_rcpt = array();
  468.  
  469.         if(!$this->SmtpConnect())
  470.             return false;
  471.  
  472.         $smtp_from = ($this->Sender == "") ? $this->From : $this->Sender;
  473.         if(!$this->smtp->Mail($smtp_from))
  474.         {
  475.             $error = $this->Lang("from_failed") . $smtp_from;
  476.             $this->SetError($error);
  477.             $this->smtp->Reset();
  478.             return false;
  479.         }
  480.  
  481.         // Attempt to send attach all recipients
  482.         for($i = 0; $i < count($this->to); $i++)
  483.         {
  484.             if(!$this->smtp->Recipient($this->to[$i][0]))
  485.                 $bad_rcpt[] = $this->to[$i][0];
  486.         }
  487.         for($i = 0; $i < count($this->cc); $i++)
  488.         {
  489.             if(!$this->smtp->Recipient($this->cc[$i][0]))
  490.                 $bad_rcpt[] = $this->cc[$i][0];
  491.         }
  492.         for($i = 0; $i < count($this->bcc); $i++)
  493.         {
  494.             if(!$this->smtp->Recipient($this->bcc[$i][0]))
  495.                 $bad_rcpt[] = $this->bcc[$i][0];
  496.         }
  497.  
  498.         if(count($bad_rcpt) > 0) // Create error message
  499.         {
  500.             for($i = 0; $i < count($bad_rcpt); $i++)
  501.             {
  502.                 if($i != 0) { $error .= ", "; }
  503.                 $error .= $bad_rcpt[$i];
  504.             }
  505.             $error = $this->Lang("recipients_failed") . $error;
  506.             $this->SetError($error);
  507.             $this->smtp->Reset();
  508.             return false;
  509.         }
  510.  
  511.         if(!$this->smtp->Data($header . $body))
  512.         {
  513.             $this->SetError($this->Lang("data_not_accepted"));
  514.             $this->smtp->Reset();
  515.             return false;
  516.         }
  517.         if($this->SMTPKeepAlive == true)
  518.             $this->smtp->Reset();
  519.         else
  520.             $this->SmtpClose();
  521.  
  522.         return true;
  523.     }
  524.  
  525.     /**
  526.      * Initiates a connection to an SMTP server.  Returns false if the
  527.      * operation failed.
  528.      * @access private
  529.      * @return bool 
  530.      */
  531.     function SmtpConnect() {
  532.         if($this->smtp == NULL) { $this->smtp = new SMTP(); }
  533.  
  534.         $this->smtp->do_debug = $this->SMTPDebug;
  535.         $hosts = explode(";", $this->Host);
  536.         $index = 0;
  537.         $connection = ($this->smtp->Connected()); 
  538.  
  539.         // Retry while there is no connection
  540.         while($index < count($hosts) && $connection == false)
  541.         {
  542.             if(strstr($hosts[$index], ":"))
  543.                 list($host, $port) = explode(":", $hosts[$index]);
  544.             else
  545.             {
  546.                 $host = $hosts[$index];
  547.                 $port = $this->Port;
  548.             }
  549.  
  550.             if($this->smtp->Connect($host, $port, $this->Timeout))
  551.             {
  552.                 if ($this->Helo != '')
  553.                     $this->smtp->Hello($this->Helo);
  554.                 else
  555.                     $this->smtp->Hello($this->ServerHostname());
  556.         
  557.                 if($this->SMTPAuth)
  558.                 {
  559.                     if(!$this->smtp->Authenticate($this->Username, 
  560.                                                   $this->Password))
  561.                     {
  562.                         $this->SetError($this->Lang("authenticate"));
  563.                         $this->smtp->Reset();
  564.                         $connection = false;
  565.                     }
  566.                 }
  567.                 $connection = true;
  568.             }
  569.             $index++;
  570.         }
  571.         if(!$connection)
  572.             $this->SetError($this->Lang("connect_host"));
  573.  
  574.         return $connection;
  575.     }
  576.  
  577.     /**
  578.      * Closes the active SMTP session if one exists.
  579.      * @return void 
  580.      */
  581.     function SmtpClose() {
  582.         if($this->smtp != NULL)
  583.         {
  584.             if($this->smtp->Connected())
  585.             {
  586.                 $this->smtp->Quit();
  587.                 $this->smtp->Close();
  588.             }
  589.         }
  590.     }
  591.  
  592.     /**
  593.      * Sets the language for all class error messages.  Returns false
  594.      * if it cannot load the language file.  The default language type
  595.      * is English.
  596.      * @param string $lang_type Type of language (e.g. Portuguese: "br")
  597.      * @param string $lang_path Path to the language file directory
  598.      * @access public
  599.      * @return bool 
  600.      */
  601.     function SetLanguage($lang_type, $lang_path = "language/") {
  602.         if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php'))
  603.             include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
  604.         else if(file_exists($lang_path.'phpmailer.lang-en.php'))
  605.             include($lang_path.'phpmailer.lang-en.php');
  606.         else
  607.         {
  608.             $this->SetError("Could not load language file");
  609.             return false;
  610.         }
  611.         $this->language = $PHPMAILER_LANG;
  612.     
  613.         return true;
  614.     }
  615.  
  616.     /////////////////////////////////////////////////
  617.     // MESSAGE CREATION METHODS
  618.     /////////////////////////////////////////////////
  619.  
  620.     
  621.     /**
  622.      * Creates recipient headers.
  623.      * @access private
  624.      * @return string 
  625.      */
  626.     function AddrAppend($type, $addr) {
  627.         $addr_str = $type . ": ";
  628.         $addr_str .= $this->AddrFormat($addr[0]);
  629.         if(count($addr) > 1)
  630.         {
  631.             for($i = 1; $i < count($addr); $i++)
  632.                 $addr_str .= ", " . $this->AddrFormat($addr[$i]);
  633.         }
  634.         $addr_str .= $this->LE;
  635.  
  636.         return $addr_str;
  637.     }
  638.     
  639.     /**
  640.      * Formats an address correctly.
  641.      * @access private
  642.      * @return string 
  643.      */
  644.     function AddrFormat($addr) {
  645.         if(empty($addr[1]))
  646.             $formatted = $addr[0];
  647.         else
  648.         {
  649.             $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" . 
  650.                          $addr[0] . ">";
  651.         }
  652.  
  653.         return $formatted;
  654.     }
  655.  
  656.     /**
  657.      * Wraps message for use with mailers that do not
  658.      * automatically perform wrapping and for quoted-printable.
  659.      * Original written by philippe.
  660.      * @access private
  661.      * @return string 
  662.      */
  663.     function WrapText($message, $length, $qp_mode = false) {
  664.         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
  665.  
  666.         $message = $this->FixEOL($message);
  667.         if (substr($message, -1) == $this->LE)
  668.             $message = substr($message, 0, -1);
  669.  
  670.         $line = explode($this->LE, $message);
  671.         $message = "";
  672.         for ($i=0 ;$i < count($line); $i++)
  673.         {
  674.           $line_part = explode(" ", $line[$i]);
  675.           $buf = "";
  676.           for ($e = 0; $e<count($line_part); $e++)
  677.           {
  678.               $word = $line_part[$e];
  679.               if ($qp_mode and (strlen($word) > $length))
  680.               {
  681.                 $space_left = $length - strlen($buf) - 1;
  682.                 if ($e != 0)
  683.                 {
  684.                     if ($space_left > 20)
  685.                     {
  686.                         $len = $space_left;
  687.                         if (substr($word, $len - 1, 1) == "=")
  688.                           $len--;
  689.                         elseif (substr($word, $len - 2, 1) == "=")
  690.                           $len -= 2;
  691.                         $part = substr($word, 0, $len);
  692.                         $word = substr($word, $len);
  693.                         $buf .= " " . $part;
  694.                         $message .= $buf . sprintf("=%s", $this->LE);
  695.                     }
  696.                     else
  697.                     {
  698.                         $message .= $buf . $soft_break;
  699.                     }
  700.                     $buf = "";
  701.                 }
  702.                 while (strlen($word) > 0)
  703.                 {
  704.                     $len = $length;
  705.                     if (substr($word, $len - 1, 1) == "=")
  706.                         $len--;
  707.                     elseif (substr($word, $len - 2, 1) == "=")
  708.                         $len -= 2;
  709.                     $part = substr($word, 0, $len);
  710.                     $word = substr($word, $len);
  711.  
  712.                     if (strlen($word) > 0)
  713.                         $message .= $part . sprintf("=%s", $this->LE);
  714.                     else
  715.                         $buf = $part;
  716.                 }
  717.               }
  718.               else
  719.               {
  720.                 $buf_o = $buf;
  721.                 $buf .= ($e == 0) ? $word : (" " . $word); 
  722.  
  723.                 if (strlen($buf) > $length and $buf_o != "")
  724.                 {
  725.                     $message .= $buf_o . $soft_break;
  726.                     $buf = $word;
  727.                 }
  728.               }
  729.           }
  730.           $message .= $buf . $this->LE;
  731.         }
  732.  
  733.         return $message;
  734.     }
  735.     
  736.     /**
  737.      * Set the body wrapping.
  738.      * @access private
  739.      * @return void 
  740.      */
  741.     function SetWordWrap() {
  742.         if($this->WordWrap < 1)
  743.             return;
  744.             
  745.         switch($this->message_type)
  746.         {
  747.            case "alt":
  748.               // fall through
  749.            case "alt_attachments":
  750.               $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
  751.               break;
  752.            default:
  753.               $this->Body = $this->WrapText($this->Body, $this->WordWrap);
  754.               break;
  755.         }
  756.     }
  757.  
  758.     /**
  759.      * Assembles message header.
  760.      * @access private
  761.      * @return string 
  762.      */
  763.     function CreateHeader() {
  764.         $result = "";
  765.         
  766.         // Set the boundaries
  767.         $uniq_id = md5(uniqid(time()));
  768.         $this->boundary[1] = "b1_" . $uniq_id;
  769.         $this->boundary[2] = "b2_" . $uniq_id;
  770.  
  771.         $result .= $this->HeaderLine("Date", $this->RFCDate());
  772.         if($this->Sender == "")
  773.             $result .= $this->HeaderLine("Return-Path", trim($this->From));
  774.         else
  775.             $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
  776.         
  777.         // To be created automatically by mail()
  778.         if($this->Mailer != "mail")
  779.         {
  780.             if(count($this->to) > 0)
  781.                 $result .= $this->AddrAppend("To", $this->to);
  782.             else if (count($this->cc) == 0)
  783.                 $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
  784.             if(count($this->cc) > 0)
  785.                 $result .= $this->AddrAppend("Cc", $this->cc);
  786.         }
  787.  
  788.         $from = array();
  789.         $from[0][0] = trim($this->From);
  790.         $from[0][1] = $this->FromName;
  791.         $result .= $this->AddrAppend("From", $from); 
  792.  
  793.         // sendmail and mail() extract Bcc from the header before sending
  794.         if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->bcc) > 0))
  795.             $result .= $this->AddrAppend("Bcc", $this->bcc);
  796.  
  797.         if(count($this->ReplyTo) > 0)
  798.             $result .= $this->AddrAppend("Reply-to", $this->ReplyTo);
  799.  
  800.         // mail() sets the subject itself
  801.         if($this->Mailer != "mail")
  802.             $result .= $this->HeaderLine("Subject", $this->EncodeHeader(trim($this->Subject)));
  803.  
  804.         $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
  805.         $result .= $this->HeaderLine("X-Priority", $this->Priority);
  806.         $result .= $this->HeaderLine("X-Mailer", "PHPMailer [version " . $this->Version . "]");
  807.         
  808.         if($this->ConfirmReadingTo != "")
  809.         {
  810.             $result .= $this->HeaderLine("Disposition-Notification-To", 
  811.                        "<" . trim($this->ConfirmReadingTo) . ">");
  812.         }
  813.  
  814.         // Add custom headers
  815.         for($index = 0; $index < count($this->CustomHeader); $index++)
  816.         {
  817.             $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), 
  818.                        $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
  819.         }
  820.         $result .= $this->HeaderLine("MIME-Version", "1.0");
  821.  
  822.         switch($this->message_type)
  823.         {
  824.             case "plain":
  825.                 $result .= $this->HeaderLine("Content-Transfer-Encoding", $this->Encoding);
  826.                 $result .= sprintf("Content-Type: %s; charset=\"%s\"",
  827.                                     $this->ContentType, $this->CharSet);
  828.                 break;
  829.             case "attachments":
  830.                 // fall through
  831.             case "alt_attachments":
  832.                 if($this->InlineImageExists())
  833.                 {
  834.                     $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s", 
  835.                                     "multipart/related", $this->LE, $this->LE, 
  836.                                     $this->boundary[1], $this->LE);
  837.                 }
  838.                 else
  839.                 {
  840.                     $result .= $this->HeaderLine("Content-Type", "multipart/mixed;");
  841.                     $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  842.                 }
  843.                 break;
  844.             case "alt":
  845.                 $result .= $this->HeaderLine("Content-Type", "multipart/alternative;");
  846.                 $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  847.                 break;
  848.         }
  849.  
  850.         if($this->Mailer != "mail")
  851.             $result .= $this->LE.$this->LE;
  852.  
  853.         return $result;
  854.     }
  855.  
  856.     /**
  857.      * Assembles the message body.  Returns an empty string on failure.
  858.      * @access private
  859.      * @return string 
  860.      */
  861.     function CreateBody() {
  862.         $result = "";
  863.  
  864.         $this->SetWordWrap();
  865.  
  866.         switch($this->message_type)
  867.         {
  868.             case "alt":
  869.                 $result .= $this->GetBoundary($this->boundary[1], "", 
  870.                                               "text/plain", "");
  871.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  872.                 $result .= $this->LE.$this->LE;
  873.                 $result .= $this->GetBoundary($this->boundary[1], "", 
  874.                                               "text/html", "");
  875.                 
  876.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  877.                 $result .= $this->LE.$this->LE;
  878.     
  879.                 $result .= $this->EndBoundary($this->boundary[1]);
  880.                 break;
  881.             case "plain":
  882.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  883.                 break;
  884.             case "attachments":
  885.                 $result .= $this->GetBoundary($this->boundary[1], "", "", "");
  886.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  887.                 $result .= $this->LE;
  888.      
  889.                 $result .= $this->AttachAll();
  890.                 break;
  891.             case "alt_attachments":
  892.                 $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
  893.                 $result .= sprintf("Content-Type: %s;%s" .
  894.                                    "\tboundary=\"%s\"%s",
  895.                                    "multipart/alternative", $this->LE, 
  896.                                    $this->boundary[2], $this->LE.$this->LE);
  897.     
  898.                 // Create text body
  899.                 $result .= $this->GetBoundary($this->boundary[2], "", 
  900.                                               "text/plain", "") . $this->LE;
  901.  
  902.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  903.                 $result .= $this->LE.$this->LE;
  904.     
  905.                 // Create the HTML body
  906.                 $result .= $this->GetBoundary($this->boundary[2], "", 
  907.                                               "text/html", "") . $this->LE;
  908.     
  909.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  910.                 $result .= $this->LE.$this->LE;
  911.  
  912.                 $result .= $this->EndBoundary($this->boundary[2]);
  913.                 
  914.                 $result .= $this->AttachAll();
  915.                 break;
  916.         }
  917.         if($this->IsError())
  918.             $result = "";
  919.  
  920.         return $result;
  921.     }
  922.  
  923.     /**
  924.      * Returns the start of a message boundary.
  925.      * @access private
  926.      */
  927.     function GetBoundary($boundary, $charSet, $contentType, $encoding) {
  928.         $result = "";
  929.         if($charSet == "") { $charSet = $this->CharSet; }
  930.         if($contentType == "") { $contentType = $this->ContentType; }
  931.         if($encoding == "") { $encoding = $this->Encoding; }
  932.  
  933.         $result .= $this->TextLine("--" . $boundary);
  934.         $result .= sprintf("Content-Type: %s; charset = \"%s\"", 
  935.                             $contentType, $charSet);
  936.         $result .= $this->LE;
  937.         $result .= $this->HeaderLine("Content-Transfer-Encoding", $encoding);
  938.         $result .= $this->LE;
  939.        
  940.         return $result;
  941.     }
  942.     
  943.     /**
  944.      * Returns the end of a message boundary.
  945.      * @access private
  946.      */
  947.     function EndBoundary($boundary) {
  948.         return $this->LE . "--" . $boundary . "--" . $this->LE; 
  949.     }
  950.     
  951.     /**
  952.      * Sets the message type.
  953.      * @access private
  954.      * @return void 
  955.      */
  956.     function SetMessageType() {
  957.         if(count($this->attachment) < 1 && strlen($this->AltBody) < 1)
  958.             $this->message_type = "plain";
  959.         else
  960.         {
  961.             if(count($this->attachment) > 0)
  962.                 $this->message_type = "attachments";
  963.             if(strlen($this->AltBody) > 0 && count($this->attachment) < 1)
  964.                 $this->message_type = "alt";
  965.             if(strlen($this->AltBody) > 0 && count($this->attachment) > 0)
  966.                 $this->message_type = "alt_attachments";
  967.         }
  968.     }
  969.  
  970.     /**
  971.      * Returns a formatted header line.
  972.      * @access private
  973.      * @return string 
  974.      */
  975.     function HeaderLine($name, $value) {
  976.         return $name . ": " . $value . $this->LE;
  977.     }
  978.  
  979.     /**
  980.      * Returns a formatted mail line.
  981.      * @access private
  982.      * @return string 
  983.      */
  984.     function TextLine($value) {
  985.         return $value . $this->LE;
  986.     }
  987.  
  988.     /////////////////////////////////////////////////
  989.     // ATTACHMENT METHODS
  990.     /////////////////////////////////////////////////
  991.  
  992.     
  993.     /**
  994.      * Adds an attachment from a path on the filesystem.
  995.      * Returns false if the file could not be found
  996.      * or accessed.
  997.      * @param string $path Path to the attachment.
  998.      * @param string $name Overrides the attachment name.
  999.      * @param string $encoding File encoding (see $Encoding).
  1000.      * @param string $type File extension (MIME) type.
  1001.      * @return bool 
  1002.      */
  1003.     function AddAttachment($path, $name = "", $encoding = "base64", 
  1004.                            $type = "application/octet-stream") {
  1005.         if(!@is_file($path))
  1006.         {
  1007.             $this->SetError($this->Lang("file_access") . $path);
  1008.             return false;
  1009.         }
  1010.  
  1011.         $filename = basename($path);
  1012.         if($name == "")
  1013.             $name = $filename;
  1014.  
  1015.         $cur = count($this->attachment);
  1016.         $this->attachment[$cur][0] = $path;
  1017.         $this->attachment[$cur][1] = $filename;
  1018.         $this->attachment[$cur][2] = $name;
  1019.         $this->attachment[$cur][3] = $encoding;
  1020.         $this->attachment[$cur][4] = $type;
  1021.         $this->attachment[$cur][5] = false; // isStringAttachment
  1022.         $this->attachment[$cur][6] = "attachment";
  1023.         $this->attachment[$cur][7] = 0;
  1024.  
  1025.         return true;
  1026.     }
  1027.  
  1028.     /**
  1029.      * Attaches all fs, string, and binary attachments to the message.
  1030.      * Returns an empty string on failure.
  1031.      * @access private
  1032.      * @return string 
  1033.      */
  1034.     function AttachAll() {
  1035.         // Return text of body
  1036.         $mime = array();
  1037.  
  1038.         // Add all attachments
  1039.         for($i = 0; $i < count($this->attachment); $i++)
  1040.         {
  1041.             // Check for string attachment
  1042.             $bString = $this->attachment[$i][5];
  1043.             if ($bString)
  1044.                 $string = $this->attachment[$i][0];
  1045.             else
  1046.                 $path = $this->attachment[$i][0];
  1047.  
  1048.             $filename    = $this->attachment[$i][1];
  1049.             $name        = $this->attachment[$i][2];
  1050.             $encoding    = $this->attachment[$i][3];
  1051.             $type        = $this->attachment[$i][4];
  1052.             $disposition = $this->attachment[$i][6];
  1053.             $cid         = $this->attachment[$i][7];
  1054.             
  1055.             $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
  1056.             $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
  1057.             $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
  1058.  
  1059.             if($disposition == "inline")
  1060.                 $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
  1061.  
  1062.             $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s", 
  1063.                               $disposition, $name, $this->LE.$this->LE);
  1064.  
  1065.             // Encode as string attachment
  1066.             if($bString)
  1067.             {
  1068.                 $mime[] = $this->EncodeString($string, $encoding);
  1069.                 if($this->IsError()) { return ""; }
  1070.                 $mime[] = $this->LE.$this->LE;
  1071.             }
  1072.             else
  1073.             {
  1074.                 $mime[] = $this->EncodeFile($path, $encoding);                
  1075.                 if($this->IsError()) { return ""; }
  1076.                 $mime[] = $this->LE.$this->LE;
  1077.             }
  1078.         }
  1079.  
  1080.         $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
  1081.  
  1082.         return join("", $mime);
  1083.     }
  1084.     
  1085.     /**
  1086.      * Encodes attachment in requested format.  Returns an
  1087.      * empty string on failure.
  1088.      * @access private
  1089.      * @return string 
  1090.      */
  1091.     function EncodeFile ($path, $encoding = "base64") {
  1092.         if(!@$fd = fopen($path, "rb"))
  1093.         {
  1094.             $this->SetError($this->Lang("file_open") . $path);
  1095.             return "";
  1096.         }
  1097.         $magic_quotes = get_magic_quotes_runtime();
  1098.         set_magic_quotes_runtime(0);
  1099.         $file_buffer = fread($fd, filesize($path));
  1100.         $file_buffer = $this->EncodeString($file_buffer, $encoding);
  1101.         fclose($fd);
  1102.         set_magic_quotes_runtime($magic_quotes);
  1103.  
  1104.         return $file_buffer;
  1105.     }
  1106.  
  1107.     /**
  1108.      * Encodes string to requested format. Returns an
  1109.      * empty string on failure.
  1110.      * @access private
  1111.      * @return string 
  1112.      */
  1113.     function EncodeString ($str, $encoding = "base64") {
  1114.         $encoded = "";
  1115.         switch(strtolower($encoding)) {
  1116.           case "base64":
  1117.               // chunk_split is found in PHP >= 3.0.6
  1118.               $encoded = chunk_split(base64_encode($str), 76, $this->LE);
  1119.               break;
  1120.           case "7bit":
  1121.           case "8bit":
  1122.               $encoded = $this->FixEOL($str);
  1123.               if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1124.                 $encoded .= $this->LE;
  1125.               break;
  1126.           case "binary":
  1127.               $encoded = $str;
  1128.               break;
  1129.           case "quoted-printable":
  1130.               $encoded = $this->EncodeQP($str);
  1131.               break;
  1132.           default:
  1133.               $this->SetError($this->Lang("encoding") . $encoding);
  1134.               break;
  1135.         }
  1136.         return $encoded;
  1137.     }
  1138.  
  1139.     /**
  1140.      * Encode a header string to best of Q, B, quoted or none.
  1141.      * @access private
  1142.      * @return string 
  1143.      */
  1144.     function EncodeHeader ($str, $position = 'text') {
  1145.       $x = 0;
  1146.       
  1147.       switch (strtolower($position)) {
  1148.         case 'phrase':
  1149.           if (!preg_match('/[\200-\377]/', $str)) {
  1150.             // Can't use addslashes as we don't know what value has magic_quotes_sybase.
  1151.             $encoded = addcslashes($str, "\0..\37\177\\\"");
  1152.  
  1153.             if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str))
  1154.               return ($encoded);
  1155.             else
  1156.               return ("\"$encoded\"");
  1157.           }
  1158.           $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
  1159.           break;
  1160.         case 'comment':
  1161.           $x = preg_match_all('/[()"]/', $str, $matches);
  1162.           // Fall-through
  1163.         case 'text':
  1164.         default:
  1165.           $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
  1166.           break;
  1167.       }
  1168.  
  1169.       if ($x == 0)
  1170.         return ($str);
  1171.  
  1172.       $maxlen = 75 - 7 - strlen($this->CharSet);
  1173.       // Try to select the encoding which should produce the shortest output
  1174.       if (strlen($str)/3 < $x) {
  1175.         $encoding = 'B';
  1176.         $encoded = base64_encode($str);
  1177.         $maxlen -= $maxlen % 4;
  1178.         $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
  1179.       } else {
  1180.         $encoding = 'Q';
  1181.         $encoded = $this->EncodeQ($str, $position);
  1182.         $encoded = $this->WrapText($encoded, $maxlen, true);
  1183.         $encoded = str_replace("=".$this->LE, "\n", trim($encoded));
  1184.       }
  1185.  
  1186.       $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
  1187.       $encoded = trim(str_replace("\n", $this->LE, $encoded));
  1188.       
  1189.       return $encoded;
  1190.     }
  1191.     
  1192.     /**
  1193.      * Encode string to quoted-printable.
  1194.      * @access private
  1195.      * @return string 
  1196.      */
  1197.     function EncodeQP ($str) {
  1198.         $encoded = $this->FixEOL($str);
  1199.         if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1200.             $encoded .= $this->LE;
  1201.  
  1202.         // Replace every high ascii, control and = characters
  1203.         $encoded = preg_replace('/([\000-\010\013\014\016-\037\075\177-\377])/e',
  1204.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1205.         // Replace every spaces and tabs when it's the last character on a line
  1206.         $encoded = preg_replace("/([\011\040])".$this->LE."/e",
  1207.                   "'='.sprintf('%02X', ord('\\1')).'".$this->LE."'", $encoded);
  1208.  
  1209.         // Maximum line length of 76 characters before CRLF (74 + space + '=')
  1210.         $encoded = $this->WrapText($encoded, 74, true);
  1211.  
  1212.         return $encoded;
  1213.     }
  1214.  
  1215.     /**
  1216.      * Encode string to q encoding.
  1217.      * @access private
  1218.      * @return string 
  1219.      */
  1220.     function EncodeQ ($str, $position = "text") {
  1221.         // There should not be any EOL in the string
  1222.         $encoded = preg_replace("[\r\n]", "", $str);
  1223.  
  1224.         switch (strtolower($position)) {
  1225.           case "phrase":
  1226.             $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1227.             break;
  1228.           case "comment":
  1229.             $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1230.           case "text":
  1231.           default:
  1232.             // Replace every high ascii, control =, ? and _ characters
  1233.             $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
  1234.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1235.             break;
  1236.         }
  1237.         
  1238.         // Replace every spaces to _ (more readable than =20)
  1239.         $encoded = str_replace(" ", "_", $encoded);
  1240.  
  1241.         return $encoded;
  1242.     }
  1243.  
  1244.     /**
  1245.      * Adds a string or binary attachment (non-filesystem) to the list.
  1246.      * This method can be used to attach ascii or binary data,
  1247.      * such as a BLOB record from a database.
  1248.      * @param string $string String attachment data.
  1249.      * @param string $filename Name of the attachment.
  1250.      * @param string $encoding File encoding (see $Encoding).
  1251.      * @param string $type File extension (MIME) type.
  1252.      * @return void 
  1253.      */
  1254.     function AddStringAttachment($string, $filename, $encoding = "base64", 
  1255.                                  $type = "application/octet-stream") {
  1256.         // Append to $attachment array
  1257.         $cur = count($this->attachment);
  1258.         $this->attachment[$cur][0] = $string;
  1259.         $this->attachment[$cur][1] = $filename;
  1260.         $this->attachment[$cur][2] = $filename;
  1261.         $this->attachment[$cur][3] = $encoding;
  1262.         $this->attachment[$cur][4] = $type;
  1263.         $this->attachment[$cur][5] = true; // isString
  1264.         $this->attachment[$cur][6] = "attachment";
  1265.         $this->attachment[$cur][7] = 0;
  1266.     }
  1267.     
  1268.     /**
  1269.      * Adds an embedded attachment.  This can include images, sounds, and
  1270.      * just about any other document.  Make sure to set the $type to an
  1271.      * image type.  For JPEG images use "image/jpeg" and for GIF images
  1272.      * use "image/gif".
  1273.      * @param string $path Path to the attachment.
  1274.      * @param string $cid Content ID of the attachment.  Use this to identify
  1275.      *         the Id for accessing the image in an HTML form.
  1276.      * @param string $name Overrides the attachment name.
  1277.      * @param string $encoding File encoding (see $Encoding).
  1278.      * @param string $type File extension (MIME) type.
  1279.      * @return bool 
  1280.      */
  1281.     function AddEmbeddedImage($path, $cid, $name = "", $encoding = "base64", 
  1282.                               $type = "application/octet-stream") {
  1283.     
  1284.         if(!@is_file($path))
  1285.         {
  1286.             $this->SetError($this->Lang("file_access") . $path);
  1287.             return false;
  1288.         }
  1289.  
  1290.         $filename = basename($path);
  1291.         if($name == "")
  1292.             $name = $filename;
  1293.  
  1294.         // Append to $attachment array
  1295.         $cur = count($this->attachment);
  1296.         $this->attachment[$cur][0] = $path;
  1297.         $this->attachment[$cur][1] = $filename;
  1298.         $this->attachment[$cur][2] = $name;
  1299.         $this->attachment[$cur][3] = $encoding;
  1300.         $this->attachment[$cur][4] = $type;
  1301.         $this->attachment[$cur][5] = false; // isStringAttachment
  1302.         $this->attachment[$cur][6] = "inline";
  1303.         $this->attachment[$cur][7] = $cid;
  1304.     
  1305.         return true;
  1306.     }
  1307.     
  1308.     /**
  1309.      * Returns true if an inline attachment is present.
  1310.      * @access private
  1311.      * @return bool 
  1312.      */
  1313.     function InlineImageExists() {
  1314.         $result = false;
  1315.         for($i = 0; $i < count($this->attachment); $i++)
  1316.         {
  1317.             if($this->attachment[$i][6] == "inline")
  1318.             {
  1319.                 $result = true;
  1320.                 break;
  1321.             }
  1322.         }
  1323.         
  1324.         return $result;
  1325.     }
  1326.  
  1327.     /////////////////////////////////////////////////
  1328.     // MESSAGE RESET METHODS
  1329.     /////////////////////////////////////////////////
  1330.  
  1331.     
  1332.     /**
  1333.      * Clears all recipients assigned in the TO array.  Returns void.
  1334.      * @return void 
  1335.      */
  1336.     function ClearAddresses() {
  1337.         $this->to = array();
  1338.     }
  1339.  
  1340.     /**
  1341.      * Clears all recipients assigned in the CC array.  Returns void.
  1342.      * @return void 
  1343.      */
  1344.     function ClearCCs() {
  1345.         $this->cc = array();
  1346.     }
  1347.  
  1348.     /**
  1349.      * Clears all recipients assigned in the BCC array.  Returns void.
  1350.      * @return void 
  1351.      */
  1352.     function ClearBCCs() {
  1353.         $this->bcc = array();
  1354.     }
  1355.  
  1356.     /**
  1357.      * Clears all recipients assigned in the ReplyTo array.  Returns void.
  1358.      * @return void 
  1359.      */
  1360.     function ClearReplyTos() {
  1361.         $this->ReplyTo = array();
  1362.     }
  1363.  
  1364.     /**
  1365.      * Clears all recipients assigned in the TO, CC and BCC
  1366.      * array.  Returns void.
  1367.      * @return void 
  1368.      */
  1369.     function ClearAllRecipients() {
  1370.         $this->to = array();
  1371.         $this->cc = array();
  1372.         $this->bcc = array();
  1373.     }
  1374.  
  1375.     /**
  1376.      * Clears all previously set filesystem, string, and binary
  1377.      * attachments.  Returns void.
  1378.      * @return void 
  1379.      */
  1380.     function ClearAttachments() {
  1381.         $this->attachment = array();
  1382.     }
  1383.  
  1384.     /**
  1385.      * Clears all custom headers.  Returns void.
  1386.      * @return void 
  1387.      */
  1388.     function ClearCustomHeaders() {
  1389.         $this->CustomHeader = array();
  1390.     }
  1391.  
  1392.  
  1393.     /////////////////////////////////////////////////
  1394.     // MISCELLANEOUS METHODS
  1395.     /////////////////////////////////////////////////
  1396.  
  1397.     
  1398.     /**
  1399.      * Adds the error message to the error container.
  1400.      * Returns void.
  1401.      * @access private
  1402.      * @return void 
  1403.      */
  1404.     function SetError($msg) {
  1405.         $this->error_count++;
  1406.         $this->ErrorInfo = $msg;
  1407.     }
  1408.  
  1409.     /**
  1410.      * Returns the proper RFC 822 formatted date.
  1411.      * @access private
  1412.      * @return string 
  1413.      */
  1414.     function RFCDate() {
  1415.         $tz = date("Z");
  1416.         $tzs = ($tz < 0) ? "-" : "+";
  1417.         $tz = abs($tz);
  1418.         $tz = ($tz/3600)*100 + ($tz%3600)/60;
  1419.         $result = sprintf("%s %s%04d", date("D, j M Y H:i:s"), $tzs, $tz);
  1420.  
  1421.         return $result;
  1422.     }
  1423.     
  1424.     /**
  1425.      * Returns the appropriate server variable.  Should work with both
  1426.      * PHP 4.1.0+ as well as older versions.  Returns an empty string
  1427.      * if nothing is found.
  1428.      * @access private
  1429.      * @return mixed 
  1430.      */
  1431.     function ServerVar($varName) {
  1432.         global $HTTP_SERVER_VARS;
  1433.         global $HTTP_ENV_VARS;
  1434.  
  1435.         if(!isset($_SERVER))
  1436.         {
  1437.             $_SERVER = $HTTP_SERVER_VARS;
  1438.             if(!isset($_SERVER["REMOTE_ADDR"]))
  1439.                 $_SERVER = $HTTP_ENV_VARS; // must be Apache
  1440.         }
  1441.         
  1442.         if(isset($_SERVER[$varName]))
  1443.             return $_SERVER[$varName];
  1444.         else
  1445.             return "";
  1446.     }
  1447.  
  1448.     /**
  1449.      * Returns the server hostname or 'localhost.localdomain' if unknown.
  1450.      * @access private
  1451.      * @return string 
  1452.      */
  1453.     function ServerHostname() {
  1454.         if ($this->Hostname != "")
  1455.             $result = $this->Hostname;
  1456.         elseif ($this->ServerVar('SERVER_NAME') != "")
  1457.             $result = $this->ServerVar('SERVER_NAME');
  1458.         else
  1459.             $result = "localhost.localdomain";
  1460.  
  1461.         return $result;
  1462.     }
  1463.  
  1464.     /**
  1465.      * Returns a message in the appropriate language.
  1466.      * @access private
  1467.      * @return string 
  1468.      */
  1469.     function Lang($key) {
  1470.         if(count($this->language) < 1)
  1471.             $this->SetLanguage("en"); // set the default language
  1472.     
  1473.         if(isset($this->language[$key]))
  1474.             return $this->language[$key];
  1475.         else
  1476.             return "Language string failed to load: " . $key;
  1477.     }
  1478.     
  1479.     /**
  1480.      * Returns true if an error occurred.
  1481.      * @return bool 
  1482.      */
  1483.     function IsError() {
  1484.         return ($this->error_count > 0);
  1485.     }
  1486.  
  1487.     /**
  1488.      * Changes every end of line from CR or LF to CRLF.
  1489.      * @access private
  1490.      * @return string 
  1491.      */
  1492.     function FixEOL($str) {
  1493.         $str = str_replace("\r\n", "\n", $str);
  1494.         $str = str_replace("\r", "\n", $str);
  1495.         $str = str_replace("\n", $this->LE, $str);
  1496.         return $str;
  1497.     }
  1498.  
  1499.     /**
  1500.      * Adds a custom header.
  1501.      * @return void 
  1502.      */
  1503.     function AddCustomHeader($custom_header) {
  1504.         $this->CustomHeader[] = explode(":", $custom_header, 2);
  1505.     }
  1506. }
  1507.  
  1508. ?>
Documentation generated on Mon, 05 Mar 2007 21:18:39 +0000 by phpDocumentor 1.3.1