PageRenderTime 19ms CodeModel.GetById 71ms app.highlight 58ms RepoModel.GetById 52ms app.codeStats 1ms

/htdocs/includes/phpmailer/class.smtp.php

https://bitbucket.org/speedealing/speedealing
PHP | 818 lines | 414 code | 111 blank | 293 comment | 90 complexity | d792e4a0d5a376d6bdc4275414bd58ab MD5 | raw file
  1<?php
  2/*~ class.smtp.php
  3.---------------------------------------------------------------------------.
  4|  Software: PHPMailer - PHP email class                                    |
  5|   Version: 5.2.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) 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 * @version $Id: class.smtp.php 450 2010-06-23 16:46:33Z coolbru $
 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
 46class 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.2.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(!feof($this->smtp_conn)) {
801      $str = @fgets($this->smtp_conn,515);
802      if($this->do_debug >= 4) {
803        echo "SMTP -> get_lines(): \$data was \"$data\"" . $this->CRLF . '<br />';
804        echo "SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '<br />';
805      }
806      $data .= $str;
807      if($this->do_debug >= 4) {
808        echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '<br />';
809      }
810      // if 4th character is a space, we are done reading, break the loop
811      if(substr($str,3,1) == " ") { break; }
812    }
813    return $data;
814  }
815
816}
817
818?>