vendor/swiftmailer/swiftmailer/lib/classes/Swift/Transport/StreamBuffer.php line 275

  1. <?php
  3. /*
  4.  * This file is part of SwiftMailer.
  5.  * (c) 2004-2009 Chris Corbyn
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  11. /**
  12.  * A generic IoBuffer implementation supporting remote sockets and local processes.
  13.  *
  14.  * @author Chris Corbyn
  15.  */
  16. class Swift_Transport_StreamBuffer extends Swift_ByteStream_AbstractFilterableInputStream implements Swift_Transport_IoBuffer
  17. {
  18.     /** A primary socket */
  19.     private $_stream;
  21.     /** The input stream */
  22.     private $_in;
  24.     /** The output stream */
  25.     private $_out;
  27.     /** Buffer initialization parameters */
  28.     private $_params = array();
  30.     /** The ReplacementFilterFactory */
  31.     private $_replacementFactory;
  33.     /** Translations performed on data being streamed into the buffer */
  34.     private $_translations = array();
  36.     /**
  37.      * Create a new StreamBuffer using $replacementFactory for transformations.
  38.      *
  39.      * @param Swift_ReplacementFilterFactory $replacementFactory
  40.      */
  41.     public function __construct(Swift_ReplacementFilterFactory $replacementFactory)
  42.     {
  43.         $this->_replacementFactory = $replacementFactory;
  44.     }
  46.     /**
  47.      * Perform any initialization needed, using the given $params.
  48.      *
  49.      * Parameters will vary depending upon the type of IoBuffer used.
  50.      *
  51.      * @param array $params
  52.      */
  53.     public function initialize(array $params)
  54.     {
  55.         $this->_params = $params;
  56.         switch ($params['type']) {
  57.             case self::TYPE_PROCESS:
  58.                 $this->_establishProcessConnection();
  59.                 break;
  60.             case self::TYPE_SOCKET:
  61.             default:
  62.                 $this->_establishSocketConnection();
  63.                 break;
  64.         }
  65.     }
  67.     /**
  68.      * Set an individual param on the buffer (e.g. switching to SSL).
  69.      *
  70.      * @param string $param
  71.      * @param mixed  $value
  72.      */
  73.     public function setParam($param, $value)
  74.     {
  75.         if (isset($this->_stream)) {
  76.             switch ($param) {
  77.                 case 'timeout':
  78.                     if ($this->_stream) {
  79.                         stream_set_timeout($this->_stream, $value);
  80.                     }
  81.                     break;
  83.                 case 'blocking':
  84.                     if ($this->_stream) {
  85.                         stream_set_blocking($this->_stream, 1);
  86.                     }
  87.             }
  88.         }
  89.         $this->_params[$param] = $value;
  90.     }
  92.     public function startTLS()
  93.     {
  94.         // STREAM_CRYPTO_METHOD_TLS_CLIENT only allow tls1.0 connections (some php versions)
  95.         // To support modern tls we allow explicit tls1.0, tls1.1, tls1.2
  96.         // Ssl3 and older are not allowed because they are vulnerable
  97.         // @TODO make tls arguments configurable
  98.         $cryptoType = STREAM_CRYPTO_METHOD_TLS_CLIENT;
  99.         if (PHP_VERSION_ID >= 50600) {
  100.             $cryptoType = STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT | STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT | STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
  101.         }
  103.         return stream_socket_enable_crypto($this->_stream, true, $cryptoType);
  104.     }
  106.     /**
  107.      * Perform any shutdown logic needed.
  108.      */
  109.     public function terminate()
  110.     {
  111.         if (isset($this->_stream)) {
  112.             switch ($this->_params['type']) {
  113.                 case self::TYPE_PROCESS:
  114.                     fclose($this->_in);
  115.                     fclose($this->_out);
  116.                     proc_close($this->_stream);
  117.                     break;
  118.                 case self::TYPE_SOCKET:
  119.                 default:
  120.                     fclose($this->_stream);
  121.                     break;
  122.             }
  123.         }
  124.         $this->_stream = null;
  125.         $this->_out = null;
  126.         $this->_in = null;
  127.     }
  129.     /**
  130.      * Set an array of string replacements which should be made on data written
  131.      * to the buffer.
  132.      *
  133.      * This could replace LF with CRLF for example.
  134.      *
  135.      * @param string[] $replacements
  136.      */
  137.     public function setWriteTranslations(array $replacements)
  138.     {
  139.         foreach ($this->_translations as $search => $replace) {
  140.             if (!isset($replacements[$search])) {
  141.                 $this->removeFilter($search);
  142.                 unset($this->_translations[$search]);
  143.             }
  144.         }
  146.         foreach ($replacements as $search => $replace) {
  147.             if (!isset($this->_translations[$search])) {
  148.                 $this->addFilter(
  149.                     $this->_replacementFactory->createFilter($search, $replace), $search
  150.                     );
  151.                 $this->_translations[$search] = true;
  152.             }
  153.         }
  154.     }
  156.     /**
  157.      * Get a line of output (including any CRLF).
  158.      *
  159.      * The $sequence number comes from any writes and may or may not be used
  160.      * depending upon the implementation.
  161.      *
  162.      * @param int $sequence of last write to scan from
  163.      *
  164.      * @throws Swift_IoException
  165.      *
  166.      * @return string
  167.      */
  168.     public function readLine($sequence)
  169.     {
  170.         if (isset($this->_out) && !feof($this->_out)) {
  171.             $line = fgets($this->_out);
  172.             if (strlen($line) == 0) {
  173.                 $metas = stream_get_meta_data($this->_out);
  174.                 if ($metas['timed_out']) {
  175.                     throw new Swift_IoException(
  176.                         'Connection to '.
  177.                             $this->_getReadConnectionDescription().
  178.                         ' Timed Out'
  179.                     );
  180.                 }
  181.             }
  183.             return $line;
  184.         }
  185.     }
  187.     /**
  188.      * Reads $length bytes from the stream into a string and moves the pointer
  189.      * through the stream by $length.
  190.      *
  191.      * If less bytes exist than are requested the remaining bytes are given instead.
  192.      * If no bytes are remaining at all, boolean false is returned.
  193.      *
  194.      * @param int $length
  195.      *
  196.      * @throws Swift_IoException
  197.      *
  198.      * @return string|bool
  199.      */
  200.     public function read($length)
  201.     {
  202.         if (isset($this->_out) && !feof($this->_out)) {
  203.             $ret = fread($this->_out, $length);
  204.             if (strlen($ret) == 0) {
  205.                 $metas = stream_get_meta_data($this->_out);
  206.                 if ($metas['timed_out']) {
  207.                     throw new Swift_IoException(
  208.                         'Connection to '.
  209.                             $this->_getReadConnectionDescription().
  210.                         ' Timed Out'
  211.                     );
  212.                 }
  213.             }
  215.             return $ret;
  216.         }
  217.     }
  219.     /** Not implemented */
  220.     public function setReadPointer($byteOffset)
  221.     {
  222.     }
  224.     /** Flush the stream contents */
  225.     protected function _flush()
  226.     {
  227.         if (isset($this->_in)) {
  228.             fflush($this->_in);
  229.         }
  230.     }
  232.     /** Write this bytes to the stream */
  233.     protected function _commit($bytes)
  234.     {
  235.         if (isset($this->_in)) {
  236.             $bytesToWrite = strlen($bytes);
  237.             $totalBytesWritten = 0;
  239.             while ($totalBytesWritten < $bytesToWrite) {
  240.                 $bytesWritten = fwrite($this->_in, substr($bytes, $totalBytesWritten));
  241.                 if (false === $bytesWritten || 0 === $bytesWritten) {
  242.                     break;
  243.                 }
  245.                 $totalBytesWritten += $bytesWritten;
  246.             }
  248.             if ($totalBytesWritten > 0) {
  249.                 return ++$this->_sequence;
  250.             }
  251.         }
  252.     }
  254.     /**
  255.      * Establishes a connection to a remote server.
  256.      */
  257.     private function _establishSocketConnection()
  258.     {
  259.         $host = $this->_params['host'];
  260.         if (!empty($this->_params['protocol'])) {
  261.             $host = $this->_params['protocol'].'://'.$host;
  262.         }
  263.         $timeout = 15;
  264.         if (!empty($this->_params['timeout'])) {
  265.             $timeout = $this->_params['timeout'];
  266.         }
  267.         $options = array();
  268.         if (!empty($this->_params['sourceIp'])) {
  269.             $options['socket']['bindto'] = $this->_params['sourceIp'].':0';
  270.         }
  271.         if (isset($this->_params['stream_context_options'])) {
  272.             $options = array_merge($options, $this->_params['stream_context_options']);
  273.         }
  274.         $streamContext = stream_context_create($options);
  275.         $this->_stream = @stream_socket_client($host.':'.$this->_params['port'], $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT, $streamContext);
  276.         if (false === $this->_stream) {
  277.             throw new Swift_TransportException(
  278.                 'Connection could not be established with host '.$this->_params['host'].
  279.                 ' ['.$errstr.' #'.$errno.']'
  280.                 );
  281.         }
  282.         if (!empty($this->_params['blocking'])) {
  283.             stream_set_blocking($this->_stream, 1);
  284.         } else {
  285.             stream_set_blocking($this->_stream, 0);
  286.         }
  287.         stream_set_timeout($this->_stream, $timeout);
  288.         $this->_in = &$this->_stream;
  289.         $this->_out = &$this->_stream;
  290.     }
  292.     /**
  293.      * Opens a process for input/output.
  294.      */
  295.     private function _establishProcessConnection()
  296.     {
  297.         $command = $this->_params['command'];
  298.         $descriptorSpec = array(
  299.             0 => array('pipe', 'r'),
  300.             1 => array('pipe', 'w'),
  301.             2 => array('pipe', 'w'),
  302.             );
  303.         $pipes = array();
  304.         $this->_stream = proc_open($command, $descriptorSpec, $pipes);
  305.         stream_set_blocking($pipes[2], 0);
  306.         if ($err = stream_get_contents($pipes[2])) {
  307.             throw new Swift_TransportException(
  308.                 'Process could not be started ['.$err.']'
  309.                 );
  310.         }
  311.         $this->_in = &$pipes[0];
  312.         $this->_out = &$pipes[1];
  313.     }
  315.     private function _getReadConnectionDescription()
  316.     {
  317.         switch ($this->_params['type']) {
  318.             case self::TYPE_PROCESS:
  319.                 return 'Process '.$this->_params['command'];
  320.                 break;
  322.             case self::TYPE_SOCKET:
  323.             default:
  324.                 $host = $this->_params['host'];
  325.                 if (!empty($this->_params['protocol'])) {
  326.                     $host = $this->_params['protocol'].'://'.$host;
  327.                 }
  328.                 $host .= ':'.$this->_params['port'];
  330.                 return $host;
  331.                 break;
  332.         }
  333.     }
  334. }