Fonctions membres publiques
	__construct ()
	Connect ($host, $port=0, $timeout=30, $options=array())
	StartTLS ()
	Authenticate ($username, $password, $authtype='LOGIN', $realm='', $workstation='')
	Connected ()
	Close ()
	Data ($msg_data)
	Hello ($host= '')
	Mail ($from)
	Quit ($close_on_error=true)
	Recipient ($to)
	Reset ()
	SendAndMail ($from)
	Turn ()
	client_send ($data)
	getError ()

Attributs publics
	$SMTP_PORT = 25
	$CRLF = "\r\n"
	$do_debug = 0
	$Debugoutput = 'echo'
	$do_verp = false
	$Timeout = 15
	$Timelimit = 30
	$Version = '5.2.6'

Fonctions membres protégées
	edebug ($str)
	hmac ($data, $key)
	SendHello ($hello, $host)
	get_lines ()

Attributs protégés
	$smtp_conn
	$error
	$helo_rply

Description détaillée

Définition à la ligne 47 du fichier smtp.php.

Documentation des constructeurs et destructeur

SMTP::__construct ( )

Initialize the class so that the data is in a known state. public

Renvoie:: SMTP

Définition à la ligne 139 du fichier smtp.php.

                                {
    $this->smtp_conn = 0;
    $this->error = null;
    $this->helo_rply = null;
    $this->do_debug = 0;
  }

Documentation des fonctions membres

SMTP::Authenticate	(	$username,
		$password,
		$authtype = `'LOGIN'`,
		$realm = `''`,
		$workstation = `''`
	)

Performs SMTP authentication. Must be run after running the Hello() method. Returns true if successfully authenticated. public

Paramètres:

string	$username
string	$password
string	$authtype
string	$realm
string	$workstation

Renvoie:: bool

Définition à la ligne 272 du fichier smtp.php.

Références client_send(), edebug(), get_lines(), et hmac().

                                                                                                    {
    if (empty($authtype)) {
      $authtype = 'LOGIN';
    }
    switch ($authtype) {
      case 'PLAIN':
        // Start authentication
        $this->client_send('AUTH PLAIN' . $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) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        // Send encoded username and password
          $this->client_send(base64_encode("\0".$username."\0".$password) . $this->CRLF);
        $rply = $this->get_lines();
        $code = substr($rply, 0, 3);
        if($code != 235) {
          $this->error =
            array('error' => 'Authentication not accepted from server',
                  'smtp_code' => $code,
                  'smtp_msg' => substr($rply, 4));
          if($this->do_debug >= 1) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        break;
      case 'LOGIN':
        // Start authentication
        $this->client_send('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) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        // Send encoded username
        $this->client_send(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) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        // Send encoded password
        $this->client_send(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) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        break;
      case 'NTLM':
        /*
         * ntlm_sasl_client.php
         ** Bundled with Permission
         **
         ** How to telnet in windows: http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
         ** PROTOCOL Documentation http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
         */
        if (file_exists('extras/ntlm_sasl_client.php')) {
         require_once 'extras/ntlm_sasl_client.php';
        }
        $temp = new stdClass();
        $ntlm_client = new ntlm_sasl_client_class;
        if(! $ntlm_client->Initialize($temp)){//let's test if every function its available
            $this->error = array('error' => $temp->error);
            if($this->do_debug >= 1) {
                $this->edebug('You need to enable some modules in your php.ini file: ' . $this->error['error']);
            }
            return false;
        }
        $msg1 = $ntlm_client->TypeMsg1($realm, $workstation);//msg1
        $this->client_send('AUTH NTLM ' . base64_encode($msg1) . $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) {
                $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
            }
            return false;
        }
        $challenge = substr($rply, 3);//though 0 based, there is a white space after the 3 digit number....//msg2
        $challenge = base64_decode($challenge);
        $ntlm_res = $ntlm_client->NTLMResponse(substr($challenge, 24, 8), $password);
        $msg3 = $ntlm_client->TypeMsg3($ntlm_res, $username, $realm, $workstation);//msg3
        // Send encoded username
        $this->client_send(base64_encode($msg3) . $this->CRLF);
        $rply = $this->get_lines();
        $code = substr($rply, 0, 3);
        if($code != 235) {
            $this->error =
                array('error' => 'Could not authenticate',
                      'smtp_code' => $code,
                      'smtp_msg' => substr($rply, 4));
            if($this->do_debug >= 1) {
                $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
            }
            return false;
        }
        break;
      case 'CRAM-MD5':
        // Start authentication
        $this->client_send('AUTH CRAM-MD5' . $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) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        // Get the challenge
        $challenge = base64_decode(substr($rply, 4));
        // Build the response
        $response = $username . ' ' . $this->hmac($challenge, $password);
        // Send encoded credentials
        $this->client_send(base64_encode($response) . $this->CRLF);
        $rply = $this->get_lines();
        $code = substr($rply, 0, 3);
        if($code != 235) {
          $this->error =
            array('error' => 'Credentials not accepted from server',
                  'smtp_code' => $code,
                  'smtp_msg' => substr($rply, 4));
          if($this->do_debug >= 1) {
            $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
          }
          return false;
        }
        break;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::client_send ( $data )

Sends data to the server

Paramètres:

string $data public

Renvoie:: Integer number of bytes sent to the server or FALSE on error

Définition à la ligne 1021 du fichier smtp.php.

Références edebug().

Référencé par Authenticate(), Data(), Mail(), Quit(), Recipient(), Reset(), SendAndMail(), SendHello(), et StartTLS().

                                     {
      if ($this->do_debug >= 1) {
          $this->edebug("CLIENT -> SMTP: $data");
      }
      return fwrite($this->smtp_conn, $data);
  }

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

SMTP::Close ( )

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. public

Renvoie:: void

Définition à la ligne 528 du fichier smtp.php.

Référencé par Connected(), et Quit().

                          {
    $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;
    }
  }

Voici le graphe des appelants de cette fonction :

SMTP::Connect	(	$host,
		$port = `0`,
		$timeout = `30`,
		$options = `array()`
	)

Connect to an SMTP server

SMTP CODE SUCCESS: 220 SMTP CODE FAILURE: 421 public

Paramètres:

string	$host	SMTP server IP or host name
int	$port	The port number to connect to, or use the default port if not specified
int	$timeout	How long to wait for the connection to open
array	$options	An array of options compatible with stream_context_create()

Renvoie:: bool

Définition à la ligne 163 du fichier smtp.php.

Références $SMTP_PORT, edebug(), et get_lines().

                                                                               {
    // Clear errors to avoid confusion
    $this->error = null;
    // Make sure we are __not__ connected
    if($this->connected()) {
      // Already connected, generate error
      $this->error = array('error' => 'Already connected to a server');
      return false;
    }
    if(empty($port)) {
      $port = $this->SMTP_PORT;
    }
    // Connect to the SMTP server
    $errno = 0;
    $errstr = '';
    $socket_context = stream_context_create($options);
    //Need to suppress errors here as connection failures can be handled at a higher level
    $this->smtp_conn = @stream_socket_client($host.":".$port, $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT, $socket_context);
    // Verify we connected properly
    if(empty($this->smtp_conn)) {
      $this->error = array('error' => 'Failed to connect to server',
                           'errno' => $errno,
                           'errstr' => $errstr);
      if($this->do_debug >= 1) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ": $errstr ($errno)");
      }
      return false;
    }
    // SMTP server can take longer to respond, give longer timeout for first read
    // Windows does not have support for this timeout function
    if(substr(PHP_OS, 0, 3) != 'WIN') {
      $max = ini_get('max_execution_time');
      if ($max != 0 && $timeout > $max) { // Don't bother if unlimited
        @set_time_limit($timeout);
      }
      stream_set_timeout($this->smtp_conn, $timeout, 0);
    }
    // get any announcement
    $announce = $this->get_lines();
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $announce);
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Connected ( )

Returns true if connected to a server otherwise false public

Renvoie:: bool

Définition à la ligne 505 du fichier smtp.php.

Références Close(), et edebug().

                              {
    if(!empty($this->smtp_conn)) {
      $sock_status = stream_get_meta_data($this->smtp_conn);
      if($sock_status['eof']) {
        // the socket is valid but we are not connected
        if($this->do_debug >= 1) {
            $this->edebug('SMTP -> NOTICE: EOF caught while checking if connected');
        }
        $this->Close();
        return false;
      }
      return true; // everything looks good
    }
    return false;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Data ( $msg_data )

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 separated 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 public

Paramètres:

string $msg_data

Renvoie:: bool

Définition à la ligne 562 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                                  {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array(
              'error' => 'Called Data() without being connected');
      return false;
    }
    $this->client_send('DATA' . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      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 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 am 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);
        } else {
          $lines_out[] = substr($line, 0, $pos);
          $line = substr($line, $pos + 1);
        }
        /* if processing headers add a LWSP-char to the front of new line
         * rfc 822 on long msg headers
         */
        if($in_headers) {
          $line = "\t" . $line;
        }
      }
      $lines_out[] = $line;
      // 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;
          }
        }
        $this->client_send($line_out . $this->CRLF);
      }
    }
    // message data has been sent
    $this->client_send($this->CRLF . '.' . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::edebug ( $str )

protected

Outputs debugging info via user-defined method

Paramètres:

string $str

Définition à la ligne 118 du fichier smtp.php.

Référencé par Authenticate(), client_send(), Connect(), Connected(), Data(), get_lines(), Mail(), Quit(), Recipient(), Reset(), SendAndMail(), SendHello(), StartTLS(), et Turn().

                                  {
    switch ($this->Debugoutput) {
      case 'error_log':
        error_log($str);
        break;
      case 'html':
        //Cleans up output a bit for a better looking display that's HTML-safe
        echo htmlentities(preg_replace('/[\r\n]+/', '', $str), ENT_QUOTES, 'UTF-8')."<br>\n";
        break;
      case 'echo':
      default:
        //Just echoes exactly what was received
        echo $str;
    }
  }

Voici le graphe des appelants de cette fonction :

SMTP::get_lines ( )

protected

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. protected

Renvoie:: string

Définition à la ligne 1050 du fichier smtp.php.

Références $Timelimit, et edebug().

Référencé par Authenticate(), Connect(), Data(), Mail(), Quit(), Recipient(), Reset(), SendAndMail(), SendHello(), et StartTLS().

                                 {
    $data = '';
    $endtime = 0;
    /* If for some reason the fp is bad, don't inf loop */
    if (!is_resource($this->smtp_conn)) {
      return $data;
    }
    stream_set_timeout($this->smtp_conn, $this->Timeout);
    if ($this->Timelimit > 0) {
      $endtime = time() + $this->Timelimit;
    }
    while(is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
      $str = @fgets($this->smtp_conn, 515);
      if($this->do_debug >= 4) {
        $this->edebug("SMTP -> get_lines(): \$data was \"$data\"");
        $this->edebug("SMTP -> get_lines(): \$str is \"$str\"");
      }
      $data .= $str;
      if($this->do_debug >= 4) {
        $this->edebug("SMTP -> get_lines(): \$data is \"$data\"");
      }
      // if 4th character is a space, we are done reading, break the loop
      if(substr($str, 3, 1) == ' ') { break; }
      // Timed-out? Log and break
      $info = stream_get_meta_data($this->smtp_conn);
      if ($info['timed_out']) {
        if($this->do_debug >= 4) {
          $this->edebug('SMTP -> get_lines(): timed-out (' . $this->Timeout . ' seconds)');
        }
        break;
      }
      // Now check if reads took too long
      if ($endtime) {
        if (time() > $endtime) {
          if($this->do_debug >= 4) {
            $this->edebug('SMTP -> get_lines(): timelimit reached (' . $this->Timelimit . ' seconds)');
          }
          break;
        }
      }
    }
    return $data;
  }

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

SMTP::getError ( )

Get the current error public

Renvoie:: array

Définition à la ligne 1033 du fichier smtp.php.

Références $error.

                             {
    return $this->error;
  }

SMTP::Hello ( $host = '' )

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 public

Paramètres:

string $host

Renvoie:: bool

Définition à la ligne 700 du fichier smtp.php.

Références SendHello().

                                    {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array(
            'error' => 'Called Hello() without being connected');
      return false;
    }
    // if hostname for HELO was not specified send default
    if(empty($host)) {
      // determine appropriate default to send to server
      $host = 'localhost';
    }
    // Send extended hello first (RFC 2821)
    if(!$this->SendHello('EHLO', $host)) {
      if(!$this->SendHello('HELO', $host)) {
        return false;
      }
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::hmac	(	$data,
		$key
	)

protected

Works like hash_hmac('md5', $data, $key) in case that function is not available protected

Paramètres:

string	$data
string	$key

Renvoie:: string

Définition à la ligne 475 du fichier smtp.php.

Référencé par Authenticate().

                                       {
      if (function_exists('hash_hmac')) {
          return hash_hmac('md5', $data, $key);
      }
      // The following borrowed from http://php.net/manual/en/function.mhash.php#27225
      // RFC 2104 HMAC implementation for php.
      // Creates an md5 HMAC.
      // Eliminates the need to install mhash to compute a HMAC
      // Hacked by Lance Rushing
      $b = 64; // byte length for md5
      if (strlen($key) > $b) {
          $key = pack('H*', md5($key));
      }
      $key  = str_pad($key, $b, chr(0x00));
      $ipad = str_pad('', $b, chr(0x36));
      $opad = str_pad('', $b, chr(0x5c));
      $k_ipad = $key ^ $ipad ;
      $k_opad = $key ^ $opad;
      return md5($k_opad  . pack('H*', md5($k_ipad . $data)));
  }

Voici le graphe des appelants de cette fonction :

SMTP::Mail ( $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.

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 public

Paramètres:

string $from

Renvoie:: bool

Définition à la ligne 773 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                              {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array(
              'error' => 'Called Mail() without being connected');
      return false;
    }
    $useVerp = ($this->do_verp ? ' XVERP' : '');
    $this->client_send('MAIL FROM:<' . $from . '>' . $useVerp . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Quit ( $close_on_error = true )

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 public

Paramètres:

bool $close_on_error

Renvoie:: bool

Définition à la ligne 817 du fichier smtp.php.

Références client_send(), Close(), edebug(), et get_lines().

                                               {
    $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
    $this->client_send('quit' . $this->CRLF);
    // get any good-bye messages
    $byemsg = $this->get_lines();
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $e['error'] . ': ' . $byemsg);
      }
    }
    if(empty($e) || $close_on_error) {
      $this->Close();
    }
    return $rval;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Recipient ( $to )

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 public

Paramètres:

string $to

Renvoie:: bool

Définition à la ligne 871 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                                 {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array(
              'error' => 'Called Recipient() without being connected');
      return false;
    }
    $this->client_send('RCPT TO:<' . $to . '>' . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Reset ( )

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 public

Renvoie:: bool

Définition à la ligne 914 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                          {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array('error' => 'Called Reset() without being connected');
      return false;
    }
    $this->client_send('RSET' . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $rply);
    }
    if($code != 250) {
      $this->error =
        array('error' => 'RSET failed',
              'smtp_code' => $code,
              'smtp_msg' => substr($rply, 4));
      if($this->do_debug >= 1) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::SendAndMail ( $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 public

Paramètres:

string $from

Renvoie:: bool

Définition à la ligne 962 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                                     {
    $this->error = null; // so no confusion is caused
    if(!$this->connected()) {
      $this->error = array(
          'error' => 'Called SendAndMail() without being connected');
      return false;
    }
    $this->client_send('SAML FROM:' . $from . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::SendHello	(	$hello,
		$host
	)

protected

Sends a HELO/EHLO command. protected

Paramètres:

string	$hello
string	$host

Renvoie:: bool

Définition à la ligne 732 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

Référencé par Hello().

                                              {
    $this->client_send($hello . ' ' . $host . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER: ' . $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) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    $this->helo_rply = $rply;
    return true;
  }

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

SMTP::StartTLS ( )

Initiate a TLS communication with the server.

SMTP CODE 220 Ready to start TLS SMTP CODE 501 Syntax error (no parameters allowed) SMTP CODE 454 TLS not available due to temporary reason public

Renvoie:: bool success

Définition à la ligne 225 du fichier smtp.php.

Références client_send(), edebug(), et get_lines().

                             {
    $this->error = null; # to avoid confusion
    if(!$this->connected()) {
      $this->error = array('error' => 'Called StartTLS() without being connected');
      return false;
    }
    $this->client_send('STARTTLS' . $this->CRLF);
    $rply = $this->get_lines();
    $code = substr($rply, 0, 3);
    if($this->do_debug >= 2) {
      $this->edebug('SMTP -> FROM SERVER:' . $rply);
    }
    if($code != 220) {
      $this->error =
         array('error'     => 'STARTTLS not accepted from server',
               'smtp_code' => $code,
               'smtp_msg'  => substr($rply, 4));
      if($this->do_debug >= 1) {
        $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply);
      }
      return false;
    }
    // Begin encrypted connection
    if(!stream_socket_enable_crypto($this->smtp_conn, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
      return false;
    }
    return true;
  }

Voici le graphe d'appel pour cette fonction :

SMTP::Turn ( )

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 public

Renvoie:: bool

Définition à la ligne 1006 du fichier smtp.php.

Références edebug().

                         {
    $this->error = array('error' => 'This method, TURN, of the SMTP '.
                                    'is not implemented');
    if($this->do_debug >= 1) {
      $this->edebug('SMTP -> NOTICE: ' . $this->error['error']);
    }
    return false;
  }

Voici le graphe d'appel pour cette fonction :

Documentation des données membres

SMTP::$CRLF = "\r\n"

Définition à la ligne 58 du fichier smtp.php.

SMTP::$Debugoutput = 'echo'

Définition à la ligne 71 du fichier smtp.php.

SMTP::$do_debug = 0

Définition à la ligne 64 du fichier smtp.php.

SMTP::$do_verp = false

Définition à la ligne 77 du fichier smtp.php.

SMTP::$error

protected

Définition à la ligne 108 du fichier smtp.php.

Référencé par getError().

SMTP::$helo_rply

protected

Définition à la ligne 112 du fichier smtp.php.

SMTP::$smtp_conn

protected

Définition à la ligne 104 du fichier smtp.php.

SMTP::$SMTP_PORT = 25

Définition à la ligne 52 du fichier smtp.php.

Référencé par Connect().

SMTP::$Timelimit = 30

Définition à la ligne 89 du fichier smtp.php.

Référencé par get_lines().

SMTP::$Timeout = 15

Définition à la ligne 83 du fichier smtp.php.

SMTP::$Version = '5.2.6'

Définition à la ligne 95 du fichier smtp.php.

La documentation de cette classe a été générée à partir du fichier suivant :

jplatform-13.1/phpmailer/smtp.php

Fonctions membres publiques

Attributs publics

Fonctions membres protégées

Attributs protégés

Description détaillée

Documentation des constructeurs et destructeur

Documentation des fonctions membres

Documentation des données membres