lib/phpmailer/class.phpmailer.php

   1 <?php
   2 ////////////////////////////////////////////////////
   3 // PHPMailer - PHP email class
   4 //
   5 // Class for sending email using either
   6 // sendmail, PHP mail(), or SMTP.  Methods are
   7 // based upon the standard AspEmail(tm) classes.
   8 //
   9 // Copyright (C) 2001 - 2003  Brent R. Matzelle
  10 //
  11 // License: LGPL, see LICENSE
  12 ////////////////////////////////////////////////////
  13
  14 /**
  15  * PHPMailer - PHP email transport class
  16  * @package PHPMailer
  17  * @author Brent R. Matzelle
  18  * @copyright 2001 - 2003 Brent R. Matzelle
  19  */
  20 class PHPMailer
  21 {
  22     /////////////////////////////////////////////////
  23     // PUBLIC VARIABLES
  24     /////////////////////////////////////////////////
  25
  26     /**
  27      * 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",
 394                 escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
 395         else
 396             $sendmail = sprintf("%s -oi -t",
 397                 escapeshellcmd($this->Sendmail));
 398
 399         if(!@$mail = popen($sendmail, "w"))
 400         {
 401             $this->SetError($this->Lang("execute") . $this->Sendmail);
 402             return false;
 403         }
 404
 405         fputs($mail, $header);
 406         fputs($mail, $body);
 407
 408         $result = pclose($mail) >> 8 & 0xFF;
 409         if($result != 0)
 410         {
 411             $this->SetError($this->Lang("execute") . $this->Sendmail);
 412             return false;
 413         }
 414
 415         return true;
 416     }
 417
 418     /**
 419      * Sends mail using the PHP mail() function.
 420      * @access private
 421      * @return bool
 422      */
 423     function MailSend($header, $body) {
 424         $to = "";
 425         for($i = 0; $i < count($this->to); $i++)
 426         {
 427             if($i != 0) { $to .= ", "; }
 428             $to .= $this->to[$i][0];
 429         }
 430
 431         if ($this->Sender != "" && strlen(ini_get("safe_mode"))< 1)
 432         {
 433             $old_from = ini_get("sendmail_from");
 434             ini_set("sendmail_from", $this->Sender);
 435             $params = sprintf("-oi -f %s", $this->Sender);
 436             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body,
 437                         $header, $params);
 438         }
 439         else
 440             $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, $header);
 441
 442         if (isset($old_from))
 443             ini_set("sendmail_from", $old_from);
 444
 445         if(!$rt)
 446         {
 447             $this->SetError($this->Lang("instantiate"));
 448             return false;
 449         }
 450
 451         return true;
 452     }
 453
 454     /**
 455      * Sends mail via SMTP using PhpSMTP (Author:
 456      * Chris Ryan).  Returns bool.  Returns false if there is a
 457      * bad MAIL FROM, RCPT, or DATA input.
 458      * @access private
 459      * @return bool
 460      */
 461     function SmtpSend($header, $body) {
 462         include_once($this->PluginDir . "class.smtp.php");
 463         $error = "";
 464         $bad_rcpt = array();
 465
 466         if(!$this->SmtpConnect())
 467             return false;
 468
 469         $smtp_from = ($this->Sender == "") ? $this->From : $this->Sender;
 470         if(!$this->smtp->Mail($smtp_from))
 471         {
 472             $error = $this->Lang("from_failed") . $smtp_from;
 473             $this->SetError($error);
 474             $this->smtp->Reset();
 475             return false;
 476         }
 477
 478         // Attempt to send attach all recipients
 479         for($i = 0; $i < count($this->to); $i++)
 480         {
 481             if(!$this->smtp->Recipient($this->to[$i][0]))
 482                 $bad_rcpt[] = $this->to[$i][0];
 483         }
 484         for($i = 0; $i < count($this->cc); $i++)
 485         {
 486             if(!$this->smtp->Recipient($this->cc[$i][0]))
 487                 $bad_rcpt[] = $this->cc[$i][0];
 488         }
 489         for($i = 0; $i < count($this->bcc); $i++)
 490         {
 491             if(!$this->smtp->Recipient($this->bcc[$i][0]))
 492                 $bad_rcpt[] = $this->bcc[$i][0];
 493         }
 494
 495         if(count($bad_rcpt) > 0) // Create error message
 496         {
 497             for($i = 0; $i < count($bad_rcpt); $i++)
 498             {
 499                 if($i != 0) { $error .= ", "; }
 500                 $error .= $bad_rcpt[$i];
 501             }
 502             $error = $this->Lang("recipients_failed") . $error;
 503             $this->SetError($error);
 504             $this->smtp->Reset();
 505             return false;
 506         }
 507
 508         if(!$this->smtp->Data($header . $body))
 509         {
 510             $this->SetError($this->Lang("data_not_accepted"));
 511             $this->smtp->Reset();
 512             return false;
 513         }
 514         if($this->SMTPKeepAlive == true)
 515             $this->smtp->Reset();
 516         else
 517             $this->SmtpClose();
 518
 519         return true;
 520     }
 521
 522     /**
 523      * Initiates a connection to an SMTP server.  Returns false if the
 524      * operation failed.
 525      * @access private
 526      * @return bool
 527      */
 528     function SmtpConnect() {
 529         if($this->smtp == NULL) { $this->smtp = new SMTP(); }
 530
 531         $this->smtp->do_debug = $this->SMTPDebug;
 532         $hosts = explode(";", $this->Host);
 533         $index = 0;
 534         $connection = ($this->smtp->Connected());
 535
 536         // Retry while there is no connection
 537         while($index < count($hosts) && $connection == false)
 538         {
 539             if(strstr($hosts[$index], ":"))
 540                 list($host, $port) = explode(":", $hosts[$index]);
 541             else
 542             {
 543                 $host = $hosts[$index];
 544                 $port = $this->Port;
 545             }
 546
 547             if($this->smtp->Connect($host, $port, $this->Timeout))
 548             {
 549                 if ($this->Helo != '')
 550                     $this->smtp->Hello($this->Helo);
 551                 else
 552                     $this->smtp->Hello($this->ServerHostname());
 553
 554                 if($this->SMTPAuth)
 555                 {
 556                     if(!$this->smtp->Authenticate($this->Username,
 557                                                   $this->Password))
 558                     {
 559                         $this->SetError($this->Lang("authenticate"));
 560                         $this->smtp->Reset();
 561                         $connection = false;
 562                     }
 563                 }
 564                 $connection = true;
 565             }
 566             $index++;
 567         }
 568         if(!$connection)
 569             $this->SetError($this->Lang("connect_host"));
 570
 571         return $connection;
 572     }
 573
 574     /**
 575      * Closes the active SMTP session if one exists.
 576      * @return void
 577      */
 578     function SmtpClose() {
 579         if($this->smtp != NULL)
 580         {
 581             if($this->smtp->Connected())
 582             {
 583                 $this->smtp->Quit();
 584                 $this->smtp->Close();
 585             }
 586         }
 587     }
 588
 589     /**
 590      * Sets the language for all class error messages.  Returns false
 591      * if it cannot load the language file.  The default language type
 592      * is English.
 593      * @param string $lang_type Type of language (e.g. Portuguese: "br")
 594      * @param string $lang_path Path to the language file directory
 595      * @access public
 596      * @return bool
 597      */
 598     function SetLanguage($lang_type, $lang_path = "language/") {
 599         if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php'))
 600             include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
 601         else if(file_exists($lang_path.'phpmailer.lang-en.php'))
 602             include($lang_path.'phpmailer.lang-en.php');
 603         else
 604         {
 605             $this->SetError("Could not load language file");
 606             return false;
 607         }
 608         $this->language = $PHPMAILER_LANG;
 609
 610         return true;
 611     }
 612
 613     /////////////////////////////////////////////////
 614     // MESSAGE CREATION METHODS
 615     /////////////////////////////////////////////////
 616
 617     /**
 618      * Creates recipient headers.
 619      * @access private
 620      * @return string
 621      */
 622     function AddrAppend($type, $addr) {
 623         $addr_str = $type . ": ";
 624         $addr_str .= $this->AddrFormat($addr[0]);
 625         if(count($addr) > 1)
 626         {
 627             for($i = 1; $i < count($addr); $i++)
 628                 $addr_str .= ", " . $this->AddrFormat($addr[$i]);
 629         }
 630         $addr_str .= $this->LE;
 631
 632         return $addr_str;
 633     }
 634
 635     /**
 636      * Formats an address correctly.
 637      * @access private
 638      * @return string
 639      */
 640     function AddrFormat($addr) {
 641         if(empty($addr[1]))
 642             $formatted = $addr[0];
 643         else
 644         {
 645             $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" .
 646                          $addr[0] . ">";
 647         }
 648
 649         return $formatted;
 650     }
 651
 652     /**
 653      * Wraps message for use with mailers that do not
 654      * automatically perform wrapping and for quoted-printable.
 655      * Original written by philippe.
 656      * @access private
 657      * @return string
 658      */
 659     function WrapText($message, $length, $qp_mode = false) {
 660         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
 661
 662         $message = $this->FixEOL($message);
 663         if (substr($message, -1) == $this->LE)
 664             $message = substr($message, 0, -1);
 665
 666         $line = explode($this->LE, $message);
 667         $message = "";
 668         for ($i=0 ;$i < count($line); $i++)
 669         {
 670           $line_part = explode(" ", $line[$i]);
 671           $buf = "";
 672           for ($e = 0; $e<count($line_part); $e++)
 673           {
 674               $word = $line_part[$e];
 675               if ($qp_mode and (strlen($word) > $length))
 676               {
 677                 $space_left = $length - strlen($buf) - 1;
 678                 if ($e != 0)
 679                 {
 680                     if ($space_left > 20)
 681                     {
 682                         $len = $space_left;
 683                         if (substr($word, $len - 1, 1) == "=")
 684                           $len--;
 685                         elseif (substr($word, $len - 2, 1) == "=")
 686                           $len -= 2;
 687                         $part = substr($word, 0, $len);
 688                         $word = substr($word, $len);
 689                         $buf .= " " . $part;
 690                         $message .= $buf . sprintf("=%s", $this->LE);
 691                     }
 692                     else
 693                     {
 694                         $message .= $buf . $soft_break;
 695                     }
 696                     $buf = "";
 697                 }
 698                 while (strlen($word) > 0)
 699                 {
 700                     $len = $length;
 701                     if (substr($word, $len - 1, 1) == "=")
 702                         $len--;
 703                     elseif (substr($word, $len - 2, 1) == "=")
 704                         $len -= 2;
 705                     $part = substr($word, 0, $len);
 706                     $word = substr($word, $len);
 707
 708                     if (strlen($word) > 0)
 709                         $message .= $part . sprintf("=%s", $this->LE);
 710                     else
 711                         $buf = $part;
 712                 }
 713               }
 714               else
 715               {
 716                 $buf_o = $buf;
 717                 $buf .= ($e == 0) ? $word : (" " . $word);
 718
 719                 if (strlen($buf) > $length and $buf_o != "")
 720                 {
 721                     $message .= $buf_o . $soft_break;
 722                     $buf = $word;
 723                 }
 724               }
 725           }
 726           $message .= $buf . $this->LE;
 727         }
 728
 729         return $message;
 730     }
 731
 732     /**
 733      * Set the body wrapping.
 734      * @access private
 735      * @return void
 736      */
 737     function SetWordWrap() {
 738         if($this->WordWrap < 1)
 739             return;
 740
 741         switch($this->message_type)
 742         {
 743            case "alt":
 744               // fall through
 745            case "alt_attachments":
 746               $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
 747               break;
 748            default:
 749               $this->Body = $this->WrapText($this->Body, $this->WordWrap);
 750               break;
 751         }
 752     }
 753
 754     /**
 755      * Assembles message header.
 756      * @access private
 757      * @return string
 758      */
 759     function CreateHeader() {
 760         $result = "";
 761
 762         // Set the boundaries
 763         $uniq_id = md5(uniqid(time()));
 764         $this->boundary[1] = "b1_" . $uniq_id;
 765         $this->boundary[2] = "b2_" . $uniq_id;
 766
 767         $result .= $this->HeaderLine("Date", $this->RFCDate());
 768         if($this->Sender == "")
 769             $result .= $this->HeaderLine("Return-Path", trim($this->From));
 770         else
 771             $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
 772
 773         // To be created automatically by mail()
 774         if($this->Mailer != "mail")
 775         {
 776             if(count($this->to) > 0)
 777                 $result .= $this->AddrAppend("To", $this->to);
 778             else if (count($this->cc) == 0)
 779                 $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
 780             if(count($this->cc) > 0)
 781                 $result .= $this->AddrAppend("Cc", $this->cc);
 782         }
 783
 784         $from = array();
 785         $from[0][0] = trim($this->From);
 786         $from[0][1] = $this->FromName;
 787         $result .= $this->AddrAppend("From", $from);
 788
 789         // sendmail and mail() extract Bcc from the header before sending
 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 ?>