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