[ Index ]
 

Code source de Cr@wltr@ck 2.2.1

Accédez au Source d'autres logiciels libresSoutenez Angelica Josefina !

title

Body

[fermer]

/phpmailer/ -> class.phpmaileriso.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  
  21  class PHPMailer
  22  {
  23      /////////////////////////////////////////////////

  24      // PUBLIC VARIABLES

  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       *  Sets the SMTP hosts.  All hosts must be separated by a

 151       *  semicolon.  You can also specify a different port

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

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

 154       *  Hosts will be tried in order.

 155       *  @var string

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

 160       *  Sets the default SMTP server port.

 161       *  @var int

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

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

 167       *  @var string

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

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

 173       *  @var bool

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

 178       *  Sets SMTP username.

 179       *  @var string

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

 184       *  Sets SMTP password.

 185       *  @var string

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

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

 191       *  work with the win32 version.

 192       *  @var int

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

 197       *  Sets SMTP class debugging on or off.

 198       *  @var bool

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

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

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

 205       * requires an explicit call to SmtpClose(). 

 206       * @var bool

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

 211       * @access private

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

 226      
 227      /////////////////////////////////////////////////

 228      // VARIABLE METHODS

 229      /////////////////////////////////////////////////

 230  
 231      /**

 232       * Sets message type to HTML.  

 233       * @param bool $bool

 234       * @return void

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

 244       * Sets Mailer to send message using SMTP.

 245       * @return void

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

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

 253       * @return void

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

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

 261       * @return void

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

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

 269       * @return void

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

 278      // RECIPIENT METHODS

 279      /////////////////////////////////////////////////

 280  
 281      /**

 282       * Adds a "To" address.  

 283       * @param string $address

 284       * @param string $name

 285       * @return void

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

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

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

 296       * mailer.  

 297       * @param string $address

 298       * @param string $name

 299       * @return void

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

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

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

 310       * mailer.  

 311       * @param string $address

 312       * @param string $name

 313       * @return void

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

 322       * Adds a "Reply-to" address.  

 323       * @param string $address

 324       * @param string $name

 325       * @return void

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

 335      // MAIL SENDING METHODS

 336      /////////////////////////////////////////////////

 337  
 338      /**

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

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

 341       * variable to view description of the error.  

 342       * @return bool

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

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

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

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

 388       * Sends mail using the $Sendmail program.  

 389       * @access private

 390       * @return bool

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

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

 419       * @access private

 420       * @return bool

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

 454       * Sends mail via SMTP using PhpSMTP (Author:

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

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

 457       * @access private

 458       * @return bool

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

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

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

 523       * operation failed.

 524       * @access private

 525       * @return bool

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

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

 574       * Closes the active SMTP session if one exists.

 575       * @return void

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

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

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

 591       * is English.

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

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

 594       * @access public

 595       * @return bool

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

 613      // MESSAGE CREATION METHODS

 614      /////////////////////////////////////////////////

 615  
 616      /**

 617       * Creates recipient headers.  

 618       * @access private

 619       * @return string

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

 635       * Formats an address correctly. 

 636       * @access private

 637       * @return string

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

 652       * Wraps message for use with mailers that do not

 653       * automatically perform wrapping and for quoted-printable.

 654       * Original written by philippe.  

 655       * @access private

 656       * @return string

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

 732       * Set the body wrapping.

 733       * @access private

 734       * @return void

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

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

 754       * Assembles message header.  

 755       * @access private

 756       * @return string

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

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

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

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

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

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

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

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

 853       * @access private

 854       * @return string

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

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

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

 919       * Returns the start of a message boundary.

 920       * @access private

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

 939       * Returns the end of a message boundary.

 940       * @access private

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

 947       * Sets the message type.

 948       * @access private

 949       * @return void

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

 966       * Returns a formatted header line.

 967       * @access private

 968       * @return string

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

 975       * Returns a formatted mail line.

 976       * @access private

 977       * @return string

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

 984      // ATTACHMENT METHODS

 985      /////////////////////////////////////////////////

 986  
 987      /**

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

 989       * Returns false if the file could not be found

 990       * or accessed.

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

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

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

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

 995       * @return bool

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

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

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

1024       * Returns an empty string on failure.

1025       * @access private

1026       * @return string

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

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

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

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

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

1080       * Encodes attachment in requested format.  Returns an

1081       * empty string on failure.

1082       * @access private

1083       * @return string

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

1102       * Encodes string to requested format. Returns an

1103       * empty string on failure.

1104       * @access private

1105       * @return string

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

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

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

1135       * @access private

1136       * @return string

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

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

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

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

1187       * Encode string to quoted-printable.  

1188       * @access private

1189       * @return string

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

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

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

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

1210       * Encode string to q encoding.  

1211       * @access private

1212       * @return string

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

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

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

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

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

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

1241       * such as a BLOB record from a database.

1242       * @param string $string String attachment data.

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

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

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

1246       * @return void

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

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

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

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

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

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

1266       * use "image/gif".

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

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

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

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

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

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

1273       * @return bool

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

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

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

1303       * Returns true if an inline attachment is present.

1304       * @access private

1305       * @return bool

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

1322      // MESSAGE RESET METHODS

1323      /////////////////////////////////////////////////

1324  
1325      /**

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

1327       * @return void

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

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

1335       * @return void

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

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

1343       * @return void

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

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

1351       * @return void

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

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

1359       * array.  Returns void.

1360       * @return void

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

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

1370       * attachments.  Returns void.

1371       * @return void

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

1378       * Clears all custom headers.  Returns void.

1379       * @return void

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

1387      // MISCELLANEOUS METHODS

1388      /////////////////////////////////////////////////

1389  
1390      /**

1391       * Adds the error message to the error container.

1392       * Returns void.

1393       * @access private

1394       * @return void

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

1402       * Returns the proper RFC 822 formatted date. 

1403       * @access private

1404       * @return string

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

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

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

1419       * if nothing is found.

1420       * @access private

1421       * @return mixed

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

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

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

1442       * @access private

1443       * @return string

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

1457       * Returns a message in the appropriate language.

1458       * @access private

1459       * @return string

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

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

1472       * Returns true if an error occurred.

1473       * @return bool

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

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

1481       * @access private

1482       * @return string

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

1492       * Adds a custom header. 

1493       * @return void

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


Généré le : Thu Sep 6 14:14:11 2007 par Balluche grâce à PHPXref 0.7