vendor/symfony/mailer/Transport/Smtp/SmtpTransport.php line 243

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Mailer\Transport\Smtp;
  14. use Psr\EventDispatcher\EventDispatcherInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Symfony\Component\Mailer\Envelope;
  17. use Symfony\Component\Mailer\Exception\LogicException;
  18. use Symfony\Component\Mailer\Exception\TransportException;
  19. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  20. use Symfony\Component\Mailer\SentMessage;
  21. use Symfony\Component\Mailer\Transport\AbstractTransport;
  22. use Symfony\Component\Mailer\Transport\Smtp\Stream\AbstractStream;
  23. use Symfony\Component\Mailer\Transport\Smtp\Stream\SocketStream;
  24. use Symfony\Component\Mime\RawMessage;
  26. /**
  27.  * Sends emails over SMTP.
  28.  *
  29.  * @author Fabien Potencier <fabien@symfony.com>
  30.  * @author Chris Corbyn
  31.  */
  32. class SmtpTransport extends AbstractTransport
  33. {
  34.     private $started = false;
  35.     private $restartThreshold = 100;
  36.     private $restartThresholdSleep = 0;
  37.     private $restartCounter;
  38.     private $pingThreshold = 100;
  39.     private $lastMessageTime = 0;
  40.     private $stream;
  41.     private $domain = '[127.0.0.1]';
  43.     public function __construct(?AbstractStream $stream = null, ?EventDispatcherInterface $dispatcher = null, ?LoggerInterface $logger = null)
  44.     {
  45.         parent::__construct($dispatcher, $logger);
  47.         $this->stream = $stream ?? new SocketStream();
  48.     }
  50.     public function getStream(): AbstractStream
  51.     {
  52.         return $this->stream;
  53.     }
  55.     /**
  56.      * Sets the maximum number of messages to send before re-starting the transport.
  57.      *
  58.      * By default, the threshold is set to 100 (and no sleep at restart).
  59.      *
  60.      * @param int $threshold The maximum number of messages (0 to disable)
  61.      * @param int $sleep     The number of seconds to sleep between stopping and re-starting the transport
  62.      *
  63.      * @return $this
  64.      */
  65.     public function setRestartThreshold(int $threshold, int $sleep = 0): self
  66.     {
  67.         $this->restartThreshold = $threshold;
  68.         $this->restartThresholdSleep = $sleep;
  70.         return $this;
  71.     }
  73.     /**
  74.      * Sets the minimum number of seconds required between two messages, before the server is pinged.
  75.      * If the transport wants to send a message and the time since the last message exceeds the specified threshold,
  76.      * the transport will ping the server first (NOOP command) to check if the connection is still alive.
  77.      * Otherwise the message will be sent without pinging the server first.
  78.      *
  79.      * Do not set the threshold too low, as the SMTP server may drop the connection if there are too many
  80.      * non-mail commands (like pinging the server with NOOP).
  81.      *
  82.      * By default, the threshold is set to 100 seconds.
  83.      *
  84.      * @param int $seconds The minimum number of seconds between two messages required to ping the server
  85.      *
  86.      * @return $this
  87.      */
  88.     public function setPingThreshold(int $seconds): self
  89.     {
  90.         $this->pingThreshold = $seconds;
  92.         return $this;
  93.     }
  95.     /**
  96.      * Sets the name of the local domain that will be used in HELO.
  97.      *
  98.      * This should be a fully-qualified domain name and should be truly the domain
  99.      * you're using.
  100.      *
  101.      * If your server does not have a domain name, use the IP address. This will
  102.      * automatically be wrapped in square brackets as described in RFC 5321,
  103.      * section 4.1.3.
  104.      *
  105.      * @return $this
  106.      */
  107.     public function setLocalDomain(string $domain): self
  108.     {
  109.         if ('' !== $domain && '[' !== $domain[0]) {
  110.             if (filter_var($domain, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
  111.                 $domain = '['.$domain.']';
  112.             } elseif (filter_var($domain, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
  113.                 $domain = '[IPv6:'.$domain.']';
  114.             }
  115.         }
  117.         $this->domain = $domain;
  119.         return $this;
  120.     }
  122.     /**
  123.      * Gets the name of the domain that will be used in HELO.
  124.      *
  125.      * If an IP address was specified, this will be returned wrapped in square
  126.      * brackets as described in RFC 5321, section 4.1.3.
  127.      */
  128.     public function getLocalDomain(): string
  129.     {
  130.         return $this->domain;
  131.     }
  133.     public function send(RawMessage $message, ?Envelope $envelope = null): ?SentMessage
  134.     {
  135.         try {
  136.             $message = parent::send($message, $envelope);
  137.         } catch (TransportExceptionInterface $e) {
  138.             if ($this->started) {
  139.                 try {
  140.                     $this->executeCommand("RSET\r\n", [250]);
  141.                 } catch (TransportExceptionInterface $_) {
  142.                     // ignore this exception as it probably means that the server error was final
  143.                 }
  144.             }
  146.             throw $e;
  147.         }
  149.         $this->checkRestartThreshold();
  151.         return $message;
  152.     }
  154.     public function __toString(): string
  155.     {
  156.         if ($this->stream instanceof SocketStream) {
  157.             $name = sprintf('smtp%s://%s', ($tls = $this->stream->isTLS()) ? 's' : '', $this->stream->getHost());
  158.             $port = $this->stream->getPort();
  159.             if (!(25 === $port || ($tls && 465 === $port))) {
  160.                 $name .= ':'.$port;
  161.             }
  163.             return $name;
  164.         }
  166.         return 'smtp://sendmail';
  167.     }
  169.     /**
  170.      * Runs a command against the stream, expecting the given response codes.
  171.      *
  172.      * @param int[] $codes
  173.      *
  174.      * @throws TransportException when an invalid response if received
  175.      *
  176.      * @internal
  177.      */
  178.     public function executeCommand(string $command, array $codes): string
  179.     {
  180.         $this->stream->write($command);
  181.         $response = $this->getFullResponse();
  182.         $this->assertResponseCode($response, $codes);
  184.         return $response;
  185.     }
  187.     protected function doSend(SentMessage $message): void
  188.     {
  189.         if (microtime(true) - $this->lastMessageTime > $this->pingThreshold) {
  190.             $this->ping();
  191.         }
  193.         if (!$this->started) {
  194.             $this->start();
  195.         }
  197.         try {
  198.             $envelope = $message->getEnvelope();
  199.             $this->doMailFromCommand($envelope->getSender()->getEncodedAddress());
  200.             foreach ($envelope->getRecipients() as $recipient) {
  201.                 $this->doRcptToCommand($recipient->getEncodedAddress());
  202.             }
  204.             $this->executeCommand("DATA\r\n", [354]);
  205.             try {
  206.                 foreach (AbstractStream::replace("\r\n.", "\r\n..", $message->toIterable()) as $chunk) {
  207.                     $this->stream->write($chunk, false);
  208.                 }
  209.                 $this->stream->flush();
  210.             } catch (TransportExceptionInterface $e) {
  211.                 throw $e;
  212.             } catch (\Exception $e) {
  213.                 $this->stream->terminate();
  214.                 $this->started = false;
  215.                 $this->getLogger()->debug(sprintf('Email transport "%s" stopped', __CLASS__));
  216.                 throw $e;
  217.             }
  218.             $this->executeCommand("\r\n.\r\n", [250]);
  219.             $message->appendDebug($this->stream->getDebug());
  220.             $this->lastMessageTime = microtime(true);
  221.         } catch (TransportExceptionInterface $e) {
  222.             $e->appendDebug($this->stream->getDebug());
  223.             $this->lastMessageTime = 0;
  224.             throw $e;
  225.         }
  226.     }
  228.     protected function doHeloCommand(): void
  229.     {
  230.         $this->executeCommand(sprintf("HELO %s\r\n", $this->domain), [250]);
  231.     }
  233.     private function doMailFromCommand(string $address): void
  234.     {
  235.         $this->executeCommand(sprintf("MAIL FROM:<%s>\r\n", $address), [250]);
  236.     }
  238.     private function doRcptToCommand(string $address): void
  239.     {
  240.         $this->executeCommand(sprintf("RCPT TO:<%s>\r\n", $address), [250, 251, 252]);
  241.     }
  243.     private function start(): void
  244.     {
  245.         if ($this->started) {
  246.             return;
  247.         }
  249.         $this->getLogger()->debug(sprintf('Email transport "%s" starting', __CLASS__));
  251.         $this->stream->initialize();
  252.         $this->assertResponseCode($this->getFullResponse(), [220]);
  253.         $this->doHeloCommand();
  254.         $this->started = true;
  255.         $this->lastMessageTime = 0;
  257.         $this->getLogger()->debug(sprintf('Email transport "%s" started', __CLASS__));
  258.     }
  260.     private function stop(): void
  261.     {
  262.         if (!$this->started) {
  263.             return;
  264.         }
  266.         $this->getLogger()->debug(sprintf('Email transport "%s" stopping', __CLASS__));
  268.         try {
  269.             $this->executeCommand("QUIT\r\n", [221]);
  270.         } catch (TransportExceptionInterface $e) {
  271.         } finally {
  272.             $this->stream->terminate();
  273.             $this->started = false;
  274.             $this->getLogger()->debug(sprintf('Email transport "%s" stopped', __CLASS__));
  275.         }
  276.     }
  278.     private function ping(): void
  279.     {
  280.         if (!$this->started) {
  281.             return;
  282.         }
  284.         try {
  285.             $this->executeCommand("NOOP\r\n", [250]);
  286.         } catch (TransportExceptionInterface $e) {
  287.             $this->stop();
  288.         }
  289.     }
  291.     /**
  292.      * @throws TransportException if a response code is incorrect
  293.      */
  294.     private function assertResponseCode(string $response, array $codes): void
  295.     {
  296.         if (!$codes) {
  297.             throw new LogicException('You must set the expected response code.');
  298.         }
  300.         [$code] = sscanf($response, '%3d');
  301.         $valid = \in_array($code, $codes);
  303.         if (!$valid || !$response) {
  304.             $codeStr = $code ? sprintf('code "%s"', $code) : 'empty code';
  305.             $responseStr = $response ? sprintf(', with message "%s"', trim($response)) : '';
  307.             throw new TransportException(sprintf('Expected response code "%s" but got ', implode('/', $codes)).$codeStr.$responseStr.'.', $code ?: 0);
  308.         }
  309.     }
  311.     private function getFullResponse(): string
  312.     {
  313.         $response = '';
  314.         do {
  315.             $line = $this->stream->readLine();
  316.             $response .= $line;
  317.         } while ($line && isset($line[3]) && ' ' !== $line[3]);
  319.         return $response;
  320.     }
  322.     private function checkRestartThreshold(): void
  323.     {
  324.         // when using sendmail via non-interactive mode, the transport is never "started"
  325.         if (!$this->started) {
  326.             return;
  327.         }
  329.         ++$this->restartCounter;
  330.         if ($this->restartCounter < $this->restartThreshold) {
  331.             return;
  332.         }
  334.         $this->stop();
  335.         if (0 < $sleep = $this->restartThresholdSleep) {
  336.             $this->getLogger()->debug(sprintf('Email transport "%s" sleeps for %d seconds after stopping', __CLASS__, $sleep));
  338.             sleep($sleep);
  339.         }
  340.         $this->start();
  341.         $this->restartCounter = 0;
  342.     }
  344.     /**
  345.      * @return array
  346.      */
  347.     public function __sleep()
  348.     {
  349.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  350.     }
  352.     public function __wakeup()
  353.     {
  354.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  355.     }
  357.     public function __destruct()
  358.     {
  359.         $this->stop();
  360.     }
  361. }