[ PHPXref.com ] [ Generated: Sun Jul 20 20:46:01 2008 ] [ Toutateam 1.5.1 ]
[ Index ]     [ Variables ]     [ Functions ]     [ Classes ]     [ Constants ]     [ Statistics ]

title

Body

[close]

/mail/ -> class.phpmailer.php (source)

   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       * Email priority (1 = High, 3 = Normal, 5 = low).

  28       * @var int

  29       */
  30      var $Priority          = 3;
  31  
  32      /**

  33       * Sets the CharSet of the message.

  34       * @var string

  35       */
  36      var $CharSet           = "iso-8859-1";
  37  
  38      /**

  39       * Sets the Content-type of the message.

  40       * @var string

  41       */
  42      var $ContentType        = "text/plain";
  43  
  44      /**

  45       * Sets the Encoding of the message. Options for this are "8bit",

  46       * "7bit", "binary", "base64", and "quoted-printable".

  47       * @var string

  48       */
  49      var $Encoding          = "8bit";
  50  
  51      /**

  52       * Holds the most recent mailer error message.

  53       * @var string

  54       */
  55      var $ErrorInfo         = "";
  56  
  57      /**

  58       * Sets the From email address for the message.

  59       * @var string

  60       */
  61      var $From               = "root@localhost";
  62  
  63      /**

  64       * Sets the From name of the message.

  65       * @var string

  66       */
  67      var $FromName           = "Root User";
  68  
  69      /**

  70       * Sets the Sender email (Return-Path) of the message.  If not empty,

  71       * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.

  72       * @var string

  73       */
  74      var $Sender            = "";
  75  
  76      /**

  77       * Sets the Subject of the message.

  78       * @var string

  79       */
  80      var $Subject           = "";
  81  
  82      /**

  83       * Sets the Body of the message.  This can be either an HTML or text body.

  84       * If HTML then run IsHTML(true).

  85       * @var string

  86       */
  87      var $Body               = "";
  88  
  89      /**

  90       * Sets the text-only body of the message.  This automatically sets the

  91       * email to multipart/alternative.  This body can be read by mail

  92       * clients that do not have HTML email capability such as mutt. Clients

  93       * that can read HTML will view the normal Body.

  94       * @var string

  95       */
  96      var $AltBody           = "";
  97  
  98      /**

  99       * Sets word wrapping on the body of the message to a given number of 

 100       * characters.

 101       * @var int

 102       */
 103      var $WordWrap          = 0;
 104  
 105      /**

 106       * Method to send mail: ("mail", "sendmail", or "smtp").

 107       * @var string

 108       */
 109      var $Mailer            = "mail";
 110  
 111      /**

 112       * Sets the path of the sendmail program.

 113       * @var string

 114       */
 115      var $Sendmail          = "/usr/sbin/sendmail";
 116      
 117      /**

 118       * Path to PHPMailer plugins.  This is now only useful if the SMTP class 

 119       * is in a different directory than the PHP include path.  

 120       * @var string

 121       */
 122      var $PluginDir         = "";
 123  
 124      /**

 125       *  Holds PHPMailer version.

 126       *  @var string

 127       */
 128      var $Version           = "1.73";
 129  
 130      /**

 131       * Sets the email address that a reading confirmation will be sent.

 132       * @var string

 133       */
 134      var $ConfirmReadingTo  = "";
 135  
 136      /**

 137       *  Sets the hostname to use in Message-Id and Received headers

 138       *  and as default HELO string. If empty, the value returned

 139       *  by SERVER_NAME is used or 'localhost.localdomain'.

 140       *  @var string

 141       */
 142      var $Hostname          = "";
 143  
 144      /////////////////////////////////////////////////

 145      // SMTP VARIABLES

 146      /////////////////////////////////////////////////

 147  
 148      /**

 149       *  Sets the SMTP hosts.  All hosts must be separated by a

 150       *  semicolon.  You can also specify a different port

 151       *  for each host by using this format: [hostname:port]

 152       *  (e.g. "smtp1.example.com:25;smtp2.example.com").

 153       *  Hosts will be tried in order.

 154       *  @var string

 155       */
 156      var $Host        = "localhost";
 157  
 158      /**

 159       *  Sets the default SMTP server port.

 160       *  @var int

 161       */
 162      var $Port        = 25;
 163  
 164      /**

 165       *  Sets the SMTP HELO of the message (Default is $Hostname).

 166       *  @var string

 167       */
 168      var $Helo        = "";
 169  
 170      /**

 171       *  Sets SMTP authentication. Utilizes the Username and Password variables.

 172       *  @var bool

 173       */
 174      var $SMTPAuth     = false;
 175  
 176      /**

 177       *  Sets SMTP username.

 178       *  @var string

 179       */
 180      var $Username     = "";
 181  
 182      /**

 183       *  Sets SMTP password.

 184       *  @var string

 185       */
 186      var $Password     = "";
 187  
 188      /**

 189       *  Sets the SMTP server timeout in seconds. This function will not 

 190       *  work with the win32 version.

 191       *  @var int

 192       */
 193      var $Timeout      = 10;
 194  
 195      /**

 196       *  Sets SMTP class debugging on or off.

 197       *  @var bool

 198       */
 199      var $SMTPDebug    = false;
 200  
 201      /**

 202       * Prevents the SMTP connection from being closed after each mail 

 203       * sending.  If this is set to true then to close the connection 

 204       * requires an explicit call to SmtpClose(). 

 205       * @var bool

 206       */
 207      var $SMTPKeepAlive = false;
 208  
 209      /**#@+

 210       * @access private

 211       */
 212      var $smtp            = NULL;
 213      var $to              = array();
 214      var $cc              = array();
 215      var $bcc             = array();
 216      var $ReplyTo         = array();
 217      var $attachment      = array();
 218      var $CustomHeader    = array();
 219      var $message_type    = "";
 220      var $boundary        = array();
 221      var $language        = array();
 222      var $error_count     = 0;
 223      var $LE              = "\n";
 224      /**#@-*/

 225      
 226      /////////////////////////////////////////////////

 227      // VARIABLE METHODS

 228      /////////////////////////////////////////////////

 229  
 230      /**

 231       * Sets message type to HTML.  

 232       * @param bool $bool

 233       * @return void

 234       */
 235      function IsHTML($bool) {
 236          if($bool == true)
 237              $this->ContentType = "text/html";
 238          else
 239              $this->ContentType = "text/plain";
 240      }
 241  
 242      /**

 243       * Sets Mailer to send message using SMTP.

 244       * @return void

 245       */
 246      function IsSMTP() {
 247          $this->Mailer = "smtp";
 248      }
 249  
 250      /**

 251       * Sets Mailer to send message using PHP mail() function.

 252       * @return void

 253       */
 254      function IsMail() {
 255          $this->Mailer = "mail";
 256      }
 257  
 258      /**

 259       * Sets Mailer to send message using the $Sendmail program.

 260       * @return void

 261       */
 262      function IsSendmail() {
 263          $this->Mailer = "sendmail";
 264      }
 265  
 266      /**

 267       * Sets Mailer to send message using the qmail MTA. 

 268       * @return void

 269       */
 270      function IsQmail() {
 271          $this->Sendmail = "/var/qmail/bin/sendmail";
 272          $this->Mailer = "sendmail";
 273      }
 274  
 275  
 276      /////////////////////////////////////////////////

 277      // RECIPIENT METHODS

 278      /////////////////////////////////////////////////

 279  
 280      /**

 281       * Adds a "To" address.  

 282       * @param string $address

 283       * @param string $name

 284       * @return void

 285       */
 286      function AddAddress($address, $name = "") {
 287          $cur = count($this->to);
 288          $this->to[$cur][0] = trim($address);
 289          $this->to[$cur][1] = $name;
 290      }
 291  
 292      /**

 293       * Adds a "Cc" address. Note: this function works

 294       * with the SMTP mailer on win32, not with the "mail"

 295       * mailer.  

 296       * @param string $address

 297       * @param string $name

 298       * @return void

 299      */
 300      function AddCC($address, $name = "") {
 301          $cur = count($this->cc);
 302          $this->cc[$cur][0] = trim($address);
 303          $this->cc[$cur][1] = $name;
 304      }
 305  
 306      /**

 307       * Adds a "Bcc" address. Note: this function works

 308       * with the SMTP mailer on win32, not with the "mail"

 309       * mailer.  

 310       * @param string $address

 311       * @param string $name

 312       * @return void

 313       */
 314      function AddBCC($address, $name = "") {
 315          $cur = count($this->bcc);
 316          $this->bcc[$cur][0] = trim($address);
 317          $this->bcc[$cur][1] = $name;
 318      }
 319  
 320      /**

 321       * Adds a "Reply-to" address.  

 322       * @param string $address

 323       * @param string $name

 324       * @return void

 325       */
 326      function AddReplyTo($address, $name = "") {
 327          $cur = count($this->ReplyTo);
 328          $this->ReplyTo[$cur][0] = trim($address);
 329          $this->ReplyTo[$cur][1] = $name;
 330      }
 331  
 332  
 333      /////////////////////////////////////////////////

 334      // MAIL SENDING METHODS

 335      /////////////////////////////////////////////////

 336  
 337      /**

 338       * Creates message and assigns Mailer. If the message is

 339       * not sent successfully then it returns false.  Use the ErrorInfo

 340       * variable to view description of the error.  

 341       * @return bool

 342       */
 343      function Send() {
 344          $header = "";
 345          $body = "";
 346          $result = true;
 347  
 348          if((count($this->to) + count($this->cc) + count($this->bcc)) < 1)
 349          {
 350              $this->SetError($this->Lang("provide_address"));
 351              return false;
 352          }
 353  
 354          // Set whether the message is multipart/alternative

 355          if(!empty($this->AltBody))
 356              $this->ContentType = "multipart/alternative";
 357  
 358          $this->error_count = 0; // reset errors

 359          $this->SetMessageType();
 360          $header .= $this->CreateHeader();
 361          $body = $this->CreateBody();
 362  
 363          if($body == "") { return false; }
 364  
 365          // Choose the mailer

 366          switch($this->Mailer)
 367          {
 368              case "sendmail":
 369                  $result = $this->SendmailSend($header, $body);
 370                  break;
 371              case "mail":
 372                  $result = $this->MailSend($header, $body);
 373                  break;
 374              case "smtp":
 375                  $result = $this->SmtpSend($header, $body);
 376                  break;
 377              default:
 378              $this->SetError($this->Mailer . $this->Lang("mailer_not_supported"));
 379                  $result = false;
 380                  break;
 381          }
 382  
 383          return $result;
 384      }
 385      
 386      /**

 387       * Sends mail using the $Sendmail program.  

 388       * @access private

 389       * @return bool

 390       */
 391      function SendmailSend($header, $body) {
 392          if ($this->Sender != "")
 393              $sendmail = sprintf("%s -oi -f %s -t", $this->Sendmail, $this->Sender);
 394          else
 395              $sendmail = sprintf("%s -oi -t", $this->Sendmail);
 396  
 397          if(!@$mail = popen($sendmail, "w"))
 398          {
 399              $this->SetError($this->Lang("execute") . $this->Sendmail);
 400              return false;
 401          }
 402  
 403          fputs($mail, $header);
 404          fputs($mail, $body);
 405          
 406          $result = pclose($mail) >> 8 & 0xFF;
 407          if($result != 0)
 408          {
 409              $this->SetError($this->Lang("execute") . $this->Sendmail);
 410              return false;
 411          }
 412  
 413          return true;
 414      }
 415  
 416      /**

 417       * Sends mail using the PHP mail() function.  

 418       * @access private

 419       * @return bool

 420       */
 421      function MailSend($header, $body) {
 422          $to = "";
 423          for($i = 0; $i < count($this->to); $i++)
 424          {
 425              if($i != 0) { $to .= ", "; }
 426              $to .= $this->to[$i][0];
 427          }
 428  
 429          if ($this->Sender != "" && strlen(ini_get("safe_mode"))< 1)
 430          {
 431              $old_from = ini_get("sendmail_from");
 432              ini_set("sendmail_from", $this->Sender);
 433              $params = sprintf("-oi -f %s", $this->Sender);
 434              $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, 
 435                          $header, $params);
 436          }
 437          else
 438              $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, $header);
 439  
 440          if (isset($old_from))
 441              ini_set("sendmail_from", $old_from);
 442  
 443          if(!$rt)
 444          {
 445              $this->SetError($this->Lang("instantiate")."To : ".$to.", Subject : ". $this->EncodeHeader($this->Subject).", Head : ". $header);
 446              return false;
 447          }
 448  
 449          return true;
 450      }
 451  
 452      /**

 453       * Sends mail via SMTP using PhpSMTP (Author:

 454       * Chris Ryan).  Returns bool.  Returns false if there is a

 455       * bad MAIL FROM, RCPT, or DATA input.

 456       * @access private

 457       * @return bool

 458       */
 459      function SmtpSend($header, $body) {
 460          include_once($this->PluginDir . "class.smtp.php");
 461          $error = "";
 462          $bad_rcpt = array();
 463  
 464          if(!$this->SmtpConnect())
 465              return false;
 466  
 467          $smtp_from = ($this->Sender == "") ? $this->From : $this->Sender;
 468          if(!$this->smtp->Mail($smtp_from))
 469          {
 470              $error = $this->Lang("from_failed") . $smtp_from;
 471              $this->SetError($error);
 472              $this->smtp->Reset();
 473              return false;
 474          }
 475  
 476          // Attempt to send attach all recipients

 477          for($i = 0; $i < count($this->to); $i++)
 478          {
 479              if(!$this->smtp->Recipient($this->to[$i][0]))
 480                  $bad_rcpt[] = $this->to[$i][0];
 481          }
 482          for($i = 0; $i < count($this->cc); $i++)
 483          {
 484              if(!$this->smtp->Recipient($this->cc[$i][0]))
 485                  $bad_rcpt[] = $this->cc[$i][0];
 486          }
 487          for($i = 0; $i < count($this->bcc); $i++)
 488          {
 489              if(!$this->smtp->Recipient($this->bcc[$i][0]))
 490                  $bad_rcpt[] = $this->bcc[$i][0];
 491          }
 492  
 493          if(count($bad_rcpt) > 0) // Create error message
 494          {
 495              for($i = 0; $i < count($bad_rcpt); $i++)
 496              {
 497                  if($i != 0) { $error .= ", "; }
 498                  $error .= $bad_rcpt[$i];
 499              }
 500              $error = $this->Lang("recipients_failed") . $error;
 501              $this->SetError($error);
 502              $this->smtp->Reset();
 503              return false;
 504          }
 505  
 506          if(!$this->smtp->Data($header . $body))
 507          {
 508              $this->SetError($this->Lang("data_not_accepted"));
 509              $this->smtp->Reset();
 510              return false;
 511          }
 512          if($this->SMTPKeepAlive == true)
 513              $this->smtp->Reset();
 514          else
 515              $this->SmtpClose();
 516  
 517          return true;
 518      }
 519  
 520      /**

 521       * Initiates a connection to an SMTP server.  Returns false if the 

 522       * operation failed.

 523       * @access private

 524       * @return bool

 525       */
 526      function SmtpConnect() {
 527          if($this->smtp == NULL) { $this->smtp = new SMTP(); }
 528  
 529          $this->smtp->do_debug = $this->SMTPDebug;
 530          $hosts = explode(";", $this->Host);
 531          $index = 0;
 532          $connection = ($this->smtp->Connected()); 
 533  
 534          // Retry while there is no connection

 535          while($index < count($hosts) && $connection == false)
 536          {
 537              if(strstr($hosts[$index], ":"))
 538                  list($host, $port) = explode(":", $hosts[$index]);
 539              else
 540              {
 541                  $host = $hosts[$index];
 542                  $port = $this->Port;
 543              }
 544  
 545              if($this->smtp->Connect($host, $port, $this->Timeout))
 546              {
 547                  if ($this->Helo != '')
 548                      $this->smtp->Hello($this->Helo);
 549                  else
 550                      $this->smtp->Hello($this->ServerHostname());
 551          
 552                  if($this->SMTPAuth)
 553                  {
 554                      if(!$this->smtp->Authenticate($this->Username, 
 555                                                    $this->Password))
 556                      {
 557                          $this->SetError($this->Lang("authenticate"));
 558                          $this->smtp->Reset();
 559                          $connection = false;
 560                      }
 561                  }
 562                  $connection = true;
 563              }
 564              $index++;
 565          }
 566          if(!$connection)
 567              $this->SetError($this->Lang("connect_host"));
 568  
 569          return $connection;
 570      }
 571  
 572      /**

 573       * Closes the active SMTP session if one exists.

 574       * @return void

 575       */
 576      function SmtpClose() {
 577          if($this->smtp != NULL)
 578          {
 579              if($this->smtp->Connected())
 580              {
 581                  $this->smtp->Quit();
 582                  $this->smtp->Close();
 583              }
 584          }
 585      }
 586  
 587      /**

 588       * Sets the language for all class error messages.  Returns false 

 589       * if it cannot load the language file.  The default language type

 590       * is English.

 591       * @param string $lang_type Type of language (e.g. Portuguese: "br")

 592       * @param string $lang_path Path to the language file directory

 593       * @access public

 594       * @return bool

 595       */
 596      function SetLanguage($lang_type, $lang_path = "language/") {
 597          if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php'))
 598              include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
 599          else if(file_exists($lang_path.'phpmailer.lang-en.php'))
 600              include ($lang_path.'phpmailer.lang-en.php');
 601          else
 602          {
 603              $this->SetError("Could not load language file");
 604              return false;
 605          }
 606          $this->language = $PHPMAILER_LANG;
 607      
 608          return true;
 609      }
 610  
 611      /////////////////////////////////////////////////

 612      // MESSAGE CREATION METHODS

 613      /////////////////////////////////////////////////

 614  
 615      /**

 616       * Creates recipient headers.  

 617       * @access private

 618       * @return string

 619       */
 620      function AddrAppend($type, $addr) {
 621          $addr_str = $type . ": ";
 622          $addr_str .= $this->AddrFormat($addr[0]);
 623          if(count($addr) > 1)
 624          {
 625              for($i = 1; $i < count($addr); $i++)
 626                  $addr_str .= ", " . $this->AddrFormat($addr[$i]);
 627          }
 628          $addr_str .= $this->LE;
 629  
 630          return $addr_str;
 631      }
 632      
 633      /**

 634       * Formats an address correctly. 

 635       * @access private

 636       * @return string

 637       */
 638      function AddrFormat($addr) {
 639          if(empty($addr[1]))
 640              $formatted = $addr[0];
 641          else
 642          {
 643              $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" . 
 644                           $addr[0] . ">";
 645          }
 646  
 647          return $formatted;
 648      }
 649  
 650      /**

 651       * Wraps message for use with mailers that do not

 652       * automatically perform wrapping and for quoted-printable.

 653       * Original written by philippe.  

 654       * @access private

 655       * @return string

 656       */
 657      function WrapText($message, $length, $qp_mode = false) {
 658          $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
 659  
 660          $message = $this->FixEOL($message);
 661          if (substr($message, -1) == $this->LE)
 662              $message = substr($message, 0, -1);
 663  
 664          $line = explode($this->LE, $message);
 665          $message = "";
 666          for ($i=0 ;$i < count($line); $i++)
 667          {
 668            $line_part = explode(" ", $line[$i]);
 669            $buf = "";
 670            for ($e = 0; $e<count($line_part); $e++)
 671            {
 672                $word = $line_part[$e];
 673                if ($qp_mode and (strlen($word) > $length))
 674                {
 675                  $space_left = $length - strlen($buf) - 1;
 676                  if ($e != 0)
 677                  {
 678                      if ($space_left > 20)
 679                      {
 680                          $len = $space_left;
 681                          if (substr($word, $len - 1, 1) == "=")
 682                            $len--;
 683                          elseif (substr($word, $len - 2, 1) == "=")
 684                            $len -= 2;
 685                          $part = substr($word, 0, $len);
 686                          $word = substr($word, $len);
 687                          $buf .= " " . $part;
 688                          $message .= $buf . sprintf("=%s", $this->LE);
 689                      }
 690                      else
 691                      {
 692                          $message .= $buf . $soft_break;
 693                      }
 694                      $buf = "";
 695                  }
 696                  while (strlen($word) > 0)
 697                  {
 698                      $len = $length;
 699                      if (substr($word, $len - 1, 1) == "=")
 700                          $len--;
 701                      elseif (substr($word, $len - 2, 1) == "=")
 702                          $len -= 2;
 703                      $part = substr($word, 0, $len);
 704                      $word = substr($word, $len);
 705  
 706                      if (strlen($word) > 0)
 707                          $message .= $part . sprintf("=%s", $this->LE);
 708                      else
 709                          $buf = $part;
 710                  }
 711                }
 712                else
 713                {
 714                  $buf_o = $buf;
 715                  $buf .= ($e == 0) ? $word : (" " . $word); 
 716  
 717                  if (strlen($buf) > $length and $buf_o != "")
 718                  {
 719                      $message .= $buf_o . $soft_break;
 720                      $buf = $word;
 721                  }
 722                }
 723            }
 724            $message .= $buf . $this->LE;
 725          }
 726  
 727          return $message;
 728      }
 729      
 730      /**

 731       * Set the body wrapping.

 732       * @access private

 733       * @return void

 734       */
 735      function SetWordWrap() {
 736          if($this->WordWrap < 1)
 737              return;
 738              
 739          switch($this->message_type)
 740          {
 741             case "alt":
 742                // fall through

 743             case "alt_attachments":
 744                $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
 745                break;
 746             default:
 747                $this->Body = $this->WrapText($this->Body, $this->WordWrap);
 748                break;
 749          }
 750      }
 751  
 752      /**

 753       * Assembles message header.  

 754       * @access private

 755       * @return string

 756       */
 757      function CreateHeader() {
 758          $result = "";
 759          
 760          // Set the boundaries

 761          $uniq_id = md5(uniqid(time()));
 762          $this->boundary[1] = "b1_" . $uniq_id;
 763          $this->boundary[2] = "b2_" . $uniq_id;
 764  
 765          $result .= $this->HeaderLine("Date", $this->RFCDate());
 766          if($this->Sender == "")
 767              $result .= $this->HeaderLine("Return-Path", trim($this->From));
 768          else
 769              $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
 770          
 771          // To be created automatically by mail()

 772          if($this->Mailer != "mail")
 773          {
 774              if(count($this->to) > 0)
 775                  $result .= $this->AddrAppend("To", $this->to);
 776              else if (count($this->cc) == 0)
 777                  $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
 778              if(count($this->cc) > 0)
 779                  $result .= $this->AddrAppend("Cc", $this->cc);
 780          }
 781  
 782          $from = array();
 783          $from[0][0] = trim($this->From);
 784          $from[0][1] = $this->FromName;
 785          $result .= $this->AddrAppend("From", $from); 
 786  
 787          // sendmail and mail() extract Bcc from the header before sending

 788          if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->cc) > 0))
 789              $result .= $this->AddrAppend("Cc", $this->cc);
 790          if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->bcc) > 0))
 791              $result .= $this->AddrAppend("Bcc", $this->bcc);
 792  
 793          if(count($this->ReplyTo) > 0)
 794              $result .= $this->AddrAppend("Reply-to", $this->ReplyTo);
 795  
 796          // mail() sets the subject itself

 797          if($this->Mailer != "mail")
 798              $result .= $this->HeaderLine("Subject", $this->EncodeHeader(trim($this->Subject)));
 799  
 800          $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
 801          $result .= $this->HeaderLine("X-Priority", $this->Priority);
 802          $result .= $this->HeaderLine("X-Mailer", "PHPMailer [version " . $this->Version . "]");
 803          
 804          if($this->ConfirmReadingTo != "")
 805          {
 806              $result .= $this->HeaderLine("Disposition-Notification-To", 
 807                         "<" . trim($this->ConfirmReadingTo) . ">");
 808          }
 809  
 810          // Add custom headers

 811          for($index = 0; $index < count($this->CustomHeader); $index++)
 812          {
 813              $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), 
 814                         $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
 815          }
 816          $result .= $this->HeaderLine("MIME-Version", "1.0");
 817  
 818          switch($this->message_type)
 819          {
 820              case "plain":
 821                  $result .= $this->HeaderLine("Content-Transfer-Encoding", $this->Encoding);
 822                  $result .= sprintf("Content-Type: %s; charset=\"%s\"",
 823                                      $this->ContentType, $this->CharSet);
 824                  break;
 825              case "attachments":
 826                  // fall through

 827              case "alt_attachments":
 828                  if($this->InlineImageExists())
 829                  {
 830                      $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s", 
 831                                      "multipart/related", $this->LE, $this->LE, 
 832                                      $this->boundary[1], $this->LE);
 833                  }
 834                  else
 835                  {
 836                      $result .= $this->HeaderLine("Content-Type", "multipart/mixed;");
 837                      $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
 838                  }
 839                  break;
 840              case "alt":
 841                  $result .= $this->HeaderLine("Content-Type", "multipart/alternative;");
 842                  $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
 843                  break;
 844          }
 845  
 846          if($this->Mailer != "mail")
 847              $result .= $this->LE.$this->LE;
 848  
 849          return $result;
 850      }
 851  
 852      /**

 853       * Assembles the message body.  Returns an empty string on failure.

 854       * @access private

 855       * @return string

 856       */
 857      function CreateBody() {
 858          $result = "";
 859  
 860          $this->SetWordWrap();
 861  
 862          switch($this->message_type)
 863          {
 864              case "alt":
 865                  $result .= $this->GetBoundary($this->boundary[1], "", 
 866                                                "text/plain", "");
 867                  $result .= $this->EncodeString($this->AltBody, $this->Encoding);
 868                  $result .= $this->LE.$this->LE;
 869                  $result .= $this->GetBoundary($this->boundary[1], "", 
 870                                                "text/html", "");
 871                  
 872                  $result .= $this->EncodeString($this->Body, $this->Encoding);
 873                  $result .= $this->LE.$this->LE;
 874      
 875                  $result .= $this->EndBoundary($this->boundary[1]);
 876                  break;
 877              case "plain":
 878                  $result .= $this->EncodeString($this->Body, $this->Encoding);
 879                  break;
 880              case "attachments":
 881                  $result .= $this->GetBoundary($this->boundary[1], "", "", "");
 882                  $result .= $this->EncodeString($this->Body, $this->Encoding);
 883                  $result .= $this->LE;
 884       
 885                  $result .= $this->AttachAll();
 886                  break;
 887              case "alt_attachments":
 888                  $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
 889                  $result .= sprintf("Content-Type: %s;%s" .
 890                                     "\tboundary=\"%s\"%s",
 891                                     "multipart/alternative", $this->LE, 
 892                                     $this->boundary[2], $this->LE.$this->LE);
 893      
 894                  // Create text body

 895                  $result .= $this->GetBoundary($this->boundary[2], "", 
 896                                                "text/plain", "") . $this->LE;
 897  
 898                  $result .= $this->EncodeString($this->AltBody, $this->Encoding);
 899                  $result .= $this->LE.$this->LE;
 900      
 901                  // Create the HTML body

 902                  $result .= $this->GetBoundary($this->boundary[2], "", 
 903                                                "text/html", "") . $this->LE;
 904      
 905                  $result .= $this->EncodeString($this->Body, $this->Encoding);
 906                  $result .= $this->LE.$this->LE;
 907  
 908                  $result .= $this->EndBoundary($this->boundary[2]);
 909                  
 910                  $result .= $this->AttachAll();
 911                  break;
 912          }
 913          if($this->IsError())
 914              $result = "";
 915  
 916          return $result;
 917      }
 918  
 919      /**

 920       * Returns the start of a message boundary.

 921       * @access private

 922       */
 923      function GetBoundary($boundary, $charSet, $contentType, $encoding) {
 924          $result = "";
 925          if($charSet == "") { $charSet = $this->CharSet; }
 926          if($contentType == "") { $contentType = $this->ContentType; }
 927          if($encoding == "") { $encoding = $this->Encoding; }
 928  
 929          $result .= $this->TextLine("--" . $boundary);
 930          $result .= sprintf("Content-Type: %s; charset = \"%s\"", 
 931                              $contentType, $charSet);
 932          $result .= $this->LE;
 933          $result .= $this->HeaderLine("Content-Transfer-Encoding", $encoding);
 934          $result .= $this->LE;
 935         
 936          return $result;
 937      }
 938      
 939      /**

 940       * Returns the end of a message boundary.

 941       * @access private

 942       */
 943      function EndBoundary($boundary) {
 944          return $this->LE . "--" . $boundary . "--" . $this->LE; 
 945      }
 946      
 947      /**

 948       * Sets the message type.

 949       * @access private

 950       * @return void

 951       */
 952      function SetMessageType() {
 953          if(count($this->attachment) < 1 && strlen($this->AltBody) < 1)
 954              $this->message_type = "plain";
 955          else
 956          {
 957              if(count($this->attachment) > 0)
 958                  $this->message_type = "attachments";
 959              if(strlen($this->AltBody) > 0 && count($this->attachment) < 1)
 960                  $this->message_type = "alt";
 961              if(strlen($this->AltBody) > 0 && count($this->attachment) > 0)
 962                  $this->message_type = "alt_attachments";
 963          }
 964      }
 965  
 966      /**

 967       * Returns a formatted header line.

 968       * @access private

 969       * @return string

 970       */
 971      function HeaderLine($name, $value) {
 972          return $name . ": " . $value . $this->LE;
 973      }
 974  
 975      /**

 976       * Returns a formatted mail line.

 977       * @access private

 978       * @return string

 979       */
 980      function TextLine($value) {
 981          return $value . $this->LE;
 982      }
 983  
 984      /////////////////////////////////////////////////

 985      // ATTACHMENT METHODS

 986      /////////////////////////////////////////////////

 987  
 988      /**

 989       * Adds an attachment from a path on the filesystem.

 990       * Returns false if the file could not be found

 991       * or accessed.

 992       * @param string $path Path to the attachment.

 993       * @param string $name Overrides the attachment name.

 994       * @param string $encoding File encoding (see $Encoding).

 995       * @param string $type File extension (MIME) type.

 996       * @return bool

 997       */
 998      function AddAttachment($path, $name = "", $encoding = "base64", 
 999                             $type = "application/octet-stream") {
1000          if(!@is_file($path))
1001          {
1002              $this->SetError($this->Lang("file_access") . $path);
1003              return false;
1004          }
1005  
1006          $filename = basename($path);
1007          if($name == "")
1008              $name = $filename;
1009  
1010          $cur = count($this->attachment);
1011          $this->attachment[$cur][0] = $path;
1012          $this->attachment[$cur][1] = $filename;
1013          $this->attachment[$cur][2] = $name;
1014          $this->attachment[$cur][3] = $encoding;
1015          $this->attachment[$cur][4] = $type;
1016          $this->attachment[$cur][5] = false; // isStringAttachment

1017          $this->attachment[$cur][6] = "attachment";
1018          $this->attachment[$cur][7] = 0;
1019  
1020          return true;
1021      }
1022  
1023      /**

1024       * Attaches all fs, string, and binary attachments to the message.

1025       * Returns an empty string on failure.

1026       * @access private

1027       * @return string

1028       */
1029      function AttachAll() {
1030          // Return text of body

1031          $mime = array();
1032  
1033          // Add all attachments

1034          for($i = 0; $i < count($this->attachment); $i++)
1035          {
1036              // Check for string attachment

1037              $bString = $this->attachment[$i][5];
1038              if ($bString)
1039                  $string = $this->attachment[$i][0];
1040              else
1041                  $path = $this->attachment[$i][0];
1042  
1043              $filename    = $this->attachment[$i][1];
1044              $name        = $this->attachment[$i][2];
1045              $encoding    = $this->attachment[$i][3];
1046              $type        = $this->attachment[$i][4];
1047              $disposition = $this->attachment[$i][6];
1048              $cid         = $this->attachment[$i][7];
1049              
1050              $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
1051              $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
1052              $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
1053  
1054              if($disposition == "inline")
1055                  $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
1056  
1057              $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s", 
1058                                $disposition, $name, $this->LE.$this->LE);
1059  
1060              // Encode as string attachment

1061              if($bString)
1062              {
1063                  $mime[] = $this->EncodeString($string, $encoding);
1064                  if($this->IsError()) { return ""; }
1065                  $mime[] = $this->LE.$this->LE;
1066              }
1067              else
1068              {
1069                  $mime[] = $this->EncodeFile($path, $encoding);                
1070                  if($this->IsError()) { return ""; }
1071                  $mime[] = $this->LE.$this->LE;
1072              }
1073          }
1074  
1075          $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
1076  
1077          return join("", $mime);
1078      }
1079      
1080      /**

1081       * Encodes attachment in requested format.  Returns an

1082       * empty string on failure.

1083       * @access private

1084       * @return string

1085       */
1086      function EncodeFile ($path, $encoding = "base64") {
1087          if(!@$fd = fopen($path, "rb"))
1088          {
1089              $this->SetError($this->Lang("file_open") . $path);
1090              return "";
1091          }
1092          $magic_quotes = get_magic_quotes_runtime();
1093          set_magic_quotes_runtime(0);
1094          $file_buffer = fread($fd, filesize($path));
1095          $file_buffer = $this->EncodeString($file_buffer, $encoding);
1096          fclose($fd);
1097          set_magic_quotes_runtime($magic_quotes);
1098  
1099          return $file_buffer;
1100      }
1101  
1102      /**

1103       * Encodes string to requested format. Returns an

1104       * empty string on failure.

1105       * @access private

1106       * @return string

1107       */
1108      function EncodeString ($str, $encoding = "base64") {
1109          $encoded = "";
1110          switch(strtolower($encoding)) {
1111            case "base64":
1112                // chunk_split is found in PHP >= 3.0.6

1113                $encoded = chunk_split(base64_encode($str), 76, $this->LE);
1114                break;
1115            case "7bit":
1116            case "8bit":
1117                $encoded = $this->FixEOL($str);
1118                if (substr($encoded, -(strlen($this->LE))) != $this->LE)
1119                  $encoded .= $this->LE;
1120                break;
1121            case "binary":
1122                $encoded = $str;
1123                break;
1124            case "quoted-printable":
1125                $encoded = $this->EncodeQP($str);
1126                break;
1127            default:
1128                $this->SetError($this->Lang("encoding") . $encoding);
1129                break;
1130          }
1131          return $encoded;
1132      }
1133  
1134      /**

1135       * Encode a header string to best of Q, B, quoted or none.  

1136       * @access private

1137       * @return string

1138       */
1139      function EncodeHeader ($str, $position = 'text') {
1140        $x = 0;
1141        
1142        switch (strtolower($position)) {
1143          case 'phrase':
1144            if (!preg_match('/[\200-\377]/', $str)) {
1145              // Can't use addslashes as we don't know what value has magic_quotes_sybase.

1146              $encoded = addcslashes($str, "\0..\37\177\\\"");
1147  
1148              if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str))
1149                return ($encoded);
1150              else
1151                return ("\"$encoded\"");
1152            }
1153            $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
1154            break;
1155          case 'comment':
1156            $x = preg_match_all('/[()"]/', $str, $matches);
1157            // Fall-through

1158          case 'text':
1159          default:
1160            $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
1161            break;
1162        }
1163  
1164        if ($x == 0)
1165          return ($str);
1166  
1167        $maxlen = 75 - 7 - strlen($this->CharSet);
1168        // Try to select the encoding which should produce the shortest output

1169        if (strlen($str)/3 < $x) {
1170          $encoding = 'B';
1171          $encoded = base64_encode($str);
1172          $maxlen -= $maxlen % 4;
1173          $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
1174        } else {
1175          $encoding = 'Q';
1176          $encoded = $this->EncodeQ($str, $position);
1177          $encoded = $this->WrapText($encoded, $maxlen, true);
1178          $encoded = str_replace("=".$this->LE, "\n", trim($encoded));
1179        }
1180  
1181        $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
1182        $encoded = trim(str_replace("\n", $this->LE, $encoded));
1183        
1184        return $encoded;
1185      }
1186      
1187      /**

1188       * Encode string to quoted-printable.  

1189       * @access private

1190       * @return string

1191       */
1192      function EncodeQP ($str) {
1193          $encoded = $this->FixEOL($str);
1194          if (substr($encoded, -(strlen($this->LE))) != $this->LE)
1195              $encoded .= $this->LE;
1196  
1197          // Replace every high ascii, control and = characters

1198          $encoded = preg_replace('/([\000-\010\013\014\016-\037\075\177-\377])/e',
1199                    "'='.sprintf('%02X', ord('\\1'))", $encoded);
1200          // Replace every spaces and tabs when it's the last character on a line

1201          $encoded = preg_replace("/([\011\040])".$this->LE."/e",
1202                    "'='.sprintf('%02X', ord('\\1')).'".$this->LE."'", $encoded);
1203  
1204          // Maximum line length of 76 characters before CRLF (74 + space + '=')

1205          $encoded = $this->WrapText($encoded, 74, true);
1206  
1207          return $encoded;
1208      }
1209  
1210      /**

1211       * Encode string to q encoding.  

1212       * @access private

1213       * @return string

1214       */
1215      function EncodeQ ($str, $position = "text") {
1216          // There should not be any EOL in the string

1217          $encoded = preg_replace("[\r\n]", "", $str);
1218  
1219          switch (strtolower($position)) {
1220            case "phrase":
1221              $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
1222              break;
1223            case "comment":
1224              $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
1225            case "text":
1226            default:
1227              // Replace every high ascii, control =, ? and _ characters

1228              $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
1229                    "'='.sprintf('%02X', ord('\\1'))", $encoded);
1230              break;
1231          }
1232          
1233          // Replace every spaces to _ (more readable than =20)

1234          $encoded = str_replace(" ", "_", $encoded);
1235  
1236          return $encoded;
1237      }
1238  
1239      /**

1240       * Adds a string or binary attachment (non-filesystem) to the list.

1241       * This method can be used to attach ascii or binary data,

1242       * such as a BLOB record from a database.

1243       * @param string $string String attachment data.

1244       * @param string $filename Name of the attachment.

1245       * @param string $encoding File encoding (see $Encoding).

1246       * @param string $type File extension (MIME) type.

1247       * @return void

1248       */
1249      function AddStringAttachment($string, $filename, $encoding = "base64", 
1250                                   $type = "application/octet-stream") {
1251          // Append to $attachment array

1252          $cur = count($this->attachment);
1253          $this->attachment[$cur][0] = $string;
1254          $this->attachment[$cur][1] = $filename;
1255          $this->attachment[$cur][2] = $filename;
1256          $this->attachment[$cur][3] = $encoding;
1257          $this->attachment[$cur][4] = $type;
1258          $this->attachment[$cur][5] = true; // isString

1259          $this->attachment[$cur][6] = "attachment";
1260          $this->attachment[$cur][7] = 0;
1261      }
1262      
1263      /**

1264       * Adds an embedded attachment.  This can include images, sounds, and 

1265       * just about any other document.  Make sure to set the $type to an 

1266       * image type.  For JPEG images use "image/jpeg" and for GIF images 

1267       * use "image/gif".

1268       * @param string $path Path to the attachment.

1269       * @param string $cid Content ID of the attachment.  Use this to identify 

1270       *        the Id for accessing the image in an HTML form.

1271       * @param string $name Overrides the attachment name.

1272       * @param string $encoding File encoding (see $Encoding).

1273       * @param string $type File extension (MIME) type.  

1274       * @return bool

1275       */
1276      function AddEmbeddedImage($path, $cid, $name = "", $encoding = "base64", 
1277                                $type = "application/octet-stream") {
1278      
1279          if(!@is_file($path))
1280          {
1281              $this->SetError($this->Lang("file_access") . $path);
1282              return false;
1283          }
1284  
1285          $filename = basename($path);
1286          if($name == "")
1287              $name = $filename;
1288  
1289          // Append to $attachment array

1290          $cur = count($this->attachment);
1291          $this->attachment[$cur][0] = $path;
1292          $this->attachment[$cur][1] = $filename;
1293          $this->attachment[$cur][2] = $name;
1294          $this->attachment[$cur][3] = $encoding;
1295          $this->attachment[$cur][4] = $type;
1296          $this->attachment[$cur][5] = false; // isStringAttachment

1297          $this->attachment[$cur][6] = "inline";
1298          $this->attachment[$cur][7] = $cid;
1299      
1300          return true;
1301      }
1302      
1303      /**

1304       * Returns true if an inline attachment is present.

1305       * @access private

1306       * @return bool

1307       */
1308      function InlineImageExists() {
1309          $result = false;
1310          for($i = 0; $i < count($this->attachment); $i++)
1311          {
1312              if($this->attachment[$i][6] == "inline")
1313              {
1314                  $result = true;
1315                  break;
1316              }
1317          }
1318          
1319          return $result;
1320      }
1321  
1322      /////////////////////////////////////////////////

1323      // MESSAGE RESET METHODS

1324      /////////////////////////////////////////////////

1325  
1326      /**

1327       * Clears all recipients assigned in the TO array.  Returns void.

1328       * @return void

1329       */
1330      function ClearAddresses() {
1331          $this->to = array();
1332      }
1333  
1334      /**

1335       * Clears all recipients assigned in the CC array.  Returns void.

1336       * @return void

1337       */
1338      function ClearCCs() {
1339          $this->cc = array();
1340      }
1341  
1342      /**

1343       * Clears all recipients assigned in the BCC array.  Returns void.

1344       * @return void

1345       */
1346      function ClearBCCs() {
1347          $this->bcc = array();
1348      }
1349  
1350      /**

1351       * Clears all recipients assigned in the ReplyTo array.  Returns void.

1352       * @return void

1353       */
1354      function ClearReplyTos() {
1355          $this->ReplyTo = array();
1356      }
1357  
1358      /**

1359       * Clears all recipients assigned in the TO, CC and BCC

1360       * array.  Returns void.

1361       * @return void

1362       */
1363      function ClearAllRecipients() {
1364          $this->to = array();
1365          $this->cc = array();
1366          $this->bcc = array();
1367      }
1368  
1369      /**

1370       * Clears all previously set filesystem, string, and binary

1371       * attachments.  Returns void.

1372       * @return void

1373       */
1374      function ClearAttachments() {
1375          $this->attachment = array();
1376      }
1377  
1378      /**

1379       * Clears all custom headers.  Returns void.

1380       * @return void

1381       */
1382      function ClearCustomHeaders() {
1383          $this->CustomHeader = array();
1384      }
1385  
1386  
1387      /////////////////////////////////////////////////

1388      // MISCELLANEOUS METHODS

1389      /////////////////////////////////////////////////

1390  
1391      /**

1392       * Adds the error message to the error container.

1393       * Returns void.

1394       * @access private

1395       * @return void

1396       */
1397      function SetError($msg) {
1398          $this->error_count++;
1399          $this->ErrorInfo = $msg;
1400      }
1401  
1402      /**

1403       * Returns the proper RFC 822 formatted date. 

1404       * @access private

1405       * @return string

1406       */
1407      function RFCDate() {
1408          $tz = date("Z");
1409          $tzs = ($tz < 0) ? "-" : "+";
1410          $tz = abs($tz);
1411          $tz = ($tz/3600)*100 + ($tz%3600)/60;
1412          $result = sprintf("%s %s%04d", date("D, j M Y H:i:s"), $tzs, $tz);
1413  
1414          return $result;
1415      }
1416      
1417      /**

1418       * Returns the appropriate server variable.  Should work with both 

1419       * PHP 4.1.0+ as well as older versions.  Returns an empty string 

1420       * if nothing is found.

1421       * @access private

1422       * @return mixed

1423       */
1424      function ServerVar($varName) {
1425          global $HTTP_SERVER_VARS;
1426          global $HTTP_ENV_VARS;
1427  
1428          if(!isset($_SERVER))
1429          {
1430              $_SERVER = $HTTP_SERVER_VARS;
1431              if(!isset($_SERVER["REMOTE_ADDR"]))
1432                  $_SERVER = $HTTP_ENV_VARS; // must be Apache

1433          }
1434          
1435          if(isset($_SERVER[$varName]))
1436              return $_SERVER[$varName];
1437          else
1438              return "";
1439      }
1440  
1441      /**

1442       * Returns the server hostname or 'localhost.localdomain' if unknown.

1443       * @access private

1444       * @return string

1445       */
1446      function ServerHostname() {
1447          if ($this->Hostname != "")
1448              $result = $this->Hostname;
1449          elseif ($this->ServerVar('SERVER_NAME') != "")
1450              $result = $this->ServerVar('SERVER_NAME');
1451          else
1452              $result = "localhost.localdomain";
1453  
1454          return $result;
1455      }
1456  
1457      /**

1458       * Returns a message in the appropriate language.

1459       * @access private

1460       * @return string

1461       */
1462      function Lang($key) {
1463          if(count($this->language) < 1)
1464              $this->SetLanguage("en"); // set the default language

1465      
1466          if(isset($this->language[$key]))
1467              return $this->language[$key];
1468          else
1469              return "Language string failed to load: " . $key;
1470      }
1471      
1472      /**

1473       * Returns true if an error occurred.

1474       * @return bool

1475       */
1476      function IsError() {
1477          return ($this->error_count > 0);
1478      }
1479  
1480      /**

1481       * Changes every end of line from CR or LF to CRLF.  

1482       * @access private

1483       * @return string

1484       */
1485      function FixEOL($str) {
1486          $str = str_replace("\r\n", "\n", $str);
1487          $str = str_replace("\r", "\n", $str);
1488          $str = str_replace("\n", $this->LE, $str);
1489          return $str;
1490      }
1491  
1492      /**

1493       * Adds a custom header. 

1494       * @return void

1495       */
1496      function AddCustomHeader($custom_header) {
1497          $this->CustomHeader[] = explode(":", $custom_header, 2);
1498      }
1499  }
1500  
1501  ?>


[ Powered by PHPXref - Served by Debian GNU/Linux ]