| <?php |
| /** |
| * File containing the ezcMailTools class |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| * @package Mail |
| * @version //autogen// |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 |
| */ |
| |
| /** |
| * This class contains static convenience methods for composing addresses |
| * and ensuring correct line-breaks in the mail. |
| * |
| * @package Mail |
| * @version //autogen// |
| * @mainclass |
| */ |
| class ezcMailTools |
| { |
| /** |
| * Reply to sender. |
| */ |
| const REPLY_SENDER = 1; |
| |
| /** |
| * Reply to all. |
| */ |
| const REPLY_ALL = 1; |
| |
| /** |
| * Server to use for validateEmailAddressMx(). Change this if this server |
| * cannot be used with your Internet Service Provider. |
| * |
| * Default value: 'smtp.ez.no'. |
| * |
| * @var string |
| */ |
| public static $mxValidateServer = 'smtp.ez.no'; |
| |
| /** |
| * Email address to use for validateEmailAddressMx(). Change this if this |
| * address cannot be used with your Internet Service Provider. |
| * |
| * Default value: 'postmaster@ez.no'. |
| * |
| * @var string |
| */ |
| public static $mxValidateAddress = 'postmaster@ez.no'; |
| |
| /** |
| * Holds the unique ID's. |
| * |
| * @var int |
| */ |
| private static $idCounter = 0; |
| |
| /** |
| * The characters to use for line-breaks in the mail. |
| * |
| * The default is \r\n which is the value specified in RFC822. |
| * |
| * @var string |
| */ |
| private static $lineBreak = "\r\n"; |
| |
| /** |
| * Returns ezcMailAddress $item as a RFC822 compliant address string. |
| * |
| * Example: |
| * <code> |
| * composeEmailAddress( new ezcMailAddress( 'sender@example.com', 'John Doe' ) ); |
| * </code> |
| * |
| * Returns: |
| * <pre> |
| * John Doe <sender@example.com> |
| * </pre> |
| * |
| * The name part of $item will be surrounded by quotes if it contains any of |
| * these characters: , @ < > : ; ' " |
| * |
| * @param ezcMailAddress $item |
| * @return string |
| */ |
| public static function composeEmailAddress( ezcMailAddress $item ) |
| { |
| $name = trim( $item->name ); |
| if ( $name !== '' ) |
| { |
| // remove the quotes around the name part if they are already there |
| if ( $name{0} === '"' && $name{strlen( $name ) - 1} === '"' ) |
| { |
| $name = substr( $name, 1, -1 ); |
| } |
| |
| // add slashes to " and \ and surround the name part with quotes |
| if ( strpbrk( $name, ",@<>:;'\"" ) !== false ) |
| { |
| $name = str_replace( '\\', '\\\\', $name ); |
| $name = str_replace( '"', '\"', $name ); |
| $name = "\"{$name}\""; |
| } |
| |
| switch ( strtolower( $item->charset ) ) |
| { |
| case 'us-ascii': |
| $text = $name . ' <' . $item->email . '>'; |
| break; |
| |
| case 'iso-8859-1': case 'iso-8859-2': case 'iso-8859-3': case 'iso-8859-4': |
| case 'iso-8859-5': case 'iso-8859-6': case 'iso-8859-7': case 'iso-8859-8': |
| case 'iso-8859-9': case 'iso-8859-10': case 'iso-8859-11': case 'iso-8859-12': |
| case 'iso-8859-13': case 'iso-8859-14': case 'iso-8859-15' :case 'iso-8859-16': |
| case 'windows-1250': case 'windows-1251': case 'windows-1252': |
| case 'utf-8': |
| if ( strpbrk( $name, "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff" ) === false ) |
| { |
| $text = $name . ' <' . $item->email . '>'; |
| break; |
| } |
| // break intentionally missing |
| |
| default: |
| $preferences = array( |
| 'input-charset' => $item->charset, |
| 'output-charset' => $item->charset, |
| 'scheme' => 'Q', |
| 'line-break-chars' => ezcMailTools::lineBreak() |
| ); |
| $name = iconv_mime_encode( 'dummy', $name, $preferences ); |
| $name = substr( $name, 7 ); // "dummy: " + 1 |
| $text = $name . ' <' . $item->email . '>'; |
| break; |
| } |
| } |
| else |
| { |
| $text = $item->email; |
| } |
| return $text; |
| } |
| |
| /** |
| * Returns the array $items consisting of ezcMailAddress objects |
| * as one RFC822 compliant address string. |
| * |
| * Set foldLength to control how many characters each line can have before a line |
| * break is inserted according to the folding rules specified in RFC2822. |
| * |
| * @param array(ezcMailAddress) $items |
| * @param int $foldLength |
| * @return string |
| */ |
| public static function composeEmailAddresses( array $items, $foldLength = null ) |
| { |
| $textElements = array(); |
| foreach ( $items as $item ) |
| { |
| $textElements[] = ezcMailTools::composeEmailAddress( $item ); |
| } |
| |
| if ( $foldLength === null ) // quick version |
| { |
| return implode( ', ', $textElements ); |
| } |
| |
| $result = ""; |
| $charsSinceFold = 0; |
| foreach ( $textElements as $element ) |
| { |
| $length = strlen( $element ); |
| if ( ( $charsSinceFold + $length + 2 /* comma, space */ ) > $foldLength ) |
| { |
| // fold last line if there is any |
| if ( $result != '' ) |
| { |
| $result .= "," . ezcMailTools::lineBreak() .' '; |
| $charsSinceFold = 0; |
| } |
| $result .= $element; |
| } |
| else |
| { |
| if ( $result == '' ) |
| { |
| $result = $element; |
| } |
| else |
| { |
| $result .= ', ' . $element; |
| } |
| } |
| $charsSinceFold += $length + 1 /*space*/; |
| } |
| return $result; |
| } |
| |
| /** |
| * Returns an ezcMailAddress object parsed from the address string $address. |
| * |
| * You can set the encoding of the name part with the $encoding parameter. |
| * If $encoding is omitted or set to "mime" parseEmailAddress will asume that |
| * the name part is mime encoded. |
| * |
| * This method does not perform validation. It will also accept slightly |
| * malformed addresses. |
| * |
| * If the mail address given can not be decoded null is returned. |
| * |
| * Example: |
| * <code> |
| * ezcMailTools::parseEmailAddress( 'John Doe <john@example.com>' ); |
| * </code> |
| * |
| * @param string $address |
| * @param string $encoding |
| * @return ezcMailAddress |
| */ |
| public static function parseEmailAddress( $address, $encoding = "mime" ) |
| { |
| // we don't care about the "group" part of the address since this is not used anywhere |
| |
| $matches = array(); |
| $pattern = '/<?\"?[a-zA-Z0-9!#\$\%\&\'\*\+\-\/=\?\^_`{\|}~\.]+\"?@[a-zA-Z0-9!#\$\%\&\'\*\+\-\/=\?\^_`{\|}~\.]+>?$/'; |
| if ( preg_match( trim( $pattern ), $address, $matches, PREG_OFFSET_CAPTURE ) != 1 ) |
| { |
| return null; |
| } |
| $name = substr( $address, 0, $matches[0][1] ); |
| |
| // trim <> from the address and "" from the name |
| $name = trim( $name, '" ' ); |
| $mail = trim( $matches[0][0], '<>' ); |
| // remove any quotes found in mail addresses like "bah,"@example.com |
| $mail = str_replace( '"', '', $mail ); |
| |
| if ( $encoding == 'mime' ) |
| { |
| // the name may contain interesting character encoding. We need to convert it. |
| $name = ezcMailTools::mimeDecode( $name ); |
| } |
| else |
| { |
| $name = ezcMailCharsetConverter::convertToUTF8( $name, $encoding ); |
| } |
| |
| $address = new ezcMailAddress( $mail, $name, 'utf-8' ); |
| return $address; |
| } |
| |
| /** |
| * Returns an array of ezcMailAddress objects parsed from the address string $addresses. |
| * |
| * You can set the encoding of the name parts with the $encoding parameter. |
| * If $encoding is omitted or set to "mime" parseEmailAddresses will asume that |
| * the name parts are mime encoded. |
| * |
| * Example: |
| * <code> |
| * ezcMailTools::parseEmailAddresses( 'John Doe <john@example.com>' ); |
| * </code> |
| * |
| * @param string $addresses |
| * @param string $encoding |
| * @return array(ezcMailAddress) |
| */ |
| public static function parseEmailAddresses( $addresses, $encoding = "mime" ) |
| { |
| $addressesArray = array(); |
| $inQuote = false; |
| $last = 0; // last hit |
| $length = strlen( $addresses ); |
| for ( $i = 0; $i < $length; $i++ ) |
| { |
| if ( $addresses[$i] == '"' ) |
| { |
| $inQuote = !$inQuote; |
| } |
| else if ( $addresses[$i] == ',' && !$inQuote ) |
| { |
| $addressesArray[] = substr( $addresses, $last, $i - $last ); |
| $last = $i + 1; // eat comma |
| } |
| } |
| |
| // fetch the last one |
| $addressesArray[] = substr( $addresses, $last ); |
| |
| $addressObjects = array(); |
| foreach ( $addressesArray as $address ) |
| { |
| $addressObject = self::parseEmailAddress( $address, $encoding ); |
| if ( $addressObject !== null ) |
| { |
| $addressObjects[] = $addressObject; |
| } |
| } |
| |
| return $addressObjects; |
| } |
| |
| /** |
| * Returns true if $address is a valid email address, false otherwise. |
| * |
| * By default it will only validate against the same regular expression |
| * used in ext/filter. It follows |
| * {@link http://www.faqs.org/rfcs/rfc822.html RFC822} and |
| * {@link http://www.faqs.org/rfcs/rfc2822.html RFC2822}. |
| * |
| * If $checkMxRecords is true, then an MX records check will be performed |
| * also, by sending a test mail (RCPT TO) to $address using the MX records |
| * found for the domain part of $address. MX record checking does not work |
| * on Windows due to the lack of getmxrr() and checkdnsrr() PHP functions. |
| * The ezcBaseFunctionalityNotSupportedException is thrown in this case. |
| * |
| * If checking against MX records, set these values before performing the |
| * check, to ensure the MX record checks work properly: |
| * <code> |
| * ezcMailTools::$mxValidateServer = 'your.mail.server'; // default 'smtp.ez.no' |
| * ezcMailTools::$mxValidateAddress = 'email@mail.server'; // default 'postmaster@ez.no' |
| * </code> |
| * |
| * The input email address $address should be trimmed from white spaces |
| * and/or quotes around it before calling this function (if needed). |
| * |
| * An email address has this form: |
| * <code> |
| * localpart@domainpart |
| * </code> |
| * |
| * The localpart has these rules, and these rules are just an approximation of |
| * the rules in RFC2822: |
| * - allowed characters: . + ~ / ' - _ ` ^ $ % & ! ' | { |
| * - the dot (.) cannot be the first or the last character |
| * - the double-quote character (") can only surround the localpart (so |
| * if it appears it must be the first and the last character of localpart) |
| * - spaces are allowed if the localpart is surrounded in double-quotes |
| * - other ASCII characters (even from the extended-ASCII set) are allowed |
| * if the localparts is surrounded in double-quotes (the function |
| * ezcMailTools::composeEmailAddress will encode it when using it |
| * in a mail header) |
| * - the double-quotes character (") cannot be escaped to appear in a |
| * localpart surrounded by double quotes (so "john"doe"@example.com is not |
| * a valid email address) |
| * |
| * The domainpart has the same rules as a domain name, as defined in |
| * {@link http://www.faqs.org/rfcs/rfc822.html RFC822} and |
| * {@link http://www.faqs.org/rfcs/rfc2822.html RFC2822}. |
| * |
| * See also the test files (in the "Mail/tests/tools/data" directory) for |
| * examples of correct and incorrect email addresses. |
| * |
| * @throws ezcBaseFunctionalityNotSupportedException |
| * if $checkMxRecords is true and getmxrr() or checkdnsrr() functions |
| * are missing (e.g. on Windows) |
| * @param string $address |
| * @param bool $checkMxRecords |
| * @return bool |
| */ |
| public static function validateEmailAddress( $address, $checkMxRecords = false ) |
| { |
| $pattern = '/^((\"[^\"\f\n\r\t\v\b]+\")|([A-Za-z0-9_\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+(\.[A-Za-z0-9_\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+)*))@((\[(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))\])|(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))|((([A-Za-z0-9\-])+\.)+[A-Za-z\-]{2,}))$/'; |
| |
| if ( preg_match( $pattern, $address ) ) |
| { |
| if ( $checkMxRecords ) |
| { |
| return self::validateEmailAddressMx( $address ); |
| } |
| else |
| { |
| // $address passed through regexp, with no MX checks |
| return true; |
| } |
| } |
| else |
| { |
| // $address did not pass through regexp |
| return false; |
| } |
| } |
| |
| /** |
| * Checks if the email address $address is valid based on its MX records. |
| * |
| * Steps: |
| * - the MX records are fetched for the domain part of $address, along with |
| * their weights |
| * - the MX records are sorted based on the weights |
| * - for each MX record a connection is open |
| * - a test mail (RCPT TO) is tried to be sent to $address |
| * - if one test mail succeeds, then the address is valid, else invalid |
| * |
| * Set these values before calling this function, to ensure the MX record |
| * checks work properly: |
| * <code> |
| * ezcMailTools::$mxValidateServer = 'your.mail.server'; // default 'smtp.ez.no' |
| * ezcMailTools::$mxValidateAddress = 'email@mail.server'; // default 'postmaster@ez.no' |
| * </code> |
| * |
| * MX record checking does not work on Windows due to the lack of getmxrr() |
| * and checkdnsrr() PHP functions. The ezcBaseFunctionalityNotSupportedException |
| * is thrown in this case. |
| * |
| * @throws ezcBaseFunctionalityNotSupportedException |
| * if getmxrr() or checkdnsrr() functions are missing (e.g. on Windows) |
| * @param string $address |
| * @return bool |
| */ |
| protected static function validateEmailAddressMx( $address ) |
| { |
| if ( !ezcBaseFeatures::hasFunction( 'getmxrr' ) || !ezcBaseFeatures::hasFunction( 'checkdnsrr' ) ) |
| { |
| throw new ezcBaseFunctionalityNotSupportedException( 'Checking DNS records', 'getmxrr() or checkdnsrr() missing' ); |
| } |
| |
| $timeoutOpen = 3; // for fsockopen() |
| $timeoutConnection = 5; // for stream_set_timeout() |
| |
| list( $local, $domain ) = explode( '@', $address ); |
| if ( !empty( $domain ) ) |
| { |
| if ( getmxrr( $domain, $hosts, $weights ) ) |
| { |
| for ( $i = 0; $i < count( $hosts ); $i++ ) |
| { |
| $mx[$hosts[$i]] = $weights[$i]; |
| } |
| |
| asort( $mx ); |
| $mx = array_keys( $mx ); |
| } |
| elseif ( checkdnsrr( $domain, 'A' ) ) |
| { |
| $mx[0] = gethostbyname( $domain ); |
| } |
| else |
| { |
| $mx = array(); |
| } |
| |
| if ( ( $numberOfMx = count( $mx ) ) > 0 ) |
| { |
| $smtp = array( |
| "HELO " . self::$mxValidateServer, |
| "MAIL FROM: <" . self::$mxValidateAddress . ">", |
| "RCPT TO: <{$address}>", |
| "QUIT", |
| ); |
| |
| for ( $i = 0; $i < $numberOfMx; $i++ ) |
| { |
| if ( $socket = @fsockopen( $mx[$i], 25, $errno = 0, $errstr = 0, $timeoutOpen ) ) |
| { |
| $response = fgets( $socket ); |
| stream_set_timeout( $socket, $timeoutConnection ); |
| $meta = stream_get_meta_data( $socket ); |
| if ( !$meta['timed_out'] && !preg_match( '/^2\d\d[ -]/', $response ) ) |
| { |
| return false; |
| } |
| foreach ( $smtp as $command ) |
| { |
| fputs( $socket, "{$command}\r\n" ); |
| $response = fgets( $socket, 4096 ); |
| if ( !$meta['timed_out'] && preg_match( '/^5\d\d[ -]/', $response ) ) |
| { |
| return false; |
| } |
| } |
| fclose( $socket ); |
| return true; |
| } |
| elseif ( $i === $numberOfMx - 1 ) |
| { |
| // none of the mail servers could be contacted |
| return false; |
| } |
| } |
| } |
| else |
| { |
| // no mail servers found |
| return false; |
| } |
| } |
| } |
| |
| /** |
| * Returns an unique message ID to be used for a mail message. |
| * |
| * The hostname $hostname will be added to the unique ID as required by RFC822. |
| * If an e-mail address is provided instead, the hostname is extracted and used. |
| * |
| * The formula to generate the message ID is: [time_and_date].[process_id].[counter] |
| * |
| * @param string $hostname |
| * @return string |
| */ |
| public static function generateMessageId( $hostname ) |
| { |
| if ( strpos( $hostname, '@' ) !== false ) |
| { |
| $hostname = strstr( $hostname, '@' ); |
| } |
| else |
| { |
| $hostname = '@' . $hostname; |
| } |
| return date( 'YmdGHjs' ) . '.' . getmypid() . '.' . self::$idCounter++ . $hostname; |
| } |
| |
| /** |
| * Returns an unique ID to be used for Content-ID headers. |
| * |
| * The part $partName is default set to "part". Another value can be used to provide, |
| * for example, a file name of a part. $partName will be encoded with base64 to be |
| * compliant with the RFCs. |
| * |
| * The formula used is [base64( $partName )]."@".[time].[counter] |
| * |
| * @param string $partName |
| * @return string |
| */ |
| public static function generateContentId( $partName = "part" ) |
| { |
| return str_replace( array( '=', '+', '/' ), '', base64_encode( $partName ) ) . '@' . date( 'His' ) . self::$idCounter++; |
| } |
| |
| /** |
| * Sets the endLine $character(s) to use when generating mail. |
| * The default is to use "\r\n" as specified by RFC 2045. |
| * |
| * @param string $characters |
| */ |
| public static function setLineBreak( $characters ) |
| { |
| self::$lineBreak = $characters; |
| } |
| |
| /** |
| * Returns one endLine character. |
| * |
| * The default is to use "\n\r" as specified by RFC 2045. |
| * |
| * @return string |
| */ |
| public static function lineBreak() |
| { |
| // Note, this function does deliberately not |
| // have a $count parameter because of speed issues. |
| return self::$lineBreak; |
| } |
| |
| /** |
| * Decodes mime encoded fields and tries to recover from errors. |
| * |
| * Decodes the $text encoded as a MIME string to the $charset. In case the |
| * strict conversion fails this method tries to workaround the issues by |
| * trying to "fix" the original $text before trying to convert it. |
| * |
| * @param string $text |
| * @param string $charset |
| * @return string |
| */ |
| public static function mimeDecode( $text, $charset = 'utf-8' ) |
| { |
| $origtext = $text; |
| $text = @iconv_mime_decode( $text, 0, $charset ); |
| if ( $text !== false ) |
| { |
| return $text; |
| } |
| |
| // something went wrong while decoding, let's see if we can fix it |
| // Try to fix lower case hex digits |
| $text = preg_replace_callback( |
| '/=(([a-f][a-f0-9])|([a-f0-9][a-f]))/', |
| create_function( '$matches', 'return strtoupper($matches[0]);' ), |
| $origtext |
| ); |
| $text = @iconv_mime_decode( $text, 0, $charset ); |
| if ( $text !== false ) |
| { |
| return $text; |
| } |
| |
| // Workaround a bug in PHP 5.1.0-5.1.3 where the "b" and "q" methods |
| // are not understood (but only "B" and "Q") |
| $text = str_replace( array( '?b?', '?q?' ), array( '?B?', '?Q?' ), $origtext ); |
| $text = @iconv_mime_decode( $text, 0, $charset ); |
| if ( $text !== false ) |
| { |
| return $text; |
| } |
| |
| // Try it as latin 1 string |
| $text = preg_replace( '/=\?([^?]+)\?/', '=?iso-8859-1?', $origtext ); |
| $text = iconv_mime_decode( $text, 0, $charset ); |
| |
| return $text; |
| } |
| |
| /** |
| * Returns a new mail object that is a reply to the current object. |
| * |
| * The new mail will have the correct to, cc, bcc and reference headers set. |
| * It will not have any body set. |
| * |
| * By default the reply will only be sent to the sender of the original mail. |
| * If $type is set to REPLY_ALL, all the original recipients will be included |
| * in the reply. |
| * |
| * Use $subjectPrefix to set the prefix to the subject of the mail. The default |
| * is to prefix with 'Re: '. |
| * |
| * @param ezcMail $mail |
| * @param ezcMailAddress $from |
| * @param int $type REPLY_SENDER or REPLY_ALL |
| * @param string $subjectPrefix |
| * @param string $mailClass |
| * @return ezcMail |
| */ |
| static public function replyToMail( ezcMail $mail, ezcMailAddress $from, |
| $type = self::REPLY_SENDER, $subjectPrefix = "Re: ", |
| $mailClass = "ezcMail" ) |
| { |
| $reply = new $mailClass(); |
| $reply->from = $from; |
| |
| // To = Reply-To if set |
| if ( $mail->getHeader( 'Reply-To' ) != '' ) |
| { |
| $reply->to = ezcMailTools::parseEmailAddresses( $mail->getHeader( 'Reply-To' ) ); |
| } |
| else // Else To = From |
| |
| { |
| $reply->to = array( $mail->from ); |
| } |
| |
| if ( $type == self::REPLY_ALL ) |
| { |
| // Cc = Cc + To - your own address |
| $cc = array(); |
| foreach ( $mail->to as $address ) |
| { |
| if ( $address->email != $from->email ) |
| { |
| $cc[] = $address; |
| } |
| } |
| foreach ( $mail->cc as $address ) |
| { |
| if ( $address->email != $from->email ) |
| { |
| $cc[] = $address; |
| } |
| } |
| $reply->cc = $cc; |
| } |
| |
| $reply->subject = $subjectPrefix . $mail->subject; |
| |
| if ( $mail->getHeader( 'Message-Id' ) ) |
| { |
| // In-Reply-To = Message-Id |
| $reply->setHeader( 'In-Reply-To', $mail->getHeader( 'Message-ID' ) ); |
| |
| // References = References . Message-Id |
| if ( $mail->getHeader( 'References' ) != '' ) |
| { |
| $reply->setHeader( 'References', $mail->getHeader( 'References' ) |
| . ' ' . $mail->getHeader( 'Message-ID' ) ); |
| } |
| else |
| { |
| $reply->setHeader( 'References', $mail->getHeader( 'Message-ID' ) ); |
| } |
| } |
| else // original mail is borked. Let's support it anyway. |
| { |
| $reply->setHeader( 'References', $mail->getHeader( 'References' ) ); |
| } |
| |
| return $reply; |
| } |
| |
| /** |
| * Guesses the content and mime type by using the file extension. |
| * |
| * The content and mime types are returned through the $contentType |
| * and $mimeType arguments. |
| * For the moment only for image files. |
| * |
| * @param string $fileName |
| * @param string $contentType |
| * @param string $mimeType |
| */ |
| static public function guessContentType( $fileName, &$contentType, &$mimeType ) |
| { |
| $extension = strtolower( pathinfo( $fileName, PATHINFO_EXTENSION ) ); |
| switch ( $extension ) |
| { |
| case 'gif': |
| $contentType = 'image'; |
| $mimeType = 'gif'; |
| break; |
| |
| case 'jpg': |
| case 'jpe': |
| case 'jpeg': |
| $contentType = 'image'; |
| $mimeType = 'jpeg'; |
| break; |
| |
| case 'png': |
| $contentType = 'image'; |
| $mimeType = 'png'; |
| break; |
| |
| case 'bmp': |
| $contentType = 'image'; |
| $mimeType = 'bmp'; |
| break; |
| |
| case 'tif': |
| case 'tiff': |
| $contentType = 'image'; |
| $mimeType = 'tiff'; |
| break; |
| |
| default: |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Replaces HTML embedded "cid:" references with replacements from $contentIdArray. |
| * |
| * The method matches all "cid:" references in the $htmlText and then loops |
| * over each match. For each match the found content ID is looked-up as key |
| * in the $contentIdArray and the value is then inserted as replacement for |
| * the "cid:" reference. |
| * |
| * <code> |
| * <?php |
| * $contentIdArray = array( 'consoletools-table.png@1421450' => 'http://localhost/consoletools-table.jpg' ); |
| * $text = "<html> Embedded image: <img src='cid:consoletools-table.png@1421450'/> </html>"; |
| * $htmlBody = ezcMailTools::replaceContentIdRefs( $text, $contentIdArray ); |
| * // $htmlBody is now: |
| * // <html> Embedded image: <img src='http://localhost/consoletools-table.jpg'/> </html> |
| * ?> |
| * </code> |
| * |
| * The $contentIdArray can be build by iterating over all parts in the |
| * mail, and for each ezcMailFilePart that you find: 1. copy the associated |
| * file (fileName property of the ezcMailFilePart object) to your webroot; |
| * 2. add an element to the array with the key created from the contentId |
| * property from the ezcMailFilePart object. See the tutorial for an |
| * example of this. |
| * |
| * @param string $htmlText |
| * @param array(string=>string) $contentIdArray |
| * @return string |
| */ |
| static function replaceContentIdRefs( $htmlText, $contentIdArray ) |
| { |
| preg_match_all( '@src=[\'"](cid:(.*?))[\'"]@', $htmlText, $matches ); |
| for ( $i = 0; $i < count( $matches[0] ); $i++ ) |
| { |
| if ( isset( $contentIdArray[$matches[2][$i]] ) ) |
| { |
| $htmlText = str_replace( $matches[1][$i], $contentIdArray[$matches[2][$i]], $htmlText ); |
| } |
| } |
| return $htmlText; |
| } |
| } |
| ?> |
