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: 
 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 . '<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: ?>
819: