Wordpress 2.8-scripts
[autoinstalls/wordpress.git] / wp-includes / class-smtp.php
1 <?php
2 /*~ class.smtp.php
3 .---------------------------------------------------------------------------.
4 |  Software: PHPMailer - PHP email class                                    |
5 |   Version: 2.0.4                                                          |
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 |    Author: Andy Prevost (project admininistrator)                         |
11 |    Author: Brent R. Matzelle (original founder)                           |
12 | Copyright (c) 2004-2007, Andy Prevost. All Rights Reserved.               |
13 | Copyright (c) 2001-2003, Brent R. Matzelle                                |
14 | ------------------------------------------------------------------------- |
15 |   License: Distributed under the Lesser General Public License (LGPL)     |
16 |            http://www.gnu.org/copyleft/lesser.html                        |
17 | This program is distributed in the hope that it will be useful - WITHOUT  |
18 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |
19 | FITNESS FOR A PARTICULAR PURPOSE.                                         |
20 | ------------------------------------------------------------------------- |
21 | We offer a number of paid services (www.codeworxtech.com):                |
22 | - Web Hosting on highly optimized fast and secure servers                 |
23 | - Technology Consulting                                                   |
24 | - Oursourcing (highly qualified programmers and graphic designers)        |
25 '---------------------------------------------------------------------------'
26  */
27 /**
28  * SMTP is rfc 821 compliant and implements all the rfc 821 SMTP
29  * commands except TURN which will always return a not implemented
30  * error. SMTP also provides some utility methods for sending mail
31  * to an SMTP server.
32  * @package PHPMailer
33  * @author Chris Ryan
34  */
35
36 class SMTP
37 {
38   /**
39    *  SMTP server port
40    *  @var int
41    */
42   var $SMTP_PORT = 25;
43
44   /**
45    *  SMTP reply line ending
46    *  @var string
47    */
48   var $CRLF = "\r\n";
49
50   /**
51    *  Sets whether debugging is turned on
52    *  @var bool
53    */
54   var $do_debug;       # the level of debug to perform
55
56   /**
57    *  Sets VERP use on/off (default is off)
58    *  @var bool
59    */
60   var $do_verp = false;
61
62   /**#@+
63    * @access private
64    */
65   var $smtp_conn;      # the socket to the server
66   var $error;          # error if any on the last call
67   var $helo_rply;      # the reply the server sent to us for HELO
68   /**#@-*/
69
70   /**
71    * Initialize the class so that the data is in a known state.
72    * @access public
73    * @return void
74    */
75   function SMTP() {
76     $this->smtp_conn = 0;
77     $this->error = null;
78     $this->helo_rply = null;
79
80     $this->do_debug = 0;
81   }
82
83   /*************************************************************
84    *                    CONNECTION FUNCTIONS                  *
85    ***********************************************************/
86
87   /**
88    * Connect to the server specified on the port specified.
89    * If the port is not specified use the default SMTP_PORT.
90    * If tval is specified then a connection will try and be
91    * established with the server for that number of seconds.
92    * If tval is not specified the default is 30 seconds to
93    * try on the connection.
94    *
95    * SMTP CODE SUCCESS: 220
96    * SMTP CODE FAILURE: 421
97    * @access public
98    * @return bool
99    */
100   function Connect($host,$port=0,$tval=30) {
101     # set the error val to null so there is no confusion
102     $this->error = null;
103
104     # make sure we are __not__ connected
105     if($this->connected()) {
106       # ok we are connected! what should we do?
107       # for now we will just give an error saying we
108       # are already connected
109       $this->error = array("error" => "Already connected to a server");
110       return false;
111     }
112
113     if(empty($port)) {
114       $port = $this->SMTP_PORT;
115     }
116
117     #connect to the smtp server
118     $this->smtp_conn = fsockopen($host,    # the host of the server
119                                  $port,    # the port to use
120                                  $errno,   # error number if any
121                                  $errstr,  # error message if any
122                                  $tval);   # give up after ? secs
123     # verify we connected properly
124     if(empty($this->smtp_conn)) {
125       $this->error = array("error" => "Failed to connect to server",
126                            "errno" => $errno,
127                            "errstr" => $errstr);
128       if($this->do_debug >= 1) {
129         echo "SMTP -> ERROR: " . $this->error["error"] .
130                  ": $errstr ($errno)" . $this->CRLF;
131       }
132       return false;
133     }
134
135     # sometimes the SMTP server takes a little longer to respond
136     # so we will give it a longer timeout for the first read
137     // Windows still does not have support for this timeout function
138     if(substr(PHP_OS, 0, 3) != "WIN")
139      socket_set_timeout($this->smtp_conn, $tval, 0);
140
141     # get any announcement stuff
142     $announce = $this->get_lines();
143
144     # set the timeout  of any socket functions at 1/10 of a second
145     //if(function_exists("socket_set_timeout"))
146     //   socket_set_timeout($this->smtp_conn, 0, 100000);
147
148     if($this->do_debug >= 2) {
149       echo "SMTP -> FROM SERVER:" . $this->CRLF . $announce;
150     }
151
152     return true;
153   }
154
155   /**
156    * Performs SMTP authentication.  Must be run after running the
157    * Hello() method.  Returns true if successfully authenticated.
158    * @access public
159    * @return bool
160    */
161   function Authenticate($username, $password) {
162     // Start authentication
163     fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);
164
165     $rply = $this->get_lines();
166     $code = substr($rply,0,3);
167
168     if($code != 334) {
169       $this->error =
170         array("error" => "AUTH not accepted from server",
171               "smtp_code" => $code,
172               "smtp_msg" => substr($rply,4));
173       if($this->do_debug >= 1) {
174         echo "SMTP -> ERROR: " . $this->error["error"] .
175                  ": " . $rply . $this->CRLF;
176       }
177       return false;
178     }
179
180     // Send encoded username
181     fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);
182
183     $rply = $this->get_lines();
184     $code = substr($rply,0,3);
185
186     if($code != 334) {
187       $this->error =
188         array("error" => "Username not accepted from server",
189               "smtp_code" => $code,
190               "smtp_msg" => substr($rply,4));
191       if($this->do_debug >= 1) {
192         echo "SMTP -> ERROR: " . $this->error["error"] .
193                  ": " . $rply . $this->CRLF;
194       }
195       return false;
196     }
197
198     // Send encoded password
199     fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);
200
201     $rply = $this->get_lines();
202     $code = substr($rply,0,3);
203
204     if($code != 235) {
205       $this->error =
206         array("error" => "Password not accepted from server",
207               "smtp_code" => $code,
208               "smtp_msg" => substr($rply,4));
209       if($this->do_debug >= 1) {
210         echo "SMTP -> ERROR: " . $this->error["error"] .
211                  ": " . $rply . $this->CRLF;
212       }
213       return false;
214     }
215
216     return true;
217   }
218
219   /**
220    * Returns true if connected to a server otherwise false
221    * @access private
222    * @return bool
223    */
224   function Connected() {
225     if(!empty($this->smtp_conn)) {
226       $sock_status = socket_get_status($this->smtp_conn);
227       if($sock_status["eof"]) {
228         # hmm this is an odd situation... the socket is
229         # valid but we are not connected anymore
230         if($this->do_debug >= 1) {
231             echo "SMTP -> NOTICE:" . $this->CRLF .
232                  "EOF caught while checking if connected";
233         }
234         $this->Close();
235         return false;
236       }
237       return true; # everything looks good
238     }
239     return false;
240   }
241
242   /**
243    * Closes the socket and cleans up the state of the class.
244    * It is not considered good to use this function without
245    * first trying to use QUIT.
246    * @access public
247    * @return void
248    */
249   function Close() {
250     $this->error = null; # so there is no confusion
251     $this->helo_rply = null;
252     if(!empty($this->smtp_conn)) {
253       # close the connection and cleanup
254       fclose($this->smtp_conn);
255       $this->smtp_conn = 0;
256     }
257   }
258
259   /***************************************************************
260    *                        SMTP COMMANDS                       *
261    *************************************************************/
262
263   /**
264    * Issues a data command and sends the msg_data to the server
265    * finializing the mail transaction. $msg_data is the message
266    * that is to be send with the headers. Each header needs to be
267    * on a single line followed by a <CRLF> with the message headers
268    * and the message body being seperated by and additional <CRLF>.
269    *
270    * Implements rfc 821: DATA <CRLF>
271    *
272    * SMTP CODE INTERMEDIATE: 354
273    *     [data]
274    *     <CRLF>.<CRLF>
275    *     SMTP CODE SUCCESS: 250
276    *     SMTP CODE FAILURE: 552,554,451,452
277    * SMTP CODE FAILURE: 451,554
278    * SMTP CODE ERROR  : 500,501,503,421
279    * @access public
280    * @return bool
281    */
282   function Data($msg_data) {
283     $this->error = null; # so no confusion is caused
284
285     if(!$this->connected()) {
286       $this->error = array(
287               "error" => "Called Data() without being connected");
288       return false;
289     }
290
291     fputs($this->smtp_conn,"DATA" . $this->CRLF);
292
293     $rply = $this->get_lines();
294     $code = substr($rply,0,3);
295
296     if($this->do_debug >= 2) {
297       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
298     }
299
300     if($code != 354) {
301       $this->error =
302         array("error" => "DATA command not accepted from server",
303               "smtp_code" => $code,
304               "smtp_msg" => substr($rply,4));
305       if($this->do_debug >= 1) {
306         echo "SMTP -> ERROR: " . $this->error["error"] .
307                  ": " . $rply . $this->CRLF;
308       }
309       return false;
310     }
311
312     # the server is ready to accept data!
313     # according to rfc 821 we should not send more than 1000
314     # including the CRLF
315     # characters on a single line so we will break the data up
316     # into lines by \r and/or \n then if needed we will break
317     # each of those into smaller lines to fit within the limit.
318     # in addition we will be looking for lines that start with
319     # a period '.' and append and additional period '.' to that
320     # line. NOTE: this does not count towards are limit.
321
322     # normalize the line breaks so we know the explode works
323     $msg_data = str_replace("\r\n","\n",$msg_data);
324     $msg_data = str_replace("\r","\n",$msg_data);
325     $lines = explode("\n",$msg_data);
326
327     # we need to find a good way to determine is headers are
328     # in the msg_data or if it is a straight msg body
329     # currently I am assuming rfc 822 definitions of msg headers
330     # and if the first field of the first line (':' sperated)
331     # does not contain a space then it _should_ be a header
332     # and we can process all lines before a blank "" line as
333     # headers.
334     $field = substr($lines[0],0,strpos($lines[0],":"));
335     $in_headers = false;
336     if(!empty($field) && !strstr($field," ")) {
337       $in_headers = true;
338     }
339
340     $max_line_length = 998; # used below; set here for ease in change
341
342     while(list(,$line) = @each($lines)) {
343       $lines_out = null;
344       if($line == "" && $in_headers) {
345         $in_headers = false;
346       }
347       # ok we need to break this line up into several
348       # smaller lines
349       while(strlen($line) > $max_line_length) {
350         $pos = strrpos(substr($line,0,$max_line_length)," ");
351
352         # Patch to fix DOS attack
353         if(!$pos) {
354           $pos = $max_line_length - 1;
355         }
356
357         $lines_out[] = substr($line,0,$pos);
358         $line = substr($line,$pos + 1);
359         # if we are processing headers we need to
360         # add a LWSP-char to the front of the new line
361         # rfc 822 on long msg headers
362         if($in_headers) {
363           $line = "\t" . $line;
364         }
365       }
366       $lines_out[] = $line;
367
368       # now send the lines to the server
369       while(list(,$line_out) = @each($lines_out)) {
370         if(strlen($line_out) > 0)
371         {
372           if(substr($line_out, 0, 1) == ".") {
373             $line_out = "." . $line_out;
374           }
375         }
376         fputs($this->smtp_conn,$line_out . $this->CRLF);
377       }
378     }
379
380     # ok all the message data has been sent so lets get this
381     # over with aleady
382     fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);
383
384     $rply = $this->get_lines();
385     $code = substr($rply,0,3);
386
387     if($this->do_debug >= 2) {
388       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
389     }
390
391     if($code != 250) {
392       $this->error =
393         array("error" => "DATA not accepted from server",
394               "smtp_code" => $code,
395               "smtp_msg" => substr($rply,4));
396       if($this->do_debug >= 1) {
397         echo "SMTP -> ERROR: " . $this->error["error"] .
398                  ": " . $rply . $this->CRLF;
399       }
400       return false;
401     }
402     return true;
403   }
404
405   /**
406    * Expand takes the name and asks the server to list all the
407    * people who are members of the _list_. Expand will return
408    * back and array of the result or false if an error occurs.
409    * Each value in the array returned has the format of:
410    *     [ <full-name> <sp> ] <path>
411    * The definition of <path> is defined in rfc 821
412    *
413    * Implements rfc 821: EXPN <SP> <string> <CRLF>
414    *
415    * SMTP CODE SUCCESS: 250
416    * SMTP CODE FAILURE: 550
417    * SMTP CODE ERROR  : 500,501,502,504,421
418    * @access public
419    * @return string array
420    */
421   function Expand($name) {
422     $this->error = null; # so no confusion is caused
423
424     if(!$this->connected()) {
425       $this->error = array(
426             "error" => "Called Expand() without being connected");
427       return false;
428     }
429
430     fputs($this->smtp_conn,"EXPN " . $name . $this->CRLF);
431
432     $rply = $this->get_lines();
433     $code = substr($rply,0,3);
434
435     if($this->do_debug >= 2) {
436       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
437     }
438
439     if($code != 250) {
440       $this->error =
441         array("error" => "EXPN not accepted from server",
442               "smtp_code" => $code,
443               "smtp_msg" => substr($rply,4));
444       if($this->do_debug >= 1) {
445         echo "SMTP -> ERROR: " . $this->error["error"] .
446                  ": " . $rply . $this->CRLF;
447       }
448       return false;
449     }
450
451     # parse the reply and place in our array to return to user
452     $entries = explode($this->CRLF,$rply);
453     while(list(,$l) = @each($entries)) {
454       $list[] = substr($l,4);
455     }
456
457     return $list;
458   }
459
460   /**
461    * Sends the HELO command to the smtp server.
462    * This makes sure that we and the server are in
463    * the same known state.
464    *
465    * Implements from rfc 821: HELO <SP> <domain> <CRLF>
466    *
467    * SMTP CODE SUCCESS: 250
468    * SMTP CODE ERROR  : 500, 501, 504, 421
469    * @access public
470    * @return bool
471    */
472   function Hello($host="") {
473     $this->error = null; # so no confusion is caused
474
475     if(!$this->connected()) {
476       $this->error = array(
477             "error" => "Called Hello() without being connected");
478       return false;
479     }
480
481     # if a hostname for the HELO was not specified determine
482     # a suitable one to send
483     if(empty($host)) {
484       # we need to determine some sort of appopiate default
485       # to send to the server
486       $host = "localhost";
487     }
488
489     // Send extended hello first (RFC 2821)
490     if(!$this->SendHello("EHLO", $host))
491     {
492       if(!$this->SendHello("HELO", $host))
493           return false;
494     }
495
496     return true;
497   }
498
499   /**
500    * Sends a HELO/EHLO command.
501    * @access private
502    * @return bool
503    */
504   function SendHello($hello, $host) {
505     fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF);
506
507     $rply = $this->get_lines();
508     $code = substr($rply,0,3);
509
510     if($this->do_debug >= 2) {
511       echo "SMTP -> FROM SERVER: " . $this->CRLF . $rply;
512     }
513
514     if($code != 250) {
515       $this->error =
516         array("error" => $hello . " not accepted from server",
517               "smtp_code" => $code,
518               "smtp_msg" => substr($rply,4));
519       if($this->do_debug >= 1) {
520         echo "SMTP -> ERROR: " . $this->error["error"] .
521                  ": " . $rply . $this->CRLF;
522       }
523       return false;
524     }
525
526     $this->helo_rply = $rply;
527
528     return true;
529   }
530
531   /**
532    * Gets help information on the keyword specified. If the keyword
533    * is not specified then returns generic help, ussually contianing
534    * A list of keywords that help is available on. This function
535    * returns the results back to the user. It is up to the user to
536    * handle the returned data. If an error occurs then false is
537    * returned with $this->error set appropiately.
538    *
539    * Implements rfc 821: HELP [ <SP> <string> ] <CRLF>
540    *
541    * SMTP CODE SUCCESS: 211,214
542    * SMTP CODE ERROR  : 500,501,502,504,421
543    * @access public
544    * @return string
545    */
546   function Help($keyword="") {
547     $this->error = null; # to avoid confusion
548
549     if(!$this->connected()) {
550       $this->error = array(
551               "error" => "Called Help() without being connected");
552       return false;
553     }
554
555     $extra = "";
556     if(!empty($keyword)) {
557       $extra = " " . $keyword;
558     }
559
560     fputs($this->smtp_conn,"HELP" . $extra . $this->CRLF);
561
562     $rply = $this->get_lines();
563     $code = substr($rply,0,3);
564
565     if($this->do_debug >= 2) {
566       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
567     }
568
569     if($code != 211 && $code != 214) {
570       $this->error =
571         array("error" => "HELP not accepted from server",
572               "smtp_code" => $code,
573               "smtp_msg" => substr($rply,4));
574       if($this->do_debug >= 1) {
575         echo "SMTP -> ERROR: " . $this->error["error"] .
576                  ": " . $rply . $this->CRLF;
577       }
578       return false;
579     }
580
581     return $rply;
582   }
583
584   /**
585    * Starts a mail transaction from the email address specified in
586    * $from. Returns true if successful or false otherwise. If True
587    * the mail transaction is started and then one or more Recipient
588    * commands may be called followed by a Data command.
589    *
590    * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
591    *
592    * SMTP CODE SUCCESS: 250
593    * SMTP CODE SUCCESS: 552,451,452
594    * SMTP CODE SUCCESS: 500,501,421
595    * @access public
596    * @return bool
597    */
598   function Mail($from) {
599     $this->error = null; # so no confusion is caused
600
601     if(!$this->connected()) {
602       $this->error = array(
603               "error" => "Called Mail() without being connected");
604       return false;
605     }
606
607     $useVerp = ($this->do_verp ? "XVERP" : "");
608     fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $useVerp . $this->CRLF);
609
610     $rply = $this->get_lines();
611     $code = substr($rply,0,3);
612
613     if($this->do_debug >= 2) {
614       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
615     }
616
617     if($code != 250) {
618       $this->error =
619         array("error" => "MAIL not accepted from server",
620               "smtp_code" => $code,
621               "smtp_msg" => substr($rply,4));
622       if($this->do_debug >= 1) {
623         echo "SMTP -> ERROR: " . $this->error["error"] .
624                  ": " . $rply . $this->CRLF;
625       }
626       return false;
627     }
628     return true;
629   }
630
631   /**
632    * Sends the command NOOP to the SMTP server.
633    *
634    * Implements from rfc 821: NOOP <CRLF>
635    *
636    * SMTP CODE SUCCESS: 250
637    * SMTP CODE ERROR  : 500, 421
638    * @access public
639    * @return bool
640    */
641   function Noop() {
642     $this->error = null; # so no confusion is caused
643
644     if(!$this->connected()) {
645       $this->error = array(
646               "error" => "Called Noop() without being connected");
647       return false;
648     }
649
650     fputs($this->smtp_conn,"NOOP" . $this->CRLF);
651
652     $rply = $this->get_lines();
653     $code = substr($rply,0,3);
654
655     if($this->do_debug >= 2) {
656       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
657     }
658
659     if($code != 250) {
660       $this->error =
661         array("error" => "NOOP not accepted from server",
662               "smtp_code" => $code,
663               "smtp_msg" => substr($rply,4));
664       if($this->do_debug >= 1) {
665         echo "SMTP -> ERROR: " . $this->error["error"] .
666                  ": " . $rply . $this->CRLF;
667       }
668       return false;
669     }
670     return true;
671   }
672
673   /**
674    * Sends the quit command to the server and then closes the socket
675    * if there is no error or the $close_on_error argument is true.
676    *
677    * Implements from rfc 821: QUIT <CRLF>
678    *
679    * SMTP CODE SUCCESS: 221
680    * SMTP CODE ERROR  : 500
681    * @access public
682    * @return bool
683    */
684   function Quit($close_on_error=true) {
685     $this->error = null; # so there is no confusion
686
687     if(!$this->connected()) {
688       $this->error = array(
689               "error" => "Called Quit() without being connected");
690       return false;
691     }
692
693     # send the quit command to the server
694     fputs($this->smtp_conn,"quit" . $this->CRLF);
695
696     # get any good-bye messages
697     $byemsg = $this->get_lines();
698
699     if($this->do_debug >= 2) {
700       echo "SMTP -> FROM SERVER:" . $this->CRLF . $byemsg;
701     }
702
703     $rval = true;
704     $e = null;
705
706     $code = substr($byemsg,0,3);
707     if($code != 221) {
708       # use e as a tmp var cause Close will overwrite $this->error
709       $e = array("error" => "SMTP server rejected quit command",
710                  "smtp_code" => $code,
711                  "smtp_rply" => substr($byemsg,4));
712       $rval = false;
713       if($this->do_debug >= 1) {
714         echo "SMTP -> ERROR: " . $e["error"] . ": " .
715                  $byemsg . $this->CRLF;
716       }
717     }
718
719     if(empty($e) || $close_on_error) {
720       $this->Close();
721     }
722
723     return $rval;
724   }
725
726   /**
727    * Sends the command RCPT to the SMTP server with the TO: argument of $to.
728    * Returns true if the recipient was accepted false if it was rejected.
729    *
730    * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
731    *
732    * SMTP CODE SUCCESS: 250,251
733    * SMTP CODE FAILURE: 550,551,552,553,450,451,452
734    * SMTP CODE ERROR  : 500,501,503,421
735    * @access public
736    * @return bool
737    */
738   function Recipient($to) {
739     $this->error = null; # so no confusion is caused
740
741     if(!$this->connected()) {
742       $this->error = array(
743               "error" => "Called Recipient() without being connected");
744       return false;
745     }
746
747     fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF);
748
749     $rply = $this->get_lines();
750     $code = substr($rply,0,3);
751
752     if($this->do_debug >= 2) {
753       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
754     }
755
756     if($code != 250 && $code != 251) {
757       $this->error =
758         array("error" => "RCPT not accepted from server",
759               "smtp_code" => $code,
760               "smtp_msg" => substr($rply,4));
761       if($this->do_debug >= 1) {
762         echo "SMTP -> ERROR: " . $this->error["error"] .
763                  ": " . $rply . $this->CRLF;
764       }
765       return false;
766     }
767     return true;
768   }
769
770   /**
771    * Sends the RSET command to abort and transaction that is
772    * currently in progress. Returns true if successful false
773    * otherwise.
774    *
775    * Implements rfc 821: RSET <CRLF>
776    *
777    * SMTP CODE SUCCESS: 250
778    * SMTP CODE ERROR  : 500,501,504,421
779    * @access public
780    * @return bool
781    */
782   function Reset() {
783     $this->error = null; # so no confusion is caused
784
785     if(!$this->connected()) {
786       $this->error = array(
787               "error" => "Called Reset() without being connected");
788       return false;
789     }
790
791     fputs($this->smtp_conn,"RSET" . $this->CRLF);
792
793     $rply = $this->get_lines();
794     $code = substr($rply,0,3);
795
796     if($this->do_debug >= 2) {
797       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
798     }
799
800     if($code != 250) {
801       $this->error =
802         array("error" => "RSET failed",
803               "smtp_code" => $code,
804               "smtp_msg" => substr($rply,4));
805       if($this->do_debug >= 1) {
806         echo "SMTP -> ERROR: " . $this->error["error"] .
807                  ": " . $rply . $this->CRLF;
808       }
809       return false;
810     }
811
812     return true;
813   }
814
815   /**
816    * Starts a mail transaction from the email address specified in
817    * $from. Returns true if successful or false otherwise. If True
818    * the mail transaction is started and then one or more Recipient
819    * commands may be called followed by a Data command. This command
820    * will send the message to the users terminal if they are logged
821    * in.
822    *
823    * Implements rfc 821: SEND <SP> FROM:<reverse-path> <CRLF>
824    *
825    * SMTP CODE SUCCESS: 250
826    * SMTP CODE SUCCESS: 552,451,452
827    * SMTP CODE SUCCESS: 500,501,502,421
828    * @access public
829    * @return bool
830    */
831   function Send($from) {
832     $this->error = null; # so no confusion is caused
833
834     if(!$this->connected()) {
835       $this->error = array(
836               "error" => "Called Send() without being connected");
837       return false;
838     }
839
840     fputs($this->smtp_conn,"SEND FROM:" . $from . $this->CRLF);
841
842     $rply = $this->get_lines();
843     $code = substr($rply,0,3);
844
845     if($this->do_debug >= 2) {
846       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
847     }
848
849     if($code != 250) {
850       $this->error =
851         array("error" => "SEND not accepted from server",
852               "smtp_code" => $code,
853               "smtp_msg" => substr($rply,4));
854       if($this->do_debug >= 1) {
855         echo "SMTP -> ERROR: " . $this->error["error"] .
856                  ": " . $rply . $this->CRLF;
857       }
858       return false;
859     }
860     return true;
861   }
862
863   /**
864    * Starts a mail transaction from the email address specified in
865    * $from. Returns true if successful or false otherwise. If True
866    * the mail transaction is started and then one or more Recipient
867    * commands may be called followed by a Data command. This command
868    * will send the message to the users terminal if they are logged
869    * in and send them an email.
870    *
871    * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
872    *
873    * SMTP CODE SUCCESS: 250
874    * SMTP CODE SUCCESS: 552,451,452
875    * SMTP CODE SUCCESS: 500,501,502,421
876    * @access public
877    * @return bool
878    */
879   function SendAndMail($from) {
880     $this->error = null; # so no confusion is caused
881
882     if(!$this->connected()) {
883       $this->error = array(
884           "error" => "Called SendAndMail() without being connected");
885       return false;
886     }
887
888     fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);
889
890     $rply = $this->get_lines();
891     $code = substr($rply,0,3);
892
893     if($this->do_debug >= 2) {
894       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
895     }
896
897     if($code != 250) {
898       $this->error =
899         array("error" => "SAML not accepted from server",
900               "smtp_code" => $code,
901               "smtp_msg" => substr($rply,4));
902       if($this->do_debug >= 1) {
903         echo "SMTP -> ERROR: " . $this->error["error"] .
904                  ": " . $rply . $this->CRLF;
905       }
906       return false;
907     }
908     return true;
909   }
910
911   /**
912    * Starts a mail transaction from the email address specified in
913    * $from. Returns true if successful or false otherwise. If True
914    * the mail transaction is started and then one or more Recipient
915    * commands may be called followed by a Data command. This command
916    * will send the message to the users terminal if they are logged
917    * in or mail it to them if they are not.
918    *
919    * Implements rfc 821: SOML <SP> FROM:<reverse-path> <CRLF>
920    *
921    * SMTP CODE SUCCESS: 250
922    * SMTP CODE SUCCESS: 552,451,452
923    * SMTP CODE SUCCESS: 500,501,502,421
924    * @access public
925    * @return bool
926    */
927   function SendOrMail($from) {
928     $this->error = null; # so no confusion is caused
929
930     if(!$this->connected()) {
931       $this->error = array(
932           "error" => "Called SendOrMail() without being connected");
933       return false;
934     }
935
936     fputs($this->smtp_conn,"SOML FROM:" . $from . $this->CRLF);
937
938     $rply = $this->get_lines();
939     $code = substr($rply,0,3);
940
941     if($this->do_debug >= 2) {
942       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
943     }
944
945     if($code != 250) {
946       $this->error =
947         array("error" => "SOML not accepted from server",
948               "smtp_code" => $code,
949               "smtp_msg" => substr($rply,4));
950       if($this->do_debug >= 1) {
951         echo "SMTP -> ERROR: " . $this->error["error"] .
952                  ": " . $rply . $this->CRLF;
953       }
954       return false;
955     }
956     return true;
957   }
958
959   /**
960    * This is an optional command for SMTP that this class does not
961    * support. This method is here to make the RFC821 Definition
962    * complete for this class and __may__ be implimented in the future
963    *
964    * Implements from rfc 821: TURN <CRLF>
965    *
966    * SMTP CODE SUCCESS: 250
967    * SMTP CODE FAILURE: 502
968    * SMTP CODE ERROR  : 500, 503
969    * @access public
970    * @return bool
971    */
972   function Turn() {
973     $this->error = array("error" => "This method, TURN, of the SMTP ".
974                                     "is not implemented");
975     if($this->do_debug >= 1) {
976       echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF;
977     }
978     return false;
979   }
980
981   /**
982    * Verifies that the name is recognized by the server.
983    * Returns false if the name could not be verified otherwise
984    * the response from the server is returned.
985    *
986    * Implements rfc 821: VRFY <SP> <string> <CRLF>
987    *
988    * SMTP CODE SUCCESS: 250,251
989    * SMTP CODE FAILURE: 550,551,553
990    * SMTP CODE ERROR  : 500,501,502,421
991    * @access public
992    * @return int
993    */
994   function Verify($name) {
995     $this->error = null; # so no confusion is caused
996
997     if(!$this->connected()) {
998       $this->error = array(
999               "error" => "Called Verify() without being connected");
1000       return false;
1001     }
1002
1003     fputs($this->smtp_conn,"VRFY " . $name . $this->CRLF);
1004
1005     $rply = $this->get_lines();
1006     $code = substr($rply,0,3);
1007
1008     if($this->do_debug >= 2) {
1009       echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
1010     }
1011
1012     if($code != 250 && $code != 251) {
1013       $this->error =
1014         array("error" => "VRFY failed on name '$name'",
1015               "smtp_code" => $code,
1016               "smtp_msg" => substr($rply,4));
1017       if($this->do_debug >= 1) {
1018         echo "SMTP -> ERROR: " . $this->error["error"] .
1019                  ": " . $rply . $this->CRLF;
1020       }
1021       return false;
1022     }
1023     return $rply;
1024   }
1025
1026   /*******************************************************************
1027    *                       INTERNAL FUNCTIONS                       *
1028    ******************************************************************/
1029
1030   /**
1031    * Read in as many lines as possible
1032    * either before eof or socket timeout occurs on the operation.
1033    * With SMTP we can tell if we have more lines to read if the
1034    * 4th character is '-' symbol. If it is a space then we don't
1035    * need to read anything else.
1036    * @access private
1037    * @return string
1038    */
1039   function get_lines() {
1040     $data = "";
1041     while($str = @fgets($this->smtp_conn,515)) {
1042       if($this->do_debug >= 4) {
1043         echo "SMTP -> get_lines(): \$data was \"$data\"" .
1044                  $this->CRLF;
1045         echo "SMTP -> get_lines(): \$str is \"$str\"" .
1046                  $this->CRLF;
1047       }
1048       $data .= $str;
1049       if($this->do_debug >= 4) {
1050         echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF;
1051       }
1052       # if the 4th character is a space then we are done reading
1053       # so just break the loop
1054       if(substr($str,3,1) == " ") { break; }
1055     }
1056     return $data;
1057   }
1058
1059 }
1060
1061
1062  ?>