vendor/zendframework/zend-mail/src/Protocol/AbstractProtocol.php

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