1: <?php
  2: /*~ class.smtp.php
  3: .---------------------------------------------------------------------------.
  4: |  Software: PHPMailer - PHP email class                                    |
  5: |   Version: 5.0.0                                                          |
  6: |   Contact: via sourceforge.net support pages (also www.codeworxtech.com)  |
  7: |      Info: http://phpmailer.sourceforge.net                               |
  8: |   Support: http://sourceforge.net/projects/phpmailer/                     |
  9: | ------------------------------------------------------------------------- |
 10: |     Admin: Andy Prevost (project admininistrator)                         |
 11: |   Authors: Andy Prevost (codeworxtech) codeworxtech@users.sourceforge.net |
 12: |          : Marcus Bointon (coolbru) coolbru@users.sourceforge.net         |
 13: |   Founder: Brent R. Matzelle (original founder)                           |
 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: | We offer a number of paid services (www.codeworxtech.com):                |
 24: | - Web Hosting on highly optimized fast and secure servers                 |
 25: | - Technology Consulting                                                   |
 26: | - Oursourcing (highly qualified programmers and graphic designers)        |
 27: '---------------------------------------------------------------------------'
 28: */
 29: 
 30: /**
 31:  * PHPMailer - PHP SMTP email transport class
 32:  * NOTE: Designed for use with PHP version 5 and up
 33:  * @package PHPMailer
 34:  * @author Andy Prevost
 35:  * @author Marcus Bointon
 36:  * @copyright 2004 - 2008 Andy Prevost
 37:  * @license http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
 38:  * @version $Id: class.smtp.php 240 2009-03-31 04:40:33Z codeworxtech $
 39:  */
 40: 
 41: /**
 42:  * SMTP is rfc 821 compliant and implements all the rfc 821 SMTP
 43:  * commands except TURN which will always return a not implemented
 44:  * error. SMTP also provides some utility methods for sending mail
 45:  * to an SMTP server.
 46:  * original author: Chris Ryan
 47:  */
 48: 
 49: class SMTP {
 50:   /**
 51:    *  SMTP server port
 52:    *  @var int
 53:    */
 54:   public $SMTP_PORT = 25;
 55: 
 56:   /**
 57:    *  SMTP reply line ending
 58:    *  @var string
 59:    */
 60:   public $CRLF = "\r\n";
 61: 
 62:   /**
 63:    *  Sets whether debugging is turned on
 64:    *  @var bool
 65:    */
 66:   public $do_debug;       // the level of debug to perform
 67: 
 68:   /**
 69:    *  Sets VERP use on/off (default is off)
 70:    *  @var bool
 71:    */
 72:   public $do_verp = false;
 73: 
 74:   /////////////////////////////////////////////////
 75:   // PROPERTIES, PRIVATE AND PROTECTED
 76:   /////////////////////////////////////////////////
 77: 
 78:   private $smtp_conn; // the socket to the server
 79:   private $error;     // error if any on the last call
 80:   private $helo_rply; // the reply the server sent to us for HELO
 81: 
 82:   /**
 83:    * Initialize the class so that the data is in a known state.
 84:    * @access public
 85:    * @return void
 86:    */
 87:   public function __construct() {
 88:     $this->smtp_conn = 0;
 89:     $this->error = null;
 90:     $this->helo_rply = null;
 91: 
 92:     $this->do_debug = 0;
 93:   }
 94: 
 95:   /////////////////////////////////////////////////
 96:   // CONNECTION FUNCTIONS
 97:   /////////////////////////////////////////////////
 98: 
 99:   /**
100:    * Connect to the server specified on the port specified.
101:    * If the port is not specified use the default SMTP_PORT.
102:    * If tval is specified then a connection will try and be
103:    * established with the server for that number of seconds.
104:    * If tval is not specified the default is 30 seconds to
105:    * try on the connection.
106:    *
107:    * SMTP CODE SUCCESS: 220
108:    * SMTP CODE FAILURE: 421
109:    * @access public
110:    * @return bool
111:    */
112:   public function Connect($host, $port = 0, $tval = 30) {
113:     // set the error val to null so there is no confusion
114:     $this->error = null;
115: 
116:     // make sure we are __not__ connected
117:     if($this->connected()) {
118:       // already connected, generate error
119:       $this->error = array("error" => "Already connected to a server");
120:       return false;
121:     }
122: 
123:     if(empty($port)) {
124:       $port = $this->SMTP_PORT;
125:     }
126: 
127:     // connect to the smtp server
128:     $this->smtp_conn = @fsockopen($host,    // the host of the server
129:                                  $port,    // the port to use
130:                                  $errno,   // error number if any
131:                                  $errstr,  // error message if any
132:                                  $tval);   // give up after ? secs
133:     // verify we connected properly
134:     if(empty($this->smtp_conn)) {
135:       $this->error = array("error" => "Failed to connect to server",
136:                            "errno" => $errno,
137:                            "errstr" => $errstr);
138:       if($this->do_debug >= 1) {
139:         echo "SMTP -> ERROR: " . $this->error["error"] . ": $errstr ($errno)" . $this->CRLF . '<br />';
140:       }
141:       return false;
142:     }
143: 
144:     // SMTP server can take longer to respond, give longer timeout for first read
145:     // Windows does not have support for this timeout function
146:     if(substr(PHP_OS, 0, 3) != "WIN")
147:      socket_set_timeout($this->smtp_conn, $tval, 0);
148: 
149:     // get any announcement
150:     $announce = $this->get_lines();
151: 
152:     if($this->do_debug >= 2) {
153:       echo "SMTP -> FROM SERVER:" . $announce . $this->CRLF . '<br />';
154:     }
155: 
156:     return true;
157:   }
158: 
159:   /**
160:    * Initiate a TLS communication with the server.
161:    *
162:    * SMTP CODE 220 Ready to start TLS
163:    * SMTP CODE 501 Syntax error (no parameters allowed)
164:    * SMTP CODE 454 TLS not available due to temporary reason
165:    * @access public
166:    * @return bool success
167:    */
168:   public function StartTLS() {
169:     $this->error = null; # to avoid confusion
170: 
171:     if(!$this->connected()) {
172:       $this->error = array("error" => "Called StartTLS() without being connected");
173:       return false;
174:     }
175: 
176:     fputs($this->smtp_conn,"STARTTLS" . $this->CRLF);
177: 
178:     $rply = $this->get_lines();
179:     $code = substr($rply,0,3);
180: 
181:     if($this->do_debug >= 2) {
182:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
183:     }
184: 
185:     if($code != 220) {
186:       $this->error =
187:          array("error"     => "STARTTLS not accepted from server",
188:                "smtp_code" => $code,
189:                "smtp_msg"  => substr($rply,4));
190:       if($this->do_debug >= 1) {
191:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
192:       }
193:       return false;
194:     }
195: 
196:     // Begin encrypted connection
197:     if(!stream_socket_enable_crypto($this->smtp_conn, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
198:       return false;
199:     }
200: 
201:     return true;
202:   }
203: 
204:   /**
205:    * Performs SMTP authentication.  Must be run after running the
206:    * Hello() method.  Returns true if successfully authenticated.
207:    * @access public
208:    * @return bool
209:    */
210:   public function Authenticate($username, $password) {
211:     // Start authentication
212:     fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);
213: 
214:     $rply = $this->get_lines();
215:     $code = substr($rply,0,3);
216: 
217:     if($code != 334) {
218:       $this->error =
219:         array("error" => "AUTH not accepted from server",
220:               "smtp_code" => $code,
221:               "smtp_msg" => substr($rply,4));
222:       if($this->do_debug >= 1) {
223:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
224:       }
225:       return false;
226:     }
227: 
228:     // Send encoded username
229:     fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);
230: 
231:     $rply = $this->get_lines();
232:     $code = substr($rply,0,3);
233: 
234:     if($code != 334) {
235:       $this->error =
236:         array("error" => "Username not accepted from server",
237:               "smtp_code" => $code,
238:               "smtp_msg" => substr($rply,4));
239:       if($this->do_debug >= 1) {
240:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
241:       }
242:       return false;
243:     }
244: 
245:     // Send encoded password
246:     fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);
247: 
248:     $rply = $this->get_lines();
249:     $code = substr($rply,0,3);
250: 
251:     if($code != 235) {
252:       $this->error =
253:         array("error" => "Password not accepted from server",
254:               "smtp_code" => $code,
255:               "smtp_msg" => substr($rply,4));
256:       if($this->do_debug >= 1) {
257:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
258:       }
259:       return false;
260:     }
261: 
262:     return true;
263:   }
264: 
265:   /**
266:    * Returns true if connected to a server otherwise false
267:    * @access public
268:    * @return bool
269:    */
270:   public function Connected() {
271:     if(!empty($this->smtp_conn)) {
272:       $sock_status = socket_get_status($this->smtp_conn);
273:       if($sock_status["eof"]) {
274:         // the socket is valid but we are not connected
275:         if($this->do_debug >= 1) {
276:             echo "SMTP -> NOTICE:" . $this->CRLF . "EOF caught while checking if connected";
277:         }
278:         $this->Close();
279:         return false;
280:       }
281:       return true; // everything looks good
282:     }
283:     return false;
284:   }
285: 
286:   /**
287:    * Closes the socket and cleans up the state of the class.
288:    * It is not considered good to use this function without
289:    * first trying to use QUIT.
290:    * @access public
291:    * @return void
292:    */
293:   public function Close() {
294:     $this->error = null; // so there is no confusion
295:     $this->helo_rply = null;
296:     if(!empty($this->smtp_conn)) {
297:       // close the connection and cleanup
298:       fclose($this->smtp_conn);
299:       $this->smtp_conn = 0;
300:     }
301:   }
302: 
303:   /////////////////////////////////////////////////
304:   // SMTP COMMANDS
305:   /////////////////////////////////////////////////
306: 
307:   /**
308:    * Issues a data command and sends the msg_data to the server
309:    * finializing the mail transaction. $msg_data is the message
310:    * that is to be send with the headers. Each header needs to be
311:    * on a single line followed by a <CRLF> with the message headers
312:    * and the message body being seperated by and additional <CRLF>.
313:    *
314:    * Implements rfc 821: DATA <CRLF>
315:    *
316:    * SMTP CODE INTERMEDIATE: 354
317:    *     [data]
318:    *     <CRLF>.<CRLF>
319:    *     SMTP CODE SUCCESS: 250
320:    *     SMTP CODE FAILURE: 552,554,451,452
321:    * SMTP CODE FAILURE: 451,554
322:    * SMTP CODE ERROR  : 500,501,503,421
323:    * @access public
324:    * @return bool
325:    */
326:   public function Data($msg_data) {
327:     $this->error = null; // so no confusion is caused
328: 
329:     if(!$this->connected()) {
330:       $this->error = array(
331:               "error" => "Called Data() without being connected");
332:       return false;
333:     }
334: 
335:     fputs($this->smtp_conn,"DATA" . $this->CRLF);
336: 
337:     $rply = $this->get_lines();
338:     $code = substr($rply,0,3);
339: 
340:     if($this->do_debug >= 2) {
341:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
342:     }
343: 
344:     if($code != 354) {
345:       $this->error =
346:         array("error" => "DATA command not accepted from server",
347:               "smtp_code" => $code,
348:               "smtp_msg" => substr($rply,4));
349:       if($this->do_debug >= 1) {
350:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
351:       }
352:       return false;
353:     }
354: 
355:     /* the server is ready to accept data!
356:      * according to rfc 821 we should not send more than 1000
357:      * including the CRLF
358:      * characters on a single line so we will break the data up
359:      * into lines by \r and/or \n then if needed we will break
360:      * each of those into smaller lines to fit within the limit.
361:      * in addition we will be looking for lines that start with
362:      * a period '.' and append and additional period '.' to that
363:      * line. NOTE: this does not count towards limit.
364:      */
365: 
366:     // normalize the line breaks so we know the explode works
367:     $msg_data = str_replace("\r\n","\n",$msg_data);
368:     $msg_data = str_replace("\r","\n",$msg_data);
369:     $lines = explode("\n",$msg_data);
370: 
371:     /* we need to find a good way to determine is headers are
372:      * in the msg_data or if it is a straight msg body
373:      * currently I am assuming rfc 822 definitions of msg headers
374:      * and if the first field of the first line (':' sperated)
375:      * does not contain a space then it _should_ be a header
376:      * and we can process all lines before a blank "" line as
377:      * headers.
378:      */
379: 
380:     $field = substr($lines[0],0,strpos($lines[0],":"));
381:     $in_headers = false;
382:     if(!empty($field) && !strstr($field," ")) {
383:       $in_headers = true;
384:     }
385: 
386:     $max_line_length = 998; // used below; set here for ease in change
387: 
388:     while(list(,$line) = @each($lines)) {
389:       $lines_out = null;
390:       if($line == "" && $in_headers) {
391:         $in_headers = false;
392:       }
393:       // ok we need to break this line up into several smaller lines
394:       while(strlen($line) > $max_line_length) {
395:         $pos = strrpos(substr($line,0,$max_line_length)," ");
396: 
397:         // Patch to fix DOS attack
398:         if(!$pos) {
399:           $pos = $max_line_length - 1;
400:           $lines_out[] = substr($line,0,$pos);
401:           $line = substr($line,$pos);
402:         } else {
403:           $lines_out[] = substr($line,0,$pos);
404:           $line = substr($line,$pos + 1);
405:         }
406: 
407:         /* if processing headers add a LWSP-char to the front of new line
408:          * rfc 822 on long msg headers
409:          */
410:         if($in_headers) {
411:           $line = "\t" . $line;
412:         }
413:       }
414:       $lines_out[] = $line;
415: 
416:       // send the lines to the server
417:       while(list(,$line_out) = @each($lines_out)) {
418:         if(strlen($line_out) > 0)
419:         {
420:           if(substr($line_out, 0, 1) == ".") {
421:             $line_out = "." . $line_out;
422:           }
423:         }
424:         fputs($this->smtp_conn,$line_out . $this->CRLF);
425:       }
426:     }
427: 
428:     // message data has been sent
429:     fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);
430: 
431:     $rply = $this->get_lines();
432:     $code = substr($rply,0,3);
433: 
434:     if($this->do_debug >= 2) {
435:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
436:     }
437: 
438:     if($code != 250) {
439:       $this->error =
440:         array("error" => "DATA not accepted from server",
441:               "smtp_code" => $code,
442:               "smtp_msg" => substr($rply,4));
443:       if($this->do_debug >= 1) {
444:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
445:       }
446:       return false;
447:     }
448:     return true;
449:   }
450: 
451:   /**
452:    * Sends the HELO command to the smtp server.
453:    * This makes sure that we and the server are in
454:    * the same known state.
455:    *
456:    * Implements from rfc 821: HELO <SP> <domain> <CRLF>
457:    *
458:    * SMTP CODE SUCCESS: 250
459:    * SMTP CODE ERROR  : 500, 501, 504, 421
460:    * @access public
461:    * @return bool
462:    */
463:   public function Hello($host = '') {
464:     $this->error = null; // so no confusion is caused
465: 
466:     if(!$this->connected()) {
467:       $this->error = array(
468:             "error" => "Called Hello() without being connected");
469:       return false;
470:     }
471: 
472:     // if hostname for HELO was not specified send default
473:     if(empty($host)) {
474:       // determine appropriate default to send to server
475:       $host = "localhost";
476:     }
477: 
478:     // Send extended hello first (RFC 2821)
479:     if(!$this->SendHello("EHLO", $host)) {
480:       if(!$this->SendHello("HELO", $host)) {
481:         return false;
482:       }
483:     }
484: 
485:     return true;
486:   }
487: 
488:   /**
489:    * Sends a HELO/EHLO command.
490:    * @access private
491:    * @return bool
492:    */
493:   private function SendHello($hello, $host) {
494:     fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF);
495: 
496:     $rply = $this->get_lines();
497:     $code = substr($rply,0,3);
498: 
499:     if($this->do_debug >= 2) {
500:       echo "SMTP -> FROM SERVER: " . $rply . $this->CRLF . '<br />';
501:     }
502: 
503:     if($code != 250) {
504:       $this->error =
505:         array("error" => $hello . " not accepted from server",
506:               "smtp_code" => $code,
507:               "smtp_msg" => substr($rply,4));
508:       if($this->do_debug >= 1) {
509:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
510:       }
511:       return false;
512:     }
513: 
514:     $this->helo_rply = $rply;
515: 
516:     return true;
517:   }
518: 
519:   /**
520:    * Starts a mail transaction from the email address specified in
521:    * $from. Returns true if successful or false otherwise. If True
522:    * the mail transaction is started and then one or more Recipient
523:    * commands may be called followed by a Data command.
524:    *
525:    * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
526:    *
527:    * SMTP CODE SUCCESS: 250
528:    * SMTP CODE SUCCESS: 552,451,452
529:    * SMTP CODE SUCCESS: 500,501,421
530:    * @access public
531:    * @return bool
532:    */
533:   public function Mail($from) {
534:     $this->error = null; // so no confusion is caused
535: 
536:     if(!$this->connected()) {
537:       $this->error = array(
538:               "error" => "Called Mail() without being connected");
539:       return false;
540:     }
541: 
542:     $useVerp = ($this->do_verp ? "XVERP" : "");
543:     fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $useVerp . $this->CRLF);
544: 
545:     $rply = $this->get_lines();
546:     $code = substr($rply,0,3);
547: 
548:     if($this->do_debug >= 2) {
549:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
550:     }
551: 
552:     if($code != 250) {
553:       $this->error =
554:         array("error" => "MAIL not accepted from server",
555:               "smtp_code" => $code,
556:               "smtp_msg" => substr($rply,4));
557:       if($this->do_debug >= 1) {
558:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
559:       }
560:       return false;
561:     }
562:     return true;
563:   }
564: 
565:   /**
566:    * Sends the quit command to the server and then closes the socket
567:    * if there is no error or the $close_on_error argument is true.
568:    *
569:    * Implements from rfc 821: QUIT <CRLF>
570:    *
571:    * SMTP CODE SUCCESS: 221
572:    * SMTP CODE ERROR  : 500
573:    * @access public
574:    * @return bool
575:    */
576:   public function Quit($close_on_error = true) {
577:     $this->error = null; // so there is no confusion
578: 
579:     if(!$this->connected()) {
580:       $this->error = array(
581:               "error" => "Called Quit() without being connected");
582:       return false;
583:     }
584: 
585:     // send the quit command to the server
586:     fputs($this->smtp_conn,"quit" . $this->CRLF);
587: 
588:     // get any good-bye messages
589:     $byemsg = $this->get_lines();
590: 
591:     if($this->do_debug >= 2) {
592:       echo "SMTP -> FROM SERVER:" . $byemsg . $this->CRLF . '<br />';
593:     }
594: 
595:     $rval = true;
596:     $e = null;
597: 
598:     $code = substr($byemsg,0,3);
599:     if($code != 221) {
600:       // use e as a tmp var cause Close will overwrite $this->error
601:       $e = array("error" => "SMTP server rejected quit command",
602:                  "smtp_code" => $code,
603:                  "smtp_rply" => substr($byemsg,4));
604:       $rval = false;
605:       if($this->do_debug >= 1) {
606:         echo "SMTP -> ERROR: " . $e["error"] . ": " . $byemsg . $this->CRLF . '<br />';
607:       }
608:     }
609: 
610:     if(empty($e) || $close_on_error) {
611:       $this->Close();
612:     }
613: 
614:     return $rval;
615:   }
616: 
617:   /**
618:    * Sends the command RCPT to the SMTP server with the TO: argument of $to.
619:    * Returns true if the recipient was accepted false if it was rejected.
620:    *
621:    * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
622:    *
623:    * SMTP CODE SUCCESS: 250,251
624:    * SMTP CODE FAILURE: 550,551,552,553,450,451,452
625:    * SMTP CODE ERROR  : 500,501,503,421
626:    * @access public
627:    * @return bool
628:    */
629:   public function Recipient($to) {
630:     $this->error = null; // so no confusion is caused
631: 
632:     if(!$this->connected()) {
633:       $this->error = array(
634:               "error" => "Called Recipient() without being connected");
635:       return false;
636:     }
637: 
638:     fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF);
639: 
640:     $rply = $this->get_lines();
641:     $code = substr($rply,0,3);
642: 
643:     if($this->do_debug >= 2) {
644:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
645:     }
646: 
647:     if($code != 250 && $code != 251) {
648:       $this->error =
649:         array("error" => "RCPT not accepted from server",
650:               "smtp_code" => $code,
651:               "smtp_msg" => substr($rply,4));
652:       if($this->do_debug >= 1) {
653:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
654:       }
655:       return false;
656:     }
657:     return true;
658:   }
659: 
660:   /**
661:    * Sends the RSET command to abort and transaction that is
662:    * currently in progress. Returns true if successful false
663:    * otherwise.
664:    *
665:    * Implements rfc 821: RSET <CRLF>
666:    *
667:    * SMTP CODE SUCCESS: 250
668:    * SMTP CODE ERROR  : 500,501,504,421
669:    * @access public
670:    * @return bool
671:    */
672:   public function Reset() {
673:     $this->error = null; // so no confusion is caused
674: 
675:     if(!$this->connected()) {
676:       $this->error = array(
677:               "error" => "Called Reset() without being connected");
678:       return false;
679:     }
680: 
681:     fputs($this->smtp_conn,"RSET" . $this->CRLF);
682: 
683:     $rply = $this->get_lines();
684:     $code = substr($rply,0,3);
685: 
686:     if($this->do_debug >= 2) {
687:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
688:     }
689: 
690:     if($code != 250) {
691:       $this->error =
692:         array("error" => "RSET failed",
693:               "smtp_code" => $code,
694:               "smtp_msg" => substr($rply,4));
695:       if($this->do_debug >= 1) {
696:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
697:       }
698:       return false;
699:     }
700: 
701:     return true;
702:   }
703: 
704:   /**
705:    * Starts a mail transaction from the email address specified in
706:    * $from. Returns true if successful or false otherwise. If True
707:    * the mail transaction is started and then one or more Recipient
708:    * commands may be called followed by a Data command. This command
709:    * will send the message to the users terminal if they are logged
710:    * in and send them an email.
711:    *
712:    * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
713:    *
714:    * SMTP CODE SUCCESS: 250
715:    * SMTP CODE SUCCESS: 552,451,452
716:    * SMTP CODE SUCCESS: 500,501,502,421
717:    * @access public
718:    * @return bool
719:    */
720:   public function SendAndMail($from) {
721:     $this->error = null; // so no confusion is caused
722: 
723:     if(!$this->connected()) {
724:       $this->error = array(
725:           "error" => "Called SendAndMail() without being connected");
726:       return false;
727:     }
728: 
729:     fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);
730: 
731:     $rply = $this->get_lines();
732:     $code = substr($rply,0,3);
733: 
734:     if($this->do_debug >= 2) {
735:       echo "SMTP -> FROM SERVER:" . $rply . $this->CRLF . '<br />';
736:     }
737: 
738:     if($code != 250) {
739:       $this->error =
740:         array("error" => "SAML not accepted from server",
741:               "smtp_code" => $code,
742:               "smtp_msg" => substr($rply,4));
743:       if($this->do_debug >= 1) {
744:         echo "SMTP -> ERROR: " . $this->error["error"] . ": " . $rply . $this->CRLF . '<br />';
745:       }
746:       return false;
747:     }
748:     return true;
749:   }
750: 
751:   /**
752:    * This is an optional command for SMTP that this class does not
753:    * support. This method is here to make the RFC821 Definition
754:    * complete for this class and __may__ be implimented in the future
755:    *
756:    * Implements from rfc 821: TURN <CRLF>
757:    *
758:    * SMTP CODE SUCCESS: 250
759:    * SMTP CODE FAILURE: 502
760:    * SMTP CODE ERROR  : 500, 503
761:    * @access public
762:    * @return bool
763:    */
764:   public function Turn() {
765:     $this->error = array("error" => "This method, TURN, of the SMTP ".
766:                                     "is not implemented");
767:     if($this->do_debug >= 1) {
768:       echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF . '<br />';
769:     }
770:     return false;
771:   }
772: 
773:   /**
774:   * Get the current error
775:   * @access public
776:   * @return array
777:   */
778:   public function getError() {
779:     return $this->error;
780:   }
781: 
782:   /////////////////////////////////////////////////
783:   // INTERNAL FUNCTIONS
784:   /////////////////////////////////////////////////
785: 
786:   /**
787:    * Read in as many lines as possible
788:    * either before eof or socket timeout occurs on the operation.
789:    * With SMTP we can tell if we have more lines to read if the
790:    * 4th character is '-' symbol. If it is a space then we don't
791:    * need to read anything else.
792:    * @access private
793:    * @return string
794:    */
795:   private function get_lines() {
796:     $data = "";
797:     while($str = @fgets($this->smtp_conn,515)) {
798:       if($this->do_debug >= 4) {
799:         echo "SMTP -> get_lines(): \$data was \"$data\"" . $this->CRLF . '<br />';
800:         echo "SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '<br />';
801:       }
802:       $data .= $str;
803:       if($this->do_debug >= 4) {
804:         echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '<br />';
805:       }
806:       // if 4th character is a space, we are done reading, break the loop
807:       if(substr($str,3,1) == " ") { break; }
808:     }
809:     return $data;
810:   }
811: 
812: }
813: 
814: ?>