SwiftMailerAdapter.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Mail;

class SwiftMailerAdapter implements \TYPO3\CMS\Core\Mail\MailerAdapterInterface {

    protected $mailer;

    protected $message;

    protected $messageHeaders;

    protected $boundary = '';

    public function __construct() {
        // create mailer object
        $this->mailer = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Mail\\Mailer');
        // create message object
        $this->message = \Swift_Message::newInstance();
    }

    public function mail($to, $subject, $messageBody, $additionalHeaders = NULL, $additionalParameters = NULL, $fakeSending = FALSE) {
        // report success for fake sending
        if ($fakeSending === TRUE) {
            return TRUE;
        }
        $this->message->setSubject($subject);
        // handle recipients
        $toAddresses = $this->parseAddresses($to);
        $this->message->setTo($toAddresses);
        // handle additional headers
        $headers = \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(LF, $additionalHeaders, TRUE);
        $this->messageHeaders = $this->message->getHeaders();
        foreach ($headers as $header) {
            list($headerName, $headerValue) = \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(':', $header, FALSE, 2);
            $this->setHeader($headerName, $headerValue);
        }
        // handle additional parameters (force return path)
        if (preg_match('/-f\\s*(\\S*?)/', $additionalParameters, $matches)) {
            $this->message->setReturnPath($this->unescapeShellArguments($matches[1]));
        }
        // handle from:
        $this->fixSender();
        // handle message body
        $this->setBody($messageBody);
        // send mail
        $result = $this->mailer->send($this->message);
        // report success/failure
        return (bool) $result;
    }

    protected function unescapeShellArguments($escapedString) {
        if (TYPO3_OS === 'WIN') {
            // on Windows double quotes are used and % signs are replaced by spaces
            if (preg_match('/^"([^"]*)"$/', trim($escapedString), $matches)) {
                $result = str_replace('\\"', '"', $matches[1]);
            }
        } else {
            // on Unix-like systems single quotes are escaped
            if (preg_match('/^\'([^' . preg_quote('\'') . ']*)\'$/', trim($escapedString), $matches)) {
                $result = str_replace('\\\'', '\'', $matches[1]);
            }
        }
        return $result;
    }

    protected function setHeader($headerName, $headerValue) {
        // check for boundary in headers
        if (preg_match('/^boundary="(.*)"$/', $headerName, $matches) > 0) {
            $this->boundary = $matches[1];
            return;
        }

        // Ignore empty header-values (like from an 'Reply-To:' without an email-address)
        $headerValue = trim($headerValue);
        if (empty($headerValue)) {
            return;
        }

        // process other, real headers
        if ($this->messageHeaders->has($headerName)) {
            $header = $this->messageHeaders->get($headerName);
            $headerType = $header->getFieldType();
            switch ($headerType) {
                case \Swift_Mime_Header::TYPE_TEXT:
                    $header->setValue($headerValue);
                    break;
                case \Swift_Mime_Header::TYPE_PARAMETERIZED:
                    $header->setValue(rtrim($headerValue, ';'));
                    break;
                case \Swift_Mime_Header::TYPE_MAILBOX:
                    $addressList = $this->parseAddresses($headerValue);
                    if (count($addressList) > 0) {
                        $header->setNameAddresses($addressList);
                    }
                    break;
                case \Swift_Mime_Header::TYPE_DATE:
                    $header->setTimeStamp(strtotime($headerValue));
                    break;
                case \Swift_Mime_Header::TYPE_ID:
                    // remove '<' and '>' from ID headers
                    $header->setId(trim($headerValue, '<>'));
                    break;
                case \Swift_Mime_Header::TYPE_PATH:
                    $header->setAddress($headerValue);
                    break;
            }
        } else {
            switch ($headerName) {
                case 'From':
                case 'To':
                case 'Cc':
                case 'Bcc':
                case 'Reply-To':
                case 'Sender':
                    $addressList = $this->parseAddresses($headerValue);
                    if (count($addressList) > 0) {
                        $this->messageHeaders->addMailboxHeader($headerName, $addressList);
                    }
                    break;
                case 'Date':
                    $this->messageHeaders->addDateHeader($headerName, strtotime($headerValue));
                    break;
                case 'Message-ID':
                    // remove '<' and '>' from ID headers
                    $this->messageHeaders->addIdHeader($headerName, trim($headerValue, '<>'));
                case 'Return-Path':
                    $this->messageHeaders->addPathHeader($headerName, $headerValue);
                    break;
                case 'Content-Type':
                case 'Content-Disposition':
                    $this->messageHeaders->addParameterizedHeader($headerName, rtrim($headerValue, ';'));
                    break;
                default:
                    $this->messageHeaders->addTextheader($headerName, $headerValue);
            }
        }
    }

    protected function setBody($body) {
        if ($this->boundary) {
            // handle multi-part
            $bodyParts = preg_split('/--' . preg_quote($this->boundary, '/') . '(--)?/m', $body, NULL, PREG_SPLIT_NO_EMPTY);
            foreach ($bodyParts as $bodyPart) {
                // skip empty parts
                if (trim($bodyPart) == '') {
                    continue;
                }
                // keep leading white space when exploding the text
                $lines = explode(LF, $bodyPart);
                // set defaults for this part
                $encoding = '';
                $charset = 'utf-8';
                $contentType = 'text/plain';
                // skip intro messages
                if (trim($lines[0]) == 'This is a multi-part message in MIME format.') {
                    continue;
                }
                // first line is empty leftover from splitting
                array_shift($lines);
                while (count($lines) > 0) {
                    $line = array_shift($lines);
                    if (preg_match('/^content-type:(.*);( charset=(.*))?$/i', $line, $matches)) {
                        $contentType = trim($matches[1]);
                        if ($matches[2]) {
                            $charset = trim($matches[3]);
                        }
                    } elseif (preg_match('/^content-transfer-encoding:(.*)$/i', $line, $matches)) {
                        $encoding = trim($matches[1]);
                    } elseif (strlen(trim($line)) == 0) {
                        // empty line before actual content of this part
                        break;
                    }
                }
                // use rest of part as body, but reverse encoding first
                $bodyPart = $this->decode(implode(LF, $lines), $encoding);
                $this->message->addPart($bodyPart, $contentType, $charset);
            }
        } else {
            // Handle single body
            // The headers have already been set, so use header information
            $contentType = $this->message->getContentType();
            $charset = $this->message->getCharset();
            $encoding = $this->message->getEncoder()->getName();
            // reverse encoding and set body
            $rawBody = $this->decode($body, $encoding);
            $this->message->setBody($rawBody, $contentType, $charset);
        }
    }

    protected function decode($text, $encoding) {
        $result = $text;
        switch ($encoding) {
            case 'quoted-printable':
                $result = quoted_printable_decode($text);
                break;
            case 'base64':
                $result = base64_decode($text);
                break;
        }
        return $result;
    }

    protected function parseAddresses($rawAddresses = '') {
        $addressParser = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Mail\\Rfc822AddressesParser', $rawAddresses);
        $addresses = $addressParser->parseAddressList();
        $addressList = array();
        foreach ($addresses as $address) {
            if ($address->personal) {
                // item with name found ( name <email@example.org> )
                $addressList[$address->mailbox . '@' . $address->host] = $address->personal;
            } else {
                // item without name found ( email@example.org )
                $addressList[] = $address->mailbox . '@' . $address->host;
            }
        }
        return $addressList;
    }

    protected function fixSender() {
        $from = $this->message->getFrom();
        if (count($from) > 0) {
            reset($from);
            list($fromAddress, $fromName) = each($from);
        } else {
            $fromAddress = $this->message->getReturnPath();
            $fromName = $fromAddress;
        }
        if (strlen($fromAddress) == 0) {
            $fromAddress = 'no-reply@example.org';
            $fromName = 'TYPO3 CMS';
        }
        $this->message->setFrom(array($fromAddress => $fromName));
    }

}