vendor/swiftmailer/swiftmailer/lib/classes/Swift/Transport/EsmtpTransport.php line 16

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.  * Sends Messages over SMTP with ESMTP support.
  13.  *
  14.  * @author Chris Corbyn
  15.  */
  16. class Swift_Transport_EsmtpTransport extends Swift_Transport_AbstractSmtpTransport implements Swift_Transport_SmtpAgent
  17. {
  18.     /**
  19.      * ESMTP extension handlers.
  20.      *
  21.      * @var Swift_Transport_EsmtpHandler[]
  22.      */
  23.     private $handlers = [];
  25.     /**
  26.      * ESMTP capabilities.
  27.      *
  28.      * @var string[]
  29.      */
  30.     private $capabilities = [];
  32.     /**
  33.      * Connection buffer parameters.
  34.      *
  35.      * @var array
  36.      */
  37.     private $params = [
  38.         'protocol' => 'tcp',
  39.         'host' => 'localhost',
  40.         'port' => 25,
  41.         'timeout' => 30,
  42.         'blocking' => 1,
  43.         'tls' => false,
  44.         'type' => Swift_Transport_IoBuffer::TYPE_SOCKET,
  45.         'stream_context_options' => [],
  46.         ];
  48.     /**
  49.      * Creates a new EsmtpTransport using the given I/O buffer.
  50.      *
  51.      * @param Swift_Transport_EsmtpHandler[] $extensionHandlers
  52.      * @param string                         $localDomain
  53.      */
  54.     public function __construct(Swift_Transport_IoBuffer $buf, array $extensionHandlers, Swift_Events_EventDispatcher $dispatcher, $localDomain = '127.0.0.1', Swift_AddressEncoder $addressEncoder = null)
  55.     {
  56.         parent::__construct($buf, $dispatcher, $localDomain, $addressEncoder);
  57.         $this->setExtensionHandlers($extensionHandlers);
  58.     }
  60.     /**
  61.      * Set the host to connect to.
  62.      *
  63.      * Literal IPv6 addresses should be wrapped in square brackets.
  64.      *
  65.      * @param string $host
  66.      *
  67.      * @return $this
  68.      */
  69.     public function setHost($host)
  70.     {
  71.         $this->params['host'] = $host;
  73.         return $this;
  74.     }
  76.     /**
  77.      * Get the host to connect to.
  78.      *
  79.      * @return string
  80.      */
  81.     public function getHost()
  82.     {
  83.         return $this->params['host'];
  84.     }
  86.     /**
  87.      * Set the port to connect to.
  88.      *
  89.      * @param int $port
  90.      *
  91.      * @return $this
  92.      */
  93.     public function setPort($port)
  94.     {
  95.         $this->params['port'] = (int) $port;
  97.         return $this;
  98.     }
  100.     /**
  101.      * Get the port to connect to.
  102.      *
  103.      * @return int
  104.      */
  105.     public function getPort()
  106.     {
  107.         return $this->params['port'];
  108.     }
  110.     /**
  111.      * Set the connection timeout.
  112.      *
  113.      * @param int $timeout seconds
  114.      *
  115.      * @return $this
  116.      */
  117.     public function setTimeout($timeout)
  118.     {
  119.         $this->params['timeout'] = (int) $timeout;
  120.         $this->buffer->setParam('timeout', (int) $timeout);
  122.         return $this;
  123.     }
  125.     /**
  126.      * Get the connection timeout.
  127.      *
  128.      * @return int
  129.      */
  130.     public function getTimeout()
  131.     {
  132.         return $this->params['timeout'];
  133.     }
  135.     /**
  136.      * Set the encryption type (tls or ssl).
  137.      *
  138.      * @param string $encryption
  139.      *
  140.      * @return $this
  141.      */
  142.     public function setEncryption($encryption)
  143.     {
  144.         $encryption = strtolower($encryption ?? '');
  145.         if ('tls' == $encryption) {
  146.             $this->params['protocol'] = 'tcp';
  147.             $this->params['tls'] = true;
  148.         } else {
  149.             $this->params['protocol'] = $encryption;
  150.             $this->params['tls'] = false;
  151.         }
  153.         return $this;
  154.     }
  156.     /**
  157.      * Get the encryption type.
  158.      *
  159.      * @return string
  160.      */
  161.     public function getEncryption()
  162.     {
  163.         return $this->params['tls'] ? 'tls' : $this->params['protocol'];
  164.     }
  166.     /**
  167.      * Sets the stream context options.
  168.      *
  169.      * @param array $options
  170.      *
  171.      * @return $this
  172.      */
  173.     public function setStreamOptions($options)
  174.     {
  175.         $this->params['stream_context_options'] = $options;
  177.         return $this;
  178.     }
  180.     /**
  181.      * Returns the stream context options.
  182.      *
  183.      * @return array
  184.      */
  185.     public function getStreamOptions()
  186.     {
  187.         return $this->params['stream_context_options'];
  188.     }
  190.     /**
  191.      * Sets the source IP.
  192.      *
  193.      * IPv6 addresses should be wrapped in square brackets.
  194.      *
  195.      * @param string $source
  196.      *
  197.      * @return $this
  198.      */
  199.     public function setSourceIp($source)
  200.     {
  201.         $this->params['sourceIp'] = $source;
  203.         return $this;
  204.     }
  206.     /**
  207.      * Returns the IP used to connect to the destination.
  208.      *
  209.      * @return string
  210.      */
  211.     public function getSourceIp()
  212.     {
  213.         return $this->params['sourceIp'] ?? null;
  214.     }
  216.     /**
  217.      * Sets whether SMTP pipelining is enabled.
  218.      *
  219.      * By default, support is auto-detected using the PIPELINING SMTP extension.
  220.      * Use this function to override that in the unlikely event of compatibility
  221.      * issues.
  222.      *
  223.      * @param bool $enabled
  224.      *
  225.      * @return $this
  226.      */
  227.     public function setPipelining($enabled)
  228.     {
  229.         $this->pipelining = $enabled;
  231.         return $this;
  232.     }
  234.     /**
  235.      * Returns whether SMTP pipelining is enabled.
  236.      *
  237.      * @return bool|null a boolean if pipelining is explicitly enabled or disabled,
  238.      *                   or null if support is auto-detected
  239.      */
  240.     public function getPipelining()
  241.     {
  242.         return $this->pipelining;
  243.     }
  245.     /**
  246.      * Set ESMTP extension handlers.
  247.      *
  248.      * @param Swift_Transport_EsmtpHandler[] $handlers
  249.      *
  250.      * @return $this
  251.      */
  252.     public function setExtensionHandlers(array $handlers)
  253.     {
  254.         $assoc = [];
  255.         foreach ($handlers as $handler) {
  256.             $assoc[$handler->getHandledKeyword()] = $handler;
  257.         }
  258.         uasort($assoc, function ($a, $b) {
  259.             return $a->getPriorityOver($b->getHandledKeyword());
  260.         });
  261.         $this->handlers = $assoc;
  262.         $this->setHandlerParams();
  264.         return $this;
  265.     }
  267.     /**
  268.      * Get ESMTP extension handlers.
  269.      *
  270.      * @return Swift_Transport_EsmtpHandler[]
  271.      */
  272.     public function getExtensionHandlers()
  273.     {
  274.         return array_values($this->handlers);
  275.     }
  277.     /**
  278.      * Run a command against the buffer, expecting the given response codes.
  279.      *
  280.      * If no response codes are given, the response will not be validated.
  281.      * If codes are given, an exception will be thrown on an invalid response.
  282.      *
  283.      * @param string   $command
  284.      * @param int[]    $codes
  285.      * @param string[] $failures An array of failures by-reference
  286.      * @param bool     $pipeline Do not wait for response
  287.      * @param string   $address  the address, if command is RCPT TO
  288.      *
  289.      * @return string|null The server response, or null if pipelining is enabled
  290.      */
  291.     public function executeCommand($command, $codes = [], &$failures = null, $pipeline = false, $address = null)
  292.     {
  293.         $failures = (array) $failures;
  294.         $stopSignal = false;
  295.         $response = null;
  296.         foreach ($this->getActiveHandlers() as $handler) {
  297.             $response = $handler->onCommand(
  298.                 $this, $command, $codes, $failures, $stopSignal
  299.                 );
  300.             if ($stopSignal) {
  301.                 return $response;
  302.             }
  303.         }
  305.         return parent::executeCommand($command, $codes, $failures, $pipeline, $address);
  306.     }
  308.     /** Mixin handling method for ESMTP handlers */
  309.     public function __call($method, $args)
  310.     {
  311.         foreach ($this->handlers as $handler) {
  312.             if (\in_array(strtolower($method),
  313.                 array_map('strtolower', (array) $handler->exposeMixinMethods())
  314.                 )) {
  315.                 $return = \call_user_func_array([$handler, $method], $args);
  316.                 // Allow fluid method calls
  317.                 if (null === $return && 'set' == substr($method, 0, 3)) {
  318.                     return $this;
  319.                 } else {
  320.                     return $return;
  321.                 }
  322.             }
  323.         }
  324.         trigger_error('Call to undefined method '.$method, E_USER_ERROR);
  325.     }
  327.     /** Get the params to initialize the buffer */
  328.     protected function getBufferParams()
  329.     {
  330.         return $this->params;
  331.     }
  333.     /** Overridden to perform EHLO instead */
  334.     protected function doHeloCommand()
  335.     {
  336.         try {
  337.             $response = $this->executeCommand(
  338.                 sprintf("EHLO %s\r\n", $this->domain), [250]
  339.                 );
  340.         } catch (Swift_TransportException $e) {
  341.             return parent::doHeloCommand();
  342.         }
  344.         if ($this->params['tls']) {
  345.             try {
  346.                 $this->executeCommand("STARTTLS\r\n", [220]);
  348.                 if (!$this->buffer->startTLS()) {
  349.                     throw new Swift_TransportException('Unable to connect with TLS encryption');
  350.                 }
  352.                 try {
  353.                     $response = $this->executeCommand(
  354.                         sprintf("EHLO %s\r\n", $this->domain), [250]
  355.                         );
  356.                 } catch (Swift_TransportException $e) {
  357.                     return parent::doHeloCommand();
  358.                 }
  359.             } catch (Swift_TransportException $e) {
  360.                 $this->throwException($e);
  361.             }
  362.         }
  364.         $this->capabilities = $this->getCapabilities($response);
  365.         if (!isset($this->pipelining)) {
  366.             $this->pipelining = isset($this->capabilities['PIPELINING']);
  367.         }
  369.         $this->setHandlerParams();
  370.         foreach ($this->getActiveHandlers() as $handler) {
  371.             $handler->afterEhlo($this);
  372.         }
  373.     }
  375.     /** Overridden to add Extension support */
  376.     protected function doMailFromCommand($address)
  377.     {
  378.         $address = $this->addressEncoder->encodeString($address);
  379.         $handlers = $this->getActiveHandlers();
  380.         $params = [];
  381.         foreach ($handlers as $handler) {
  382.             $params = array_merge($params, (array) $handler->getMailParams());
  383.         }
  384.         $paramStr = !empty($params) ? ' '.implode(' ', $params) : '';
  385.         $this->executeCommand(
  386.             sprintf("MAIL FROM:<%s>%s\r\n", $address, $paramStr), [250], $failures, true
  387.             );
  388.     }
  390.     /** Overridden to add Extension support */
  391.     protected function doRcptToCommand($address)
  392.     {
  393.         $address = $this->addressEncoder->encodeString($address);
  394.         $handlers = $this->getActiveHandlers();
  395.         $params = [];
  396.         foreach ($handlers as $handler) {
  397.             $params = array_merge($params, (array) $handler->getRcptParams());
  398.         }
  399.         $paramStr = !empty($params) ? ' '.implode(' ', $params) : '';
  400.         $this->executeCommand(
  401.             sprintf("RCPT TO:<%s>%s\r\n", $address, $paramStr), [250, 251, 252], $failures, true, $address
  402.             );
  403.     }
  405.     /** Determine ESMTP capabilities by function group */
  406.     private function getCapabilities($ehloResponse)
  407.     {
  408.         $capabilities = [];
  409.         $ehloResponse = trim($ehloResponse ?? '');
  410.         $lines = explode("\r\n", $ehloResponse);
  411.         array_shift($lines);
  412.         foreach ($lines as $line) {
  413.             if (preg_match('/^[0-9]{3}[ -]([A-Z0-9-]+)((?:[ =].*)?)$/Di', $line, $matches)) {
  414.                 $keyword = strtoupper($matches[1]);
  415.                 $paramStr = strtoupper(ltrim($matches[2], ' ='));
  416.                 $params = !empty($paramStr) ? explode(' ', $paramStr) : [];
  417.                 $capabilities[$keyword] = $params;
  418.             }
  419.         }
  421.         return $capabilities;
  422.     }
  424.     /** Set parameters which are used by each extension handler */
  425.     private function setHandlerParams()
  426.     {
  427.         foreach ($this->handlers as $keyword => $handler) {
  428.             if (\array_key_exists($keyword, $this->capabilities)) {
  429.                 $handler->setKeywordParams($this->capabilities[$keyword]);
  430.             }
  431.         }
  432.     }
  434.     /** Get ESMTP handlers which are currently ok to use */
  435.     private function getActiveHandlers()
  436.     {
  437.         $handlers = [];
  438.         foreach ($this->handlers as $keyword => $handler) {
  439.             if (\array_key_exists($keyword, $this->capabilities)) {
  440.                 $handlers[] = $handler;
  441.             }
  442.         }
  444.         return $handlers;
  445.     }
  446. }