wp-includes/class-smtp.php

   1 <?php
   2 /**
   3  * PHPMailer RFC821 SMTP email transport class.
   4  * Version 5.2.7
   5  * PHP version 5.0.0
   6  * @category  PHP
   7  * @package   PHPMailer
   8  * @link      https://github.com/PHPMailer/PHPMailer/
   9  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
  10  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
  11  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
  12  * @copyright 2013 Marcus Bointon
  13  * @copyright 2004 - 2008 Andy Prevost
  14  * @copyright 2010 - 2012 Jim Jagielski
  15  * @license   http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
  16  */
  17
  18 /**
  19  * PHPMailer RFC821 SMTP email transport class.
  20  *
  21  * Implements RFC 821 SMTP commands
  22  * and provides some utility methods for sending mail to an SMTP server.
  23  *
  24  * PHP Version 5.0.0
  25  *
  26  * @category PHP
  27  * @package  PHPMailer
  28  * @link     https://github.com/PHPMailer/PHPMailer/blob/master/class.smtp.php
  29  * @author   Chris Ryan <unknown@example.com>
  30  * @author   Marcus Bointon <phpmailer@synchromedia.co.uk>
  31  * @license  http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
  32  */
  33
  34 class SMTP
  35 {
  36     /**
  37      * The PHPMailer SMTP Version number.
  38      */
  39     const VERSION = '5.2.7';
  40
  41     /**
  42      * SMTP line break constant.
  43      */
  44     const CRLF = "\r\n";
  45
  46     /**
  47      * The SMTP port to use if one is not specified.
  48      */
  49     const DEFAULT_SMTP_PORT = 25;
  50
  51     /**
  52      * The PHPMailer SMTP Version number.
  53      * @type string
  54      * @deprecated This should be a constant
  55      * @see SMTP::VERSION
  56      */
  57     public $Version = '5.2.7';
  58
  59     /**
  60      * SMTP server port number.
  61      * @type int
  62      * @deprecated This is only ever ued as default value, so should be a constant
  63      * @see SMTP::DEFAULT_SMTP_PORT
  64      */
  65     public $SMTP_PORT = 25;
  66
  67     /**
  68      * SMTP reply line ending
  69      * @type string
  70      * @deprecated Use the class constant instead
  71      * @see SMTP::CRLF
  72      */
  73     public $CRLF = "\r\n";
  74
  75     /**
  76      * Debug output level.
  77      * Options: 0 for no output, 1 for commands, 2 for data and commands
  78      * @type int
  79      */
  80     public $do_debug = 0;
  81
  82     /**
  83      * The function/method to use for debugging output.
  84      * Options: 'echo', 'html' or 'error_log'
  85      * @type string
  86      */
  87     public $Debugoutput = 'echo';
  88
  89     /**
  90      * Whether to use VERP.
  91      * @type bool
  92      */
  93     public $do_verp = false;
  94
  95     /**
  96      * The SMTP timeout value for reads, in seconds.
  97      * @type int
  98      */
  99     public $Timeout = 15;
 100
 101     /**
 102      * The SMTP timelimit value for reads, in seconds.
 103      * @type int
 104      */
 105     public $Timelimit = 30;
 106
 107     /**
 108      * The socket for the server connection.
 109      * @type resource
 110      */
 111     protected $smtp_conn;
 112
 113     /**
 114      * Error message, if any, for the last call.
 115      * @type string
 116      */
 117     protected $error = '';
 118
 119     /**
 120      * The reply the server sent to us for HELO.
 121      * @type string
 122      */
 123     protected $helo_rply = '';
 124
 125     /**
 126      * The most recent reply received from the server.
 127      * @type string
 128      */
 129     protected $last_reply = '';
 130
 131     /**
 132      * Constructor.
 133      * @access public
 134      */
 135     public function __construct()
 136     {
 137         $this->smtp_conn = 0;
 138         $this->error = null;
 139         $this->helo_rply = null;
 140
 141         $this->do_debug = 0;
 142     }
 143
 144     /**
 145      * Output debugging info via a user-selected method.
 146      * @param string $str Debug string to output
 147      * @return void
 148      */
 149     protected function edebug($str)
 150     {
 151         switch ($this->Debugoutput) {
 152             case 'error_log':
 153                 //Don't output, just log
 154                 error_log($str);
 155                 break;
 156             case 'html':
 157                 //Cleans up output a bit for a better looking, HTML-safe output
 158                 echo htmlentities(
 159                     preg_replace('/[\r\n]+/', '', $str),
 160                     ENT_QUOTES,
 161                     'UTF-8'
 162                 )
 163                 . "<br>\n";
 164                 break;
 165             case 'echo':
 166             default:
 167                 //Just echoes whatever was received
 168                 echo $str;
 169         }
 170     }
 171
 172     /**
 173      * Connect to an SMTP server.
 174      * @param string $host    SMTP server IP or host name
 175      * @param int $port    The port number to connect to
 176      * @param int $timeout How long to wait for the connection to open
 177      * @param array $options An array of options for stream_context_create()
 178      * @access public
 179      * @return bool
 180      */
 181     public function connect($host, $port = null, $timeout = 30, $options = array())
 182     {
 183         // Clear errors to avoid confusion
 184         $this->error = null;
 185
 186         // Make sure we are __not__ connected
 187         if ($this->connected()) {
 188             // Already connected, generate error
 189             $this->error = array('error' => 'Already connected to a server');
 190             return false;
 191         }
 192
 193         if (empty($port)) {
 194             $port = self::DEFAULT_SMTP_PORT;
 195         }
 196
 197         // Connect to the SMTP server
 198         $errno = 0;
 199         $errstr = '';
 200         $socket_context = stream_context_create($options);
 201         //Suppress errors; connection failures are handled at a higher level
 202         $this->smtp_conn = @stream_socket_client(
 203             $host . ":" . $port,
 204             $errno,
 205             $errstr,
 206             $timeout,
 207             STREAM_CLIENT_CONNECT,
 208             $socket_context
 209         );
 210
 211         // Verify we connected properly
 212         if (empty($this->smtp_conn)) {
 213             $this->error = array(
 214                 'error' => 'Failed to connect to server',
 215                 'errno' => $errno,
 216                 'errstr' => $errstr
 217             );
 218             if ($this->do_debug >= 1) {
 219                 $this->edebug(
 220                     'SMTP -> ERROR: ' . $this->error['error']
 221                     . ": $errstr ($errno)"
 222                 );
 223             }
 224             return false;
 225         }
 226
 227         // SMTP server can take longer to respond, give longer timeout for first read
 228         // Windows does not have support for this timeout function
 229         if (substr(PHP_OS, 0, 3) != 'WIN') {
 230             $max = ini_get('max_execution_time');
 231             if ($max != 0 && $timeout > $max) { // Don't bother if unlimited
 232                 @set_time_limit($timeout);
 233             }
 234             stream_set_timeout($this->smtp_conn, $timeout, 0);
 235         }
 236
 237         // Get any announcement
 238         $announce = $this->get_lines();
 239
 240         if ($this->do_debug >= 2) {
 241             $this->edebug('SMTP -> FROM SERVER:' . $announce);
 242         }
 243
 244         return true;
 245     }
 246
 247     /**
 248      * Initiate a TLS (encrypted) session.
 249      * @access public
 250      * @return bool
 251      */
 252     public function startTLS()
 253     {
 254         if (!$this->sendCommand("STARTTLS", "STARTTLS", 220)) {
 255             return false;
 256         }
 257         // Begin encrypted connection
 258         if (!stream_socket_enable_crypto(
 259             $this->smtp_conn,
 260             true,
 261             STREAM_CRYPTO_METHOD_TLS_CLIENT
 262         )
 263         ) {
 264             return false;
 265         }
 266         return true;
 267     }
 268
 269     /**
 270      * Perform SMTP authentication.
 271      * Must be run after hello().
 272      * @see hello()
 273      * @param string $username    The user name
 274      * @param string $password    The password
 275      * @param string $authtype    The auth type (PLAIN, LOGIN, NTLM, CRAM-MD5)
 276      * @param string $realm       The auth realm for NTLM
 277      * @param string $workstation The auth workstation for NTLM
 278      * @access public
 279      * @return bool True if successfully authenticated.
 280      */
 281     public function authenticate(
 282         $username,
 283         $password,
 284         $authtype = 'LOGIN',
 285         $realm = '',
 286         $workstation = ''
 287     ) {
 288         if (empty($authtype)) {
 289             $authtype = 'LOGIN';
 290         }
 291
 292         switch ($authtype) {
 293             case 'PLAIN':
 294                 // Start authentication
 295                 if (!$this->sendCommand('AUTH', 'AUTH PLAIN', 334)) {
 296                     return false;
 297                 }
 298                 // Send encoded username and password
 299                 if (!$this->sendCommand(
 300                     'User & Password',
 301                     base64_encode("\0" . $username . "\0" . $password),
 302                     235
 303                 )
 304                 ) {
 305                     return false;
 306                 }
 307                 break;
 308             case 'LOGIN':
 309                 // Start authentication
 310                 if (!$this->sendCommand('AUTH', 'AUTH LOGIN', 334)) {
 311                     return false;
 312                 }
 313                 if (!$this->sendCommand("Username", base64_encode($username), 334)) {
 314                     return false;
 315                 }
 316                 if (!$this->sendCommand("Password", base64_encode($password), 235)) {
 317                     return false;
 318                 }
 319                 break;
 320             case 'NTLM':
 321                 /*
 322                  * ntlm_sasl_client.php
 323                  * Bundled with Permission
 324                  *
 325                  * How to telnet in windows:
 326                  * http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
 327                  * PROTOCOL Docs http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
 328                  */
 329                 require_once 'extras/ntlm_sasl_client.php';
 330                 $temp = new stdClass();
 331                 $ntlm_client = new ntlm_sasl_client_class;
 332                 //Check that functions are available
 333                 if (!$ntlm_client->Initialize($temp)) {
 334                     $this->error = array('error' => $temp->error);
 335                     if ($this->do_debug >= 1) {
 336                         $this->edebug(
 337                             'You need to enable some modules in your php.ini file: '
 338                             . $this->error['error']
 339                         );
 340                     }
 341                     return false;
 342                 }
 343                 //msg1
 344                 $msg1 = $ntlm_client->TypeMsg1($realm, $workstation); //msg1
 345
 346                 if (!$this->sendCommand(
 347                     'AUTH NTLM',
 348                     'AUTH NTLM ' . base64_encode($msg1),
 349                     334
 350                 )
 351                 ) {
 352                     return false;
 353                 }
 354
 355                 //Though 0 based, there is a white space after the 3 digit number
 356                 //msg2
 357                 $challenge = substr($this->last_reply, 3);
 358                 $challenge = base64_decode($challenge);
 359                 $ntlm_res = $ntlm_client->NTLMResponse(
 360                     substr($challenge, 24, 8),
 361                     $password
 362                 );
 363                 //msg3
 364                 $msg3 = $ntlm_client->TypeMsg3(
 365                     $ntlm_res,
 366                     $username,
 367                     $realm,
 368                     $workstation
 369                 );
 370                 // send encoded username
 371                 return $this->sendCommand('Username', base64_encode($msg3), 235);
 372                 break;
 373             case 'CRAM-MD5':
 374                 // Start authentication
 375                 if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
 376                     return false;
 377                 }
 378                 // Get the challenge
 379                 $challenge = base64_decode(substr($this->last_reply, 4));
 380
 381                 // Build the response
 382                 $response = $username . ' ' . $this->hmac($challenge, $password);
 383
 384                 // send encoded credentials
 385                 return $this->sendCommand('Username', base64_encode($response), 235);
 386                 break;
 387         }
 388         return true;
 389     }
 390
 391     /**
 392      * Calculate an MD5 HMAC hash.
 393      * Works like hash_hmac('md5', $data, $key)
 394      * in case that function is not available
 395      * @param string $data The data to hash
 396      * @param string $key  The key to hash with
 397      * @access protected
 398      * @return string
 399      */
 400     protected function hmac($data, $key)
 401     {
 402         if (function_exists('hash_hmac')) {
 403             return hash_hmac('md5', $data, $key);
 404         }
 405
 406         // The following borrowed from
 407         // http://php.net/manual/en/function.mhash.php#27225
 408
 409         // RFC 2104 HMAC implementation for php.
 410         // Creates an md5 HMAC.
 411         // Eliminates the need to install mhash to compute a HMAC
 412         // Hacked by Lance Rushing
 413
 414         $b = 64; // byte length for md5
 415         if (strlen($key) > $b) {
 416             $key = pack('H*', md5($key));
 417         }
 418         $key = str_pad($key, $b, chr(0x00));
 419         $ipad = str_pad('', $b, chr(0x36));
 420         $opad = str_pad('', $b, chr(0x5c));
 421         $k_ipad = $key ^ $ipad;
 422         $k_opad = $key ^ $opad;
 423
 424         return md5($k_opad . pack('H*', md5($k_ipad . $data)));
 425     }
 426
 427     /**
 428      * Check connection state.
 429      * @access public
 430      * @return bool True if connected.
 431      */
 432     public function connected()
 433     {
 434         if (!empty($this->smtp_conn)) {
 435             $sock_status = stream_get_meta_data($this->smtp_conn);
 436             if ($sock_status['eof']) {
 437                 // the socket is valid but we are not connected
 438                 if ($this->do_debug >= 1) {
 439                     $this->edebug(
 440                         'SMTP -> NOTICE: EOF caught while checking if connected'
 441                     );
 442                 }
 443                 $this->close();
 444                 return false;
 445             }
 446             return true; // everything looks good
 447         }
 448         return false;
 449     }
 450
 451     /**
 452      * Close the socket and clean up the state of the class.
 453      * Don't use this function without first trying to use QUIT.
 454      * @see quit()
 455      * @access public
 456      * @return void
 457      */
 458     public function close()
 459     {
 460         $this->error = null; // so there is no confusion
 461         $this->helo_rply = null;
 462         if (!empty($this->smtp_conn)) {
 463             // close the connection and cleanup
 464             fclose($this->smtp_conn);
 465             $this->smtp_conn = 0;
 466         }
 467     }
 468
 469     /**
 470      * Send an SMTP DATA command.
 471      * Issues a data command and sends the msg_data to the server,
 472      * finializing the mail transaction. $msg_data is the message
 473      * that is to be send with the headers. Each header needs to be
 474      * on a single line followed by a <CRLF> with the message headers
 475      * and the message body being separated by and additional <CRLF>.
 476      * Implements rfc 821: DATA <CRLF>
 477      * @param string $msg_data Message data to send
 478      * @access public
 479      * @return bool
 480      */
 481     public function data($msg_data)
 482     {
 483         if (!$this->sendCommand('DATA', 'DATA', 354)) {
 484             return false;
 485         }
 486
 487         /* The server is ready to accept data!
 488          * according to rfc821 we should not send more than 1000
 489          * including the CRLF
 490          * characters on a single line so we will break the data up
 491          * into lines by \r and/or \n then if needed we will break
 492          * each of those into smaller lines to fit within the limit.
 493          * in addition we will be looking for lines that start with
 494          * a period '.' and append and additional period '.' to that
 495          * line. NOTE: this does not count towards limit.
 496          */
 497
 498         // Normalize the line breaks before exploding
 499         $msg_data = str_replace("\r\n", "\n", $msg_data);
 500         $msg_data = str_replace("\r", "\n", $msg_data);
 501         $lines = explode("\n", $msg_data);
 502
 503         /* We need to find a good way to determine if headers are
 504          * in the msg_data or if it is a straight msg body
 505          * currently I am assuming rfc822 definitions of msg headers
 506          * and if the first field of the first line (':' separated)
 507          * does not contain a space then it _should_ be a header
 508          * and we can process all lines before a blank "" line as
 509          * headers.
 510          */
 511
 512         $field = substr($lines[0], 0, strpos($lines[0], ':'));
 513         $in_headers = false;
 514         if (!empty($field) && !strstr($field, ' ')) {
 515             $in_headers = true;
 516         }
 517
 518         //RFC 2822 section 2.1.1 limit
 519         $max_line_length = 998;
 520
 521         foreach ($lines as $line) {
 522             $lines_out = null;
 523             if ($line == '' && $in_headers) {
 524                 $in_headers = false;
 525             }
 526             // ok we need to break this line up into several smaller lines
 527             while (strlen($line) > $max_line_length) {
 528                 $pos = strrpos(substr($line, 0, $max_line_length), ' ');
 529
 530                 // Patch to fix DOS attack
 531                 if (!$pos) {
 532                     $pos = $max_line_length - 1;
 533                     $lines_out[] = substr($line, 0, $pos);
 534                     $line = substr($line, $pos);
 535                 } else {
 536                     $lines_out[] = substr($line, 0, $pos);
 537                     $line = substr($line, $pos + 1);
 538                 }
 539
 540                 /* If processing headers add a LWSP-char to the front of new line
 541                  * rfc822 on long msg headers
 542                  */
 543                 if ($in_headers) {
 544                     $line = "\t" . $line;
 545                 }
 546             }
 547             $lines_out[] = $line;
 548
 549             // send the lines to the server
 550             while (list(, $line_out) = @each($lines_out)) {
 551                 if (strlen($line_out) > 0) {
 552                     if (substr($line_out, 0, 1) == '.') {
 553                         $line_out = '.' . $line_out;
 554                     }
 555                 }
 556                 $this->client_send($line_out . self::CRLF);
 557             }
 558         }
 559
 560         // Message data has been sent, complete the command
 561         return $this->sendCommand('DATA END', '.', 250);
 562     }
 563
 564     /**
 565      * Send an SMTP HELO or EHLO command.
 566      * Used to identify the sending server to the receiving server.
 567      * This makes sure that client and server are in a known state.
 568      * Implements from RFC 821: HELO <SP> <domain> <CRLF>
 569      * and RFC 2821 EHLO.
 570      * @param string $host The host name or IP to connect to
 571      * @access public
 572      * @return bool
 573      */
 574     public function hello($host = '')
 575     {
 576         // Try extended hello first (RFC 2821)
 577         if (!$this->sendHello('EHLO', $host)) {
 578             if (!$this->sendHello('HELO', $host)) {
 579                 return false;
 580             }
 581         }
 582
 583         return true;
 584     }
 585
 586     /**
 587      * Send an SMTP HELO or EHLO command.
 588      * Low-level implementation used by hello()
 589      * @see hello()
 590      * @param string $hello The HELO string
 591      * @param string $host  The hostname to say we are
 592      * @access protected
 593      * @return bool
 594      */
 595     protected function sendHello($hello, $host)
 596     {
 597         $noerror = $this->sendCommand($hello, $hello . ' ' . $host, 250);
 598         $this->helo_rply = $this->last_reply;
 599         return $noerror;
 600     }
 601
 602     /**
 603      * Send an SMTP MAIL command.
 604      * Starts a mail transaction from the email address specified in
 605      * $from. Returns true if successful or false otherwise. If True
 606      * the mail transaction is started and then one or more recipient
 607      * commands may be called followed by a data command.
 608      * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
 609      * @param string $from Source address of this message
 610      * @access public
 611      * @return bool
 612      */
 613     public function mail($from)
 614     {
 615         $useVerp = ($this->do_verp ? ' XVERP' : '');
 616         return $this->sendCommand(
 617             'MAIL FROM',
 618             'MAIL FROM:<' . $from . '>' . $useVerp,
 619             250
 620         );
 621     }
 622
 623     /**
 624      * Send an SMTP QUIT command.
 625      * Closes the socket if there is no error or the $close_on_error argument is true.
 626      * Implements from rfc 821: QUIT <CRLF>
 627      * @param bool $close_on_error Should the connection close if an error occurs?
 628      * @access public
 629      * @return bool
 630      */
 631     public function quit($close_on_error = true)
 632     {
 633         $noerror = $this->sendCommand('QUIT', 'QUIT', 221);
 634         $e = $this->error; //Save any error
 635         if ($noerror or $close_on_error) {
 636             $this->close();
 637             $this->error = $e; //Restore any error from the quit command
 638         }
 639         return $noerror;
 640     }
 641
 642     /**
 643      * Send an SMTP RCPT command.
 644      * Sets the TO argument to $to.
 645      * Returns true if the recipient was accepted false if it was rejected.
 646      * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
 647      * @param string $to The address the message is being sent to
 648      * @access public
 649      * @return bool
 650      */
 651     public function recipient($to)
 652     {
 653         return $this->sendCommand(
 654             'RCPT TO ',
 655             'RCPT TO:<' . $to . '>',
 656             array(250, 251)
 657         );
 658     }
 659
 660     /**
 661      * Send an SMTP RSET command.
 662      * Abort any transaction that is currently in progress.
 663      * Implements rfc 821: RSET <CRLF>
 664      * @access public
 665      * @return bool True on success.
 666      */
 667     public function reset()
 668     {
 669         return $this->sendCommand('RSET', 'RSET', 250);
 670     }
 671
 672     /**
 673      * Send a command to an SMTP server and check its return code.
 674      * @param string $command       The command name - not sent to the server
 675      * @param string $commandstring The actual command to send
 676      * @param int|array $expect     One or more expected integer success codes
 677      * @access protected
 678      * @return bool True on success.
 679      */
 680     protected function sendCommand($command, $commandstring, $expect)
 681     {
 682         if (!$this->connected()) {
 683             $this->error = array(
 684                 "error" => "Called $command without being connected"
 685             );
 686             return false;
 687         }
 688         $this->client_send($commandstring . self::CRLF);
 689
 690         $reply = $this->get_lines();
 691         $code = substr($reply, 0, 3);
 692
 693         if ($this->do_debug >= 2) {
 694             $this->edebug('SMTP -> FROM SERVER:' . $reply);
 695         }
 696
 697         if (!in_array($code, (array)$expect)) {
 698             $this->last_reply = null;
 699             $this->error = array(
 700                 "error" => "$command command failed",
 701                 "smtp_code" => $code,
 702                 "detail" => substr($reply, 4)
 703             );
 704             if ($this->do_debug >= 1) {
 705                 $this->edebug(
 706                     'SMTP -> ERROR: ' . $this->error['error'] . ': ' . $reply
 707                 );
 708             }
 709             return false;
 710         }
 711
 712         $this->last_reply = $reply;
 713         $this->error = null;
 714         return true;
 715     }
 716
 717     /**
 718      * Send an SMTP SAML command.
 719      * Starts a mail transaction from the email address specified in $from.
 720      * Returns true if successful or false otherwise. If True
 721      * the mail transaction is started and then one or more recipient
 722      * commands may be called followed by a data command. This command
 723      * will send the message to the users terminal if they are logged
 724      * in and send them an email.
 725      * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
 726      * @param string $from The address the message is from
 727      * @access public
 728      * @return bool
 729      */
 730     public function sendAndMail($from)
 731     {
 732         return $this->sendCommand("SAML", "SAML FROM:$from", 250);
 733     }
 734
 735     /**
 736      * Send an SMTP VRFY command.
 737      * @param string $name The name to verify
 738      * @access public
 739      * @return bool
 740      */
 741     public function verify($name)
 742     {
 743         return $this->sendCommand("VRFY", "VRFY $name", array(250, 251));
 744     }
 745
 746     /**
 747      * Send an SMTP NOOP command.
 748      * Used to keep keep-alives alive, doesn't actually do anything
 749      * @access public
 750      * @return bool
 751      */
 752     public function noop()
 753     {
 754         return $this->sendCommand("NOOP", "NOOP", 250);
 755     }
 756
 757     /**
 758      * Send an SMTP TURN command.
 759      * This is an optional command for SMTP that this class does not support.
 760      * This method is here to make the RFC821 Definition
 761      * complete for this class and __may__ be implemented in future
 762      * Implements from rfc 821: TURN <CRLF>
 763      * @access public
 764      * @return bool
 765      */
 766     public function turn()
 767     {
 768         $this->error = array(
 769             'error' => 'The SMTP TURN command is not implemented'
 770         );
 771         if ($this->do_debug >= 1) {
 772             $this->edebug('SMTP -> NOTICE: ' . $this->error['error']);
 773         }
 774         return false;
 775     }
 776
 777     /**
 778      * Send raw data to the server.
 779      * @param string $data The data to send
 780      * @access public
 781      * @return int|bool The number of bytes sent to the server or FALSE on error
 782      */
 783     public function client_send($data)
 784     {
 785         if ($this->do_debug >= 1) {
 786             $this->edebug("CLIENT -> SMTP: $data");
 787         }
 788         return fwrite($this->smtp_conn, $data);
 789     }
 790
 791     /**
 792      * Get the latest error.
 793      * @access public
 794      * @return array
 795      */
 796     public function getError()
 797     {
 798         return $this->error;
 799     }
 800
 801     /**
 802      * Get the last reply from the server.
 803      * @access public
 804      * @return string
 805      */
 806     public function getLastReply()
 807     {
 808         return $this->last_reply;
 809     }
 810
 811     /**
 812      * Read the SMTP server's response.
 813      * Either before eof or socket timeout occurs on the operation.
 814      * With SMTP we can tell if we have more lines to read if the
 815      * 4th character is '-' symbol. If it is a space then we don't
 816      * need to read anything else.
 817      * @access protected
 818      * @return string
 819      */
 820     protected function get_lines()
 821     {
 822         $data = '';
 823         $endtime = 0;
 824         // If the connection is bad, give up now
 825         if (!is_resource($this->smtp_conn)) {
 826             return $data;
 827         }
 828         stream_set_timeout($this->smtp_conn, $this->Timeout);
 829         if ($this->Timelimit > 0) {
 830             $endtime = time() + $this->Timelimit;
 831         }
 832         while (is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
 833             $str = @fgets($this->smtp_conn, 515);
 834             if ($this->do_debug >= 4) {
 835                 $this->edebug("SMTP -> get_lines(): \$data was \"$data\"");
 836                 $this->edebug("SMTP -> get_lines(): \$str is \"$str\"");
 837             }
 838             $data .= $str;
 839             if ($this->do_debug >= 4) {
 840                 $this->edebug("SMTP -> get_lines(): \$data is \"$data\"");
 841             }
 842             // if 4th character is a space, we are done reading, break the loop
 843             if (substr($str, 3, 1) == ' ') {
 844                 break;
 845             }
 846             // Timed-out? Log and break
 847             $info = stream_get_meta_data($this->smtp_conn);
 848             if ($info['timed_out']) {
 849                 if ($this->do_debug >= 4) {
 850                     $this->edebug(
 851                         'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)'
 852                     );
 853                 }
 854                 break;
 855             }
 856             // Now check if reads took too long
 857             if ($endtime) {
 858                 if (time() > $endtime) {
 859                     if ($this->do_debug >= 4) {
 860                         $this->edebug(
 861                             'SMTP -> get_lines(): timelimit reached ('
 862                             . $this->Timelimit . ' sec)'
 863                         );
 864                     }
 865                     break;
 866                 }
 867             }
 868         }
 869         return $data;
 870     }
 871
 872     /**
 873      * Enable or disable VERP address generation.
 874      * @param bool $enabled
 875      */
 876     public function setVerp($enabled = false)
 877     {
 878         $this->do_verp = $enabled;
 879     }
 880
 881     /**
 882      * Get VERP address generation mode.
 883      * @return bool
 884      */
 885     public function getVerp()
 886     {
 887         return $this->do_verp;
 888     }
 889
 890     /**
 891      * Set debug output method.
 892      * @param string $method The function/method to use for debugging output.
 893      */
 894     public function setDebugOutput($method = 'echo')
 895     {
 896         $this->Debugoutput = $method;
 897     }
 898
 899     /**
 900      * Get debug output method.
 901      * @return string
 902      */
 903     public function getDebugOutput()
 904     {
 905         return $this->Debugoutput;
 906     }
 907
 908     /**
 909      * Set debug output level.
 910      * @param int $level
 911      */
 912     public function setDebugLevel($level = 0)
 913     {
 914         $this->do_debug = $level;
 915     }
 916
 917     /**
 918      * Get debug output level.
 919      * @return int
 920      */
 921     public function getDebugLevel()
 922     {
 923         return $this->do_debug;
 924     }
 925
 926     /**
 927      * Set SMTP timeout.
 928      * @param int $timeout
 929      */
 930     public function setTimeout($timeout = 0)
 931     {
 932         $this->Timeout = $timeout;
 933     }
 934
 935     /**
 936      * Get SMTP timeout.
 937      * @return int
 938      */
 939     public function getTimeout()
 940     {
 941         return $this->Timeout;
 942     }
 943 }