silverstripe-framework/Control/Email/Mailer.php

<?php

namespace SilverStripe\Control\Email;

use InvalidArgumentException;
use SilverStripe\Control\HTTP;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Object;

/**
 * Mailer objects are responsible for actually sending emails.
 * The default Mailer class will use PHP's mail() function.
 */
class Mailer extends Object {

	/**
	 * Default encoding type for messages. Available options are:
	 * - quoted-printable
	 * - base64
	 *
	 * @var string
	 * @config
	 */
	private static $default_message_encoding = 'quoted-printable';

	/**
	 * Encoding type currently set
	 *
	 * @var string
	 */
	protected $messageEncoding = null;

	/**
	 * Email used for bounces
	 *
	 * @var string
	 * @config
	 */
	private static $default_bounce_email = null;

	/**
	 * Email used for bounces
	 *
	 * @var string
	 */
	protected $bounceEmail = null;

	/**
	 * Email used for bounces
	 *
	 * @return string
	 */
	public function getBounceEmail() {
		return $this->bounceEmail
			?: (defined('BOUNCE_EMAIL') ? BOUNCE_EMAIL : null)
			?: self::config()->default_bounce_email;
	}

	/**
	 * Set the email used for bounces
	 *
	 * @param string $email
	 */
	public function setBounceEmail($email) {
		$this->bounceEmail = $email;
	}

	/**
	 * Get the encoding type used for plain text messages
	 *
	 * @return string
	 */
	public function getMessageEncoding() {
		return $this->messageEncoding ?: static::config()->default_message_encoding;
	}

	/**
	 * Sets encoding type for messages. Available options are:
	 * - quoted-printable
	 * - base64
	 *
	 * @param string $encoding
	 */
	public function setMessageEncoding($encoding) {
		$this->messageEncoding = $encoding;
	}

	/**
	 * Encode a message using the given encoding mechanism
	 *
	 * @param string $message
	 * @param string $encoding
	 * @return string Encoded $message
	 */
	protected function encodeMessage($message, $encoding) {
		switch($encoding) {
			case 'base64':
				return chunk_split(base64_encode($message), 60);
			case 'quoted-printable':
				return quoted_printable_encode($message);
			default:
				return $message;
		}
	}

	/**
	 * Merge custom headers with default ones
	 *
	 * @param array $headers Default headers
	 * @param array $customHeaders Custom headers
	 * @return array Resulting message headers
	 */
	protected function mergeCustomHeaders($headers, $customHeaders) {
		$headers["X-Mailer"] = X_MAILER;
		if(!isset($customHeaders["X-Priority"])) {
			$headers["X-Priority"]	= 3;
		}

		// Merge!
		$headers = array_merge($headers, $customHeaders);

		// Headers 'Cc' and 'Bcc' need to have the correct case
		foreach(array('Bcc', 'Cc') as $correctKey) {
			foreach($headers as $key => $value) {
				if(strcmp($key, $correctKey) !== 0 && strcasecmp($key, $correctKey) === 0) {
					$headers[$correctKey] = $value;
					unset($headers[$key]);
				}
			}
		}

		return $headers;
	}

	/**
	 * Send a plain-text email.
	 *
	 * @param string $to Email recipient
	 * @param string $from Email from
	 * @param string $subject Subject text
	 * @param string $plainContent Plain text content
	 * @param array $attachedFiles List of attached files
	 * @param array $customHeaders List of custom headers
	 * @return mixed Return false if failure, or list of arguments if success
	 */
	public function sendPlain($to, $from, $subject, $plainContent, $attachedFiles = array(), $customHeaders = array()) {
		// Prepare plain text body
		$fullBody = $this->encodeMessage($plainContent, $this->getMessageEncoding());
		$headers["Content-Type"] = "text/plain; charset=utf-8";
		$headers["Content-Transfer-Encoding"] = $this->getMessageEncoding();

		// Send prepared message
		return $this->sendPreparedMessage($to, $from, $subject, $attachedFiles, $customHeaders, $fullBody, $headers);
	}


	/**
	 * Sends an email as a both HTML and plaintext
	 *
	 * @param string $to Email recipient
	 * @param string $from Email from
	 * @param string $subject Subject text
	 * @param string $htmlContent HTML Content
	 * @param array $attachedFiles List of attachments
	 * @param array $customHeaders User specified headers
	 * @param string $plainContent Plain text content. If omitted, will be generated from $htmlContent
	 * @return mixed Return false if failure, or list of arguments if success
	 */
	public function sendHTML($to, $from, $subject, $htmlContent,
		$attachedFiles = array(), $customHeaders = array(), $plainContent = ''
	) {
		// Prepare both Plain and HTML components and merge
		$plainPart = $this->preparePlainSubmessage($plainContent, $htmlContent);
		$htmlPart = $this->prepareHTMLSubmessage($htmlContent);
		list($fullBody, $headers) = $this->encodeMultipart(
			array($plainPart, $htmlPart),
			"multipart/alternative"
		);

		// Send prepared message
		return $this->sendPreparedMessage($to, $from, $subject, $attachedFiles, $customHeaders, $fullBody, $headers);
	}

	/**
	 * Send an email of an arbitrary format
	 *
	 * @param string $to To
	 * @param string $from From
	 * @param string $subject Subject
	 * @param array $attachedFiles List of attachments
	 * @param array $customHeaders User specified headers
	 * @param string $fullBody Prepared message
	 * @param array $headers Prepared headers
	 * @return mixed Return false if failure, or list of arguments if success
	 */
	protected function sendPreparedMessage($to, $from, $subject, $attachedFiles, $customHeaders, $fullBody, $headers) {
		// If the subject line contains extended characters, we must encode the
		$subjectEncoded = "=?UTF-8?B?" . base64_encode($subject) . "?=";
		$to = $this->validEmailAddress($to);
		$from = $this->validEmailAddress($from);

		// Messages with attachments are handled differently
		if($attachedFiles) {
			list($fullBody, $headers) = $this->encodeAttachments($attachedFiles, $headers, $fullBody);
		}

		// Get bounce email
		$bounceAddress = $this->getBounceEmail() ?: $from;
		if(preg_match('/^([^<>]*)<([^<>]+)> *$/', $bounceAddress, $parts)) $bounceAddress = $parts[2];

		// Get headers
		$headers["From"] = $from;
		$headers = $this->mergeCustomHeaders($headers, $customHeaders);
		$headersEncoded = $this->processHeaders($headers);

		return $this->email($to, $subjectEncoded, $fullBody, $headersEncoded, $bounceAddress);
	}

	/**
	 * Send the actual email
	 *
	 * @param string $to
	 * @param string $subjectEncoded
	 * @param string $fullBody
	 * @param string $headersEncoded
	 * @param string $bounceAddress
	 * @return mixed Return false if failure, or list of arguments if success
	 */
	protected function email($to, $subjectEncoded, $fullBody, $headersEncoded, $bounceAddress) {
		// Try it without the -f option if it fails
		$result = @mail($to, $subjectEncoded, $fullBody, $headersEncoded, escapeshellarg("-f$bounceAddress"));
		if(!$result) {
			$result = mail($to, $subjectEncoded, $fullBody, $headersEncoded);
		}

		if($result) {
			return array($to, $subjectEncoded, $fullBody, $headersEncoded, $bounceAddress);
		}

		return false;
	}

	/**
	 * Encode attachments into a message
	 *
	 * @param array $attachments
	 * @param array $headers
	 * @param string $body
	 * @return array Array containing completed body followed by headers
	 */
	protected function encodeAttachments($attachments, $headers, $body) {
		// The first part is the message itself
		$fullMessage = $this->processHeaders($headers, $body);
		$messageParts = array($fullMessage);

		// Include any specified attachments as additional parts
		foreach($attachments as $file) {
			if(isset($file['tmp_name']) && isset($file['name'])) {
				$messageParts[] = $this->encodeFileForEmail($file['tmp_name'], $file['name']);
			} else {
				$messageParts[] = $this->encodeFileForEmail($file);
			}
		}

		// We further wrap all of this into another multipart block
		return $this->encodeMultipart($messageParts, "multipart/mixed");
	}

	/**
	 * Generate the plainPart of a html message
	 *
	 * @param string $plainContent Plain body
	 * @param string $htmlContent HTML message
	 * @return string Encoded headers / message in a single block
	 */
	protected function preparePlainSubmessage($plainContent, $htmlContent) {
		$plainEncoding = $this->getMessageEncoding();

		// Generate plain text version if not explicitly given
		if(!$plainContent) $plainContent = Convert::xml2raw($htmlContent);

		// Make the plain text part
		$headers["Content-Type"] = "text/plain; charset=utf-8";
		$headers["Content-Transfer-Encoding"] = $plainEncoding;
		$plainContentEncoded = $this->encodeMessage($plainContent, $plainEncoding);

		// Merge with headers
		return $this->processHeaders($headers, $plainContentEncoded);
	}

	/**
	 * Generate the html part of a html message
	 *
	 * @param string $htmlContent HTML message
	 * @return string Encoded headers / message in a single block
	 */
	protected function prepareHTMLSubmessage($htmlContent) {
		// Add basic wrapper tags if the body tag hasn't been given
		if(stripos($htmlContent, '<body') === false) {
			$htmlContent =
				"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">\n" .
				"<HTML><HEAD>\n" .
				"<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n" .
				"<STYLE type=\"text/css\"></STYLE>\n\n".
				"</HEAD>\n" .
				"<BODY bgColor=\"#ffffff\">\n" .
					$htmlContent .
				"\n</BODY>\n" .
				"</HTML>";
		}

		// Make the HTML part
		$headers["Content-Type"] = "text/html; charset=utf-8";
		$headers["Content-Transfer-Encoding"] = $this->getMessageEncoding();
		$htmlContentEncoded = $this->encodeMessage($htmlContent, $this->getMessageEncoding());

		// Merge with headers
		return $this->processHeaders($headers, $htmlContentEncoded);
	}

	/**
	 * Encode an array of parts using multipart
	 *
	 * @param array $parts List of parts
	 * @param string $contentType Content-type of parts
	 * @param array $headers Existing headers to include in response
	 * @return array Array with two items, the body followed by headers
	 */
	protected function encodeMultipart($parts, $contentType, $headers = array()) {
		$separator = "----=_NextPart_" . preg_replace('/[^0-9]/', '', rand() * 10000000000);

		$headers["MIME-Version"] = "1.0";
		$headers["Content-Type"] = "$contentType; boundary=\"$separator\"";
		$headers["Content-Transfer-Encoding"] = "7bit";

		if($contentType == "multipart/alternative") {
			// $baseMessage = "This is an encoded HTML message.  There are two parts: a plain text and an HTML message,
			// open whatever suits you better.";
			$baseMessage = "\nThis is a multi-part message in MIME format.";
		} else {
			// $baseMessage = "This is a message containing attachments.  The e-mail body is contained in the first
			// attachment";
			$baseMessage = "\nThis is a multi-part message in MIME format.";
		}

		$separator = "\n--$separator\n";
		$body = "$baseMessage\n" .
			$separator . implode("\n".$separator, $parts) . "\n" . trim($separator) . "--";

		return array($body, $headers);
	}


	/**
	 * Add headers to the start of the message
	 *
	 * @param array $headers
	 * @param string $body
	 * @return string Resulting message body
	 */
	protected function processHeaders($headers, $body = '') {
		$result = '';
		foreach($headers as $key => $value) {
			$result .= "$key: $value\n";
		}
		if($body) $result .= "\n$body";

		return $result;
	}

	/**
	 * Encode the contents of a file for emailing, including headers
	 *
	 * $file can be an array, in which case it expects these members:
	 *   'filename'        - the filename of the file
	 *   'contents'        - the raw binary contents of the file as a string
	 *  and can optionally include these members:
	 *   'mimetype'        - the mimetype of the file (calculated from filename if missing)
	 *   'contentLocation' - the 'Content-Location' header value for the file
	 *
	 * $file can also be a string, in which case it is assumed to be the filename
	 *
	 * h5. contentLocation
	 *
	 * Content Location is one of the two methods allowed for embedding images into an html email.
	 * It's also the simplest, and best supported.
	 *
	 * Assume we have an email with this in the body:
	 *
	 *   <img src="http://example.com/image.gif" />
	 *
	 * To display the image, an email viewer would have to download the image from the web every time
	 * it is displayed. Due to privacy issues, most viewers will not display any images unless
	 * the user clicks 'Show images in this email'. Not optimal.
	 *
	 * However, we can also include a copy of this image as an attached file in the email.
	 * By giving it a contentLocation of "http://example.com/image.gif" most email viewers
	 * will use this attached copy instead of downloading it. Better,
	 * most viewers will show it without a 'Show images in this email' conformation.
	 *
	 * Here is an example of passing this information through Email.php:
	 *
	 *   $email = new Email();
	 *   $email->attachments[] = array(
	 *     'filename' => BASE_PATH . "/themes/mytheme/images/header.gif",
	 *     'contents' => file_get_contents(BASE_PATH . "/themes/mytheme/images/header.gif"),
	 *     'mimetype' => 'image/gif',
	 *     'contentLocation' => Director::absoluteBaseURL() . "/themes/mytheme/images/header.gif"
	 *   );
	 *
	 * @param array|string $file
	 * @param bool $destFileName
	 * @param string $disposition
	 * @param string $extraHeaders
	 * @return string
	 */
	protected function encodeFileForEmail($file, $destFileName = false, $disposition = NULL, $extraHeaders = "") {
		if(!$file) {
			throw new InvalidArgumentException("Not passed a filename and/or data");
		}

		if (is_string($file)) {
			$file = array('filename' => $file);
			$fh = fopen($file['filename'], "rb");
			if ($fh) {
				$file['contents'] = "";
				while(!feof($fh)) $file['contents'] .= fread($fh, 10000);
				fclose($fh);
			}
		}

		// Build headers, including content type
		if(!$destFileName) $base = basename($file['filename']);
		else $base = $destFileName;

		$mimeType = !empty($file['mimetype']) ? $file['mimetype'] : HTTP::get_mime_type($file['filename']);
		if(!$mimeType) $mimeType = "application/unknown";
		if (empty($disposition)) $disposition = isset($file['contentLocation']) ? 'inline' : 'attachment';

		// Encode for emailing
		if (substr($mimeType, 0, 4) != 'text') {
			$encoding = "base64";
			$file['contents'] = chunk_split(base64_encode($file['contents']));
		} else {
			// This mime type is needed, otherwise some clients will show it as an inline attachment
			$mimeType = 'application/octet-stream';
			$encoding = "quoted-printable";
			$file['contents'] = quoted_printable_encode($file['contents']);
		}

		$headers =	"Content-type: $mimeType;\n\tname=\"$base\"\n".
					"Content-Transfer-Encoding: $encoding\n".
					"Content-Disposition: $disposition;\n\tfilename=\"$base\"\n";

		if ( isset($file['contentLocation']) ) $headers .= 'Content-Location: ' . $file['contentLocation'] . "\n" ;

		$headers .= $extraHeaders . "\n";

		// Return completed packet
		return $headers . $file['contents'];
	}

	/**
	 * Cleans up emails which may be in 'Name <email@silverstripe.com>' format
	 *
	 * @param string $emailAddress
	 * @return string
	 */
	protected function validEmailAddress($emailAddress) {
		$emailAddress = trim($emailAddress);
		$openBracket = strpos($emailAddress, '<');
		$closeBracket = strpos($emailAddress, '>');

		// Unwrap email contained by braces
		if($openBracket === 0 && $closeBracket !== false) {
			return substr($emailAddress, 1, $closeBracket - 1);
		}

		// Ensure name component cannot be mistaken for an email address
		if($openBracket) {
			$emailAddress = str_replace('@', '', substr($emailAddress, 0, $openBracket))
				. substr($emailAddress, $openBracket);
		}

		return $emailAddress;
	}
}