string get_lines ( )

/**
 * Read in as many lines as possible
 * either before eof or socket timeout occurs on the operation.
 * With SMTP we can tell if we have more lines to read if the
 * 4th character is '-' symbol. If it is a space then we don't
 * need to read anything else.
 * @access private
 * @return string
 */
function get_lines() {
    $data = "";
    while($str = @fgets($this->smtp_conn,515)) {
        if($this->do_debug >= 4) {
            echo "-------------------" .
            $this->CRLF;
            echo "SMTP -> get_lines(): \$data was \"$data\"" .
            $this->CRLF;
            echo "SMTP -> get_lines(): \$str is \"$str\"" .
            $this->CRLF;
        }
        $data .= $str;
        if($this->do_debug >= 4) {
            echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF;
        }
        // if the 4th character is a space then we are done reading
        // so just break the loop
        if(substr($str,3,1) == " ") { break; }
    }
    return $data;
}

　　如果服务器返回的数据是以三位状态码开头，接着一个空格的格式，该函数只返回第一行。

　　至此，这个PHP SMTP类就分析完了，它完整地实现了SMTP协议的功能，除了 TURN 命令之外。所有输入的内容都必须符合 RFC 821 协议，这就需要使用者在调用函数之前对数据进行符合协议的格式化。

　　然而，戒烟如你只需要使用SMTP邮件功能，显然这个类有点复杂了，暂时记录在这里，以后再用吧。

　　另外，附加一个 RFC 821 协议的中文文本：rfc821.txt ，备查。

　　Turn ( ) 在这个类里实际上是不支持的，使用它只会返回一个错误，该函数定义在这里只是为了体现这是一个完整的SMTP类。

/**
 * This is an optional command for SMTP that this class does not
 * support. This method is here to make the RFC821 Definition
 * complete for this class and __may__ be implimented in the future
 *
 * Implements from rfc 821: TURN <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE FAILURE: 502
 * SMTP CODE ERROR  : 500, 503
 * @access public
 * @return bool
 */
function Turn() {
    $this->error = array("error" => "This method, TURN, of the SMTP ".
    "is not implemented");
    if($this->do_debug >= 1) {
        echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF;
    }
    return false;
}

　　string | bool Verify ( string $name )　该函数用于验证给定的用户名 $name 是否为SMTP服务器的用户，如果是，则返回服务器应答的信息，否则返回 false 。

/**
 * Verifies that the name is recognized by the server.
 * Returns false if the name could not be verified otherwise
 * the response from the server is returned.
 *
 * Implements rfc 821: VRFY <SP> <string> <CRLF>
 *
 * SMTP CODE SUCCESS: 250,251
 * SMTP CODE FAILURE: 550,551,553
 * SMTP CODE ERROR  : 500,501,502,421
 * @access public
 * @return int
 */
function Verify($name) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Verify() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"VRFY " . $name . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250 && $code != 251) {
        $this->error =
        array("error" => "VRFY failed on name '$name'",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return $rply;
}

　　Send ( ) 用于开始一个发送命令，将邮件发送到一个或多个终端上。

　　SendAndMail ( ) 用于开始一个邮件操作将邮件内容传送到一个或多个终端上，并传送到邮箱中。

　　SendOrMail ( ) 用于开始一个邮件操作将邮件内容传送到一个或多个终端上，或者传送到邮箱中。

　　三个函数传入的参数都是 string $from ，标识回复路径，执行成功返回的标识码都是 250 。

　　bool Send ( string $from )

/**
 * Starts a mail transaction from the email address specified in
 * $from. Returns true if successful or false otherwise. If True
 * the mail transaction is started and then one or more Recipient
 * commands may be called followed by a Data command. This command
 * will send the message to the users terminal if they are logged
 * in.
 *
 * Implements rfc 821: SEND <SP> FROM:<reverse-path> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE SUCCESS: 552,451,452
 * SMTP CODE SUCCESS: 500,501,502,421
 * @access public
 * @return bool
 */
function Send($from) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Send() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"SEND FROM:" . $from . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "SEND not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　bool SendAndMail ( string $from )

/**
 * Starts a mail transaction from the email address specified in
 * $from. Returns true if successful or false otherwise. If True
 * the mail transaction is started and then one or more Recipient
 * commands may be called followed by a Data command. This command
 * will send the message to the users terminal if they are logged
 * in and send them an email.
 *
 * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE SUCCESS: 552,451,452
 * SMTP CODE SUCCESS: 500,501,502,421
 * @access public
 * @return bool
 */
function SendAndMail($from) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called SendAndMail() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "SAML not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　bool SendOrMail ( string $from )

/**
 * Starts a mail transaction from the email address specified in
 * $from. Returns true if successful or false otherwise. If True
 * the mail transaction is started and then one or more Recipient
 * commands may be called followed by a Data command. This command
 * will send the message to the users terminal if they are logged
 * in or mail it to them if they are not.
 *
 * Implements rfc 821: SOML <SP> FROM:<reverse-path> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE SUCCESS: 552,451,452
 * SMTP CODE SUCCESS: 500,501,502,421
 * @access public
 * @return bool
 */
function SendOrMail($from) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called SendOrMail() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"SOML FROM:" . $from . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "SOML not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　这三个函数都不复杂，发送相应的SMTP命令，接受返回的代码，如果是失败代码，将错误信息设置到 $error 中，返回 false ，否则返回 true 。

　　bool Quit ( bool $close_on_error = true )

　　这里传入的参数 $close_on_error 如果为 true ，即使发送 QUIT 命令返回失败，也调用 Close ( ) 断开与SMTP服务器的连接；如果为 false ，QUIT 命令成功则调用 Close ( ) 断开连接，失败则返回错误信息，不断开连接。

/**
 * Sends the quit command to the server and then closes the socket
 * if there is no error or the $close_on_error argument is true.
 *
 * Implements from rfc 821: QUIT <CRLF>
 *
 * SMTP CODE SUCCESS: 221
 * SMTP CODE ERROR  : 500
 * @access public
 * @return bool
 */
function Quit($close_on_error=true) {
    $this->error = null; // so there is no confusion

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Quit() without being connected");
        return false;
    }

    // send the quit command to the server
    fputs($this->smtp_conn,"quit" . $this->CRLF);

    // get any good-bye messages
    $byemsg = $this->get_lines();

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $byemsg;
    }

    $rval = true;
    $e = null;

    $code = substr($byemsg,0,3);
    if($code != 221) {
        // use e as a tmp var cause Close will overwrite $this->error
        $e = array("error" => "SMTP server rejected quit command",
        "smtp_code" => $code,
        "smtp_rply" => substr($byemsg,4));
        $rval = false;
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $e["error"] . ": " .
            $byemsg . $this->CRLF;
        }
    }

    if(empty($e) || $close_on_error) {
        $this->Close();
    }

    return $rval;
}

　　bool Recipient ( string $to )　把收件人 $to 用 RCPT <SP> TO 命令发送到SMTP服务器。

/**
 * Sends the command RCPT to the SMTP server with the TO: argument of $to.
 * Returns true if the recipient was accepted false if it was rejected.
 *
 * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
 *
 * SMTP CODE SUCCESS: 250,251
 * SMTP CODE FAILURE: 550,551,552,553,450,451,452
 * SMTP CODE ERROR  : 500,501,503,421
 * @access public
 * @return bool
 */
function Recipient($to) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Recipient() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250 && $code != 251) {
        $this->error =
        array("error" => "RCPT not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　bool Reset ( )　发送 RSET 命令中止当前连接的传输，重置会话。

/**
 * Sends the RSET command to abort and transaction that is
 * currently in progress. Returns true if successful false
 * otherwise.
 *
 * Implements rfc 821: RSET <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE ERROR  : 500,501,504,421
 * @access public
 * @return bool
 */
function Reset() {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Reset() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"RSET" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "RSET failed",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    return true;
}

　　bool | string Help ( $keyword = "" )

　　如果定义了 $keyword ，则获取该命令的帮助信息；如果没有定义，则返回通用帮助，通常包含一个支持的命令列表。该函数将结果返回给用户，由用户自行处理返回的数据。如果有错误发生（即SMTP服务器返回的状态码不是 211 或 214 ），则将错误信息返回到 $error 中。

/**
 * Gets help information on the keyword specified. If the keyword
 * is not specified then returns generic help, ussually contianing
 * A list of keywords that help is available on. This function
 * returns the results back to the user. It is up to the user to
 * handle the returned data. If an error occurs then false is
 * returned with $this->error set appropiately.
 *
 * Implements rfc 821: HELP [ <SP> <string> ] <CRLF>
 *
 * SMTP CODE SUCCESS: 211,214
 * SMTP CODE ERROR  : 500,501,502,504,421
 * @access public
 * @return string
 */
function Help($keyword="") {
    $this->error = null; // to avoid confusion

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Help() without being connected");
        return false;
    }

    $extra = "";
    if(!empty($keyword)) {
        $extra = " " . $keyword;
    }

    fputs($this->smtp_conn,"HELP" . $extra . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 211 && $code != 214) {
        $this->error =
        array("error" => "HELP not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    return $rply;
}

　　bool Mail ( string $from )

　　以指定的邮件地址 $from 开始一个邮件会话，成功返回 true ，失败则返回 false 。如果返回 true ，邮件会话建立成功，就可以发送一个或多个收件人命令，继而是 DATA 命令。

　　在 RFC 821 中，该命令为： MAIL <SP> FROM: <reverse-path> <CRLF>

/**
 * Starts a mail transaction from the email address specified in
 * $from. Returns true if successful or false otherwise. If True
 * the mail transaction is started and then one or more Recipient
 * commands may be called followed by a Data command.
 *
 * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE SUCCESS: 552,451,452
 * SMTP CODE SUCCESS: 500,501,421
 * @access public
 * @return bool
 */
function Mail($from) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Mail() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "MAIL not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　首先重置 $error 为空，调用 connected ( ) 函数检查是否已经与SMTP服务器建立连接，如果没有建立，设置 $error 为“Called Mail() without being connected”，并返回 false 。

　　如果SMTP服务器对 MAIL 命令返回的状态码不是 250 ，则将 $error 设置为“MAIL not accepted from server”，并返回 false ；否则返回 true 。

　　bool Noop ( )　这个函数很简单了，就是发送 NOOP 命令给SMTP服务器，告诉它目前没有任何操作。代码如下：

/**
 * Sends the command NOOP to the SMTP server.
 *
 * Implements from rfc 821: NOOP <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE ERROR  : 500, 421
 * @access public
 * @return bool
 */
function Noop() {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Noop() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"NOOP" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "NOOP not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　bool | array Expand ( string $name )

　　该函数发送一个邮箱列表的名称 $name 给SMTP服务器，请求服务器给出该列表中成员。成功的话会返回结果数组，失败则返回 false 。返回数组中值的格式为 [ <full-name> <sp> ] <path> 。 <path> 的定义在 RFC 821 中给定。在 RFC 821 中，该命令为： EXPN <SP> <string> <CRLF>

/**
 * Expand takes the name and asks the server to list all the
 * people who are members of the _list_. Expand will return
 * back and array of the result or false if an error occurs.
 * Each value in the array returned has the format of:
 *     [ <full-name> <sp> ] <path>
 * The definition of <path> is defined in rfc 821
 *
 * Implements rfc 821: EXPN <SP> <string> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE FAILURE: 550
 * SMTP CODE ERROR  : 500,501,502,504,421
 * @access public
 * @return string array
 */
function Expand($name) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Expand() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"EXPN " . $name . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "EXPN not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    // parse the reply and place in our array to return to user
    $entries = explode($this->CRLF,$rply);
    while(list(,$l) = @each($entries)) {
        $list[] = substr($l,4);
    }

    return $list;
}

　　首先重置 $error 为空，调用 connected ( ) 函数检查是否已经与SMTP服务器建立连接，如果没有建立，设置 $error 为“Called Expand() without being connected”，并返回 false 。

　　如果服务器返回的状态码不是 250 ，则将 $error 设置为“EXPN not accepted from server”，并返回 false ；否则对返回的数据进行整理，以数组 $list 返回。

　　bool Hello ( $host = "" )

　　向SMTP服务器发送 HELO 命令，确认双方都处于一个已知的状态。在 RFC 821 中，该命令为： HELO <SP> <domain> <CRLF>

/**
 * Sends the HELO command to the smtp server.
 * This makes sure that we and the server are in
 * the same known state.
 *
 * Implements from rfc 821: HELO <SP> <domain> <CRLF>
 *
 * SMTP CODE SUCCESS: 250
 * SMTP CODE ERROR  : 500, 501, 504, 421
 * @access public
 * @return bool
 */
function Hello($host="") {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Hello() without being connected");
        return false;
    }

    // if a hostname for the HELO wasn't specified determine
    // a suitable one to send
    if(empty($host)) {
        # we need to determine some sort of appopiate default
        # to send to the server
        $host = "localhost";
    }

    // Send extended hello first (RFC 2821)
    if(!$this->SendHello("EHLO", $host))
    {
        if(!$this->SendHello("HELO", $host))
        return false;
    }

    return true;
}

　　先重置 $error 为空，调用 connected ( ) 函数检查是否已经与SMTP服务器建立连接，如果没有建立，设置 $error 为“Called Hello() without being connected”，并返回 false 。

　　如果主机名 $host 为空，则使用默认的“localhost”，依次尝试使用 EHLO 和 HELO 调用私有函数 SendHello ( ) 发送命令，成功则返回 true ，失败则返回 false 。

　　bool SendHello ( string $hello , string $host )

　　这是一个私有方法，用于发送 HELO/EHLO 命令给SMTP服务器。

/**
 * Sends a HELO/EHLO command.
 * @access private
 * @return bool
 */
function SendHello($hello, $host) {
    fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER: " . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => $hello . " not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    $this->helo_rply = $rply;

    return true;
}

　　如果服务器返回的状态码不是 250 ，则将 $error 设置为“HELO not accepted from server”，并返回 false 。

　　bool Data ( string $msg_data )

　　发送一个 DATA 命令和 $msg_date 到SMTP服务器进行邮件传输。 $msg_date 是一个连同消息头在一起发送的信息。每一个消息头需要由 <CRLF> 为结尾的单独一行，消息头和信息体也需要添加 <CRLF> 分开。

/**
 * Issues a data command and sends the msg_data to the server
 * finializing the mail transaction. $msg_data is the message
 * that is to be send with the headers. Each header needs to be
 * on a single line followed by a <CRLF> with the message headers
 * and the message body being seperated by and additional <CRLF>.
 *
 * Implements rfc 821: DATA <CRLF>
 *
 * SMTP CODE INTERMEDIATE: 354
 *     [data]
 *     <CRLF>.<CRLF>
 *     SMTP CODE SUCCESS: 250
 *     SMTP CODE FAILURE: 552,554,451,452
 * SMTP CODE FAILURE: 451,554
 * SMTP CODE ERROR  : 500,501,503,421
 * @access public
 * @return bool
 */
function Data($msg_data) {
    $this->error = null; // so no confusion is caused

    if(!$this->connected()) {
        $this->error = array(
        "error" => "Called Data() without being connected");
        return false;
    }

    fputs($this->smtp_conn,"DATA" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 354) {
        $this->error =
        array("error" => "DATA command not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    // the server is ready to accept data!
    // according to rfc 821 we should not send more than 1000
    // including the CRLF
    // characters on a single line so we will break the data up
    // into lines by \r and/or \n then if needed we will break
    // each of those into smaller lines to fit within the limit.
    // in addition we will be looking for lines that start with
    // a period '.' and append and additional period '.' to that
    // line. NOTE: this does not count towards are limit.

    // normalize the line breaks so we know the explode works
    $msg_data = str_replace("\r\n","\n",$msg_data);
    $msg_data = str_replace("\r","\n",$msg_data);
    $lines = explode("\n",$msg_data);

    // we need to find a good way to determine is headers are
    // in the msg_data or if it is a straight msg body
    // currently I'm assuming rfc 822 definitions of msg headers
    // and if the first field of the first line (':' sperated)
    // does not contain a space then it _should_ be a header
    // and we can process all lines before a blank "" line as
    // headers.
    $field = substr($lines[0],0,strpos($lines[0],":"));
    $in_headers = false;
    if(!empty($field) && !strstr($field," ")) {
        $in_headers = true;
    }

    $max_line_length = 998; // used below; set here for ease in change

    while(list(,$line) = @each($lines)) {
        $lines_out = null;
        if($line == "" && $in_headers) {
            $in_headers = false;
        }
        // ok we need to break this line up into several
        // smaller lines
        while(strlen($line) > $max_line_length) {
            $pos = strrpos(substr($line,0,$max_line_length)," ");

            // Patch to fix DOS attack
            if(!$pos) {
                $pos = $max_line_length - 1;
            }

            $lines_out[] = substr($line,0,$pos);
            $line = substr($line,$pos + 1);
            // if we are processing headers we need to
            // add a LWSP-char to the front of the new line
            // rfc 822 on long msg headers
            if($in_headers) {
                $line = "\t" . $line;
            }
        }
        $lines_out[] = $line;

        // now send the lines to the server
        while(list(,$line_out) = @each($lines_out)) {
            if(strlen($line_out) > 0)
            {
                if(substr($line_out, 0, 1) == ".") {
                    $line_out = "." . $line_out;
                }
            }
            fputs($this->smtp_conn,$line_out . $this->CRLF);
        }
    }

    // ok all the message data has been sent so lets get this
    // over with aleady
    fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
    }

    if($code != 250) {
        $this->error =
        array("error" => "DATA not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }
    return true;
}

　　首先重置 $error 为空，调用 connected ( ) 函数检查是否已经与SMTP服务器建立连接，如果没有建立，设置 $error 为“Called Data() without being connected”，并返回 false 。

　　接着向服务器发送 DATA 命令，如果服务器返回的状态码不是 354 ，则将 $error 设置为“DATA command not accepted from server”，并返回 false 。

　　现在SMTP服务器已经准备好接收数据了，根据 RFC 821 协议，包括 $CRLF 在内，我们不能在一行内发送超过 1000 个字符，所以如果有必要，我们将使用 \r 和（或） \n 把每行数据分成符合限制的更小的行。此外，我们要寻找以句号“.”开始的行，并添加一个额外的句号“.”在该行（这不计入字符数限制）。

　　把 $msg_data 中的 \r\n 和 \r 替换为 \n ，然后用 \n 将 $msg_data 拆分成数组 $lines 。

　　我们需要一个好办法来确定 $msg_data 已经包含了消息头还是仅仅是消息体，这里检查第一行的第一部分（以“:”分隔），即冒号“:”之前的部分，其中没有空格，则认为 $msg_data 中包含了消息头。

　　下面用 array each ( array &$array ) 逐个读取 $lines 中的数据到 $line ，如果 $line 为空且 $msg_data 中包含了消息头，则把包含消息头标识 $in_headers 设置为 false 。如果 $line 长度大于设定的长度 $max_line_length ，则按照该设定长度分成多行，如果信息头为多行，则根据 RFC 822 协议在每一行前添加一个制表符（\t），然后将分割好的小行输出到数组 $lines_out 中。

　　逐个小行发送到SMTP服务器，如果小行以句号“.”开头，则在其前面再加一个句号“.”，因为单个句号“.”开头会被SMTP服务器认为是 DATA 结束的标识。

　　DATA 发送完毕后，发送一个句号“.”，通知SMTP服务器发送完成，如果SMTP服务器返回的状态码不是 250 ，则将 $error 设置为“DATA not accepted from server”并返回 false 。

　　发送成功，返回 true 。

　　bool Authenticate ( string $username , string $password )

　　该函数用于执行SMTP认证，必须在 Hello ( ) 函数后运行，如果身份验证成功，则返回 true 。

/**
 * Performs SMTP authentication.  Must be run after running the
 * Hello() method.  Returns true if successfully authenticated.
 * @access public
 * @return bool
 */
function Authenticate($username, $password) {
    // Start authentication
    fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($code != 334) {
        $this->error =
        array("error" => "AUTH not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    // Send encoded username
    fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($code != 334) {
        $this->error =
        array("error" => "Username not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    // Send encoded password
    fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);

    $rply = $this->get_lines();
    $code = substr($rply,0,3);

    if($code != 235) {
        $this->error =
        array("error" => "Password not accepted from server",
        "smtp_code" => $code,
        "smtp_msg" => substr($rply,4));
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": " . $rply . $this->CRLF;
        }
        return false;
    }

    return true;
}

　　首先执行 int fputs ( resource $handle , string $string [, int $length ] )，向SMTP服务器发送身份验证请求（AUTH LOGIN），如果SMTP服务器返回的状态码不是 334 ，则将 $error 设置为“AUTH not accepted from server”并返回 false 。

　　接着发送经过 base64_encode ( ) 编码的用户名，如果SMTP服务器返回的状态码不是 334 ，则将 $error 设置为“Username not accepted from server”并返回 false 。

　　继续发送经过 base64_encode ( ) 编码的密码。如果SMTP服务器返回 235 ，则说明登录成功，返回 true ；否则则将 $error 设置为“Password not accepted from server”并返回 false 。

　　void Close ( )

　　该函数关闭socket连接并清理类的状态，如果不首先使用 Quit ( )，直接使用该函数并不是一个好主意。

/**
 * Closes the socket and cleans up the state of the class.
 * It is not considered good to use this function without
 * first trying to use QUIT.
 * @access public
 * @return void
 */
function Close() {
    $this->error = null; // so there is no confusion
    $this->helo_rply = null;
    if(!empty($this->smtp_conn)) {
        // close the connection and cleanup
        fclose($this->smtp_conn);
        $this->smtp_conn = 0;
    }
}

　　首先清理掉 $error 、 $helo_rply 两个私有属性，判断私有属性 $smtp_conn 是否存在，也就是SMTP是否已经连接，如果连接了，就关闭该连接，将 $smtp_conn 设置为 0 。

　　bool Connect ( string $host [, int $port = 0 [, int $tval = 30 ]] )

　　通过指定端口连接到SMTP服务器，如果没有指定端口$port，将使用默认的端口（$SMTP_PORT=25），如果 $tval 被指定，将尝试建立与SMTP服务器连接 $tval 秒，如果没有指定，则默认为30秒。这里支持对Gmail的服务器的连接。

/**
 * Connect to the server specified on the port specified.
 * If the port is not specified use the default SMTP_PORT.
 * If tval is specified then a connection will try and be
 * established with the server for that number of seconds.
 * If tval is not specified the default is 30 seconds to
 * try on the connection.
 *
 * SMTP CODE SUCCESS: 220
 * SMTP CODE FAILURE: 421
 * @access public
 * @return bool
 */
function Connect($host,$port=0,$tval=30) {
    // set the error val to null so there is no confusion
    $this->error = null;

    // make sure we are __not__ connected
    if($this->connected()) {
        // ok we are connected! what should we do?
        // for now we will just give an error saying we
        // are already connected
        $this->error =
        array("error" => "Already connected to a server");
        return false;
    }

    if(empty($port)) {
        $port = $this->SMTP_PORT;
    }
    //Added for Gmail support CER
    if($this->Protocol != '') $host = $this->Protocol."://".$host;

    #connect to the smtp server
    $this->smtp_conn = @fsockopen($host,    // the host of the server
    $port,    // the port to use
    $errno,   // error number if any
    $errstr,  // error message if any
    $tval);   // give up after ? secs
    // verify we connected properly
    if(empty($this->smtp_conn)) {
        $this->error = array("error" => "Failed to connect to server $host $port",
        "errno" => $errno,
        "errstr" => $errstr);
        if($this->do_debug >= 1) {
            echo "SMTP -> ERROR: " . $this->error["error"] .
            ": $errstr ($errno)" . $this->CRLF;
        }
        return false;
    }

    // sometimes the SMTP server takes a little longer to respond
    // so we will give it a longer timeout for the first read
    // Windows still does not have support for this timeout function
    if(substr(PHP_OS, 0, 3) != "WIN")
    socket_set_timeout($this->smtp_conn, $tval, 0);

    // get any announcement stuff
    $announce = $this->get_lines();

    // set the timeout  of any socket functions at 1/10 of a second
    //if(function_exists("socket_set_timeout"))
    //   socket_set_timeout($this->smtp_conn, 0, 100000);

    if($this->do_debug >= 2) {
        echo "SMTP -> FROM SERVER:" . $this->CRLF . $announce;
    }

    return true;
}

　　该函数首先重置错误信息 $error 为空，然后通过私有函数 connected ( ) 检查SMTP服务器的连接是否已经被建立。如果已经建立连接，则将 $error 设置为“Already connected to a server”，返回 false 。

　　如果没有指定 $port ，则设置 $port 为 $SMTP_PORT ，即25。

　　如果公共属性 $Protocol 被定义，则在主机前加上协议名称，用于建立对Gmail的连接，Gmail协议使用了ssl，也就是说，如果试图连接Gmail邮箱发送邮件，就需要在使用时定义该属性为“ssl”。

　　接着就是最关键的一个东东——连接了，使用的PHP函数是： resource fsockopen ( string $hostname [, int $port = -1 [, int &$errno [, string &$errstr [, float $timeout = ini_get("default_socket_timeout") ]]]] )，用于通过启用一个对 $hostname 的SOCKET连接并返回标识符，并把标识符记录到私有属性 $smtp_conn 中，后面还要继续使用。

　　再来验证一下我们建立的连接，如果连接没有成功，$smtp_conn 就是空的，把 fsockopen 函数返回的错误 $errno 、$errstr 传递给私有属性 $error ，如果开启了调试功能，则输出错误信息，返回 false 。

　　有时SMTP服务器需要稍长一点的时间来回应，所以我们给它第一次读取一个较长的超时，但是WINDOWS系统不支持socket_set_timeout ( )函数。

　　如果开启了调试功能并设置为2级，则输出连接成功的通知。

　　返回 true 。

　　bool Connected ( )

　　检查是否已经连接到SMTP服务器，如果已连接，返回 true ，否则返回 false 。

/**
 * Returns true if connected to a server otherwise false
 * @access private
 * @return bool
 */
function Connected() {
    if(!empty($this->smtp_conn)) {
        $sock_status = socket_get_status($this->smtp_conn);
        if($sock_status["eof"]) {
            // hmm this is an odd situation... the socket is
            // valid but we aren't connected anymore
            if($this->do_debug >= 1) {
                echo "SMTP -> NOTICE:" . $this->CRLF .
                "EOF caught while checking if connected";
            }
            $this->Close();
            return false;
        }
        return true; // everything looks good
    }
    return false;
}

　　首先检查SMTP连接 $smtp_conn 是否存在，如果不存在，自然返回 false ，否则，需要进一步确认连接是否真正建立。

　　通过 array socket_get_status ( int $fp ) 获取连接的状态。如果其中的 EOF 值为 false ，则说明正在连接中，那就返回 true ；如果 EOF 值为 true ，一个奇怪的现象出现了， socket 连接是有效的，但我们确实没有什么连接了，那就调用公共函数 Close ( ) 关闭掉当前连接，返回 false 。

　　文件原代码：class.smtp.rar

　　首先来看类的注释：

/**
 * SMTP Class
 * 
 * SMTP is rfc 821 compliant and implements all the rfc 821 SMTP
 * commands except TURN which will always return a not implemented
 * error. SMTP also provides some utility methods for sending mail
 * to an SMTP server.
 * 
 * @package classes
 */

　　意思和文件的注释差不多，介绍了什么是SMTP，还有其中的TURN会带来一个无法执行的错误。

　　下面我们看一下类的属性：

/**
 *  SMTP server port
 *  @var int
 */
var $SMTP_PORT = 25;

/**
 *  SMTP reply line ending
 *  @var string
 */
var $CRLF = "\r\n";

/**
 *  Sets whether debugging is turned on
 *  @var bool
 */
var $do_debug;       // the level of debug to perform

/**
 *  Sets protocol to help enable support for gmail
 *  @var string
 *  Added CER
 */
var $Protocol = '';

/**#@+
 * @access private
 */
var $smtp_conn;      // the socket to the server
var $error;          // error if any on the last call
var $helo_rply;      // the reply the server sent to us for HELO
/**#@-*/

　　$SMTP_PORT ，SMTP服务器端口，通常是25

　　$CRLF ，分隔符，用于分行，一个回车一个换行

　　$do_debug ，设置是否开启调试功能

　　$Protocol ，设置支持Gmail的协议

　　上面四个是公共属性，还有三个私有属性：

　　$smtp_conn ，SMTP服务器连接

　　$error ，最后一个对话（call）的错误

　　$helo_rply ，服务器对HELO的回复

　　再来看看构造函数：

/**
 * Initialize the class so that the data is in a known state.
 * @access public
 * @return void
 */
function SMTP() {
    $this->smtp_conn = 0;
    $this->error = null;
    $this->helo_rply = null;

    $this->do_debug = 0;
}

　　这个构造函数比较简单，把三个私有属性设置为默认值，同时将调试功能给关闭了，如果开启调试功能，需要从这里进行修改。

　　根据网上的办法，戒烟如你整理了一段小程序，可以在IE 6.0、Firefox 2.0、Netscape 8.1、Opera 9.24中使用。

　上面的第3、4行其实就是判断在IE中的那个document.getElementById()能不能用，能用最好，不能用就直接将iFrame作为对象赋值给pTar。第5行是戒烟如你加的测试代码，弹出提示框，内容是iFrame的地址。

　　这里面用到了一个戒烟如你不太熟悉的eval()，查了微软的《Microsoft Windows 脚本技术》才看了个差不多，各位需要的话可以自己去查。

　　调用函数：changecss('.exampleA','color','red')，三个参数分别是CSS名称、属性名称、参数。需要注意的是如果需要修改的是类，即用class="ClassName"的，在CSS名称前需要加“.”（英文半角句号）；如果需要修改的是ID，即用id="IDName"的，在CSS名称前需要加“#”。

　　该函数返回的是一个数组，宽和高各有两个值，可以根据需要取舍。

　　第一个函数，用来确定对象：

　　第二个函数，插入一行：

　　第三个函数，删除指定的行：

　　说来也没有什么新鲜的玩意儿，其实关键还是在于取得表格对象。具体的用法就不详细说了，自己举一反三吧。

　　该代码仅适用于UTF-8编码的字符串，输入参数分别是原字符串和长度，输出是截取后的字符串。

1. function AliasNbPages($alias='{nb}')
2. {
3.     // 设置页面总数的别名
4.     $this->AliasNbPages = $alias;
5. }

　　该方法用于设置页面总数的别名，默认该别名是 {nb}，例如你在文档的每个页眉或页脚输出了“共 {nb} 页”，在文档输出的时候该内容会自动替换成页面总数。

　　前面一直在设置PDF文档的一些东西，这里则正式开始一个文档了，把文档状态标记为1。

　　关闭文档时将文档状态设置为3，然后检查文档页面数，如果为0，即没有任何页面，则添加一个空白页（ AddPage() ），处理页脚，关闭页面和文档。

　　这三个方法在一起实现的就是 SetMargins() 的作用，因为它们可能是在运行过程中设置的，因此在设置左边距的时候特别识别了一下当前横坐标，如果当前横坐标在左边距外，那就调整下从左边距开始。

　　这5个方法是设置PDF文档属性的，也是设置类属性的，只是其中调用了一个 _UTF8toUTF16 () 内部方法，用于把UTF8编码的文字变成UTF16编码的，注意一下，由于fpdf.php文件本身不是UTF8编码的，所以如果使用GBK编码做PDF的话，需要先将GBK文字变成UTF8编码的，然后在第二个参数设置为 TRUE，否则汉字显示的就是乱码，戒烟如你亲自测试的。

　　该方法似乎以后会有用，先留在这里，暂时不研究它了，知道它的作用就OK！

　　这里对系统做了一些检查，用到了几个PHP函数：

　　string sprintf  ( string $format  [, mixed $args  [, mixed $...  ]] )，用于将字符串格式化，其中参数里的 F 是从 PHP 4.3.10 和 PHP 5.0.3 开始使用的。

　　string ini_get  ( string $varname  )，检查php.ini，这里检查是否装载了 mbstring 扩展，这个什么扩展的偶倒从来没用过。

　　int get_magic_quotes_runtime  ( void  )，检查运行时魔术引号是否打开，通常这个是不开的，如果开了，可以用 bool set_magic_quotes_runtime  ( int $new_setting  )来关闭它。

　　这里用于根据纸张样式获取纸张大小，参数是纸张样式，比如A4，从类的属性 $PageFormats 中得到对应的长度和宽度，形成一个数组返回。

　　这个很简单了，出现致命错误，中断PHP程序，把传递来的错误信息输出。

　　这是遇到的第一个真正被外部使用的方法，虽然被构造函数调用，但只是初步按照默认值（都为 1 cm）设定，该方法可以修改这种设定。如果使用该方法，其前两个参数必须设置，第三个参数如果不设置，默认使用第一个参数，单位是 cm 。

　　这也是一个可以被外部使用的方法，该方法第一个参数 $auto 用于设置是否自动分页，如果为自动分页（TRUE），第二个参数则设置页面的下边距，系统初始化时默认下边距为 2 cm，但该方法的默认值为 0。在该方法中，下边距是通过自动分页的触发值来实现的。

　　这个方法用于设置页面的显示模式，前一个参数是缩放模式，后一个参数是分页模式，具体的参数解释在手册里有，这里就不说了。

　　这个方法是设置页面压缩的，依赖于PHP的Zlib，所以先进行检测是否支持 gzcompress() 如果不支持，即使设置为 true，也会设置为 false。

　　下面是FPDF类的构造函数，带了三个参数，分别是页面方向（默认为纵向）、使用的单位（默认为 mm）、页面样式（默认为 A4）。

　　构造函数中调用了2个私有方法 _dochecks() 和 _getpageformat()，还有5个公共方法 Error()、SetMargins()、SetAutoPageBreak()、SetDisplayMode() 和 SetCompression()，下一篇逐个分析它们。