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

Open in your IDE?
  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 = [];
  30.     /** The ReplacementFilterFactory */
  31.     private $replacementFactory;
  33.     /** Translations performed on data being streamed into the buffer */
  34.     private $translations = [];
  36.     /**
  37.      * Create a new StreamBuffer using $replacementFactory for transformations.
  38.      */
  39.     public function __construct(Swift_ReplacementFilterFactory $replacementFactory)
  40.     {
  41.         $this->replacementFactory = $replacementFactory;
  42.     }
  44.     /**
  45.      * Perform any initialization needed, using the given $params.
  46.      *
  47.      * Parameters will vary depending upon the type of IoBuffer used.
  48.      */
  49.     public function initialize(array $params)
  50.     {
  51.         $this->params = $params;
  52.         switch ($params['type']) {
  53.             case self::TYPE_PROCESS:
  54.                 $this->establishProcessConnection();
  55.                 break;
  56.             case self::TYPE_SOCKET:
  57.             default:
  58.                 $this->establishSocketConnection();
  59.                 break;
  60.         }
  61.     }
  63.     /**
  64.      * Set an individual param on the buffer (e.g. switching to SSL).
  65.      *
  66.      * @param string $param
  67.      * @param mixed  $value
  68.      */
  69.     public function setParam($param, $value)
  70.     {
  71.         if (isset($this->stream)) {
  72.             switch ($param) {
  73.                 case 'timeout':
  74.                     if ($this->stream) {
  75.                         stream_set_timeout($this->stream, $value);
  76.                     }
  77.                     break;
  79.                 case 'blocking':
  80.                     if ($this->stream) {
  81.                         stream_set_blocking($this->stream, 1);
  82.                     }
  83.             }
  84.         }
  85.         $this->params[$param] = $value;
  86.     }
  88.     public function startTLS()
  89.     {
  90.         // STREAM_CRYPTO_METHOD_TLS_CLIENT only allow tls1.0 connections (some php versions)
  91.         // To support modern tls we allow explicit tls1.0, tls1.1, tls1.2
  92.         // Ssl3 and older are not allowed because they are vulnerable
  93.         // @TODO make tls arguments configurable
  94.         return stream_socket_enable_crypto($this->stream, true, STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT | STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT | STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
  95.     }
  97.     /**
  98.      * Perform any shutdown logic needed.
  99.      */
  100.     public function terminate()
  101.     {
  102.         if (isset($this->stream)) {
  103.             switch ($this->params['type']) {
  104.                 case self::TYPE_PROCESS:
  105.                     fclose($this->in);
  106.                     fclose($this->out);
  107.                     proc_close($this->stream);
  108.                     break;
  109.                 case self::TYPE_SOCKET:
  110.                 default:
  111.                     fclose($this->stream);
  112.                     break;
  113.             }
  114.         }
  115.         $this->stream = null;
  116.         $this->out = null;
  117.         $this->in = null;
  118.     }
  120.     /**
  121.      * Set an array of string replacements which should be made on data written
  122.      * to the buffer.
  123.      *
  124.      * This could replace LF with CRLF for example.
  125.      *
  126.      * @param string[] $replacements
  127.      */
  128.     public function setWriteTranslations(array $replacements)
  129.     {
  130.         foreach ($this->translations as $search => $replace) {
  131.             if (!isset($replacements[$search])) {
  132.                 $this->removeFilter($search);
  133.                 unset($this->translations[$search]);
  134.             }
  135.         }
  137.         foreach ($replacements as $search => $replace) {
  138.             if (!isset($this->translations[$search])) {
  139.                 $this->addFilter(
  140.                     $this->replacementFactory->createFilter($search, $replace), $search
  141.                     );
  142.                 $this->translations[$search] = true;
  143.             }
  144.         }
  145.     }
  147.     /**
  148.      * Get a line of output (including any CRLF).
  149.      *
  150.      * The $sequence number comes from any writes and may or may not be used
  151.      * depending upon the implementation.
  152.      *
  153.      * @param int $sequence of last write to scan from
  154.      *
  155.      * @return string
  156.      *
  157.      * @throws Swift_IoException
  158.      */
  159.     public function readLine($sequence)
  160.     {
  161.         if (isset($this->out) && !feof($this->out)) {
  162.             $line = fgets($this->out);
  163.             if (0 == strlen($line)) {
  164.                 $metas = stream_get_meta_data($this->out);
  165.                 if ($metas['timed_out']) {
  166.                     throw new Swift_IoException(
  167.                         'Connection to '.
  168.                             $this->getReadConnectionDescription().
  169.                         ' Timed Out'
  170.                     );
  171.                 }
  172.             }
  174.             return $line;
  175.         }
  176.     }
  178.     /**
  179.      * Reads $length bytes from the stream into a string and moves the pointer
  180.      * through the stream by $length.
  181.      *
  182.      * If less bytes exist than are requested the remaining bytes are given instead.
  183.      * If no bytes are remaining at all, boolean false is returned.
  184.      *
  185.      * @param int $length
  186.      *
  187.      * @return string|bool
  188.      *
  189.      * @throws Swift_IoException
  190.      */
  191.     public function read($length)
  192.     {
  193.         if (isset($this->out) && !feof($this->out)) {
  194.             $ret = fread($this->out, $length);
  195.             if (0 == strlen($ret)) {
  196.                 $metas = stream_get_meta_data($this->out);
  197.                 if ($metas['timed_out']) {
  198.                     throw new Swift_IoException(
  199.                         'Connection to '.
  200.                             $this->getReadConnectionDescription().
  201.                         ' Timed Out'
  202.                     );
  203.                 }
  204.             }
  206.             return $ret;
  207.         }
  208.     }
  210.     /** Not implemented */
  211.     public function setReadPointer($byteOffset)
  212.     {
  213.     }
  215.     /** Flush the stream contents */
  216.     protected function flush()
  217.     {
  218.         if (isset($this->in)) {
  219.             fflush($this->in);
  220.         }
  221.     }
  223.     /** Write this bytes to the stream */
  224.     protected function doCommit($bytes)
  225.     {
  226.         if (isset($this->in)) {
  227.             $bytesToWrite = strlen($bytes);
  228.             $totalBytesWritten = 0;
  230.             while ($totalBytesWritten < $bytesToWrite) {
  231.                 $bytesWritten = fwrite($this->in, substr($bytes, $totalBytesWritten));
  232.                 if (false === $bytesWritten || 0 === $bytesWritten) {
  233.                     break;
  234.                 }
  236.                 $totalBytesWritten += $bytesWritten;
  237.             }
  239.             if ($totalBytesWritten > 0) {
  240.                 return ++$this->sequence;
  241.             }
  242.         }
  243.     }
  245.     /**
  246.      * Establishes a connection to a remote server.
  247.      */
  248.     private function establishSocketConnection()
  249.     {
  250.         $host = $this->params['host'];
  251.         if (!empty($this->params['protocol'])) {
  252.             $host = $this->params['protocol'].'://'.$host;
  253.         }
  254.         $timeout = 15;
  255.         if (!empty($this->params['timeout'])) {
  256.             $timeout = $this->params['timeout'];
  257.         }
  258.         $options = [];
  259.         if (!empty($this->params['sourceIp'])) {
  260.             $options['socket']['bindto'] = $this->params['sourceIp'].':0';
  261.         }
  263.         if (isset($this->params['stream_context_options'])) {
  264.             $options = array_merge($options, $this->params['stream_context_options']);
  265.         }
  266.         $streamContext = stream_context_create($options);
  268.         set_error_handler(function ($type, $msg) {
  269.             throw new Swift_TransportException('Connection could not be established with host '.$this->params['host'].' :'.$msg);
  270.         });
  271.         try {
  272.             $this->stream = stream_socket_client($host.':'.$this->params['port'], $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT, $streamContext);
  273.         } finally {
  274.             restore_error_handler();
  275.         }
  277.         if (!empty($this->params['blocking'])) {
  278.             stream_set_blocking($this->stream, 1);
  279.         } else {
  280.             stream_set_blocking($this->stream, 0);
  281.         }
  282.         stream_set_timeout($this->stream, $timeout);
  283.         $this->in = &$this->stream;
  284.         $this->out = &$this->stream;
  285.     }
  287.     /**
  288.      * Opens a process for input/output.
  289.      */
  290.     private function establishProcessConnection()
  291.     {
  292.         $command = $this->params['command'];
  293.         $descriptorSpec = [
  294.             0 => ['pipe', 'r'],
  295.             1 => ['pipe', 'w'],
  296.             2 => ['pipe', 'w'],
  297.             ];
  298.         $pipes = [];
  299.         $this->stream = proc_open($command, $descriptorSpec, $pipes);
  300.         stream_set_blocking($pipes[2], 0);
  301.         if ($err = stream_get_contents($pipes[2])) {
  302.             throw new Swift_TransportException(
  303.                 'Process could not be started ['.$err.']'
  304.                 );
  305.         }
  306.         $this->in = &$pipes[0];
  307.         $this->out = &$pipes[1];
  308.     }
  310.     private function getReadConnectionDescription()
  311.     {
  312.         switch ($this->params['type']) {
  313.             case self::TYPE_PROCESS:
  314.                 return 'Process '.$this->params['command'];
  315.                 break;
  317.             case self::TYPE_SOCKET:
  318.             default:
  319.                 $host = $this->params['host'];
  320.                 if (!empty($this->params['protocol'])) {
  321.                     $host = $this->params['protocol'].'://'.$host;
  322.                 }
  323.                 $host .= ':'.$this->params['port'];
  325.                 return $host;
  326.                 break;
  327.         }
  328.     }
  329. }