File:
0.00.1a/core/phpmailer/class.smtp.php (
View as Code)
1: 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:
46: class SMTP {
47: /**
48: * SMTP server port
49: * @var int
50: */
51: public $SMTP_PORT = 25;
52:
53: /**
54: * SMTP reply line ending
55: * @var string
56: */
57: public $CRLF = "\r\n";
58:
59: /**
60: * Sets whether debugging is turned on
61: * @var bool
62: */
63: public $do_debug; // the level of debug to perform
64:
65: /**
66: * Sets VERP use on/off (default is off)
67: * @var bool
68: */
69: public $do_verp = false;
70:
71: /**
72: * Sets the SMTP PHPMailer Version number
73: * @var string
74: */
75: public $Version = '5.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 . '
';
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 . '
';
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 . '
';
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 . '
';
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 . '
';
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 . '
';
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 . '
';
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 with the message headers
315: * and the message body being seperated by and additional .
316: *
317: * Implements rfc 821: DATA
318: *
319: * SMTP CODE INTERMEDIATE: 354
320: * [data]
321: * .
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 . '
';
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 . '
';
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 . '
';
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 . '
';
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
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 . '
';
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 . '
';
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 FROM:
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 . '
';
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 . '
';
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
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 . '
';
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 . '
';
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 TO:
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 . '
';
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 . '
';
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
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 . '
';
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 . '
';
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 FROM:
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 . '
';
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 . '
';
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
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 . '
';
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 . '
';
804: echo "SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '
';
805: }
806: $data .= $str;
807: if($this->do_debug >= 4) {
808: echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '
';
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: ?>
819: