lib/phpmailer/class.smtp.php

   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 ?>