[Summary view] [Print] [Text view]

   1  <?php
   2  /*~ class.smtp.php
   3  .---------------------------------------------------------------------------.
   4  |  Software: PHPMailer - PHP email class                                    |
   5  |   Version: 5.1                                                            |
   6  |      Site: https://code.google.com/a/apache-extras.org/p/phpmailer/       |
   7  | ------------------------------------------------------------------------- |
   8  |     Admin: Jim Jagielski (project admininistrator)                        |
   9  |   Authors: Andy Prevost (codeworxtech) [email protected] |
  10  |          : Marcus Bointon (coolbru) [email protected]         |
  11  |          : Jim Jagielski (jimjag) [email protected]                        |
  12  |   Founder: Brent R. Matzelle (original founder)                           |
  13  | Copyright (c) 2010-2011, 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 - 2011 Jim Jagielski
  34   * @license http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
  35   * @version $Id: class.smtp.php 13883 2013-10-03 06:36:17Z prasad $
  36   */
  37  
  38  /**
  39   * SMTP is rfc 821 compliant and implements all the rfc 821 SMTP
  40   * commands except TURN which will always return a not implemented
  41   * error. SMTP also provides some utility methods for sending mail
  42   * to an SMTP server.
  43   * original author: Chris Ryan
  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
  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 VERP use on/off (default is off)
  67     *  @var bool
  68     */
  69    public $do_verp = false;
  70  
  71    /**
  72     * Sets the SMTP PHPMailer Version number
  73     * @var string
  74     */
  75    public $Version         = '5.1';
  76  
  77    /////////////////////////////////////////////////
  78    // PROPERTIES, PRIVATE AND PROTECTED
  79    /////////////////////////////////////////////////
  80  
  81    private $smtp_conn; // the socket to the server
  82    private $error;     // error if any on the last call
  83    private $helo_rply; // the reply the server sent to us for HELO
  84  
  85    /**
  86     * Initialize the class so that the data is in a known state.
  87     * @access public
  88     * @return void
  89     */
  90    public function __construct() {
  91      $this->smtp_conn = 0;
  92      $this->error = null;
  93      $this->helo_rply = null;
  94  
  95      $this->do_debug = 0;
  96    }
  97  
  98    /////////////////////////////////////////////////
  99    // CONNECTION FUNCTIONS
 100    /////////////////////////////////////////////////
 101  
 102    /**
 103     * Connect to the server specified on the port specified.
 104     * If the port is not specified use the default SMTP_PORT.
 105     * If tval is specified then a connection will try and be
 106     * established with the server for that number of seconds.
 107     * If tval is not specified the default is 30 seconds to
 108     * try on the connection.
 109     *
 110     * SMTP CODE SUCCESS: 220
 111     * SMTP CODE FAILURE: 421
 112     * @access public
 113     * @return bool
 114     */
 115    public function Connect($host, $port = 0, $tval = 30) {
 116      // set the error val to null so there is no confusion
 117      $this->error = null;
 118  
 119      // make sure we are __not__ connected
 120      if($this->connected()) {
 121        // already connected, generate error
 122        $this->error = array("error" => "Already connected to a server");
 123        return false;
 124      }
 125  
 126      if(empty($port)) {
 127        $port = $this->SMTP_PORT;
 128      }
 129  
 130      // connect to the smtp server
 131      $this->smtp_conn = @fsockopen($host,    // the host of the server
 132                                   $port,    // the port to use
 133                                   $errno,   // error number if any
 134                                   $errstr,  // error message if any
 135                                   $tval);   // give up after ? secs
 136      // verify we connected properly
 137      if(empty($this->smtp_conn)) {
 138        $this->error = array("error" => "Failed to connect to server",
 139                             "errno" => $errno,
 140                             "errstr" => $errstr);
 141        if($this->do_debug >= 1) {
 142          echo "SMTP -> ERROR: " . $this->error["error"] . ": $errstr ($errno)" . $this->CRLF . '<br />';
 143        }
 144        return false;
 145      }
 146  
 147      // SMTP server can take longer to respond, give longer timeout for first read
 148      // Windows does not have support for this timeout function
 149      if(substr(PHP_OS, 0, 3) != "WIN")
 150       socket_set_timeout($this->smtp_conn, $tval, 0);
 151  
 152      // get any announcement
 153      $announce = $this->get_lines();
 154  
 155      if($this->do_debug >= 2) {
 156        echo "SMTP -> FROM SERVER:" . $announce . $this->CRLF . '<br />';
 157      }
 158  
 159      return true;
 160    }
 161  
 162    /**
 163     * Initiate a TLS communication with the server.
 164     *
 165     * SMTP CODE 220 Ready to start TLS
 166     * SMTP CODE 501 Syntax error (no parameters allowed)
 167     * SMTP CODE 454 TLS not available due to temporary reason
 168     * @access public
 169     * @return bool success
 170     */
 171    public function StartTLS() {
 172      $this->error = null; # to avoid confusion
 173  
 174      if(!$this->connected()) {
 175        $this->error = array("error" => "Called StartTLS() without being connected");
 176        return false;
 177      }
 178  
 179      fputs($this->smtp_conn,"STARTTLS" . $this->CRLF);
 180  
 181      $rply = $this->get_lines();
 182      $code = substr($rply,0,3);
 183  
 184      if($this->do_debug >= 2) {
 185        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 186      }
 187  
 188      if($code != 220) {
 189        $this->error =
 190           array("error"     => "STARTTLS not accepted from server",
 191                 "smtp_code" => $code,
 192                 "smtp_msg"  => substr($rply,4));
 193        if($this->do_debug >= 1) {
 194          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 195        }
 196        return false;
 197      }
 198  
 199      // Begin encrypted connection
 200      if(!stream_socket_enable_crypto($this->smtp_conn, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
 201        return false;
 202      }
 203  
 204      return true;
 205    }
 206  
 207    /**
 208     * Performs SMTP authentication.  Must be run after running the
 209     * Hello() method.  Returns true if successfully authenticated.
 210     * @access public
 211     * @return bool
 212     */
 213    public function Authenticate($username, $password) {
 214      // Start authentication
 215      fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);
 216  
 217      $rply = $this->get_lines();
 218      $code = substr($rply,0,3);
 219  
 220      if($code != 334) {
 221        $this->error =
 222          array("error" => "AUTH not accepted from server",
 223                "smtp_code" => $code,
 224                "smtp_msg" => substr($rply,4));
 225        if($this->do_debug >= 1) {
 226          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 227        }
 228        return false;
 229      }
 230  
 231      // Send encoded username
 232      fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);
 233  
 234      $rply = $this->get_lines();
 235      $code = substr($rply,0,3);
 236  
 237      if($code != 334) {
 238        $this->error =
 239          array("error" => "Username not accepted from server",
 240                "smtp_code" => $code,
 241                "smtp_msg" => substr($rply,4));
 242        if($this->do_debug >= 1) {
 243          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 244        }
 245        return false;
 246      }
 247  
 248      // Send encoded password
 249      fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);
 250  
 251      $rply = $this->get_lines();
 252      $code = substr($rply,0,3);
 253  
 254      if($code != 235) {
 255        $this->error =
 256          array("error" => "Password not accepted from server",
 257                "smtp_code" => $code,
 258                "smtp_msg" => substr($rply,4));
 259        if($this->do_debug >= 1) {
 260          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 261        }
 262        return false;
 263      }
 264  
 265      return true;
 266    }
 267  
 268    /**
 269     * Returns true if connected to a server otherwise false
 270     * @access public
 271     * @return bool
 272     */
 273    public function Connected() {
 274      if(!empty($this->smtp_conn)) {
 275        $sock_status = socket_get_status($this->smtp_conn);
 276        if($sock_status["eof"]) {
 277          // the socket is valid but we are not connected
 278          if($this->do_debug >= 1) {
 279              echo "SMTP -> NOTICE:" . $this->CRLF . "EOF caught while checking if connected";
 280          }
 281          $this->Close();
 282          return false;
 283        }
 284        return true; // everything looks good
 285      }
 286      return false;
 287    }
 288  
 289    /**
 290     * Closes the socket and cleans up the state of the class.
 291     * It is not considered good to use this function without
 292     * first trying to use QUIT.
 293     * @access public
 294     * @return void
 295     */
 296    public function Close() {
 297      $this->error = null; // so there is no confusion
 298      $this->helo_rply = null;
 299      if(!empty($this->smtp_conn)) {
 300        // close the connection and cleanup
 301        fclose($this->smtp_conn);
 302        $this->smtp_conn = 0;
 303      }
 304    }
 305  
 306    /////////////////////////////////////////////////
 307    // SMTP COMMANDS
 308    /////////////////////////////////////////////////
 309  
 310    /**
 311     * Issues a data command and sends the msg_data to the server
 312     * finializing the mail transaction. $msg_data is the message
 313     * that is to be send with the headers. Each header needs to be
 314     * on a single line followed by a <CRLF> with the message headers
 315     * and the message body being seperated by and additional <CRLF>.
 316     *
 317     * Implements rfc 821: DATA <CRLF>
 318     *
 319     * SMTP CODE INTERMEDIATE: 354
 320     *     [data]
 321     *     <CRLF>.<CRLF>
 322     *     SMTP CODE SUCCESS: 250
 323     *     SMTP CODE FAILURE: 552,554,451,452
 324     * SMTP CODE FAILURE: 451,554
 325     * SMTP CODE ERROR  : 500,501,503,421
 326     * @access public
 327     * @return bool
 328     */
 329    public function Data($msg_data) {
 330      $this->error = null; // so no confusion is caused
 331  
 332      if(!$this->connected()) {
 333        $this->error = array(
 334                "error" => "Called Data() without being connected");
 335        return false;
 336      }
 337  
 338      fputs($this->smtp_conn,"DATA" . $this->CRLF);
 339  
 340      $rply = $this->get_lines();
 341      $code = substr($rply,0,3);
 342  
 343      if($this->do_debug >= 2) {
 344        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 345      }
 346  
 347      if($code != 354) {
 348        $this->error =
 349          array("error" => "DATA command not accepted from server",
 350                "smtp_code" => $code,
 351                "smtp_msg" => substr($rply,4));
 352        if($this->do_debug >= 1) {
 353          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 354        }
 355        return false;
 356      }
 357  
 358      /* the server is ready to accept data!
 359       * according to rfc 821 we should not send more than 1000
 360       * including the CRLF
 361       * characters on a single line so we will break the data up
 362       * into lines by \r and/or \n then if needed we will break
 363       * each of those into smaller lines to fit within the limit.
 364       * in addition we will be looking for lines that start with
 365       * a period '.' and append and additional period '.' to that
 366       * line. NOTE: this does not count towards limit.
 367       */
 368  
 369      // normalize the line breaks so we know the explode works
 370      $msg_data = str_replace("\r\n","\n",$msg_data);
 371      $msg_data = str_replace("\r","\n",$msg_data);
 372      $lines = explode("\n",$msg_data);
 373  
 374      /* we need to find a good way to determine is headers are
 375       * in the msg_data or if it is a straight msg body
 376       * currently I am assuming rfc 822 definitions of msg headers
 377       * and if the first field of the first line (':' sperated)
 378       * does not contain a space then it _should_ be a header
 379       * and we can process all lines before a blank "" line as
 380       * headers.
 381       */
 382  
 383      $field = substr($lines[0],0,strpos($lines[0],":"));
 384      $in_headers = false;
 385      if(!empty($field) && !strstr($field," ")) {
 386        $in_headers = true;
 387      }
 388  
 389      $max_line_length = 998; // used below; set here for ease in change
 390  
 391      while(list(,$line) = @each($lines)) {
 392        $lines_out = null;
 393        if($line == "" && $in_headers) {
 394          $in_headers = false;
 395        }
 396        // ok we need to break this line up into several smaller lines
 397        while(strlen($line) > $max_line_length) {
 398          $pos = strrpos(substr($line,0,$max_line_length)," ");
 399  
 400          // Patch to fix DOS attack
 401          if(!$pos) {
 402            $pos = $max_line_length - 1;
 403            $lines_out[] = substr($line,0,$pos);
 404            $line = substr($line,$pos);
 405          } else {
 406            $lines_out[] = substr($line,0,$pos);
 407            $line = substr($line,$pos + 1);
 408          }
 409  
 410          /* if processing headers add a LWSP-char to the front of new line
 411           * rfc 822 on long msg headers
 412           */
 413          if($in_headers) {
 414            $line = "\t" . $line;
 415          }
 416        }
 417        $lines_out[] = $line;
 418  
 419        // send the lines to the server
 420        while(list(,$line_out) = @each($lines_out)) {
 421          if(strlen($line_out) > 0)
 422          {
 423            if(substr($line_out, 0, 1) == ".") {
 424              $line_out = "." . $line_out;
 425            }
 426          }
 427          fputs($this->smtp_conn,$line_out . $this->CRLF);
 428        }
 429      }
 430  
 431      // message data has been sent
 432      fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);
 433  
 434      $rply = $this->get_lines();
 435      $code = substr($rply,0,3);
 436  
 437      if($this->do_debug >= 2) {
 438        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 439      }
 440  
 441      if($code != 250) {
 442        $this->error =
 443          array("error" => "DATA not accepted from server",
 444                "smtp_code" => $code,
 445                "smtp_msg" => substr($rply,4));
 446        if($this->do_debug >= 1) {
 447          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 448        }
 449        return false;
 450      }
 451      return true;
 452    }
 453  
 454    /**
 455     * Sends the HELO command to the smtp server.
 456     * This makes sure that we and the server are in
 457     * the same known state.
 458     *
 459     * Implements from rfc 821: HELO <SP> <domain> <CRLF>
 460     *
 461     * SMTP CODE SUCCESS: 250
 462     * SMTP CODE ERROR  : 500, 501, 504, 421
 463     * @access public
 464     * @return bool
 465     */
 466    public function Hello($host = '') {
 467      $this->error = null; // so no confusion is caused
 468  
 469      if(!$this->connected()) {
 470        $this->error = array(
 471              "error" => "Called Hello() without being connected");
 472        return false;
 473      }
 474  
 475      // if hostname for HELO was not specified send default
 476      if(empty($host)) {
 477        // determine appropriate default to send to server
 478        $host = "localhost";
 479      }
 480  
 481      // Send extended hello first (RFC 2821)
 482      if(!$this->SendHello("EHLO", $host)) {
 483        if(!$this->SendHello("HELO", $host)) {
 484          return false;
 485        }
 486      }
 487  
 488      return true;
 489    }
 490  
 491    /**
 492     * Sends a HELO/EHLO command.
 493     * @access private
 494     * @return bool
 495     */
 496    private function SendHello($hello, $host) {
 497      fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF);
 498  
 499      $rply = $this->get_lines();
 500      $code = substr($rply,0,3);
 501  
 502      if($this->do_debug >= 2) {
 503        echo "SMTP -> FROM SERVER: " . $rply . $this->CRLF . '<br />';
 504      }
 505  
 506      if($code != 250) {
 507        $this->error =
 508          array("error" => $hello . " not accepted from server",
 509                "smtp_code" => $code,
 510                "smtp_msg" => substr($rply,4));
 511        if($this->do_debug >= 1) {
 512          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 513        }
 514        return false;
 515      }
 516  
 517      $this->helo_rply = $rply;
 518  
 519      return true;
 520    }
 521  
 522    /**
 523     * Starts a mail transaction from the email address specified in
 524     * $from. Returns true if successful or false otherwise. If True
 525     * the mail transaction is started and then one or more Recipient
 526     * commands may be called followed by a Data command.
 527     *
 528     * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
 529     *
 530     * SMTP CODE SUCCESS: 250
 531     * SMTP CODE SUCCESS: 552,451,452
 532     * SMTP CODE SUCCESS: 500,501,421
 533     * @access public
 534     * @return bool
 535     */
 536    public function Mail($from) {
 537      $this->error = null; // so no confusion is caused
 538  
 539      if(!$this->connected()) {
 540        $this->error = array(
 541                "error" => "Called Mail() without being connected");
 542        return false;
 543      }
 544  
 545      $useVerp = ($this->do_verp ? "XVERP" : "");
 546      fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $useVerp . $this->CRLF);
 547  
 548      $rply = $this->get_lines();
 549      $code = substr($rply,0,3);
 550  
 551      if($this->do_debug >= 2) {
 552        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 553      }
 554  
 555      if($code != 250) {
 556        $this->error =
 557          array("error" => "MAIL not accepted from server",
 558                "smtp_code" => $code,
 559                "smtp_msg" => substr($rply,4));
 560        if($this->do_debug >= 1) {
 561          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 562        }
 563        return false;
 564      }
 565      return true;
 566    }
 567  
 568    /**
 569     * Sends the quit command to the server and then closes the socket
 570     * if there is no error or the $close_on_error argument is true.
 571     *
 572     * Implements from rfc 821: QUIT <CRLF>
 573     *
 574     * SMTP CODE SUCCESS: 221
 575     * SMTP CODE ERROR  : 500
 576     * @access public
 577     * @return bool
 578     */
 579    public function Quit($close_on_error = true) {
 580      $this->error = null; // so there is no confusion
 581  
 582      if(!$this->connected()) {
 583        $this->error = array(
 584                "error" => "Called Quit() without being connected");
 585        return false;
 586      }
 587  
 588      // send the quit command to the server
 589      fputs($this->smtp_conn,"quit" . $this->CRLF);
 590  
 591      // get any good-bye messages
 592      $byemsg = $this->get_lines();
 593  
 594      if($this->do_debug >= 2) {
 595        echo "SMTP -> FROM SERVER:" . $byemsg . $this->CRLF . '<br />';
 596      }
 597  
 598      $rval = true;
 599      $e = null;
 600  
 601      $code = substr($byemsg,0,3);
 602      if($code != 221) {
 603        // use e as a tmp var cause Close will overwrite $this->error
 604        $e = array("error" => "SMTP server rejected quit command",
 605                   "smtp_code" => $code,
 606                   "smtp_rply" => substr($byemsg,4));
 607        $rval = false;
 608        if($this->do_debug >= 1) {
 609          echo "SMTP -> ERROR: " . $e["error"] . ": " . $byemsg . $this->CRLF . '<br />';
 610        }
 611      }
 612  
 613      if(empty($e) || $close_on_error) {
 614        $this->Close();
 615      }
 616  
 617      return $rval;
 618    }
 619  
 620    /**
 621     * Sends the command RCPT to the SMTP server with the TO: argument of $to.
 622     * Returns true if the recipient was accepted false if it was rejected.
 623     *
 624     * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
 625     *
 626     * SMTP CODE SUCCESS: 250,251
 627     * SMTP CODE FAILURE: 550,551,552,553,450,451,452
 628     * SMTP CODE ERROR  : 500,501,503,421
 629     * @access public
 630     * @return bool
 631     */
 632    public function Recipient($to) {
 633      $this->error = null; // so no confusion is caused
 634  
 635      if(!$this->connected()) {
 636        $this->error = array(
 637                "error" => "Called Recipient() without being connected");
 638        return false;
 639      }
 640  
 641      fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF);
 642  
 643      $rply = $this->get_lines();
 644      $code = substr($rply,0,3);
 645  
 646      if($this->do_debug >= 2) {
 647        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 648      }
 649  
 650      if($code != 250 && $code != 251) {
 651        $this->error =
 652          array("error" => "RCPT not accepted from server",
 653                "smtp_code" => $code,
 654                "smtp_msg" => substr($rply,4));
 655        if($this->do_debug >= 1) {
 656          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 657        }
 658        return false;
 659      }
 660      return true;
 661    }
 662  
 663    /**
 664     * Sends the RSET command to abort and transaction that is
 665     * currently in progress. Returns true if successful false
 666     * otherwise.
 667     *
 668     * Implements rfc 821: RSET <CRLF>
 669     *
 670     * SMTP CODE SUCCESS: 250
 671     * SMTP CODE ERROR  : 500,501,504,421
 672     * @access public
 673     * @return bool
 674     */
 675    public function Reset() {
 676      $this->error = null; // so no confusion is caused
 677  
 678      if(!$this->connected()) {
 679        $this->error = array(
 680                "error" => "Called Reset() without being connected");
 681        return false;
 682      }
 683  
 684      fputs($this->smtp_conn,"RSET" . $this->CRLF);
 685  
 686      $rply = $this->get_lines();
 687      $code = substr($rply,0,3);
 688  
 689      if($this->do_debug >= 2) {
 690        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 691      }
 692  
 693      if($code != 250) {
 694        $this->error =
 695          array("error" => "RSET failed",
 696                "smtp_code" => $code,
 697                "smtp_msg" => substr($rply,4));
 698        if($this->do_debug >= 1) {
 699          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 700        }
 701        return false;
 702      }
 703  
 704      return true;
 705    }
 706  
 707    /**
 708     * Starts a mail transaction from the email address specified in
 709     * $from. Returns true if successful or false otherwise. If True
 710     * the mail transaction is started and then one or more Recipient
 711     * commands may be called followed by a Data command. This command
 712     * will send the message to the users terminal if they are logged
 713     * in and send them an email.
 714     *
 715     * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
 716     *
 717     * SMTP CODE SUCCESS: 250
 718     * SMTP CODE SUCCESS: 552,451,452
 719     * SMTP CODE SUCCESS: 500,501,502,421
 720     * @access public
 721     * @return bool
 722     */
 723    public function SendAndMail($from) {
 724      $this->error = null; // so no confusion is caused
 725  
 726      if(!$this->connected()) {
 727        $this->error = array(
 728            "error" => "Called SendAndMail() without being connected");
 729        return false;
 730      }
 731  
 732      fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);
 733  
 734      $rply = $this->get_lines();
 735      $code = substr($rply,0,3);
 736  
 737      if($this->do_debug >= 2) {
 738        echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
 739      }
 740  
 741      if($code != 250) {
 742        $this->error =
 743          array("error" => "SAML not accepted from server",
 744                "smtp_code" => $code,
 745                "smtp_msg" => substr($rply,4));
 746        if($this->do_debug >= 1) {
 747          echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
 748        }
 749        return false;
 750      }
 751      return true;
 752    }
 753  
 754    /**
 755     * This is an optional command for SMTP that this class does not
 756     * support. This method is here to make the RFC821 Definition
 757     * complete for this class and __may__ be implimented in the future
 758     *
 759     * Implements from rfc 821: TURN <CRLF>
 760     *
 761     * SMTP CODE SUCCESS: 250
 762     * SMTP CODE FAILURE: 502
 763     * SMTP CODE ERROR  : 500, 503
 764     * @access public
 765     * @return bool
 766     */
 767    public function Turn() {
 768      $this->error = array("error" => "This method, TURN, of the SMTP ".
 769                                      "is not implemented");
 770      if($this->do_debug >= 1) {
 771        echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF . '<br />';
 772      }
 773      return false;
 774    }
 775  
 776    /**
 777    * Get the current error
 778    * @access public
 779    * @return array
 780    */
 781    public function getError() {
 782      return $this->error;
 783    }
 784  
 785    /////////////////////////////////////////////////
 786    // INTERNAL FUNCTIONS
 787    /////////////////////////////////////////////////
 788  
 789    /**
 790     * Read in as many lines as possible
 791     * either before eof or socket timeout occurs on the operation.
 792     * With SMTP we can tell if we have more lines to read if the
 793     * 4th character is '-' symbol. If it is a space then we don't
 794     * need to read anything else.
 795     * @access private
 796     * @return string
 797     */
 798    private function get_lines() {
 799      $data = "";
 800      while($str = @fgets($this->smtp_conn,515)) {
 801        if($this->do_debug >= 4) {
 802          echo "SMTP -> get_lines(): \$data was \"$data\"" . $this->CRLF . '<br />';
 803          echo "SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '<br />';
 804        }
 805        $data .= $str;
 806        if($this->do_debug >= 4) {
 807          echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '<br />';
 808        }
 809        // if 4th character is a space, we are done reading, break the loop
 810        if(substr($str,3,1) == " ") { break; }
 811      }
 812      return $data;
 813    }
 814  
 815  }
 816  
 817  ?>