wwwroot/inc/phpmailer/class.smtp.php

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