[Summary view] [Print] [Text view]

   1  <?php
   2  /*~ class.smtp.php
   3  .---------------------------------------------------------------------------.
   4  |  Software: PHPMailer - PHP email class                                    |
   5  |   Version: 5.2.4                                                          |
   6  |      Site: https://code.google.com/a/apache-extras.org/p/phpmailer/       |
   7  | ------------------------------------------------------------------------- |
   8  |     Admin: Jim Jagielski (project admininistrator)                        |
   9  |   Authors: Andy Prevost (codeworxtech) codeworxtech@users.sourceforge.net |
  10  |          : Marcus Bointon (coolbru) coolbru@users.sourceforge.net         |
  11  |          : Jim Jagielski (jimjag) jimjag@gmail.com                        |
  12  |   Founder: Brent R. Matzelle (original founder)                           |
  13  | Copyright (c) 2010-2012, Jim Jagielski. All Rights Reserved.              |
  14  | Copyright (c) 2004-2009, Andy Prevost. All Rights Reserved.               |
  15  | Copyright (c) 2001-2003, Brent R. Matzelle                                |
  16  | ------------------------------------------------------------------------- |
  17  |   License: Distributed under the Lesser General Public License (LGPL)     |
  18  |            http://www.gnu.org/copyleft/lesser.html                        |
  19  | This program is distributed in the hope that it will be useful - WITHOUT  |
  20  | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |
  21  | FITNESS FOR A PARTICULAR PURPOSE.                                         |
  22  '---------------------------------------------------------------------------'
  23  */
  24  
  25  /**
  26   * PHPMailer - PHP SMTP email transport class
  27   * NOTE: Designed for use with PHP version 5 and up
  28   * @package PHPMailer
  29   * @author Andy Prevost
  30   * @author Marcus Bointon
  31   * @copyright 2004 - 2008 Andy Prevost
  32   * @author Jim Jagielski
  33   * @copyright 2010 - 2012 Jim Jagielski
  34   * @license http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
  35   */
  36  
  37  /**
  38   * PHP RFC821 SMTP client
  39   *
  40   * Implements all the RFC 821 SMTP commands except TURN which will always return a not implemented error.
  41   * SMTP also provides some utility methods for sending mail to an SMTP server.
  42   * @author Chris Ryan
  43   * @package PHPMailer
  44   */
  45  
  46  class SMTP {
  47    /**
  48     *  SMTP server port
  49     *  @var int
  50     */
  51    public $SMTP_PORT = 25;
  52  
  53    /**
  54     *  SMTP reply line ending (don't change)
  55     *  @var string
  56     */
  57    public $CRLF = "\r\n";
  58  
  59    /**
  60     *  Sets whether debugging is turned on
  61     *  @var bool
  62     */
  63    public $do_debug;       // the level of debug to perform
  64  
  65    /**
  66     * Sets the function/method to use for debugging output.
  67     * Right now we only honor "echo" or "error_log"
  68     * @var string
  69     */
  70    public $Debugoutput     = "echo";
  71  
  72    /**
  73     *  Sets VERP use on/off (default is off)
  74     *  @var bool
  75     */
  76    public $do_verp = false;
  77  
  78    /**
  79     * Sets the SMTP timeout value for reads, in seconds
  80     * @var int
  81     */
  82    public $Timeout         = 15;
  83  
  84    /**
  85     * Sets the SMTP timelimit value for reads, in seconds
  86     * @var int
  87     */
  88    public $Timelimit       = 30;
  89  
  90    /**
  91     * Sets the SMTP PHPMailer Version number
  92     * @var string
  93     */
  94    public $Version         = '5.2.4';
  95  
  96    /////////////////////////////////////////////////
  97    // PROPERTIES, PRIVATE AND PROTECTED
  98    /////////////////////////////////////////////////
  99  
 100    /**
 101     * @var resource The socket to the server
 102     */
 103    private $smtp_conn;
 104    /**
 105     * @var string Error message, if any, for the last call
 106     */
 107    private $error;
 108    /**
 109     * @var string The reply the server sent to us for HELO
 110     */
 111    private $helo_rply;
 112  
 113    /**
 114     * Outputs debugging info via user-defined method
 115     * @param string $str
 116     */
 117    private function edebug($str) {
 118      if ($this->Debugoutput == "error_log") {
 119          error_log($str);
 120      } else {
 121          echo $str;
 122      }
 123    }
 124  
 125    /**
 126     * Initialize the class so that the data is in a known state.
 127     * @access public
 128     * @return SMTP
 129     */
 130    public function __construct() {
 131      $this->smtp_conn = 0;
 132      $this->error = null;
 133      $this->helo_rply = null;
 134  
 135      $this->do_debug = 0;
 136    }
 137  
 138    /////////////////////////////////////////////////
 139    // CONNECTION FUNCTIONS
 140    /////////////////////////////////////////////////
 141  
 142    /**
 143     * Connect to the server specified on the port specified.
 144     * If the port is not specified use the default SMTP_PORT.
 145     * If tval is specified then a connection will try and be
 146     * established with the server for that number of seconds.
 147     * If tval is not specified the default is 30 seconds to
 148     * try on the connection.
 149     *
 150     * SMTP CODE SUCCESS: 220
 151     * SMTP CODE FAILURE: 421
 152     * @access public
 153     * @param string $host
 154     * @param int $port
 155     * @param int $tval
 156     * @return bool
 157     */
 158    public function Connect($host, $port = 0, $tval = 30) {
 159      // set the error val to null so there is no confusion
 160      $this->error = null;
 161  
 162      // make sure we are __not__ connected
 163      if($this->connected()) {
 164        // already connected, generate error
 165        $this->error = array("error" => "Already connected to a server");
 166        return false;
 167      }
 168  
 169      if(empty($port)) {
 170        $port = $this->SMTP_PORT;
 171      }
 172  
 173      // connect to the smtp server
 174      $this->smtp_conn = @fsockopen($host,    // the host of the server
 175                                   $port,    // the port to use
 176                                   $errno,   // error number if any
 177                                   $errstr,  // error message if any
 178                                   $tval);   // give up after ? secs
 179      // verify we connected properly
 180      if(empty($this->smtp_conn)) {
 181        $this->error = array("error" => "Failed to connect to server",
 182                             "errno" => $errno,
 183                             "errstr" => $errstr);
 184        if($this->do_debug >= 1) {
 185          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": $errstr ($errno)" . $this->CRLF . '<br />');
 186        }
 187        return false;
 188      }
 189  
 190      // SMTP server can take longer to respond, give longer timeout for first read
 191      // Windows does not have support for this timeout function
 192      if(substr(PHP_OS, 0, 3) != "WIN") {
 193       $max = ini_get('max_execution_time');
 194       if ($max != 0 && $tval > $max) { // don't bother if unlimited
 195        @set_time_limit($tval);
 196       }
 197       stream_set_timeout($this->smtp_conn, $tval, 0);
 198      }
 199  
 200      // get any announcement
 201      $announce = $this->get_lines();
 202  
 203      if($this->do_debug >= 2) {
 204        $this->edebug("SMTP -> FROM SERVER:" . $announce . $this->CRLF . '<br />');
 205      }
 206  
 207      return true;
 208    }
 209  
 210    /**
 211     * Initiate a TLS communication with the server.
 212     *
 213     * SMTP CODE 220 Ready to start TLS
 214     * SMTP CODE 501 Syntax error (no parameters allowed)
 215     * SMTP CODE 454 TLS not available due to temporary reason
 216     * @access public
 217     * @return bool success
 218     */
 219    public function StartTLS() {
 220      $this->error = null; # to avoid confusion
 221  
 222      if(!$this->connected()) {
 223        $this->error = array("error" => "Called StartTLS() without being connected");
 224        return false;
 225      }
 226  
 227      fputs($this->smtp_conn,"STARTTLS" . $this->CRLF);
 228  
 229      $rply = $this->get_lines();
 230      $code = substr($rply,0,3);
 231  
 232      if($this->do_debug >= 2) {
 233        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 234      }
 235  
 236      if($code != 220) {
 237        $this->error =
 238           array("error"     => "STARTTLS not accepted from server",
 239                 "smtp_code" => $code,
 240                 "smtp_msg"  => substr($rply,4));
 241        if($this->do_debug >= 1) {
 242          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 243        }
 244        return false;
 245      }
 246  
 247      // Begin encrypted connection
 248      if(!stream_socket_enable_crypto($this->smtp_conn, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
 249        return false;
 250      }
 251  
 252      return true;
 253    }
 254  
 255    /**
 256     * Performs SMTP authentication.  Must be run after running the
 257     * Hello() method.  Returns true if successfully authenticated.
 258     * @access public
 259     * @param string $username
 260     * @param string $password
 261     * @param string $authtype
 262     * @param string $realm
 263     * @param string $workstation
 264     * @return bool
 265     */
 266    public function Authenticate($username, $password, $authtype='LOGIN', $realm='', $workstation='') {
 267      if (empty($authtype)) {
 268        $authtype = 'LOGIN';
 269      }
 270  
 271      switch ($authtype) {
 272        case 'PLAIN':
 273          // Start authentication
 274          fputs($this->smtp_conn,"AUTH PLAIN" . $this->CRLF);
 275      
 276          $rply = $this->get_lines();
 277          $code = substr($rply,0,3);
 278      
 279          if($code != 334) {
 280            $this->error =
 281              array("error" => "AUTH not accepted from server",
 282                    "smtp_code" => $code,
 283                    "smtp_msg" => substr($rply,4));
 284            if($this->do_debug >= 1) {
 285              $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 286            }
 287            return false;
 288          }
 289          // Send encoded username and password
 290          fputs($this->smtp_conn, base64_encode("\0".$username."\0".$password) . $this->CRLF);
 291  
 292          $rply = $this->get_lines();
 293          $code = substr($rply,0,3);
 294      
 295          if($code != 235) {
 296            $this->error =
 297              array("error" => "Authentication not accepted from server",
 298                    "smtp_code" => $code,
 299                    "smtp_msg" => substr($rply,4));
 300            if($this->do_debug >= 1) {
 301              $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 302            }
 303            return false;
 304          }
 305          break;
 306        case 'LOGIN':
 307          // Start authentication
 308          fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);
 309      
 310          $rply = $this->get_lines();
 311          $code = substr($rply,0,3);
 312      
 313          if($code != 334) {
 314            $this->error =
 315              array("error" => "AUTH not accepted from server",
 316                    "smtp_code" => $code,
 317                    "smtp_msg" => substr($rply,4));
 318            if($this->do_debug >= 1) {
 319              $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 320            }
 321            return false;
 322          }
 323      
 324          // Send encoded username
 325          fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);
 326      
 327          $rply = $this->get_lines();
 328          $code = substr($rply,0,3);
 329      
 330          if($code != 334) {
 331            $this->error =
 332              array("error" => "Username not accepted from server",
 333                    "smtp_code" => $code,
 334                    "smtp_msg" => substr($rply,4));
 335            if($this->do_debug >= 1) {
 336              $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 337            }
 338            return false;
 339          }
 340      
 341          // Send encoded password
 342          fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);
 343      
 344          $rply = $this->get_lines();
 345          $code = substr($rply,0,3);
 346      
 347          if($code != 235) {
 348            $this->error =
 349              array("error" => "Password not accepted from server",
 350                    "smtp_code" => $code,
 351                    "smtp_msg" => substr($rply,4));
 352            if($this->do_debug >= 1) {
 353              $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 354            }
 355            return false;
 356          }
 357          break;
 358        case 'NTLM':
 359          /*
 360           * ntlm_sasl_client.php
 361           ** Bundled with Permission
 362           **
 363           ** How to telnet in windows: http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
 364           ** PROTOCOL Documentation http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
 365           */
 366          require_once('ntlm_sasl_client.php');
 367          $temp = new stdClass();
 368          $ntlm_client = new ntlm_sasl_client_class;
 369          if(! $ntlm_client->Initialize($temp)){//let's test if every function its available
 370              $this->error = array("error" => $temp->error);
 371              if($this->do_debug >= 1) {
 372                  $this->edebug("You need to enable some modules in your php.ini file: " . $this->error["error"] . $this->CRLF);
 373              }
 374              return false;
 375          }
 376          $msg1 = $ntlm_client->TypeMsg1($realm, $workstation);//msg1
 377          
 378          fputs($this->smtp_conn,"AUTH NTLM " . base64_encode($msg1) . $this->CRLF);
 379  
 380          $rply = $this->get_lines();
 381          $code = substr($rply,0,3);
 382          
 383  
 384          if($code != 334) {
 385              $this->error =
 386                  array("error" => "AUTH not accepted from server",
 387                        "smtp_code" => $code,
 388                        "smtp_msg" => substr($rply,4));
 389              if($this->do_debug >= 1) {
 390                  $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF);
 391              }
 392              return false;
 393          }
 394          
 395          $challange = substr($rply,3);//though 0 based, there is a white space after the 3 digit number....//msg2
 396          $challange = base64_decode($challange);
 397          $ntlm_res = $ntlm_client->NTLMResponse(substr($challange,24,8),$password);
 398          $msg3 = $ntlm_client->TypeMsg3($ntlm_res,$username,$realm,$workstation);//msg3
 399          // Send encoded username
 400          fputs($this->smtp_conn, base64_encode($msg3) . $this->CRLF);
 401  
 402          $rply = $this->get_lines();
 403          $code = substr($rply,0,3);
 404  
 405          if($code != 235) {
 406              $this->error =
 407                  array("error" => "Could not authenticate",
 408                        "smtp_code" => $code,
 409                        "smtp_msg" => substr($rply,4));
 410              if($this->do_debug >= 1) {
 411                  $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF);
 412              }
 413              return false;
 414          }
 415          break;
 416      }
 417      return true;
 418    }
 419  
 420    /**
 421     * Returns true if connected to a server otherwise false
 422     * @access public
 423     * @return bool
 424     */
 425    public function Connected() {
 426      if(!empty($this->smtp_conn)) {
 427        $sock_status = socket_get_status($this->smtp_conn);
 428        if($sock_status["eof"]) {
 429          // the socket is valid but we are not connected
 430          if($this->do_debug >= 1) {
 431              $this->edebug("SMTP -> NOTICE:" . $this->CRLF . "EOF caught while checking if connected");
 432          }
 433          $this->Close();
 434          return false;
 435        }
 436        return true; // everything looks good
 437      }
 438      return false;
 439    }
 440  
 441    /**
 442     * Closes the socket and cleans up the state of the class.
 443     * It is not considered good to use this function without
 444     * first trying to use QUIT.
 445     * @access public
 446     * @return void
 447     */
 448    public function Close() {
 449      $this->error = null; // so there is no confusion
 450      $this->helo_rply = null;
 451      if(!empty($this->smtp_conn)) {
 452        // close the connection and cleanup
 453        fclose($this->smtp_conn);
 454        $this->smtp_conn = 0;
 455      }
 456    }
 457  
 458    /////////////////////////////////////////////////
 459    // SMTP COMMANDS
 460    /////////////////////////////////////////////////
 461  
 462    /**
 463     * Issues a data command and sends the msg_data to the server
 464     * finializing the mail transaction. $msg_data is the message
 465     * that is to be send with the headers. Each header needs to be
 466     * on a single line followed by a <CRLF> with the message headers
 467     * and the message body being seperated by and additional <CRLF>.
 468     *
 469     * Implements rfc 821: DATA <CRLF>
 470     *
 471     * SMTP CODE INTERMEDIATE: 354
 472     *     [data]
 473     *     <CRLF>.<CRLF>
 474     *     SMTP CODE SUCCESS: 250
 475     *     SMTP CODE FAILURE: 552,554,451,452
 476     * SMTP CODE FAILURE: 451,554
 477     * SMTP CODE ERROR  : 500,501,503,421
 478     * @access public
 479     * @param string $msg_data
 480     * @return bool
 481     */
 482    public function Data($msg_data) {
 483      $this->error = null; // so no confusion is caused
 484  
 485      if(!$this->connected()) {
 486        $this->error = array(
 487                "error" => "Called Data() without being connected");
 488        return false;
 489      }
 490  
 491      fputs($this->smtp_conn,"DATA" . $this->CRLF);
 492  
 493      $rply = $this->get_lines();
 494      $code = substr($rply,0,3);
 495  
 496      if($this->do_debug >= 2) {
 497        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 498      }
 499  
 500      if($code != 354) {
 501        $this->error =
 502          array("error" => "DATA command not accepted from server",
 503                "smtp_code" => $code,
 504                "smtp_msg" => substr($rply,4));
 505        if($this->do_debug >= 1) {
 506          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 507        }
 508        return false;
 509      }
 510  
 511      /* the server is ready to accept data!
 512       * according to rfc 821 we should not send more than 1000
 513       * including the CRLF
 514       * characters on a single line so we will break the data up
 515       * into lines by \r and/or \n then if needed we will break
 516       * each of those into smaller lines to fit within the limit.
 517       * in addition we will be looking for lines that start with
 518       * a period '.' and append and additional period '.' to that
 519       * line. NOTE: this does not count towards limit.
 520       */
 521  
 522      // normalize the line breaks so we know the explode works
 523      $msg_data = str_replace("\r\n","\n",$msg_data);
 524      $msg_data = str_replace("\r","\n",$msg_data);
 525      $lines = explode("\n",$msg_data);
 526  
 527      /* we need to find a good way to determine is headers are
 528       * in the msg_data or if it is a straight msg body
 529       * currently I am assuming rfc 822 definitions of msg headers
 530       * and if the first field of the first line (':' sperated)
 531       * does not contain a space then it _should_ be a header
 532       * and we can process all lines before a blank "" line as
 533       * headers.
 534       */
 535  
 536      $field = substr($lines[0],0,strpos($lines[0],":"));
 537      $in_headers = false;
 538      if(!empty($field) && !strstr($field," ")) {
 539        $in_headers = true;
 540      }
 541  
 542      $max_line_length = 998; // used below; set here for ease in change
 543  
 544      while(list(,$line) = @each($lines)) {
 545        $lines_out = null;
 546        if($line == "" && $in_headers) {
 547          $in_headers = false;
 548        }
 549        // ok we need to break this line up into several smaller lines
 550        while(strlen($line) > $max_line_length) {
 551          $pos = strrpos(substr($line,0,$max_line_length)," ");
 552  
 553          // Patch to fix DOS attack
 554          if(!$pos) {
 555            $pos = $max_line_length - 1;
 556            $lines_out[] = substr($line,0,$pos);
 557            $line = substr($line,$pos);
 558          } else {
 559            $lines_out[] = substr($line,0,$pos);
 560            $line = substr($line,$pos + 1);
 561          }
 562  
 563          /* if processing headers add a LWSP-char to the front of new line
 564           * rfc 822 on long msg headers
 565           */
 566          if($in_headers) {
 567            $line = "\t" . $line;
 568          }
 569        }
 570        $lines_out[] = $line;
 571  
 572        // send the lines to the server
 573        while(list(,$line_out) = @each($lines_out)) {
 574          if(strlen($line_out) > 0)
 575          {
 576            if(substr($line_out, 0, 1) == ".") {
 577              $line_out = "." . $line_out;
 578            }
 579          }
 580          fputs($this->smtp_conn,$line_out . $this->CRLF);
 581        }
 582      }
 583  
 584      // message data has been sent
 585      fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);
 586  
 587      $rply = $this->get_lines();
 588      $code = substr($rply,0,3);
 589  
 590      if($this->do_debug >= 2) {
 591        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 592      }
 593  
 594      if($code != 250) {
 595        $this->error =
 596          array("error" => "DATA not accepted from server",
 597                "smtp_code" => $code,
 598                "smtp_msg" => substr($rply,4));
 599        if($this->do_debug >= 1) {
 600          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 601        }
 602        return false;
 603      }
 604      return true;
 605    }
 606  
 607    /**
 608     * Sends the HELO command to the smtp server.
 609     * This makes sure that we and the server are in
 610     * the same known state.
 611     *
 612     * Implements from rfc 821: HELO <SP> <domain> <CRLF>
 613     *
 614     * SMTP CODE SUCCESS: 250
 615     * SMTP CODE ERROR  : 500, 501, 504, 421
 616     * @access public
 617     * @param string $host
 618     * @return bool
 619     */
 620    public function Hello($host = '') {
 621      $this->error = null; // so no confusion is caused
 622  
 623      if(!$this->connected()) {
 624        $this->error = array(
 625              "error" => "Called Hello() without being connected");
 626        return false;
 627      }
 628  
 629      // if hostname for HELO was not specified send default
 630      if(empty($host)) {
 631        // determine appropriate default to send to server
 632        $host = "localhost";
 633      }
 634  
 635      // Send extended hello first (RFC 2821)
 636      if(!$this->SendHello("EHLO", $host)) {
 637        if(!$this->SendHello("HELO", $host)) {
 638          return false;
 639        }
 640      }
 641  
 642      return true;
 643    }
 644  
 645    /**
 646     * Sends a HELO/EHLO command.
 647     * @access private
 648     * @param string $hello
 649     * @param string $host
 650     * @return bool
 651     */
 652    private function SendHello($hello, $host) {
 653      fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF);
 654  
 655      $rply = $this->get_lines();
 656      $code = substr($rply,0,3);
 657  
 658      if($this->do_debug >= 2) {
 659        $this->edebug("SMTP -> FROM SERVER: " . $rply . $this->CRLF . '<br />');
 660      }
 661  
 662      if($code != 250) {
 663        $this->error =
 664          array("error" => $hello . " not accepted from server",
 665                "smtp_code" => $code,
 666                "smtp_msg" => substr($rply,4));
 667        if($this->do_debug >= 1) {
 668          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 669        }
 670        return false;
 671      }
 672  
 673      $this->helo_rply = $rply;
 674  
 675      return true;
 676    }
 677  
 678    /**
 679     * Starts a mail transaction from the email address specified in
 680     * $from. Returns true if successful or false otherwise. If True
 681     * the mail transaction is started and then one or more Recipient
 682     * commands may be called followed by a Data command.
 683     *
 684     * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
 685     *
 686     * SMTP CODE SUCCESS: 250
 687     * SMTP CODE SUCCESS: 552,451,452
 688     * SMTP CODE SUCCESS: 500,501,421
 689     * @access public
 690     * @param string $from
 691     * @return bool
 692     */
 693    public function Mail($from) {
 694      $this->error = null; // so no confusion is caused
 695  
 696      if(!$this->connected()) {
 697        $this->error = array(
 698                "error" => "Called Mail() without being connected");
 699        return false;
 700      }
 701  
 702      $useVerp = ($this->do_verp ? " XVERP" : "");
 703      fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $useVerp . $this->CRLF);
 704  
 705      $rply = $this->get_lines();
 706      $code = substr($rply,0,3);
 707  
 708      if($this->do_debug >= 2) {
 709        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 710      }
 711  
 712      if($code != 250) {
 713        $this->error =
 714          array("error" => "MAIL not accepted from server",
 715                "smtp_code" => $code,
 716                "smtp_msg" => substr($rply,4));
 717        if($this->do_debug >= 1) {
 718          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 719        }
 720        return false;
 721      }
 722      return true;
 723    }
 724  
 725    /**
 726     * Sends the quit command to the server and then closes the socket
 727     * if there is no error or the $close_on_error argument is true.
 728     *
 729     * Implements from rfc 821: QUIT <CRLF>
 730     *
 731     * SMTP CODE SUCCESS: 221
 732     * SMTP CODE ERROR  : 500
 733     * @access public
 734     * @param bool $close_on_error
 735     * @return bool
 736     */
 737    public function Quit($close_on_error = true) {
 738      $this->error = null; // so there is no confusion
 739  
 740      if(!$this->connected()) {
 741        $this->error = array(
 742                "error" => "Called Quit() without being connected");
 743        return false;
 744      }
 745  
 746      // send the quit command to the server
 747      fputs($this->smtp_conn,"quit" . $this->CRLF);
 748  
 749      // get any good-bye messages
 750      $byemsg = $this->get_lines();
 751  
 752      if($this->do_debug >= 2) {
 753        $this->edebug("SMTP -> FROM SERVER:" . $byemsg . $this->CRLF . '<br />');
 754      }
 755  
 756      $rval = true;
 757      $e = null;
 758  
 759      $code = substr($byemsg,0,3);
 760      if($code != 221) {
 761        // use e as a tmp var cause Close will overwrite $this->error
 762        $e = array("error" => "SMTP server rejected quit command",
 763                   "smtp_code" => $code,
 764                   "smtp_rply" => substr($byemsg,4));
 765        $rval = false;
 766        if($this->do_debug >= 1) {
 767          $this->edebug("SMTP -> ERROR: " . $e["error"] . ": " . $byemsg . $this->CRLF . '<br />');
 768        }
 769      }
 770  
 771      if(empty($e) || $close_on_error) {
 772        $this->Close();
 773      }
 774  
 775      return $rval;
 776    }
 777  
 778    /**
 779     * Sends the command RCPT to the SMTP server with the TO: argument of $to.
 780     * Returns true if the recipient was accepted false if it was rejected.
 781     *
 782     * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
 783     *
 784     * SMTP CODE SUCCESS: 250,251
 785     * SMTP CODE FAILURE: 550,551,552,553,450,451,452
 786     * SMTP CODE ERROR  : 500,501,503,421
 787     * @access public
 788     * @param string $to
 789     * @return bool
 790     */
 791    public function Recipient($to) {
 792      $this->error = null; // so no confusion is caused
 793  
 794      if(!$this->connected()) {
 795        $this->error = array(
 796                "error" => "Called Recipient() without being connected");
 797        return false;
 798      }
 799  
 800      fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF);
 801  
 802      $rply = $this->get_lines();
 803      $code = substr($rply,0,3);
 804  
 805      if($this->do_debug >= 2) {
 806        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 807      }
 808  
 809      if($code != 250 && $code != 251) {
 810        $this->error =
 811          array("error" => "RCPT not accepted from server",
 812                "smtp_code" => $code,
 813                "smtp_msg" => substr($rply,4));
 814        if($this->do_debug >= 1) {
 815          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 816        }
 817        return false;
 818      }
 819      return true;
 820    }
 821  
 822    /**
 823     * Sends the RSET command to abort and transaction that is
 824     * currently in progress. Returns true if successful false
 825     * otherwise.
 826     *
 827     * Implements rfc 821: RSET <CRLF>
 828     *
 829     * SMTP CODE SUCCESS: 250
 830     * SMTP CODE ERROR  : 500,501,504,421
 831     * @access public
 832     * @return bool
 833     */
 834    public function Reset() {
 835      $this->error = null; // so no confusion is caused
 836  
 837      if(!$this->connected()) {
 838        $this->error = array(
 839                "error" => "Called Reset() without being connected");
 840        return false;
 841      }
 842  
 843      fputs($this->smtp_conn,"RSET" . $this->CRLF);
 844  
 845      $rply = $this->get_lines();
 846      $code = substr($rply,0,3);
 847  
 848      if($this->do_debug >= 2) {
 849        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 850      }
 851  
 852      if($code != 250) {
 853        $this->error =
 854          array("error" => "RSET failed",
 855                "smtp_code" => $code,
 856                "smtp_msg" => substr($rply,4));
 857        if($this->do_debug >= 1) {
 858          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 859        }
 860        return false;
 861      }
 862  
 863      return true;
 864    }
 865  
 866    /**
 867     * Starts a mail transaction from the email address specified in
 868     * $from. Returns true if successful or false otherwise. If True
 869     * the mail transaction is started and then one or more Recipient
 870     * commands may be called followed by a Data command. This command
 871     * will send the message to the users terminal if they are logged
 872     * in and send them an email.
 873     *
 874     * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
 875     *
 876     * SMTP CODE SUCCESS: 250
 877     * SMTP CODE SUCCESS: 552,451,452
 878     * SMTP CODE SUCCESS: 500,501,502,421
 879     * @access public
 880     * @param string $from
 881     * @return bool
 882     */
 883    public function SendAndMail($from) {
 884      $this->error = null; // so no confusion is caused
 885  
 886      if(!$this->connected()) {
 887        $this->error = array(
 888            "error" => "Called SendAndMail() without being connected");
 889        return false;
 890      }
 891  
 892      fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);
 893  
 894      $rply = $this->get_lines();
 895      $code = substr($rply,0,3);
 896  
 897      if($this->do_debug >= 2) {
 898        $this->edebug("SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />');
 899      }
 900  
 901      if($code != 250) {
 902        $this->error =
 903          array("error" => "SAML not accepted from server",
 904                "smtp_code" => $code,
 905                "smtp_msg" => substr($rply,4));
 906        if($this->do_debug >= 1) {
 907          $this->edebug("SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />');
 908        }
 909        return false;
 910      }
 911      return true;
 912    }
 913  
 914    /**
 915     * This is an optional command for SMTP that this class does not
 916     * support. This method is here to make the RFC821 Definition
 917     * complete for this class and __may__ be implimented in the future
 918     *
 919     * Implements from rfc 821: TURN <CRLF>
 920     *
 921     * SMTP CODE SUCCESS: 250
 922     * SMTP CODE FAILURE: 502
 923     * SMTP CODE ERROR  : 500, 503
 924     * @access public
 925     * @return bool
 926     */
 927    public function Turn() {
 928      $this->error = array("error" => "This method, TURN, of the SMTP ".
 929                                      "is not implemented");
 930      if($this->do_debug >= 1) {
 931        $this->edebug("SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF . '<br />');
 932      }
 933      return false;
 934    }
 935  
 936    /**
 937    * Get the current error
 938    * @access public
 939    * @return array
 940    */
 941    public function getError() {
 942      return $this->error;
 943    }
 944  
 945    /////////////////////////////////////////////////
 946    // INTERNAL FUNCTIONS
 947    /////////////////////////////////////////////////
 948  
 949    /**
 950     * Read in as many lines as possible
 951     * either before eof or socket timeout occurs on the operation.
 952     * With SMTP we can tell if we have more lines to read if the
 953     * 4th character is '-' symbol. If it is a space then we don't
 954     * need to read anything else.
 955     * @access private
 956     * @return string
 957     */
 958    private function get_lines() {
 959      $data = "";
 960      $endtime = 0;
 961      /* If for some reason the fp is bad, don't inf loop */
 962      if (!is_resource($this->smtp_conn)) {
 963        return $data;
 964      }
 965      stream_set_timeout($this->smtp_conn, $this->Timeout);
 966      if ($this->Timelimit > 0) {
 967        $endtime = time() + $this->Timelimit;
 968      }
 969      while(is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
 970        $str = @fgets($this->smtp_conn,515);
 971        if($this->do_debug >= 4) {
 972          $this->edebug("SMTP -> get_lines(): \$data was \"$data\"" . $this->CRLF . '<br />');
 973          $this->edebug("SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '<br />');
 974        }
 975        $data .= $str;
 976        if($this->do_debug >= 4) {
 977          $this->edebug("SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '<br />');
 978        }
 979        // if 4th character is a space, we are done reading, break the loop
 980        if(substr($str,3,1) == " ") { break; }
 981        // Timed-out? Log and break
 982        $info = stream_get_meta_data($this->smtp_conn);
 983        if ($info['timed_out']) {
 984          if($this->do_debug >= 4) {
 985            $this->edebug("SMTP -> get_lines(): timed-out (" . $this->Timeout . " seconds) <br />");
 986          }
 987          break;
 988        }
 989        // Now check if reads took too long
 990        if ($endtime) {
 991          if (time() > $endtime) {
 992            if($this->do_debug >= 4) {
 993              $this->edebug("SMTP -> get_lines(): timelimit reached (" . $this->Timelimit . " seconds) <br />");
 994            }
 995            break;
 996          }
 997        }
 998      }
 999      return $data;
1000    }
1001  
1002  }
1003  ?>