Collaboration diagram for SMTP:

Public Member Functions
	connect ($host, $port=null, $timeout=30, $options=array())
	Connect to an SMTP server. More...

	startTLS ()
	Initiate a TLS (encrypted) session. More...

	authenticate ( $username, $password, $authtype=null, $realm='', $workstation='', $OAuth=null)
	Perform SMTP authentication. More...

	connected ()
	Check connection state. More...

	close ()
	Close the socket and clean up the state of the class. More...

	data ($msg_data)
	Send an SMTP DATA command. More...

	hello ($host='')
	Send an SMTP HELO or EHLO command. More...

	mail ($from)
	Send an SMTP MAIL command. More...

	quit ($close_on_error=true)
	Send an SMTP QUIT command. More...

	recipient ($address)
	Send an SMTP RCPT command. More...

	reset ()
	Send an SMTP RSET command. More...

	sendAndMail ($from)
	Send an SMTP SAML command. More...

	verify ($name)
	Send an SMTP VRFY command. More...

	noop ()
	Send an SMTP NOOP command. More...

	turn ()
	Send an SMTP TURN command. More...

	client_send ($data)
	Send raw data to the server. More...

	getError ()
	Get the latest error. More...

	getServerExtList ()
	Get SMTP extensions available on the server public. More...

	getServerExt ($name)
	A multipurpose method The method works in three ways, dependent on argument value and current state. More...

	getLastReply ()
	Get the last reply from the server. More...

	setVerp ($enabled=false)
	Enable or disable VERP address generation. More...

	getVerp ()
	Get VERP address generation mode. More...

	setDebugOutput ($method='echo')
	Set debug output method. More...

	getDebugOutput ()
	Get debug output method. More...

	setDebugLevel ($level=0)
	Set debug output level. More...

	getDebugLevel ()
	Get debug output level. More...

	setTimeout ($timeout=0)
	Set SMTP timeout. More...

	getTimeout ()
	Get SMTP timeout. More...

	getLastTransactionID ()
	Will return the ID of the last smtp transaction based on a list of patterns provided in SMTP::$smtp_transaction_id_patterns. More...

Data Fields
const	VERSION = '5.2.24'

const	CRLF = "\r\n"

const	DEFAULT_SMTP_PORT = 25

const	MAX_LINE_LENGTH = 998

const	DEBUG_OFF = 0
	Debug level for no output. More...

const	DEBUG_CLIENT = 1
	Debug level to show client -> server messages. More...

const	DEBUG_SERVER = 2
	Debug level to show client -> server and server -> client messages. More...

const	DEBUG_CONNECTION = 3
	Debug level to show connection status, client -> server and server -> client messages. More...

const	DEBUG_LOWLEVEL = 4
	Debug level to show all messages. More...

	$Version = '5.2.24'

	$SMTP_PORT = 25

	$CRLF = "\r\n"

	$do_debug = self::DEBUG_OFF

	$Debugoutput = 'echo'

	$do_verp = false

	$Timeout = 300

	$Timelimit = 300

Protected Member Functions
	edebug ($str, $level=0)
	Output debugging info via a user-selected method. More...

	hmac ($data, $key)
	Calculate an MD5 HMAC hash. More...

	sendHello ($hello, $host)
	Send an SMTP HELO or EHLO command. More...

	parseHelloFields ($type)
	Parse a reply to HELO/EHLO command to discover server extensions. More...

	sendCommand ($command, $commandstring, $expect)
	Send a command to an SMTP server and check its return code. More...

	get_lines ()
	Read the SMTP server's response. More...

	setError ($message, $detail='', $smtp_code='', $smtp_code_ex='')
	Set error messages and codes. More...

	errorHandler ($errno, $errmsg, $errfile='', $errline=0)
	Reports an error number and string. More...

Protected Attributes
	$smtp_transaction_id_patterns

	$smtp_conn

	$error

	$helo_rply = null

	$server_caps = null

	$last_reply = ''

Detailed Description

Definition at line 27 of file class.smtp.php.

Member Function Documentation

◆ authenticate()

SMTP::authenticate	(	$username,
		$password,
		$authtype = `null`,
		$realm = `''`,
		$workstation = `''`,
		$OAuth = `null`
	)

Perform SMTP authentication.

Must be run after hello().

See also: hello()

Parameters

string	$username	The user name
string	$password	The password
string	$authtype	The auth type (PLAIN, LOGIN, NTLM, CRAM-MD5, XOAUTH2)
string	$realm	The auth realm for NTLM
string	$workstation	The auth workstation for NTLM
null \| OAuth	$OAuth	An optional OAuth instance (

See also: PHPMailerOAuth)

Returns: bool True if successfully authenticated.* public

Definition at line 387 of file class.smtp.php.

References $password, $response, array, edebug(), hmac(), sendCommand(), and setError().

       {
         if (!$this->server_caps) {
             $this->setError('Authentication is not allowed before HELO/EHLO');
             return false;
         }
 
         if (array_key_exists('EHLO', $this->server_caps)) {
             // SMTP extensions are available; try to find a proper authentication method
             if (!array_key_exists('AUTH', $this->server_caps)) {
                 $this->setError('Authentication is not allowed at this stage');
                 // 'at this stage' means that auth may be allowed after the stage changes
                 // e.g. after STARTTLS
                 return false;
             }
 
             self::edebug('Auth method requested: ' . ($authtype ? $authtype : 'UNKNOWN'), self::DEBUG_LOWLEVEL);
             self::edebug(
                 'Auth methods available on the server: ' . implode(',', $this->server_caps['AUTH']),
                 self::DEBUG_LOWLEVEL
             );
 
             if (empty($authtype)) {
                 foreach (array('CRAM-MD5', 'LOGIN', 'PLAIN', 'NTLM', 'XOAUTH2') as $method) {
                     if (in_array($method, $this->server_caps['AUTH'])) {
                         $authtype = $method;
                         break;
                     }
                 }
                 if (empty($authtype)) {
                     $this->setError('No supported authentication methods found');
                     return false;
                 }
                 self::edebug('Auth method selected: ' . $authtype, self::DEBUG_LOWLEVEL);
             }
 
             if (!in_array($authtype, $this->server_caps['AUTH'])) {
                 $this->setError("The requested authentication method \"$authtype\" is not supported by the server");
                 return false;
             }
         } elseif (empty($authtype)) {
             $authtype = 'LOGIN';
         }
         switch ($authtype) {
             case 'PLAIN':
                 // Start authentication
                 if (!$this->sendCommand('AUTH', 'AUTH PLAIN', 334)) {
                     return false;
                 }
                 // Send encoded username and password
                 if (!$this->sendCommand(
                     'User & Password',
                     base64_encode("\0" . $username . "\0" . $password),
                     235
                 )
                 ) {
                     return false;
                 }
                 break;
             case 'LOGIN':
                 // Start authentication
                 if (!$this->sendCommand('AUTH', 'AUTH LOGIN', 334)) {
                     return false;
                 }
                 if (!$this->sendCommand("Username", base64_encode($username), 334)) {
                     return false;
                 }
                 if (!$this->sendCommand("Password", base64_encode($password), 235)) {
                     return false;
                 }
                 break;
             case 'XOAUTH2':
                 //If the OAuth Instance is not set. Can be a case when PHPMailer is used
                 //instead of PHPMailerOAuth
                 if (is_null($OAuth)) {
                     return false;
                 }
                 $oauth = $OAuth->getOauth64();
 
                 // Start authentication
                 if (!$this->sendCommand('AUTH', 'AUTH XOAUTH2 ' . $oauth, 235)) {
                     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 Docs http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
                  */
                 require_once 'extras/ntlm_sasl_client.php';
                 $temp = new stdClass;
                 $ntlm_client = new ntlm_sasl_client_class;
                 //Check that functions are available
                 if (!$ntlm_client->initialize($temp)) {
                     $this->setError($temp->error);
                     $this->edebug(
                         'You need to enable some modules in your php.ini file: '
                         . $this->error['error'],
                         self::DEBUG_CLIENT
                     );
                     return false;
                 }
                 //msg1
                 $msg1 = $ntlm_client->typeMsg1($realm, $workstation); //msg1
 
                 if (!$this->sendCommand(
                     'AUTH NTLM',
                     'AUTH NTLM ' . base64_encode($msg1),
                     334
                 )
                 ) {
                     return false;
                 }
                 //Though 0 based, there is a white space after the 3 digit number
                 //msg2
                 $challenge = substr($this->last_reply, 3);
                 $challenge = base64_decode($challenge);
                 $ntlm_res = $ntlm_client->NTLMResponse(
                     substr($challenge, 24, 8),
                     $password
                 );
                 //msg3
                 $msg3 = $ntlm_client->typeMsg3(
                     $ntlm_res,
                     $username,
                     $realm,
                     $workstation
                 );
                 // send encoded username
                 return $this->sendCommand('Username', base64_encode($msg3), 235);
             case 'CRAM-MD5':
                 // Start authentication
                 if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
                     return false;
                 }
                 // Get the challenge
                 $challenge = base64_decode(substr($this->last_reply, 4));
 
                 // Build the response
                 $response = $username . ' ' . $this->hmac($challenge, $password);
 
                 // send encoded credentials
                 return $this->sendCommand('Username', base64_encode($response), 235);
             default:
                 $this->setError("Authentication method \"$authtype\" is not supported");
                 return false;
         }
         return true;
     }

Here is the call graph for this function:

◆ client_send()

SMTP::client_send ( $data )

Send raw data to the server.

Parameters

string $data The data to send public

Returns: integer|boolean The number of bytes sent to the server or false on error

Definition at line 989 of file class.smtp.php.

References $data, $result, array, and edebug().

Referenced by data(), and sendCommand().

     {
         $this->edebug("CLIENT -> SERVER: $data", self::DEBUG_CLIENT);
         set_error_handler(array($this, 'errorHandler'));
         $result = fwrite($this->smtp_conn, $data);
         restore_error_handler();
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close()

SMTP::close ( )

Close the socket and clean up the state of the class.

Don't use this function without first trying to use QUIT.

See also: quit() User interface

Returns: void

Definition at line 613 of file class.smtp.php.

References edebug(), and setError().

Referenced by connected(), and quit().

     {
         $this->setError('');
         $this->server_caps = null;
         $this->helo_rply = null;
         if (is_resource($this->smtp_conn)) {
             // close the connection and cleanup
             fclose($this->smtp_conn);
             $this->smtp_conn = null; //Makes for cleaner serialization
             $this->edebug('Connection: closed', self::DEBUG_CONNECTION);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connect()

SMTP::connect	(	$host,
		$port = `null`,
		$timeout = `30`,
		$options = `array()`
	)

Connect to an SMTP server.

Parameters

string	$host	SMTP server IP or host name
integer	$port	The port number to connect to
integer	$timeout	How long to wait for the connection to open
array	$options	An array of options for stream_context_create() public

Returns: boolean

Definition at line 257 of file class.smtp.php.

References $options, array, connected(), edebug(), get_lines(), and setError().

     {
         static $streamok;
         //This is enabled by default since 5.0.0 but some providers disable it
         //Check this once and cache the result
         if (is_null($streamok)) {
             $streamok = function_exists('stream_socket_client');
         }
         // Clear errors to avoid confusion
         $this->setError('');
         // Make sure we are __not__ connected
         if ($this->connected()) {
             // Already connected, generate error
             $this->setError('Already connected to a server');
             return false;
         }
         if (empty($port)) {
             $port = self::DEFAULT_SMTP_PORT;
         }
         // Connect to the SMTP server
         $this->edebug(
             "Connection: opening to $host:$port, timeout=$timeout, options=" .
             var_export($options, true),
             self::DEBUG_CONNECTION
         );
         $errno = 0;
         $errstr = '';
         if ($streamok) {
             $socket_context = stream_context_create($options);
             set_error_handler(array($this, 'errorHandler'));
             $this->smtp_conn = stream_socket_client(
                 $host . ":" . $port,
                 $errno,
                 $errstr,
                 $timeout,
                 STREAM_CLIENT_CONNECT,
                 $socket_context
             );
             restore_error_handler();
         } else {
             //Fall back to fsockopen which should work in more places, but is missing some features
             $this->edebug(
                 "Connection: stream_socket_client not available, falling back to fsockopen",
                 self::DEBUG_CONNECTION
             );
             set_error_handler(array($this, 'errorHandler'));
             $this->smtp_conn = fsockopen(
                 $host,
                 $port,
                 $errno,
                 $errstr,
                 $timeout
             );
             restore_error_handler();
         }
         // Verify we connected properly
         if (!is_resource($this->smtp_conn)) {
             $this->setError(
                 'Failed to connect to server',
                 $errno,
                 $errstr
             );
             $this->edebug(
                 'SMTP ERROR: ' . $this->error['error']
                 . ": $errstr ($errno)",
                 self::DEBUG_CLIENT
             );
             return false;
         }
         $this->edebug('Connection: opened', self::DEBUG_CONNECTION);
         // 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');
             // Don't bother if unlimited
             if ($max != 0 && $timeout > $max) {
                 @set_time_limit($timeout);
             }
             stream_set_timeout($this->smtp_conn, $timeout, 0);
         }
         // Get any announcement
         $announce = $this->get_lines();
         $this->edebug('SERVER -> CLIENT: ' . $announce, self::DEBUG_SERVER);
         return true;
     }

Here is the call graph for this function:

◆ connected()

SMTP::connected ( )

Check connection state.

public

Returns: boolean True if connected.

Definition at line 588 of file class.smtp.php.

References close(), and edebug().

Referenced by connect(), and sendCommand().

     {
         if (is_resource($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
                 $this->edebug(
                     'SMTP NOTICE: EOF caught while checking if connected',
                     self::DEBUG_CLIENT
                 );
                 $this->close();
                 return false;
             }
             return true; // everything looks good
         }
         return false;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ data()

SMTP::data ( $msg_data )

Send an SMTP DATA command.

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>

Parameters

string $msg_data Message data to send public

Returns: boolean

Definition at line 638 of file class.smtp.php.

References $result, $Timelimit, array, client_send(), and sendCommand().

     {
         //This will use the standard timelimit
         if (!$this->sendCommand('DATA', 'DATA', 354)) {
             return false;
         }
 
         /* The server is ready to accept data!
          * According to rfc821 we should not send more than 1000 characters on a single line (including the CRLF)
          * 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.
          * We will also look for lines that start with a '.' and prepend an additional '.'.
          * NOTE: this does not count towards line-length limit.
          */
 
         // Normalize line breaks before exploding
         $lines = explode("\n", str_replace(array("\r\n", "\r"), "\n", $msg_data));
 
         /* To distinguish between a complete RFC822 message and a plain message body, we check if the first field
          * of the first line (':' separated) does not contain a space then it _should_ be a header and we will
          * process all lines before a blank line as headers.
          */
 
         $field = substr($lines[0], 0, strpos($lines[0], ':'));
         $in_headers = false;
         if (!empty($field) && strpos($field, ' ') === false) {
             $in_headers = true;
         }
 
         foreach ($lines as $line) {
             $lines_out = array();
             if ($in_headers and $line == '') {
                 $in_headers = false;
             }
             //Break this line up into several smaller lines if it's too long
             //Micro-optimisation: isset($str[$len]) is faster than (strlen($str) > $len),
             while (isset($line[self::MAX_LINE_LENGTH])) {
                 //Working backwards, try to find a space within the last MAX_LINE_LENGTH chars of the line to break on
                 //so as to avoid breaking in the middle of a word
                 $pos = strrpos(substr($line, 0, self::MAX_LINE_LENGTH), ' ');
                 //Deliberately matches both false and 0
                 if (!$pos) {
                     //No nice break found, add a hard break
                     $pos = self::MAX_LINE_LENGTH - 1;
                     $lines_out[] = substr($line, 0, $pos);
                     $line = substr($line, $pos);
                 } else {
                     //Break at the found point
                     $lines_out[] = substr($line, 0, $pos);
                     //Move along by the amount we dealt with
                     $line = substr($line, $pos + 1);
                 }
                 //If processing headers add a LWSP-char to the front of new line RFC822 section 3.1.1
                 if ($in_headers) {
                     $line = "\t" . $line;
                 }
             }
             $lines_out[] = $line;
 
             //Send the lines to the server
             foreach ($lines_out as $line_out) {
                 //RFC2821 section 4.5.2
                 if (!empty($line_out) and $line_out[0] == '.') {
                     $line_out = '.' . $line_out;
                 }
                 $this->client_send($line_out . self::CRLF);
             }
         }
 
         //Message data has been sent, complete the command
         //Increase timelimit for end of DATA command
         $savetimelimit = $this->Timelimit;
         $this->Timelimit = $this->Timelimit * 2;
         $result = $this->sendCommand('DATA END', '.', 250);
         //Restore timelimit
         $this->Timelimit = $savetimelimit;
         return $result;
     }

Here is the call graph for this function:

◆ edebug()

SMTP::edebug	(	$str,
		$level = `0`
	)

protected

Output debugging info via a user-selected method.

See also: SMTP::$Debugoutput; SMTP::$do_debug

Parameters

string	$str	Debug string to output
integer	$level	The debug level of this message; see DEBUG_* constants

Returns: void

Definition at line 213 of file class.smtp.php.

References array, and Monolog\Handler\error_log().

Referenced by authenticate(), client_send(), close(), connect(), connected(), errorHandler(), get_lines(), sendCommand(), and turn().

     {
         if ($level > $this->do_debug) {
             return;
         }
         //Avoid clash with built-in function names
         if (!in_array($this->Debugoutput, array('error_log', 'html', 'echo')) and is_callable($this->Debugoutput)) {
             call_user_func($this->Debugoutput, $str, $level);
             return;
         }
         switch ($this->Debugoutput) {
             case 'error_log':
                 //Don't output, just log
                 error_log($str);
                 break;
             case 'html':
                 //Cleans up output a bit for a better looking, HTML-safe output
                 echo gmdate('Y-m-d H:i:s') . ' ' . htmlentities(
                     preg_replace('/[\r\n]+/', '', $str),
                     ENT_QUOTES,
                     'UTF-8'
                 ) . "<br>\n";
                 break;
             case 'echo':
             default:
                 //Normalize line breaks
                 $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
                 echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
                     "\n",
                     "\n                   \t                  ",
                     trim($str)
                 ) . "\n";
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ errorHandler()

SMTP::errorHandler	(	$errno,
		$errmsg,
		$errfile = `''`,
		$errline = `0`
	)

protected

Reports an error number and string.

Parameters

integer	$errno	The error number returned by PHP.
string	$errmsg	The error message returned by PHP.
string	$errfile	The file the error occurred in
integer	$errline	The line number the error occurred on

Definition at line 1219 of file class.smtp.php.

References edebug(), and setError().

     {
         $notice = 'Connection failed.';
         $this->setError(
             $notice,
             $errno,
             $errmsg
         );
         $this->edebug(
             $notice . ' Error #' . $errno . ': ' . $errmsg . " [$errfile line $errline]",
             self::DEBUG_CONNECTION
         );
     }

Here is the call graph for this function:

◆ get_lines()

SMTP::get_lines ( )

protected

Read the SMTP server's response.

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

Returns: string

Definition at line 1078 of file class.smtp.php.

References $data, $info, $Timelimit, edebug(), and time.

Referenced by connect(), and sendCommand().

     {
         // If the connection is bad, give up straight away
         if (!is_resource($this->smtp_conn)) {
             return '';
         }
         $data = '';
         $endtime = 0;
         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);
             $this->edebug("SMTP -> get_lines(): \$data is \"$data\"", self::DEBUG_LOWLEVEL);
             $this->edebug("SMTP -> get_lines(): \$str is  \"$str\"", self::DEBUG_LOWLEVEL);
             $data .= $str;
             // If response is only 3 chars (not valid, but RFC5321 S4.2 says it must be handled),
             // or 4th character is a space, we are done reading, break the loop,
             // string array access is a micro-optimisation over strlen
             if (!isset($str[3]) or (isset($str[3]) and $str[3] == ' ')) {
                 break;
             }
             // Timed-out? Log and break
             $info = stream_get_meta_data($this->smtp_conn);
             if ($info['timed_out']) {
                 $this->edebug(
                     'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)',
                     self::DEBUG_LOWLEVEL
                 );
                 break;
             }
             // Now check if reads took too long
             if ($endtime and time() > $endtime) {
                 $this->edebug(
                     'SMTP -> get_lines(): timelimit reached (' .
                     $this->Timelimit . ' sec)',
                     self::DEBUG_LOWLEVEL
                 );
                 break;
             }
         }
         return $data;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDebugLevel()

SMTP::getDebugLevel ( )

Get debug output level.

Returns: integer

Definition at line 1189 of file class.smtp.php.

References $do_debug.

     {
         return $this->do_debug;
     }

◆ getDebugOutput()

SMTP::getDebugOutput ( )

Get debug output method.

Returns: string

Definition at line 1171 of file class.smtp.php.

References $Debugoutput.

     {
         return $this->Debugoutput;
     }

◆ getError()

SMTP::getError ( )

Get the latest error.

public

Returns: array

Definition at line 1003 of file class.smtp.php.

References $error.

     {
         return $this->error;
     }

◆ getLastReply()

SMTP::getLastReply ( )

Get the last reply from the server.

public

Returns: string

Definition at line 1064 of file class.smtp.php.

References $last_reply.

Referenced by getLastTransactionID().

     {
         return $this->last_reply;
     }

Here is the caller graph for this function:

◆ getLastTransactionID()

SMTP::getLastTransactionID ( )

Will return the ID of the last smtp transaction based on a list of patterns provided in SMTP::$smtp_transaction_id_patterns.

If no reply has been received yet, it will return null. If no pattern has been matched, it will return false.

Returns: bool|null|string

Definition at line 1240 of file class.smtp.php.

References getLastReply().

     {
         $reply = $this->getLastReply();
 
         if (empty($reply)) {
             return null;
         }
 
         foreach ($this->smtp_transaction_id_patterns as $smtp_transaction_id_pattern) {
             if (preg_match($smtp_transaction_id_pattern, $reply, $matches)) {
                 return $matches[1];
             }
         }
 
         return false;
     }

Here is the call graph for this function:

◆ getServerExt()

SMTP::getServerExt ( $name )

A multipurpose method The method works in three ways, dependent on argument value and current state.

HELO/EHLO was not sent - returns null and set up $this->error
HELO was sent $name = 'HELO': returns server name $name = 'EHLO': returns boolean false $name = any string: returns null and set up $this->error
EHLO was sent $name = 'HELO'|'EHLO': returns server name $name = any string: if extension $name exists, returns boolean True or its options. Otherwise returns boolean False In other words, one can use this method to detect 3 conditions:

null returned: handshake was not or we don't know about ext (refer to $this->error)

false returned: the requested feature exactly not exists
positive value returned: the requested feature exists
Parameters

string $name Name of SMTP extension or 'HELO'|'EHLO'

Returns
mixed

Definition at line 1037 of file class.smtp.php.

References $name, and setError().

     {
         if (!$this->server_caps) {
             $this->setError('No HELO/EHLO was sent');
             return null;
         }
 
         // the tight logic knot ;)
         if (!array_key_exists($name, $this->server_caps)) {
             if ($name == 'HELO') {
                 return $this->server_caps['EHLO'];
             }
             if ($name == 'EHLO' || array_key_exists('EHLO', $this->server_caps)) {
                 return false;
             }
             $this->setError('HELO handshake was used. Client knows nothing about server extensions');
             return null;
         }
 
         return $this->server_caps[$name];
     }

Here is the call graph for this function:

◆ getServerExtList()

SMTP::getServerExtList ( )

Get SMTP extensions available on the server public.

Returns: array|null

Definition at line 1013 of file class.smtp.php.

References $server_caps.

     {
         return $this->server_caps;
     }

◆ getTimeout()

SMTP::getTimeout ( )

Get SMTP timeout.

Returns: integer

Definition at line 1207 of file class.smtp.php.

References $Timeout.

     {
         return $this->Timeout;
     }

◆ getVerp()

SMTP::getVerp ( )

Get VERP address generation mode.

Returns: boolean

Definition at line 1136 of file class.smtp.php.

References $do_verp.

     {
         return $this->do_verp;
     }

◆ hello()

SMTP::hello ( $host = '' )

Send an SMTP HELO or EHLO command.

Used to identify the sending server to the receiving server. This makes sure that client and server are in a known state. Implements RFC 821: HELO <SP> <domain> <CRLF> and RFC 2821 EHLO.

Parameters

string $host The host name or IP to connect to public

Returns: boolean

Definition at line 727 of file class.smtp.php.

References sendHello().

     {
         //Try extended hello first (RFC 2821)
         return (boolean)($this->sendHello('EHLO', $host) or $this->sendHello('HELO', $host));
     }

Here is the call graph for this function:

◆ hmac()

SMTP::hmac	(	$data,
		$key
	)

protected

Calculate an MD5 HMAC hash.

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

Parameters

string	$data	The data to hash
string	$key	The key to hash with protected

Returns: string

Definition at line 556 of file class.smtp.php.

References $data, and $key.

Referenced by 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
         // by Lance Rushing
 
         $bytelen = 64; // byte length for md5
         if (strlen($key) > $bytelen) {
             $key = pack('H*', md5($key));
         }
         $key = str_pad($key, $bytelen, chr(0x00));
         $ipad = str_pad('', $bytelen, chr(0x36));
         $opad = str_pad('', $bytelen, chr(0x5c));
         $k_ipad = $key ^ $ipad;
         $k_opad = $key ^ $opad;
 
         return md5($k_opad . pack('H*', md5($k_ipad . $data)));
     }

Here is the caller graph for this function:

◆ mail()

SMTP::mail ( $from )

Send an SMTP MAIL command.

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>

Parameters

string $from Source address of this message public

Returns: boolean

Definition at line 807 of file class.smtp.php.

References $from, and sendCommand().

     {
         $useVerp = ($this->do_verp ? ' XVERP' : '');
         return $this->sendCommand(
             'MAIL FROM',
             'MAIL FROM:<' . $from . '>' . $useVerp,
             250
         );
     }

Here is the call graph for this function:

◆ noop()

SMTP::noop ( )

Send an SMTP NOOP command.

Used to keep keep-alives alive, doesn't actually do anything public

Returns: boolean

Definition at line 962 of file class.smtp.php.

References sendCommand().

     {
         return $this->sendCommand('NOOP', 'NOOP', 250);
     }

Here is the call graph for this function:

◆ parseHelloFields()

SMTP::parseHelloFields ( $type )

protected

Parse a reply to HELO/EHLO command to discover server extensions.

In case of HELO, the only parameter that can be discovered is a server name. protected

Parameters

string $type - 'HELO' or 'EHLO'

Definition at line 760 of file class.smtp.php.

References $n, $name, $s, $type, and array.

Referenced by sendHello().

     {
         $this->server_caps = array();
         $lines = explode("\n", $this->helo_rply);
 
         foreach ($lines as $n => $s) {
             //First 4 chars contain response code followed by - or space
             $s = trim(substr($s, 4));
             if (empty($s)) {
                 continue;
             }
             $fields = explode(' ', $s);
             if (!empty($fields)) {
                 if (!$n) {
                     $name = $type;
                     $fields = $fields[0];
                 } else {
                     $name = array_shift($fields);
                     switch ($name) {
                         case 'SIZE':
                             $fields = ($fields ? $fields[0] : 0);
                             break;
                         case 'AUTH':
                             if (!is_array($fields)) {
                                 $fields = array();
                             }
                             break;
                         default:
                             $fields = true;
                     }
                 }
                 $this->server_caps[$name] = $fields;
             }
         }
     }

Here is the caller graph for this function:

◆ quit()

SMTP::quit ( $close_on_error = true )

Send an SMTP QUIT command.

Closes the socket if there is no error or the $close_on_error argument is true. Implements from rfc 821: QUIT <CRLF>

Parameters

boolean $close_on_error Should the connection close if an error occurs? public

Returns: boolean

Definition at line 825 of file class.smtp.php.

References $error, close(), and sendCommand().

     {
         $noerror = $this->sendCommand('QUIT', 'QUIT', 221);
         $err = $this->error; //Save any error
         if ($noerror or $close_on_error) {
             $this->close();
             $this->error = $err; //Restore any error from the quit command
         }
         return $noerror;
     }

Here is the call graph for this function:

◆ recipient()

SMTP::recipient ( $address )

Send an SMTP RCPT command.

Sets the TO argument to $toaddr. Returns true if the recipient was accepted false if it was rejected. Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>

Parameters

string $address The address the message is being sent to public

Returns: boolean

Definition at line 845 of file class.smtp.php.

References array, and sendCommand().

     {
         return $this->sendCommand(
             'RCPT TO',
             'RCPT TO:<' . $address . '>',
             array(250, 251)
         );
     }

Here is the call graph for this function:

◆ reset()

SMTP::reset ( )

Send an SMTP RSET command.

Abort any transaction that is currently in progress. Implements rfc 821: RSET <CRLF> public

Returns: boolean True on success.

Definition at line 861 of file class.smtp.php.

References sendCommand().

     {
         return $this->sendCommand('RSET', 'RSET', 250);
     }

Here is the call graph for this function:

◆ sendAndMail()

SMTP::sendAndMail ( $from )

Send an SMTP SAML command.

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>

Parameters

string $from The address the message is from public

Returns: boolean

Definition at line 940 of file class.smtp.php.

References sendCommand().

     {
         return $this->sendCommand('SAML', "SAML FROM:$from", 250);
     }

Here is the call graph for this function:

◆ sendCommand()

SMTP::sendCommand	(	$command,
		$commandstring,
		$expect
	)

protected

Send a command to an SMTP server and check its return code.

Parameters

string	$command	The command name - not sent to the server
string	$commandstring	The actual command to send
integer \| array	$expect	One or more expected integer success codes protected

Returns: boolean True on success.

Definition at line 874 of file class.smtp.php.

References $code, array, client_send(), connected(), edebug(), get_lines(), and setError().

Referenced by authenticate(), data(), mail(), noop(), quit(), recipient(), reset(), sendAndMail(), sendHello(), startTLS(), and verify().

     {
         if (!$this->connected()) {
             $this->setError("Called $command without being connected");
             return false;
         }
         //Reject line breaks in all commands
         if (strpos($commandstring, "\n") !== false or strpos($commandstring, "\r") !== false) {
             $this->setError("Command '$command' contained line breaks");
             return false;
         }
         $this->client_send($commandstring . self::CRLF);
 
         $this->last_reply = $this->get_lines();
         // Fetch SMTP code and possible error code explanation
         $matches = array();
         if (preg_match("/^([0-9]{3})[ -](?:([0-9]\\.[0-9]\\.[0-9]) )?/", $this->last_reply, $matches)) {
             $code = $matches[1];
             $code_ex = (count($matches) > 2 ? $matches[2] : null);
             // Cut off error code from each response line
             $detail = preg_replace(
                 "/{$code}[ -]" .
                 ($code_ex ? str_replace('.', '\\.', $code_ex) . ' ' : '') . "/m",
                 '',
                 $this->last_reply
             );
         } else {
             // Fall back to simple parsing if regex fails
             $code = substr($this->last_reply, 0, 3);
             $code_ex = null;
             $detail = substr($this->last_reply, 4);
         }
 
         $this->edebug('SERVER -> CLIENT: ' . $this->last_reply, self::DEBUG_SERVER);
 
         if (!in_array($code, (array)$expect)) {
             $this->setError(
                 "$command command failed",
                 $detail,
                 $code,
                 $code_ex
             );
             $this->edebug(
                 'SMTP ERROR: ' . $this->error['error'] . ': ' . $this->last_reply,
                 self::DEBUG_CLIENT
             );
             return false;
         }
 
         $this->setError('');
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendHello()

SMTP::sendHello	(	$hello,
		$host
	)

protected

Send an SMTP HELO or EHLO command.

Low-level implementation used by hello()

See also: hello()

Parameters

string	$hello	The HELO string
string	$host	The hostname to say we are protected

Returns: boolean

Definition at line 742 of file class.smtp.php.

References $last_reply, parseHelloFields(), and sendCommand().

Referenced by hello().

     {
         $noerror = $this->sendCommand($hello, $hello . ' ' . $host, 250);
         $this->helo_rply = $this->last_reply;
         if ($noerror) {
             $this->parseHelloFields($hello);
         } else {
             $this->server_caps = null;
         }
         return $noerror;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDebugLevel()

SMTP::setDebugLevel ( $level = 0 )

Set debug output level.

Parameters

integer $level

Definition at line 1180 of file class.smtp.php.

     {
         $this->do_debug = $level;
     }

◆ setDebugOutput()

SMTP::setDebugOutput ( $method = 'echo' )

Set debug output method.

Parameters

string | callable $method The name of the mechanism to use for debugging output, or a callable to handle it.

Definition at line 1162 of file class.smtp.php.

     {
         $this->Debugoutput = $method;
     }

◆ setError()

SMTP::setError	(	$message,
		$detail = `''`,
		$smtp_code = `''`,
		$smtp_code_ex = `''`
	)

protected

Set error messages and codes.

Parameters

string	$message	The error message
string	$detail	Further detail on the error
string	$smtp_code	An associated SMTP error code
string	$smtp_code_ex	Extended SMTP code

Definition at line 1148 of file class.smtp.php.

References $message, and array.

Referenced by authenticate(), close(), connect(), errorHandler(), getServerExt(), sendCommand(), and turn().

     {
         $this->error = array(
             'error' => $message,
             'detail' => $detail,
             'smtp_code' => $smtp_code,
             'smtp_code_ex' => $smtp_code_ex
         );
     }

Here is the caller graph for this function:

◆ setTimeout()

SMTP::setTimeout ( $timeout = 0 )

Set SMTP timeout.

Parameters

integer $timeout

Definition at line 1198 of file class.smtp.php.

     {
         $this->Timeout = $timeout;
     }

◆ setVerp()

SMTP::setVerp ( $enabled = false )

Enable or disable VERP address generation.

Parameters

boolean $enabled

Definition at line 1127 of file class.smtp.php.

     {
         $this->do_verp = $enabled;
     }

◆ startTLS()

SMTP::startTLS ( )

Initiate a TLS (encrypted) session.

public

Returns: boolean

Definition at line 348 of file class.smtp.php.

References array, defined, and sendCommand().

     {
         if (!$this->sendCommand('STARTTLS', 'STARTTLS', 220)) {
             return false;
         }
 
         //Allow the best TLS version(s) we can
         $crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT;
 
         //PHP 5.6.7 dropped inclusion of TLS 1.1 and 1.2 in STREAM_CRYPTO_METHOD_TLS_CLIENT
         //so add them back in manually if we can
         if (defined('STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT')) {
             $crypto_method |= STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
             $crypto_method |= STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT;
         }
 
         // Begin encrypted connection
         set_error_handler(array($this, 'errorHandler'));
         $crypto_ok = stream_socket_enable_crypto(
             $this->smtp_conn,
             true,
             $crypto_method
         );
         restore_error_handler();
         return $crypto_ok;
     }

Here is the call graph for this function:

◆ turn()

SMTP::turn ( )

Send an SMTP TURN command.

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 implemented in future Implements from rfc 821: TURN <CRLF> public

Returns: boolean

Definition at line 976 of file class.smtp.php.

References edebug(), and setError().

     {
         $this->setError('The SMTP TURN command is not implemented');
         $this->edebug('SMTP NOTICE: ' . $this->error['error'], self::DEBUG_CLIENT);
         return false;
     }

Here is the call graph for this function:

◆ verify()

SMTP::verify ( $name )

Send an SMTP VRFY command.

Parameters

string $name The name to verify public

Returns: boolean

Definition at line 951 of file class.smtp.php.

References array, and sendCommand().

     {
         return $this->sendCommand('VRFY', "VRFY $name", array(250, 251));
     }

Here is the call graph for this function:

Field Documentation

◆ $CRLF

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

Definition at line 100 of file class.smtp.php.

◆ $Debugoutput

SMTP::$Debugoutput = 'echo'

Definition at line 127 of file class.smtp.php.

Referenced by getDebugOutput().

◆ $do_debug

SMTP::$do_debug = self::DEBUG_OFF

Definition at line 112 of file class.smtp.php.

Referenced by getDebugLevel().

◆ $do_verp

SMTP::$do_verp = false

Definition at line 135 of file class.smtp.php.

Referenced by getVerp().

◆ $error

SMTP::$error

protected

Initial value:

= array(
        'error' => '',
        'detail' => '',
        'smtp_code' => '',
        'smtp_code_ex' => ''
    )

Definition at line 174 of file class.smtp.php.

Referenced by getError(), and quit().

◆ $helo_rply

SMTP::$helo_rply = null

protected

Definition at line 186 of file class.smtp.php.

◆ $last_reply

SMTP::$last_reply = ''

protected

Definition at line 203 of file class.smtp.php.

Referenced by getLastReply(), and sendHello().

◆ $server_caps

SMTP::$server_caps = null

protected

Definition at line 197 of file class.smtp.php.

Referenced by getServerExtList().

◆ $smtp_conn

SMTP::$smtp_conn

protected

Definition at line 168 of file class.smtp.php.

◆ $SMTP_PORT

SMTP::$SMTP_PORT = 25

Definition at line 92 of file class.smtp.php.

◆ $smtp_transaction_id_patterns

SMTP::$smtp_transaction_id_patterns

protected

Initial value:

= array(
        'exim' => '/[0-9]{3} OK id=(.*)/',
        'sendmail' => '/[0-9]{3} 2.0.0 (.*) Message/',
        'postfix' => '/[0-9]{3} 2.0.0 Ok: queued as (.*)/'
    )

Definition at line 158 of file class.smtp.php.

◆ $Timelimit

SMTP::$Timelimit = 300

Definition at line 151 of file class.smtp.php.

Referenced by data(), and get_lines().

◆ $Timeout

SMTP::$Timeout = 300

Definition at line 144 of file class.smtp.php.

Referenced by getTimeout().

◆ $Version

SMTP::$Version = '5.2.24'

Definition at line 84 of file class.smtp.php.

◆ CRLF

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

Definition at line 39 of file class.smtp.php.

◆ DEBUG_CLIENT

const SMTP::DEBUG_CLIENT = 1

Debug level to show client -> server messages.

Definition at line 61 of file class.smtp.php.

◆ DEBUG_CONNECTION

const SMTP::DEBUG_CONNECTION = 3

Debug level to show connection status, client -> server and server -> client messages.

Definition at line 71 of file class.smtp.php.

◆ DEBUG_LOWLEVEL

const SMTP::DEBUG_LOWLEVEL = 4

Debug level to show all messages.

Definition at line 76 of file class.smtp.php.

◆ DEBUG_OFF

const SMTP::DEBUG_OFF = 0

Debug level for no output.

Definition at line 56 of file class.smtp.php.

◆ DEBUG_SERVER

const SMTP::DEBUG_SERVER = 2

Debug level to show client -> server and server -> client messages.

Definition at line 66 of file class.smtp.php.

◆ DEFAULT_SMTP_PORT

const SMTP::DEFAULT_SMTP_PORT = 25

Definition at line 45 of file class.smtp.php.

◆ MAX_LINE_LENGTH

const SMTP::MAX_LINE_LENGTH = 998

Definition at line 51 of file class.smtp.php.

◆ VERSION

const SMTP::VERSION = '5.2.24'

Definition at line 33 of file class.smtp.php.

The documentation for this class was generated from the following file:

libs/composer/vendor/phpmailer/phpmailer/class.smtp.php

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ authenticate()

◆ client_send()

◆ close()

◆ connect()

◆ connected()

◆ data()

◆ edebug()

◆ errorHandler()

◆ get_lines()

◆ getDebugLevel()

◆ getDebugOutput()

◆ getError()

◆ getLastReply()

◆ getLastTransactionID()

◆ getServerExt()

◆ getServerExtList()

◆ getTimeout()

◆ getVerp()

◆ hello()

◆ hmac()

◆ mail()

◆ noop()

◆ parseHelloFields()

◆ quit()

◆ recipient()

◆ reset()

◆ sendAndMail()

◆ sendCommand()

◆ sendHello()

◆ setDebugLevel()

◆ setDebugOutput()

◆ setError()

◆ setTimeout()

◆ setVerp()

◆ startTLS()

◆ turn()

◆ verify()

Field Documentation

◆ $CRLF

◆ $Debugoutput

◆ $do_debug

◆ $do_verp

◆ $error

◆ $helo_rply

◆ $last_reply

◆ $server_caps

◆ $smtp_conn

◆ $SMTP_PORT

◆ $smtp_transaction_id_patterns

◆ $Timelimit

◆ $Timeout

◆ $Version

◆ CRLF

◆ DEBUG_CLIENT

◆ DEBUG_CONNECTION

◆ DEBUG_LOWLEVEL

◆ DEBUG_OFF

◆ DEBUG_SERVER

◆ DEFAULT_SMTP_PORT

◆ MAX_LINE_LENGTH

◆ VERSION