File: smtp.class.inc

<?php
/**
 * The SMTP Class provide access to a smtp server.
 * Multiple message sending is possible, too.
 *  
 *
 * @package: smtp.class.inc
 * @author: Steffen 'j0inty' Stollfuß
 * @created 12.06.2008
 * @copyright: Steffen 'j0inty' Stollfuß
 * @version: 0.7.1-dev
 */
/**
 * Class SMTP_Exception
 *
 * @author j0inty
 * @version 1.1.0-final
 */
class SMTP_Exception extends Exception
{
	/**
	 * SMTP Exception constructor
	 * 
	 * @param integer $intErrorCode
	 * @param string $strErrorMessage
	 */
	function __construct($intErrorCode, $strErrorMessage = null)
	{
		switch($intErrorCode)
		{
			case SMTP::ERR_SOCKETS:
				$strErrorMessage = "Sockets Error: (". socket_last_error() .") -- ". socket_strerror(socket_last_error());
			break;
			
			case SMTP::ERR_NOT_IMPLEMENTED:
				$strErrorMessage = "Not implemented now.";
			break;
		}
		parent::__construct($strErrorMessage, $intErrorCode);
	}
	/**
	 * Store the Exception string to a given file
	 * 
	 * @param string $strLogFile  logfile name with path
	 */
	public function saveToFile($strLogFile)
	{
		if( !$resFp = @fopen($strLogFile,"a+") )
		{
			return false;
		}
		$strMsg = date("Y-m-d H:i:s -- ") . $this;
		if( !@fputs($resFp, $strMsg, strlen($strMsg)) )
		{
			return false;
		}
		@fclose($resFp);
	}
	/**
	 * toString method
	 */
	public function __toString()
	{
		return __CLASS__ ."[". $this->getCode() ."] -- ". $this->getMessage() ." in file ". $this->getFile() ." at line ". $this->getLine().PHP_EOL."Trace: ". $this->getTraceAsString() .PHP_EOL;
	}
}

/**
 * SMTP class
 * 
 * @author j0inty
 */
class SMTP
{
	/**
	 * E-Mail Priotities
	 * 
	 * @var const integer
	 */
	const MESSAGE_PRIO_LOW = 5;
	const MESSAGE_PRIO_MEDIUM = 3;
	const MESSAGE_PRIO_HIGH = 1;
	/**
	 * @var const string XMAILER
	 */
	const XMAILER = "smtp.class.php 0.7.1-final -- Steffen 'j0inty' Stollfuss";
	/**
	 * @var const integer No errors occured
	 * @access public
	 */
	const ERR_NONE = 0;
	/**
	 * @var const integer parameter error
	 */
	const ERR_PARAMETER = 1;
	/**
	 * @var const integer logging error
	 */
	const ERR_LOG = 2;
	/**
	 * @var const integer sockets extension error
	 */
	const ERR_SOCKETS = 3;
	/**
	 * @var const integer sockets extension error
	 */
	const ERR_STREAM = 4;
	/**
	 * @var const integer invalid response code came from the server
	 */
	const ERR_INVALID_RESPONSE = 5;
	/**
	 * @var const integer comes when a function isn't implemented yet
	 */
	const ERR_NOT_IMPLEMENTED = 20;
	/**
	 * Authorization method constant
	 */
	const AUTH_PLAIN = 100;
	/**
	 * Regular Expression for a valid email adress
	 * I know that this regex isn't the best
	 * 
	 */
	const REGEX_EMAIL = "((<)|([A-Za-z0-9._-](\+[A-Za-z0-9])*)+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}|(>))";
	/**
	 * default buffer size for socket reads
	 * 
	 * @var const integer
	 */
	const DEFAULT_BUFFER_SIZE = 4096;
	/**
	 * @var string SMTP Server Hostname
	 * @access private
	 */
	private $strHostname = null;
	/**
	 * @var string $strIPAdress
	 * @access private
	 */
	private $strIPAdress = null;
	/**
	 * @var integer SMTP Server Port
	 * @access private
	 */
	private $intPort = 25;
	/**
	 * @var resource Socket
	 * @access private
	 */
	private $resSocket = false;
	/**
	 * @var boolean $bSocketConnected
	 */
	private $bSocketConnected = false;
	/**
	 * @var array Connection Timeout
	 * @access private
	 */
	private $arrConnectionTimeout = array("sec" => "10", "msec" => "0");
	/**
	 * @var boolean Using sockets extension
	 * @access private
	 */
	private $bUseSockets = true;
	/**
	 * @var boolean  Hide the username at the log file (sha256)
	 * @access private
	 */
	private $bHideUsernameAtLog = true;
	/**
	 * @var string log path to file
	 * @access private
	 */
	private $strLogFile = null;
	/**
	 * @var boolean log filedescriptor opened
	 * @access private
	 */
	private $bLogOpened = false;
	/**
	 * @var resource log file descriptor
	 * @access private 
	 */
	private $resLogFp = false;
	/**
	 * @var string  Use it as prefix for every log line
	 * @access private
	 */
	private $strLogDatetimeFormat = "Y-m-d H:i:s";
	/**
	 * constructor
	 * 
	 * @param string $strLogFile filename where the class will log
	 * @param boolean $bHideUsernameAtLog should the username hide in the logfile
	 * @param boolean $bUseSockets should the class use the sockets extension ?
	 * 
	 * @return SMTP SMTP class object
	 * @throw SMTP_Exception
	 * @access public
	 */
	function __construct( $strLogFile = null, $bHideUsernameAtLog = true, $bUseSockets = true)
	{
		// Check input
		if( !is_bool($bHideUsernameAtLog) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid hide username at logfile parameter given");
		}
		if( !is_bool($bUseSockets) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid UseSockets parameter given");
		}
		elseif( $bUseSockets && !extension_loaded("sockets") )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"You choose the socket extension support, but this isn't available");
		}
		if( is_string($strLogFile) )
		{
			$this->strLogFile = $strLogFile;
			$this->openLog();
		}
		$this->bHideUsernameAtLog = $bHideUsernameAtLog;
		$this->bUseSockets = $bUseSockets;
	}
	
	/**
	 * destructor
	 * 
	 * @access public
	 * @throw SMTP_Exception
	 */
	function __destruct()
	{
		$this->disconnect();
		$this->closeLog();
	}
	/**
	 * connect to the smtp server
	 * 
	 * @param string $strHostname  IP or hostname of the smtp server
	 * @param integer $intPort  Port where the smtp server is listen to
	 * @param array $arrConnectionTimeout
	 * @param boolean $bIPv6
	 * 
	 * @access public
	 * @throw SMTP_Exception
	 */
	public function connect( $strHostname, $intPort = 25, $arrConnectionTimeout = null, $bIPv6 = false)
	{
		if( !is_string($strHostname) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid hostname string given");
		}
		if( !is_int($intPort) && $intPort > 0 && $intPort < 65535 )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid port given");
		}
		if( !is_bool($bIPv6) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid ipv6 given");
		}
		
		if( $this->bUseSockets )
		{
			if( !$this->resSocket = @socket_create( (($bIPv6) ? AF_INET6 : AF_INET), SOL_SOCKET, SOL_TCP ) )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
			
			$this->log((($bIPv6) ? "AF_INET6" : "AF_INET") ."-TCP-Socket created.");
			
			if(!is_null($arrConnectionTimeout) )
			{
				$this->setSocketTimeout($arrConnectionTimeout);
			}
			
			if( !@socket_connect($this->resSocket,$strHostname,$intPort)
				|| !@socket_getpeername($this->resSocket,$this->strIPAdress) )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
		}
		else
		{
			$dTimeout = (double) implode(".",$arrConnectionTimeout);
			if( !@fsockopen("tcp://". $strHostname .":". $intPort, &$intErrno, &$strError, $dTimeout) )
			{
				throw new SMTP_Exception(self::ERR_STREAM,"fopen: [". $intErrno ."] -- ". $strError);
			}
			if(!is_null($arrConnectionTimeout) ) $this->setSocketTimeout($arrConnectionTimeout);
			$this->strIPAdress = @gethostbyname($strHostname);
		}
		$this->strHostname = $strHostname;
		$this->intPort = $intPort;
		$this->bSocketConnected = true;
		$this->log("socket: Connected to ". $this->strIPAdress .":". $intPort ." [". $strHostname ."]");
		// Welcome message from the server
		$this->parseResponse("220");
		// EHLO Stuff
		$this->sendCommand("EHLO ". $strHostname,250);
		
	}
	/**
	 * disconnect from the smtp server
	 * 
	 * @access public
	 * @throw SMTP_Exception
	 */
	public function disconnect()
	{
		if( $this->bSocketConnected )
		{
			$this->sendCommand("QUIT", 221);
			if( $this->bUseSockets )
			{
				if( @socket_close($this->resSocket) === false)
				{
					throw new SMTP_Exception(self::ERR_SOCKETS);
				}
			}
			else
			{
				if( !@fclose($this->resSocket) )
				{
					throw new SMTP_Exception(self::ERR_STREAM,"fclose: Faild to close the socket" );
				}
			}
			$this->bSocketConnected = false;
			$this->log("socket: Disconnected from ". $this->strIPAdress .":". $this->intPort ." [". $this->strHostname ."]");
		}
		
	}
	/**
	 * login into the server
	 * 
	 * !!! Cauition !!!
	 * This is only need for smtp server with authorization, else you don't need to call this function
	 * 
	 * @param string $strUsername Username of your account on the smtp server
	 * @param string $strPassword The password for your account
	 * 
	 * @throw SMTP_Exception
	 * @access public
	 */
	public function login( $strUsername = "", $strPassword = "" , $intAuthMethod = self::AUTH_PLAIN )
	{
		if( empty($strUsername) || empty($strPassword) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid username or password given. If is no login needed don't use this function here.");
		}
		if( $intAuthMethod == self::AUTH_PLAIN )
		{
			$this->sendCommand("AUTH LOGIN", 334);
			$this->sendCommand(base64_encode($strUsername),334,"Username: ". $strUsername);
			$this->sendCommand(base64_encode($strPassword),235,"Password: ". sha1($strPassword));
		}
		else
		{
			throw new Exception(self::ERR_NOT_IMPLEMENTED);
		}
	}
	/**
	 * Send an email
	 * 
	 * @param string $strFrom  From/Sender Adress
	 * @param 
	 */
	public function sendMessage($strFrom, $mixedTo, $strSubject, $strMessage, $mixedOptionalHeader = null, $mixedCC = null, $mixedBCC = null, $intPriority = self::MESSAGE_PRIO_MEDIUM)
	{
		$arrMailHeader = array();
		if( !is_string($strFrom) || !preg_match(self::REGEX_EMAIL,$strFrom) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid \"from\" parameter given or invalid adress [". $strFrom ."]");
		}
		if( !is_array($mixedTo) )
		{
			if( !is_string($mixedTo) ) 
				throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid \"to\" parameter given");
		}
		if( !is_string($strSubject) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid subject parameter given");
		}
		if( !is_string($strMessage) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid message parameter given");
		}
		if( !is_null($mixedOptionalHeader) && !is_array($mixedOptionalHeader) )
		{
			if( !is_string($mixedOptionalHeader) )
				throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid optional header parameter given");
		}
		if( !is_null($mixedCC) && !is_array($mixedCC) )
		{
			if(!is_string($mixedCC))
				throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid \"cc\" parameter given");
		}
		if( !is_null($mixedBCC) && !is_array($mixedBCC) )
		{
			if( !is_string($mixedBCC) )
				throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid \"bcc\" parameter given");
		}
		if( !is_int($intPriority) || ($intPriority < 1 || $intPriority > 5) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER, "Invalid priority parameter given. Allowed is a value between [1-5]");
		}
		// Prepare the Header
		
		
		// From
		$this->sendCommand("MAIL FROM: <". $strFrom .">",250);
		$arrMailHeader["from"] = $strFrom;
		
		// TO
		if( !is_array($mixedTo) )
		{
			$this->rcptTo($mixedTo);
			$arrMailHeader["to"] = "<". $mixedTo .">";
		}
		else
		{
			$bFirst = true;
			$arrMailHeader["to"] = "";
			foreach( $mixedTo AS $email )
			{
				$this->rcptTo($email);
				if( $bFirst )
				{
					$arrMailHeader["to"] .= "<". $email .">";
					$bFirst = false;
				}
				else
				{
					$arrMailHeader["to"] .= ", <". $email .">";
				}
			}
		}
		
		// CC
		if( !is_null($mixedCC) )
		{
			if( !is_array($mixedCC) )
			{
				$this->rcptTo($mixedCC);
				$arrMailHeader["cc"] = "<". $mixedCC .">";
			}
			else
			{
				$bFirst = true;
				$arrMailHeader["cc"] = "";
				foreach( $mixedCC AS $email )
				{
					$this->rcptTo($email);
					if( $bFirst )
					{
						$arrMailHeader["cc"] .= "<". $email .">";
						$bFirst = false;
					}
					else
					{
						$arrMailHeader["cc"] .= ", <". $email .">";
					}
				}
			}
		}
		
		// BCC
		if( !is_null($mixedBCC) )
		{
			if( !is_array($mixedBCC) )
			{
				$this->rcptTo($mixedBCC);
				$arrMailHeader["bcc"] = "<". $mixedBCC .">";
			}
			else
			{
				$bFirst = true;
				$arrMailHeader["bcc"] = "";
				foreach( $mixedBCC AS $email )
				{
					$this->rcptTo($email);
					if( $bFirst )
					{
						$arrMailHeader["bcc"] .= "<". $email .">";
						$bFirst = false;
					}
					else
					{
						$arrMailHeader["bcc"] .= ", <". $email .">";
					}
				}
			}
		}
		
		/*
		 *  Send the message
		 */
		$this->sendCommand("DATA", 354);
		// Header first
		while( ($key = key($arrMailHeader)) != null )
		{
			$this->send(ucfirst($key) .": ". $arrMailHeader[$key]);
			next($arrMailHeader);
		}
		$this->send("Subject: ". $strSubject);
		$this->send("Date: ". date("r"));
		$this->send("X-Mailer: ". self::XMAILER);
		
		// default priority for a mail is 3 so we don't need to add a line for that
		if( $intPriority != 3 )
		{
			$this->send("X-Priority: ". $intPriority);
			if( $intPriority == 1 || $intPriority == 2 )
			{
				$this->send("X-MSMail-Priority: High");
			}
			else
			{
				$this->send("X-MSMail-Priority: Low");
			}
		}
		// Optional header
		if( !is_null($mixedOptionalHeader) )
		{
			if( !is_array($mixedOptionalHeader) )
			{
				$this->send($mixedOptionalHeader);
			}
			else
			{
				foreach( $mixedOptionalHeader as &$strHeader )
				{
					$this->send($strHeader);
				}
			}
		}
		// Close the Header part
		$this->send("");
		// Message body
		$this->send($strMessage);
		// Close the message
		$this->sendCommand(".",250);
	}
	/**
	 * Set the socket send and recv timeouts
	 * 
	 * @param array $arrTimeout
	 * 
	 * @throw SMTP_Exception
	 * @return void
	 * @access private
	 */
	private function setSocketTimeout( $arrTimeout )
	{
		if( !is_array($arrTimeout) || !is_int($arrTimeout["sec"]) || !is_int($arrTimeout["usec"]) )
		{
			throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid connection timeout given");
		}
		if( $this->bUseSockets )
		{
			if( !@socket_set_option($this->resSocket,SOL_SOCKET,SO_RCVTIMEO,$arrTimeout)
				|| !@socket_set_option($this->resSocket,SOL_SOCKET,SO_SNDTIMEO,$arrTimeout) )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
		}
		else
		{
			if( !@stream_set_timeout($this->resSocket,$arrTimeout["sec"],$arrTimeout["usec"]) )
			{
				throw new SMTP_Exception(self::ERR_STREAM,"stream_set_timeout: Failed to set stream connection timeout");
			}
		}
		$this->log("socket timeout: ". implode(".",$arrTimeout) ." seconds");
	}
	/**
	 * Send a string to the server
	 * 
	 * @param string $str
	 * @param integer $intFlags  socket_send() flags (only need for socket_extension)
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function send( $str, $intFlags = 0 )
	{
		$str = $str ."\r\n";
		if( $this->bUseSockets )
		{
			if( !@socket_send($this->resSocket,$str,strlen($str),$intFlags) )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
		}
		else
		{
			if( !@fwrite($this->resSocket,$str,strlen($str)) )
			{
				throw new SMTP_Exception(self::ERR_STREAM,"fwrite: Failed to write to socket");
			}
		}
	}
	/**
	 * Recieve a string from the server
	 * 
	 * @param integer $intBufferSize
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function recvString( $intBufferSize = self::DEFAULT_BUFFER_SIZE )
	{
		$strBuffer = "";
		if( $this->bUseSockets )
		{
			if( ($strBuffer = @socket_read($this->resSocket, $intBufferSize, PHP_NORMAL_READ)) === false )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
			/*
			 * Workaround: PHP_NORMAL_READ stops at "\r" but the network string is terminated by "\r\n",
			 * 			   so we need to call socket_read again for this 1 char "\n"
			 */
			if( ($strBuffer2 = @socket_read($this->resSocket, 1, PHP_NORMAL_READ)) === false )
			{
				throw new SMTP_Exception(self::ERR_SOCKETS);
			}
			$strBuffer .= $strBuffer2;
		}
		else
		{
			if( !$strBuffer = @fgets($this->resSocket,$intBufferSize) )
			{
				throw new SMTP_Exception(self::ERR_STREAM,"fgets: Couldn't read string from socket");
			}
		}
		return $strBuffer;
	}
	/**
	 * Recieve a string from the socket and check was the need response code given.
	 * Else not it will throw an exception with the message from the server
	 * 
	 * @param integer $intNeededCode needed Responsecode from the server
	 * @param integer $intBufferSize  @see recvString()
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function parseResponse( $intNeededCode, $intBufferSize = self::DEFAULT_BUFFER_SIZE )
	{
		while(true)
		{
			$strBuffer = $this->recvString($intBufferSize);
			$this->log($strBuffer);
			if(preg_match("/^[0-9]{3}( )/", $strBuffer))
			{
				break;
			}
		}
		if( !preg_match("/^(". $intNeededCode .")/",$strBuffer) )
		{
			throw new SMTP_Exception(self::ERR_INVALID_RESPONSE,$strBuffer);
		}
	}
	/**
	 * Send the command to the server and check for the needed response code
	 * 
	 * @param string $cmd  command for the server
	 * @param integer $neededCode @see parseResponse()
	 * @param string $strLog  String that should log, else we use the command string
	 * @param integer $intFlags  @see send()
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function sendCommand( $strCommand, $intNeededCode, $strLog = null, $intFlags = 0 )
	{
		( !is_null($strLog) ) ? $this->log($strLog) : $this->log($strCommand);
		$this->send($strCommand,$intFlags);
		$this->parseResponse($intNeededCode);
	}
	/**
	 * reciept to
	 * 
	 * @param string $email  E-Mail-Adress
	 */
	private function rcptTo($email)
	{
		if( !is_null($email) )
		{
			if( !preg_match(self::REGEX_EMAIL,$email) )
			{
				throw new SMTP_Exception(self::ERR_PARAMETER,"Invalid email address given [". $email ."]");
			}
			$this->sendCommand("RCPT TO: ". $email, 250);
		}
	}
	/**
	 * open the log filedescriptor
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function openLog()
	{
		// Note: Constructor checks is it a string or not so we don't need to check for null again
		// Think about, test it.
		if( !$this->bLogOpened /*&& !is_null($this->strLogFile)*/ )
		{
			if( !$this->resLogFp = @fopen($this->strLogFile,"a+") )
			{
				throw new SMTP_Exception(self::ERR_LOG,"fopen: Couldn't open log file: ". $this->strLogFile);
			}
			$this->bLogOpened = true;
		}
	}
	/**
	 * close the log filedescriptor
	 * 
	 * @access private
	 */
	private function closeLog()
	{
		if( $this->bLogOpened )
		{
			@fclose($this->resLogFp);
			$this->bLogOpened = false;
		}
	}
	/**
	 * open the log filedescriptor
	 * 
	 * @param string $str  String to log
	 * 
	 * @throw SMTP_Exception
	 * @access private
	 */
	private function log( $str )
	{
		if( $this->bLogOpened )
		{
			$str = date($this->strLogDatetimeFormat). ": ". trim($str) .PHP_EOL;
			if( !@fwrite($this->resLogFp, $str, strlen($str)) )
			{
				throw new SMTP_Exception(self::ERR_LOG,"fwrite: Failed to wrote to logfile. (". trim($str) .")");
			}
		}
	}
}
?>