interface/modules/zend_modules/library/Zend/Mail/Protocol/AbstractProtocol.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Mail\Protocol;
  11
  12 use Zend\Validator;
  13
  14 /**
  15  * Provides low-level methods for concrete adapters to communicate with a remote mail server and track requests and responses.
  16  *
  17  * @todo Implement proxy settings
  18  */
  19 abstract class AbstractProtocol
  20 {
  21     /**
  22      * Mail default EOL string
  23      */
  24     const EOL = "\r\n";
  25
  26     /**
  27      * Default timeout in seconds for initiating session
  28      */
  29     const TIMEOUT_CONNECTION = 30;
  30
  31     /**
  32      * Maximum of the transaction log
  33      * @var int
  34      */
  35     protected $maximumLog = 64;
  36
  37     /**
  38      * Hostname or IP address of remote server
  39      * @var string
  40      */
  41     protected $host;
  42
  43     /**
  44      * Port number of connection
  45      * @var int
  46      */
  47     protected $port;
  48
  49     /**
  50      * Instance of Zend\Validator\ValidatorChain to check hostnames
  51      * @var \Zend\Validator\ValidatorChain
  52      */
  53     protected $validHost;
  54
  55     /**
  56      * Socket connection resource
  57      * @var resource
  58      */
  59     protected $socket;
  60
  61     /**
  62      * Last request sent to server
  63      * @var string
  64      */
  65     protected $request;
  66
  67     /**
  68      * Array of server responses to last request
  69      * @var array
  70      */
  71     protected $response;
  72
  73     /**
  74      * Log of mail requests and server responses for a session
  75      * @var array
  76      */
  77     private $log = array();
  78
  79     /**
  80      * Constructor.
  81      *
  82      * @param  string  $host OPTIONAL Hostname of remote connection (default: 127.0.0.1)
  83      * @param  int $port OPTIONAL Port number (default: null)
  84      * @throws Exception\RuntimeException
  85      */
  86     public function __construct($host = '127.0.0.1', $port = null)
  87     {
  88         $this->validHost = new Validator\ValidatorChain();
  89         $this->validHost->attach(new Validator\Hostname(Validator\Hostname::ALLOW_ALL));
  90
  91         if (!$this->validHost->isValid($host)) {
  92             throw new Exception\RuntimeException(implode(', ', $this->validHost->getMessages()));
  93         }
  94
  95         $this->host = $host;
  96         $this->port = $port;
  97     }
  98
  99     /**
 100      * Class destructor to cleanup open resources
 101      *
 102      */
 103     public function __destruct()
 104     {
 105         $this->_disconnect();
 106     }
 107
 108     /**
 109      * Set the maximum log size
 110      *
 111      * @param int $maximumLog Maximum log size
 112      */
 113     public function setMaximumLog($maximumLog)
 114     {
 115         $this->maximumLog = (int) $maximumLog;
 116     }
 117
 118     /**
 119      * Get the maximum log size
 120      *
 121      * @return int the maximum log size
 122      */
 123     public function getMaximumLog()
 124     {
 125         return $this->maximumLog;
 126     }
 127
 128     /**
 129      * Create a connection to the remote host
 130      *
 131      * Concrete adapters for this class will implement their own unique connect scripts, using the _connect() method to create the socket resource.
 132      */
 133     abstract public function connect();
 134
 135     /**
 136      * Retrieve the last client request
 137      *
 138      * @return string
 139      */
 140     public function getRequest()
 141     {
 142         return $this->request;
 143     }
 144
 145     /**
 146      * Retrieve the last server response
 147      *
 148      * @return array
 149      */
 150     public function getResponse()
 151     {
 152         return $this->response;
 153     }
 154
 155     /**
 156      * Retrieve the transaction log
 157      *
 158      * @return string
 159      */
 160     public function getLog()
 161     {
 162         return implode('', $this->log);
 163     }
 164
 165     /**
 166      * Reset the transaction log
 167      *
 168      */
 169     public function resetLog()
 170     {
 171         $this->log = array();
 172     }
 173
 174     /**
 175      * Add the transaction log
 176      *
 177      * @param  string $value new transaction
 178      */
 179     protected function _addLog($value)
 180     {
 181         if ($this->maximumLog >= 0 && count($this->log) >= $this->maximumLog) {
 182             array_shift($this->log);
 183         }
 184
 185         $this->log[] = $value;
 186     }
 187
 188     /**
 189      * Connect to the server using the supplied transport and target
 190      *
 191      * An example $remote string may be 'tcp://mail.example.com:25' or 'ssh://hostname.com:2222'
 192      *
 193      * @param  string $remote Remote
 194      * @throws Exception\RuntimeException
 195      * @return bool
 196      */
 197     protected function _connect($remote)
 198     {
 199         $errorNum = 0;
 200         $errorStr = '';
 201
 202         // open connection
 203         $this->socket = @stream_socket_client($remote, $errorNum, $errorStr, self::TIMEOUT_CONNECTION);
 204
 205         if ($this->socket === false) {
 206             if ($errorNum == 0) {
 207                 $errorStr = 'Could not open socket';
 208             }
 209             throw new Exception\RuntimeException($errorStr);
 210         }
 211
 212         if (($result = stream_set_timeout($this->socket, self::TIMEOUT_CONNECTION)) === false) {
 213             throw new Exception\RuntimeException('Could not set stream timeout');
 214         }
 215
 216         return $result;
 217     }
 218
 219     /**
 220      * Disconnect from remote host and free resource
 221      *
 222      */
 223     protected function _disconnect()
 224     {
 225         if (is_resource($this->socket)) {
 226             fclose($this->socket);
 227         }
 228     }
 229
 230     /**
 231      * Send the given request followed by a LINEEND to the server.
 232      *
 233      * @param  string $request
 234      * @throws Exception\RuntimeException
 235      * @return int|bool Number of bytes written to remote host
 236      */
 237     protected function _send($request)
 238     {
 239         if (!is_resource($this->socket)) {
 240             throw new Exception\RuntimeException('No connection has been established to ' . $this->host);
 241         }
 242
 243         $this->request = $request;
 244
 245         $result = fwrite($this->socket, $request . self::EOL);
 246
 247         // Save request to internal log
 248         $this->_addLog($request . self::EOL);
 249
 250         if ($result === false) {
 251             throw new Exception\RuntimeException('Could not send request to ' . $this->host);
 252         }
 253
 254         return $result;
 255     }
 256
 257     /**
 258      * Get a line from the stream.
 259      *
 260      * @param  int $timeout Per-request timeout value if applicable
 261      * @throws Exception\RuntimeException
 262      * @return string
 263      */
 264     protected function _receive($timeout = null)
 265     {
 266         if (!is_resource($this->socket)) {
 267             throw new Exception\RuntimeException('No connection has been established to ' . $this->host);
 268         }
 269
 270         // Adapters may wish to supply per-commend timeouts according to appropriate RFC
 271         if ($timeout !== null) {
 272             stream_set_timeout($this->socket, $timeout);
 273         }
 274
 275         // Retrieve response
 276         $response = fgets($this->socket, 1024);
 277
 278         // Save request to internal log
 279         $this->_addLog($response);
 280
 281         // Check meta data to ensure connection is still valid
 282         $info = stream_get_meta_data($this->socket);
 283
 284         if (!empty($info['timed_out'])) {
 285             throw new Exception\RuntimeException($this->host . ' has timed out');
 286         }
 287
 288         if ($response === false) {
 289             throw new Exception\RuntimeException('Could not read from ' . $this->host);
 290         }
 291
 292         return $response;
 293     }
 294
 295     /**
 296      * Parse server response for successful codes
 297      *
 298      * Read the response from the stream and check for expected return code.
 299      * Throws a Zend\Mail\Protocol\Exception\ExceptionInterface if an unexpected code is returned.
 300      *
 301      * @param  string|array $code One or more codes that indicate a successful response
 302      * @param  int $timeout Per-request timeout value if applicable
 303      * @throws Exception\RuntimeException
 304      * @return string Last line of response string
 305      */
 306     protected function _expect($code, $timeout = null)
 307     {
 308         $this->response = array();
 309         $errMsg = '';
 310
 311         if (!is_array($code)) {
 312             $code = array($code);
 313         }
 314
 315         do {
 316             $this->response[] = $result = $this->_receive($timeout);
 317             list($cmd, $more, $msg) = preg_split('/([\s-]+)/', $result, 2, PREG_SPLIT_DELIM_CAPTURE);
 318
 319             if ($errMsg !== '') {
 320                 $errMsg .= ' ' . $msg;
 321             } elseif ($cmd === null || !in_array($cmd, $code)) {
 322                 $errMsg =  $msg;
 323             }
 324         } while (strpos($more, '-') === 0); // The '-' message prefix indicates an information string instead of a response string.
 325
 326         if ($errMsg !== '') {
 327             throw new Exception\RuntimeException($errMsg);
 328         }
 329
 330         return $msg;
 331     }
 332 }