pfSense

<?php

/*

 * smtp.php

 *

 * @(#) $Header: /opt2/ena/metal/smtp/smtp.php,v 1.50 2016/01/19 00:16:06 mlemos Exp $

 *

 */

/*

{metadocument}<?xml version="1.0" encoding="ISO-8859-1"?>

<class>

	<package>net.manuellemos.smtp</package>

	<version>@(#) $Id: smtp.php,v 1.50 2016/01/19 00:16:06 mlemos Exp $</version>

	<copyright>Copyright (C) Manuel Lemos 1999-2011</copyright>

	<title>Sending e-mail messages via SMTP protocol</title>

	<author>Manuel Lemos</author>

	<authoraddress>mlemos-at-acm.org</authoraddress>

	<documentation>

		<idiom>en</idiom>

		<purpose>Sending e-mail messages via SMTP protocol</purpose>

		<translation>If you are interested in translating the documentation of

			this class to your own idiom, please <link>

				<data>contact the author</data>

				<url>mailto:<getclassproperty>authoraddress</getclassproperty></url>

			</link>.</translation>

		<support>Technical support for using this class may be obtained in the

			<tt>smtpclass</tt> support forum. Just go to the support forum pages

			page to browse the forum archives and post support request

			messages:<paragraphbreak />

			<link>

				<data>http://www.phpclasses.org/discuss/package/14/</data>

				<url>http://www.phpclasses.org/discuss/package/14/</url>

			</link></support>

		<usage>To use this class just create a new object, set any variables

			to configure its options and call the

			<functionlink>SendMessage</functionlink> function to send a

			message.<paragraphbreak />It is not recommended that you use this

			class alone unless you have deep understanding of Internet mail

			standards on how to compose compliant e-mail messages. Instead, use

			the <link>

				<data>MIME message composing and sending class</data>

				<url>http://www.phpclasses.org/mimemessage</url>

			</link> and its sub-class SMTP message together with this SMTP class

			to properly compose e-mail messages, so your messages are not

			discarded for not being correctly composed.</usage>

	</documentation>

{/metadocument}

*/

class smtp_class

{

/*

{metadocument}

	<variable>

		<name>user</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the authorized user when sending messages to a SMTP

				server.</purpose>

			<usage>Set this variable to the user name when the SMTP server

				requires authentication.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $user="";

/*

{metadocument}

	<variable>

		<name>realm</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the authentication realm when sending messages to a

				SMTP server.</purpose>

			<usage>Set this variable when the SMTP server requires

				authentication and if more than one authentication realm is

				supported.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $realm="";

/*

{metadocument}

	<variable>

		<name>password</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the authorized user password when sending messages

				to a SMTP server.</purpose>

			<usage>Set this variable to the user password when the SMTP server

				requires authentication.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $password="";

/*

{metadocument}

	<variable>

		<name>workstation</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the client workstation name when sending messages

				to a SMTP server.</purpose>

			<usage>Set this variable to the client workstation when the SMTP

				server requires authentication identifiying the origin workstation

				name.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $workstation="";

/*

{metadocument}

	<variable>

		<name>authentication_mechanism</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Force the use of a specific authentication mechanism.</purpose>

			<usage>Set it to an empty string to let the class determine the

				authentication mechanism to use automatically based on the

				supported mechanisms by the server and by the SASL client library

				classes.<paragraphbreak />

				Set this variable to a specific mechanism name if you want to

				override the automatic authentication mechanism selection.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $authentication_mechanism="";

/*

{metadocument}

	<variable>

		<name>host_name</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the SMTP server host name.</purpose>

			<usage>Set to the host name of the SMTP server to which you want to

				relay the messages.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $host_name="";

/*

{metadocument}

	<variable>

		<name>host_port</name>

		<type>INTEGER</type>

		<value>25</value>

		<documentation>

			<purpose>Define the SMTP server host port.</purpose>

			<usage>Set to the TCP port of the SMTP server host to connect.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $host_port=25;

/*

{metadocument}

	<variable>

		<name>socks_host_name</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the SOCKS server host name.</purpose>

			<usage>Set to the SOCKS server host name through which the SMTP

				connection should be routed. Leave it empty if you do not want the

				connections to be established through a SOCKS server.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $socks_host_name = '';

/*

{metadocument}

	<variable>

		<name>socks_host_port</name>

		<type>INTEGER</type>

		<value>1080</value>

		<documentation>

			<purpose>Define the SOCKS server host port.</purpose>

			<usage>Set to the port of the SOCKS server host through which the

				the SMTP connection should be routed.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $socks_host_port=1080;

/*

{metadocument}

	<variable>

		<name>socks_version</name>

		<type>STRING</type>

		<value>5</value>

		<documentation>

			<purpose>Set the SOCKS protocol version.</purpose>

			<usage>Change this value if SOCKS server you want to use is

				listening to a different port.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $socks_version='5';

/*

{metadocument}

	<variable>

		<name>http_proxy_host_name</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Define the HTTP proxy server host name.</purpose>

			<usage>Set to the HTTP proxy server host name through which the

				SMTP connection should be routed. Leave it empty if you do not

				want the connections to be established through an HTTP proxy.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $http_proxy_host_name = '';

/*

{metadocument}

	<variable>

		<name>http_proxy_host_port</name>

		<type>INTEGER</type>

		<value>80</value>

		<documentation>

			<purpose>Define the HTTP proxy server host port.</purpose>

			<usage>Set to the port of the HTTP proxy server host through which

				the SMTP connection should be routed.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $http_proxy_host_port=80;

/*

{metadocument}

	<variable>

		<name>user_agent</name>

		<type>STRING</type>

		<value>SMTP Class (http://www.phpclasses.org/smtpclass $Revision: 1.50 $)</value>

		<documentation>

			<purpose>Set the user agent used when connecting via an HTTP proxy.</purpose>

			<usage>Change this value only if for some reason you want emulate a

				certain e-mail client.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $user_agent='SMTP Class (http://www.phpclasses.org/smtpclass $Revision: 1.50 $)';

/*

{metadocument}

	<variable>

		<name>ssl</name>

		<type>BOOLEAN</type>

		<value>0</value>

		<documentation>

			<purpose>Define whether the connection to the SMTP server should be

				established securely using SSL protocol.</purpose>

			<usage>Set to <booleanvalue>1</booleanvalue> if the SMTP server

				requires secure connections using SSL protocol.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $ssl=0;

/*

{metadocument}

	<variable>

		<name>start_tls</name>

		<type>BOOLEAN</type>

		<value>0</value>

		<documentation>

			<purpose>Define whether the connection to the SMTP server should use

				encryption after the connection is established using TLS

				protocol.</purpose>

			<usage>Set to <booleanvalue>1</booleanvalue> if the SMTP server

				requires that authentication be done securely starting the TLS

				protocol after the connection is established.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $start_tls = 0;

/*

{metadocument}

	<variable>

		<name>localhost</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Name of the local host computer</purpose>

			<usage>Set to the name of the computer connecting to the SMTP

				server from the local network.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $localhost="";

/*

{metadocument}

	<variable>

		<name>timeout</name>

		<type>INTEGER</type>

		<value>0</value>

		<documentation>

			<purpose>Specify the connection timeout period in seconds.</purpose>

			<usage>Leave it set to <integervalue>0</integervalue> if you want

				the connection attempts to wait forever. Change this value if for

				some reason the timeout period seems insufficient or otherwise it

				seems too long.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $timeout=0;

/*

{metadocument}

	<variable>

		<name>data_timeout</name>

		<type>INTEGER</type>

		<value>0</value>

		<documentation>

			<purpose>Specify the timeout period in seconds to wait for data from

				the server.</purpose>

			<usage>Leave it set to <integervalue>0</integervalue> if you want

				to use the same value defined in the

				<variablelink>timeout</variablelink> variable. Change this value

				if for some reason the default data timeout period seems

				insufficient or otherwise it seems too long.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $data_timeout=0;

/*

{metadocument}

	<variable>

		<name>direct_delivery</name>

		<type>BOOLEAN</type>

		<value>0</value>

		<documentation>

			<purpose>Boolean flag that indicates whether the message should be

				sent in direct delivery mode, i.e. the message is sent to the SMTP

				server associated to the domain of the recipient instead of

				relaying to the server specified by the

				<variablelink>host_name</variablelink> variable.</purpose>

			<usage>Set this to <tt><booleanvalue>1</booleanvalue></tt> if you

				want to send urgent messages directly to the recipient domain SMTP

				server.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $direct_delivery=0;

/*

{metadocument}

	<variable>

		<name>error</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Message that describes the error when a call to a class

				function fails.</purpose>

			<usage>Check this variable when an error occurs to understand what

				happened.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $error="";

/*

{metadocument}

	<variable>

		<name>debug</name>

		<type>BOOLEAN</type>

		<value>0</value>

		<documentation>

			<purpose>Specify whether it is necessary to output SMTP connection

				debug information.</purpose>

			<usage>Set this variable to

				<tt><booleanvalue>1</booleanvalue></tt> if you need to see

				the progress of the SMTP connection and protocol dialog when you

				need to understand the reason for delivery problems.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $debug=0;

/*

{metadocument}

	<variable>

		<name>html_debug</name>

		<type>BOOLEAN</type>

		<value>0</value>

		<documentation>

			<purpose>Specify whether the debug information should be outputted in

				HTML format.</purpose>

			<usage>Set this variable to

				<tt><booleanvalue>1</booleanvalue></tt> if you need to see

				the debug output in a Web page.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $html_debug=0;

/*

{metadocument}

	<variable>

		<name>esmtp</name>

		<type>BOOLEAN</type>

		<value>1</value>

		<documentation>

			<purpose>Specify whether the class should attempt to use ESMTP

				extensions supported by the server.</purpose>

			<usage>Set this variable to

				<tt><booleanvalue>0</booleanvalue></tt> if for some reason you

				want to avoid benefitting from ESMTP extensions.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $esmtp=1;

/*

{metadocument}

	<variable>

		<name>esmtp_extensions</name>

		<type>HASH</type>

		<value></value>

		<documentation>

			<purpose>Associative array with the list of ESMTP extensions

				supported by the SMTP server.</purpose>

			<usage>Check this variable after connecting to the SMTP server to

				determine which ESMTP extensions are supported.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $esmtp_extensions=array();

/*

{metadocument}

	<variable>

		<name>exclude_address</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Specify an address that should be considered invalid

				when resolving host name addresses.</purpose>

			<usage>In some networks any domain name that does not exist is

				resolved as a sub-domain of the default local domain. If the DNS is

				configured in such way that it always resolves any sub-domain of

				the default local domain to a given address, it is hard to

				determine whether a given domain does not exist.<paragraphbreak />

				If your network is configured this way, you may set this variable

				to the address that all sub-domains of the default local domain

				resolves, so the class can assume that such address is invalid.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $exclude_address="";

/*

{metadocument}

	<variable>

		<name>getmxrr</name>

		<type>STRING</type>

		<value>getmxrr</value>

		<documentation>

			<purpose>Specify the name of the function that is called to determine

				the SMTP server address of a given domain.</purpose>

			<usage>Change this to a working replacement of the PHP

				<tt>getmxrr()</tt> function if this is not working in your system

					and you want to send messages in direct delivery mode.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $getmxrr="GetMXRR";

/*

{metadocument}

	<variable>

		<name>pop3_auth_host</name>

		<type>STRING</type>

		<value></value>

		<documentation>

			<purpose>Specify the server address for POP3 based authentication.</purpose>

			<usage>Set this variable to the address of the POP3 server if the

				SMTP server requires POP3 based authentication.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $pop3_auth_host="";

/*

{metadocument}

	<variable>

		<name>pop3_auth_port</name>

		<type>INTEGER</type>

		<value>110</value>

		<documentation>

			<purpose>Specify the server port for POP3 based authentication.</purpose>

			<usage>Set this variable to the port of the POP3 server if the

				SMTP server requires POP3 based authentication.</usage>

		</documentation>

	</variable>

{/metadocument}

*/

	var $pop3_auth_port=110;

	/* private variables - DO NOT ACCESS */

	var $state="Disconnected";

	var $connection=0;

	var $pending_recipients=0;

	var $next_token="";

	var $direct_sender="";

	var $connected_domain="";

	var $result_code;

	var $disconnected_error=0;

	var $esmtp_host="";

	var $maximum_piped_recipients=100;

	/* Private methods - DO NOT CALL */

	Function Tokenize($string,$separator="")

	{

		if(!strcmp($separator,""))

		{

			$separator=$string;

			$string=$this->next_token;

		}

		for($character=0;$character<strlen($separator);$character++)

		{

			if(GetType($position=strpos($string,$separator[$character]))=="integer")

				$found=(IsSet($found) ? min($found,$position) : $position);

		}

		if(IsSet($found))

		{

			$this->next_token=substr($string,$found+1);

			return(substr($string,0,$found));

		}

		else

		{

			$this->next_token="";

			return($string);

		}

	}

	Function OutputDebug($message)

	{

		$message.="\n";

		if($this->html_debug)

			$message=str_replace("\n","<br />\n",HtmlEntities($message));

		echo $message;

		flush();

	}

	Function SetDataAccessError($error)

	{

		$this->error=$error;

		if(function_exists("socket_get_status"))

		{

			$status=socket_get_status($this->connection);

			if($status["timed_out"])

				$this->error.=": data access time out";

			elseif($status["eof"])

			{

				$this->error.=": the server disconnected";

				$this->disconnected_error=1;

			}

		}

		return($this->error);

	}

	Function SetError($error)

	{

		return($this->error=$error);

	}

	Function GetLine()

	{

		for($line="";;)

		{

			if(feof($this->connection))

			{

				$this->error="reached the end of data while reading from the SMTP server conection";

				return("");

			}

			if(GetType($data=@fgets($this->connection,100))!="string"

			|| strlen($data)==0)

			{

				$this->SetDataAccessError("it was not possible to read line from the SMTP server");

				return("");

			}

			$line.=$data;

			$length=strlen($line);

			if($length>=2

			&& substr($line,$length-2,2)=="\r\n")

			{

				$line=substr($line,0,$length-2);

				if($this->debug)

					$this->OutputDebug("S $line");

				return($line);

			}

		}

	}

	Function PutLine($line)

	{

		if($this->debug)

			$this->OutputDebug("C $line");

		if(!@fputs($this->connection,"$line\r\n"))

		{

			$this->SetDataAccessError("it was not possible to send a line to the SMTP server");

			return(0);

		}

		return(1);

	}

	Function PutData(&$data)

	{

		if(strlen($data))

		{

			if($this->debug)

				$this->OutputDebug("C $data");

			if(!@fputs($this->connection,$data))

			{

				$this->SetDataAccessError("it was not possible to send data to the SMTP server");

				return(0);

			}

		}

		return(1);

	}

	Function VerifyResultLines($code,&$responses)

	{

		$responses=array();

		Unset($this->result_code);

		while(strlen($line=$this->GetLine($this->connection)))

		{

			if(IsSet($this->result_code))

			{

				if(strcmp($this->Tokenize($line," -"),$this->result_code))

				{

					$this->error=$line;

					return(0);

				}

			}

			else

			{

				$this->result_code=$this->Tokenize($line," -");

				if(GetType($code)=="array")

				{

					for($codes=0;$codes<count($code) && strcmp($this->result_code,$code[$codes]);$codes++);

					if($codes>=count($code))

					{

						$this->error=$line;

						return(0);

					}

				}

				else

				{

					if(strcmp($this->result_code,$code))

					{

						$this->error=$line;

						return(0);

					}

				}

			}

			$responses[]=$this->Tokenize("");

			if(!strcmp($this->result_code,$this->Tokenize($line," ")))

				return(1);

		}

		return(-1);

	}

	Function FlushRecipients()

	{

		if($this->pending_sender)

		{

			if($this->VerifyResultLines("250",$responses)<=0)

				return(0);

			$this->pending_sender=0;

		}

		for(;$this->pending_recipients;$this->pending_recipients--)

		{

			if($this->VerifyResultLines(array("250","251"),$responses)<=0)

				return(0);

		}

		return(1);

	}

	Function Resolve($domain, &$ip, $server_type)

	{

		if(preg_match('/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/',$domain))

			$ip=$domain;

		else

		{

			if($this->debug)

				$this->OutputDebug('Resolving '.$server_type.' server domain "'.$domain.'"...');

			if(!strcmp($ip=@gethostbyname($domain),$domain))

				$ip="";

		}

		if(strlen($ip)==0

		|| (strlen($this->exclude_address)

		&& !strcmp(@gethostbyname($this->exclude_address),$ip)))

			return($this->SetError("could not resolve the host domain \"".$domain."\""));

		return('');

	}

	Function ConnectToHost($domain, $port, $resolve_message)

	{

		if($this->ssl)

		{

			$version=explode(".",function_exists("phpversion") ? phpversion() : "3.0.7");

			$php_version=intval($version[0])*1000000+intval($version[1])*1000+intval($version[2]);

			if($php_version<4003000)

				return("establishing SSL connections requires at least PHP version 4.3.0");

			if(!function_exists("extension_loaded")

			|| !extension_loaded("openssl"))

				return("establishing SSL connections requires the OpenSSL extension enabled");

		}

		if(strlen($this->Resolve($domain, $ip, 'SMTP')))

			return($this->error);

		if(strlen($this->socks_host_name))

		{

			switch($this->socks_version)

			{

				case '4':

					$version = 4;

					break;

				case '5':

					$version = 5;

					break;

				default:

					return('it was not specified a supported SOCKS protocol version');

					break;

			}

			$host_ip = $ip;

			$host_port = $port;

			if(strlen($this->error = $this->Resolve($this->socks_host_name, $ip, 'SOCKS')))

				return($this->error);

			if($this->ssl)

				$ip="ssl://".($socks_host = $this->socks_host_name);

			else

				$socks_host = $ip;

			if($this->debug)

				$this->OutputDebug("Connecting to SOCKS server \"".$socks_host."\" port ".$this->http_proxy_host_port."...");

			if(($this->connection=($this->timeout ? fsockopen($ip, $this->socks_host_port, $errno, $error, $this->timeout) : fsockopen($ip, $this->socks_host_port, $errno, $error))))

			{

				$timeout=($this->data_timeout ? $this->data_timeout : $this->timeout);

				if($timeout

				&& function_exists("socket_set_timeout"))

					socket_set_timeout($this->connection,$timeout,0);

				if(strlen($this->socks_host_name))

				{

					if($this->debug)

						$this->OutputDebug('Connected to the SOCKS server '.$this->socks_host_name);

					$send_error = 'it was not possible to send data to the SOCKS server';

					$receive_error = 'it was not possible to receive data from the SOCKS server';

					switch($version)

					{

						case 4:

							$command = 1;

							$user = '';

							if(!fputs($this->connection, chr($version).chr($command).pack('nN', $host_port, ip2long($host_ip)).$user.Chr(0)))

								$error = $this->SetDataAccessError($send_error);

							else

							{

								$response = fgets($this->connection, 9);

								if(strlen($response) != 8)

									$error = $this->SetDataAccessError($receive_error);

								else

								{

									$socks_errors = array(

										"\x5a"=>'',

										"\x5b"=>'request rejected',

										"\x5c"=>'request failed because client is not running identd (or not reachable from the server)',

										"\x5d"=>'request failed because client\'s identd could not confirm the user ID string in the request',

									);

									$error_code = $response[1];

									$error = (IsSet($socks_errors[$error_code]) ? $socks_errors[$error_code] : 'unknown');

									if(strlen($error))

										$error = 'SOCKS error: '.$error;

								}

							}

							break;

						case 5:

							if($this->debug)

								$this->OutputDebug('Negotiating the authentication method ...');

							$methods = 1;

							$method = 0;

							if(!fputs($this->connection, chr($version).chr($methods).chr($method)))

								$error = $this->SetDataAccessError($send_error);

							else

							{

								$response = fgets($this->connection, 3);

								if(strlen($response) != 2)

									$error = $this->SetDataAccessError($receive_error);

								elseif(Ord($response[1]) != $method)

									$error = 'the SOCKS server requires an authentication method that is not yet supported';

								else

								{

									if($this->debug)

										$this->OutputDebug('Connecting to SMTP server IP '.$host_ip.' port '.$host_port.'...');

									$command = 1;

									$address_type = 1;

									if(!fputs($this->connection, chr($version).chr($command)."\x00".chr($address_type).pack('Nn', ip2long($host_ip), $host_port)))

										$error = $this->SetDataAccessError($send_error);

									else

									{

										$response = fgets($this->connection, 11);

										if(strlen($response) != 10)

											$error = $this->SetDataAccessError($receive_error);

										else

										{

											$socks_errors = array(

												"\x00"=>'',

												"\x01"=>'general SOCKS server failure',

												"\x02"=>'connection not allowed by ruleset',

												"\x03"=>'Network unreachable',

												"\x04"=>'Host unreachable',

												"\x05"=>'Connection refused',

												"\x06"=>'TTL expired',

												"\x07"=>'Command not supported',

												"\x08"=>'Address type not supported'

											);

											$error_code = $response[1];

											$error = (IsSet($socks_errors[$error_code]) ? $socks_errors[$error_code] : 'unknown');

											if(strlen($error))

												$error = 'SOCKS error: '.$error;

										}

									}

								}

							}

							break;

						default:

							$error = 'support for SOCKS protocol version '.$this->socks_version.' is not yet implemented';

							break;

					}

					if(strlen($this->error = $error))

					{

						fclose($this->connection);

						return($error);

					}

				}

				return('');

			}

		}

		elseif(strlen($this->http_proxy_host_name))

		{

			if(strlen($error = $this->Resolve($this->http_proxy_host_name, $ip, 'SMTP')))

				return($error);

			if($this->ssl)

				$ip = 'ssl://'.($proxy_host = $this->http_proxy_host_name);

			else

				$proxy_host = $ip;

			if($this->debug)

				$this->OutputDebug("Connecting to HTTP proxy server \"".$ip."\" port ".$this->http_proxy_host_port."...");

			if(($this->connection=($this->timeout ? @fsockopen($ip, $this->http_proxy_host_port, $errno, $error, $this->timeout) : @fsockopen($ip, $this->http_proxy_host_port, $errno, $error))))

			{

				if($this->debug)

					$this->OutputDebug('Connected to HTTP proxy host "'.$this->http_proxy_host_name.'".');

				$timeout=($this->data_timeout ? $this->data_timeout : $this->timeout);

				if($timeout

				&& function_exists("socket_set_timeout"))

					socket_set_timeout($this->connection,$timeout,0);

				if($this->PutLine('CONNECT '.$domain.':'.$port.' HTTP/1.0')

				&& $this->PutLine('User-Agent: '.$this->user_agent)

				&& $this->PutLine(''))

				{

					if(GetType($response = $this->GetLine()) == 'string')

					{

						if(!preg_match('/^http\\/[0-9]+\\.[0-9]+[ \t]+([0-9]+)[ \t]*(.*)$/i', $response,$matches))

							return($this->SetError("3 it was received an unexpected HTTP response status"));

						$error = $matches[1];

						switch($error)

						{

							case '200':

								for(;;)

								{

									if(GetType($response = $this->GetLine()) != 'string')

										break;

									if(strlen($response) == 0)

										return('');

								}

								break;

							default:

								$this->error = 'the HTTP proxy returned error '.$error.' '.$matches[2];

								break;

						}

					}

				}

				if($this->debug)

					$this->OutputDebug("Disconnected.");

				fclose($this->connection);

				$this->connection = 0;

				return($this->error);

			}

		}

		else

		{

			if($this->ssl)

				$ip = 'ssl://'.($host = $domain);

			elseif($this->start_tls)

				$ip = $host = $domain;

			else

				$host = $ip;

			if($this->debug)

				$this->OutputDebug("Connecting to SMTP server \"".$host."\" port ".$port."...");

			if(($this->connection=($this->timeout ? @fsockopen($ip, $port, $errno, $error, $this->timeout) : @fsockopen($ip, $port, $errno, $error))))

				return("");

		}

		$error=($this->timeout ? strval($error) : "??");

		switch($error)

		{

			case "-3":

				return("-3 socket could not be created");

			case "-4":

				return("-4 dns lookup on hostname \"".$domain."\" failed");

			case "-5":

				return("-5 connection refused or timed out");

			case "-6":

				return("-6 fdopen() call failed");

			case "-7":

				return("-7 setvbuf() call failed");

		}

		return("could not connect to the host \"".$domain."\": ".$error);

	}

	Function SASLAuthenticate($mechanisms, $credentials, &$authenticated, &$mechanism)

	{

		$authenticated=0;

		if(!function_exists("class_exists")