diff options
Diffstat (limited to 'Postman/Postman-Mail/PostmanMessage.php')
| -rw-r--r-- | Postman/Postman-Mail/PostmanMessage.php | 824 |
1 files changed, 824 insertions, 0 deletions
diff --git a/Postman/Postman-Mail/PostmanMessage.php b/Postman/Postman-Mail/PostmanMessage.php new file mode 100644 index 0000000..12099ba --- /dev/null +++ b/Postman/Postman-Mail/PostmanMessage.php @@ -0,0 +1,824 @@ +<?php +if ( ! defined( 'ABSPATH' ) ) { + exit; // Exit if accessed directly +} + +if ( ! class_exists( 'PostmanMessage' ) ) { + + require_once 'PostmanEmailAddress.php'; + + /** + * This class knows how to interface with Wordpress + * including loading/saving to the database. + * + * The various Transports available: + * http://framework.zend.com/manual/current/en/modules/zend.mail.smtp.options.html + * + * @author jasonhendriks + */ + class PostmanMessage { + const EOL = "\r\n"; + + // logger for all concrete classes - populate with setLogger($logger) + protected $logger; + + // set by the caller + private $from; + private $replyTo; + private $toRecipients; + private $ccRecipients; + private $bccRecipients; + private $subject; + private $body; + private $bodyTextPart; + private $bodyHtmlPart; + private $headers; + private $attachments; + private $date; + private $messageId; + + // determined by the send() method + private $isTextHtml; + private $contentType = 'text/plain'; + private $charset; + + private $boundary; + + /** + * No-argument constructor + */ + function __construct() { + $this->logger = new PostmanLogger( get_class( $this ) ); + $this->headers = array(); + $this->toRecipients = array(); + $this->ccRecipients = array(); + $this->bccRecipients = array(); + } + + function __get( $name ) { + $message = __( '<code>%1$s</code> property of a <code>PostmanMessage</code> object is <strong>not supported</strong>. For now all of this class properties are private.', 'post-smtp' ); + + if ( WP_DEBUG ) { + trigger_error( sprintf( $message, $name ) ); + } + } + + function __call($name, $args) { + $class = new ReflectionClass(__CLASS__); + $methods = $class->getMethods(ReflectionMethod::IS_PUBLIC ); + + $message = __( '<code>%1$s</code> method of a <code>PostmanMessage</code> object is <strong>not supported</strong>. Use one of the following methods <pre><code>%2$s</code></pre>', 'post-smtp' ); + + if ( WP_DEBUG ) { + trigger_error( sprintf( $message, $name, print_r( $methods, true ) ) ); + } + } + + /** + * + * @return boolean + */ + public function isBodyPartsEmpty() { + return empty( $this->bodyTextPart ) && empty( $this->bodyHtmlPart ); + } + + /** + * + * @param PostmanModuleTransport $transport + */ + public function validate( PostmanModuleTransport $transport ) { + if ( $transport->isEmailValidationSupported() ) { + $this->internalValidate(); + } + } + + /** + * Create body parts based on content type + * MyMail creates its own body parts + */ + public function createBodyParts() { + + // modify the content-type to include the boundary + if ( false !== stripos( $this->contentType, 'multipart' ) && ! empty( $this->boundary ) ) { + // Lines in email are terminated by CRLF ("\r\n") according to RFC2821 + $this->contentType = sprintf( "%s;\r\n\t boundary=\"%s\"", $this->contentType, $this->getBoundary() ); + } + + $body = $this->getBody(); + $contentType = $this->getContentType(); + // add the message content as either text or html + if ( empty( $contentType ) || substr( $contentType, 0, 10 ) === 'text/plain' ) { + $this->logger->debug( 'Creating text body part' ); + $this->setBodyTextPart( $body ); + } else if ( substr( $contentType, 0, 9 ) === 'text/html' ) { + $this->logger->debug( 'Creating html body part' ); + $this->setBodyHtmlPart( $body ); + } else if ( substr( $contentType, 0, 21 ) === 'multipart/alternative' ) { + $this->logger->debug( 'Adding body as multipart/alternative' ); + $arr = explode( PHP_EOL, $body ); + $textBody = ''; + $htmlBody = ''; + $mode = ''; + foreach ( $arr as $s ) { + $this->logger->trace( 'mode: ' . $mode . ' bodyline: ' . $s ); + if ( substr( $s, 0, 25 ) === 'Content-Type: text/plain;' ) { + $mode = 'foundText'; + } else if ( substr( $s, 0, 24 ) === 'Content-Type: text/html;' ) { + $mode = 'foundHtml'; + } else if ( $mode == 'textReading' ) { + $textBody .= $s; + } else if ( $mode == 'htmlReading' ) { + $htmlBody .= $s; + } else if ( $mode == 'foundText' ) { + $trim = trim( $s ); + if ( empty( $trim ) ) { + $mode = 'textReading'; + } + } else if ( $mode == 'foundHtml' ) { + $trim = trim( $s ); + if ( empty( $trim ) ) { + $mode = 'htmlReading'; + } + } + } + $this->setBodyHtmlPart( $htmlBody ); + $this->setBodyTextPart( $textBody ); + } else { + $this->logger->error( 'Unknown content-type: ' . $contentType ); + $this->setBodyTextPart( $body ); + } + } + + /** + * Apply the WordPress filters to the email + */ + public function applyFilters() { + if ( $this->logger->isDebug() ) { + $this->logger->debug( 'Applying WordPress filters' ); + } + + /** + * Filter the email address to send from. + * + * @since 2.2.0 + * + * @param string $from_email + * Email address to send from. + */ + $filteredEmail = apply_filters( 'wp_mail_from', $this->getFromAddress()->getEmail() ); + if ( $this->logger->isTrace() ) { + $this->logger->trace( 'wp_mail_from: ' . $filteredEmail ); + } + if ( $this->getFromAddress()->getEmail() !== $filteredEmail ) { + $this->logger->debug( sprintf( 'Filtering From email address: before=%s after=%s', $this->getFromAddress()->getEmail(), $filteredEmail ) ); + $this->getFromAddress()->setEmail( $filteredEmail ); + } + + /** + * Filter the name to associate with the "from" email address. + * + * @since 2.3.0 + * + * @param string $from_name + * Name associated with the "from" email address. + */ + $filteredName = apply_filters( 'wp_mail_from_name', $this->getFromAddress()->getName() ); + if ( $this->logger->isTrace() ) { + $this->logger->trace( 'wp_mail_from_name: ' . $filteredName ); + } + if ( $this->getFromAddress()->getName() !== $filteredName ) { + $this->logger->debug( sprintf( 'Filtering From email name: before=%s after=%s', $this->getFromAddress()->getName(), $filteredName ) ); + $this->getFromAddress()->setName( $filteredName ); + } + + /** + * Filter the default wp_mail() charset. + * + * @since 2.3.0 + * + * @param string $charset + * Default email charset. + */ + $filteredCharset = apply_filters( 'wp_mail_charset', $this->getCharset() ); + if ( $this->logger->isTrace() ) { + $this->logger->trace( 'wp_mail_charset: ' . $filteredCharset ); + } + if ( $this->getCharset() !== $filteredCharset ) { + $this->logger->debug( sprintf( 'Filtering Charset: before=%s after=%s', $this->getCharset(), $filteredCharset ) ); + $this->setCharset( $filteredCharset ); + } + + /** + * Filter the wp_mail() content type. + * + * @since 2.3.0 + * + * @param string $content_type + * Default wp_mail() content type. + */ + $filteredContentType = apply_filters( 'wp_mail_content_type', $this->getContentType() ); + if ( $this->logger->isTrace() ) { + $this->logger->trace( sprintf( 'wp_mail_content_type: "%s"', $filteredContentType ) ); + } + if ( $this->getContentType() != $filteredContentType ) { + $this->logger->debug( sprintf( 'Filtering Content-Type: before=%s after=%s', $this->getContentType(), $filteredContentType ) ); + $this->setContentType( $filteredContentType ); + } + + // Postman has it's own 'user override' filter + $options = PostmanOptions::getInstance(); + $forcedEmailAddress = $options->getMessageSenderEmail(); + if ( $options->isSenderEmailOverridePrevented() && $this->getFromAddress()->getEmail() !== $forcedEmailAddress ) { + $this->logger->debug( sprintf( 'Forced From email address: before=%s after=%s', $this->getFromAddress()->getEmail(), $forcedEmailAddress ) ); + $this->getFromAddress()->setEmail( $forcedEmailAddress ); + } + + if ( $options->is_fallback ) { + $fallback_email = $options->getFallbackFromEmail(); + $this->logger->debug( sprintf( 'Fallback: Forced From email address: before=%s after=%s', $this->getFromAddress()->getEmail(), $fallback_email ) ); + $this->getFromAddress()->setEmail( $fallback_email ); + } + + $forcedEmailName = $options->getMessageSenderName(); + if ( $options->isSenderNameOverridePrevented() && $this->getFromAddress()->getName() !== $forcedEmailName ) { + $this->logger->debug( sprintf( 'Forced From email name: before=%s after=%s', $this->getFromAddress()->getName(), $forcedEmailName ) ); + $this->getFromAddress()->setName( $forcedEmailName ); + } + } + + /** + * Check all email headers for errors + * Throw an exception if an error is found + */ + private function internalValidate() { + // check the reply-to address for errors + if ( isset( $this->replyTo ) ) { + $this->getReplyTo()->validate( 'Reply-To' ); + } + + // check the from address for errors + $this->getFromAddress()->validate( 'From' ); + + // validate the To recipients + foreach ( ( array ) $this->getToRecipients() as $toRecipient ) { + $toRecipient->validate( 'To' ); + } + + // validate the Cc recipients + foreach ( ( array ) $this->getCcRecipients() as $ccRecipient ) { + $ccRecipient->validate( 'Cc' ); + } + + // validate the Bcc recipients + foreach ( ( array ) $this->getBccRecipients() as $bccRecipient ) { + $bccRecipient->validate( 'Bcc' ); + } + } + + /** + * + * @return PostmanEmailAddress + */ + public function getFromAddress() { + return $this->from; + } + + /** + * Get the charset, checking first the WordPress bloginfo, then the header, then the wp_mail_charset filter. + * + * @return string + */ + public function getCharset() { + return $this->charset; + } + + /** + * Set the charset + * + * @param mixed $charset + */ + public function setCharset( $charset ) { + $this->charset = $charset; + } + + /** + * Get the content type, checking first the header, then the wp_mail_content_type filter + * + * @return string + */ + public function getContentType() { + return $this->contentType; + } + public function setContentType( $contentType ) { + $this->contentType = $contentType; + } + /** + * + * @param mixed $recipients + * Array or comma-separated list of email addresses to send message. + * @throws Exception + */ + public function addTo( $to ) { + $this->addRecipients( $this->toRecipients, $to ); + } + /** + * + * @param mixed $recipients + * Array or comma-separated list of email addresses to send message. + * @throws Exception + */ + public function addCc( $cc ) { + $this->addRecipients( $this->ccRecipients, $cc ); + } + /** + * + * @param mixed $recipients + * Array or comma-separated list of email addresses to send message. + * @throws Exception + */ + public function addBcc( $bcc ) { + $this->addRecipients( $this->bccRecipients, $bcc ); + } + /** + * + * @param mixed $recipients + * Array or comma-separated list of email addresses to send message. + * @throws Exception + */ + private function addRecipients( &$recipientList, $recipients ) { + if ( ! empty( $recipients ) ) { + $recipients = PostmanEmailAddress::convertToArray( $recipients ); + foreach ( $recipients as $recipient ) { + if ( ! empty( $recipient ) ) { + $this->logger->debug( sprintf( 'User added recipient: "%s"', $recipient ) ); + array_push( $recipientList, new PostmanEmailAddress( $recipient ) ); + } + } + } + } + + /** + * For the string version, each header line (beginning with From:, Cc:, etc.) is delimited with a newline ("\r\n") + */ + public function addHeaders( $headers ) { + if ( ! is_array( $headers ) ) { + // WordPress may send a string where "each header line (beginning with From:, Cc:, etc.) is delimited with a newline ("\r\n") (advanced)" + // this converts that string to an array + $headers = explode( "\n", str_replace( "\r\n", "\n", $headers ) ); + // $headers = explode ( PHP_EOL, $headers ); + } + // otherwise WordPress sends an array + foreach ( $headers as $header ) { + if ( ! empty( $header ) ) { + // boundary may be in a header line, but it's not a header + // eg. boundary="----=_NextPart_DC7E1BB5... + if ( strpos( $header, ':' ) === false ) { + if ( false !== stripos( $header, 'boundary=' ) ) { + $parts = preg_split( '/boundary=/i', trim( $header ) ); + $this->boundary = trim( str_replace( array( + "'", + '"', + ), '', $parts [1] ) ); + $this->logger->debug( sprintf( 'Processing special boundary header \'%s\'', $this->getBoundary() ) ); + } else { + $this->logger->debug( sprintf( 'Ignoring broken header \'%s\'', $header ) ); + } + continue; + } + list ( $name, $content ) = explode( ':', trim( $header ), 2 ); + $this->processHeader( $name, $content ); + } + } + } + + /** + * Add the headers that were processed in processHeaders() + * Zend requires that several headers are specially handled. + * + * @param mixed $name + * @param mixed $value + * @param Postman_Zend_Mail $mail + */ + private function processHeader( $name, $content ) { + $name = trim( $name ); + $content = trim( $content ); + switch ( strtolower( $name ) ) { + case 'content-type' : + $this->logProcessHeader( 'Content-Type', $name, $content ); + if ( strpos( $content, ';' ) !== false ) { + list ( $type, $charset ) = explode( ';', $content ); + $this->setContentType( trim( $type ) ); + if ( false !== stripos( $charset, 'charset=' ) ) { + $charset = trim( str_replace( array( + 'charset=', + '"', + ), '', $charset ) ); + } elseif ( false !== stripos( $charset, 'boundary=' ) ) { + $this->boundary = trim( str_replace( array( + 'BOUNDARY=', + 'boundary=', + '"', + ), '', $charset ) ); + $charset = ''; + } + if ( ! empty( $charset ) ) { + $this->setCharset( $charset ); + } + } else { + $this->setContentType( trim( $content ) ); + } + break; + case 'to' : + $this->logProcessHeader( 'To', $name, $content ); + $this->addTo( $content ); + break; + case 'cc' : + $this->logProcessHeader( 'Cc', $name, $content ); + $this->addCc( $content ); + break; + case 'bcc' : + $this->logProcessHeader( 'Bcc', $name, $content ); + $this->addBcc( $content ); + break; + case 'from' : + $this->logProcessHeader( 'From', $name, $content ); + $this->setFrom( $content ); + break; + case 'subject' : + $this->logProcessHeader( 'Subject', $name, $content ); + $this->setSubject( $content ); + break; + case 'reply-to' : + $this->logProcessHeader( 'Reply-To', $name, $content ); + $this->setReplyTo( $content ); + break; + case 'sender' : + $this->logProcessHeader( 'Sender', $name, $content ); + $this->logger->warn( sprintf( 'Ignoring Sender header \'%s\'', $content ) ); + break; + case 'return-path' : + $this->logProcessHeader( 'Return-Path', $name, $content ); + $this->logger->warn( sprintf( 'Ignoring Return-Path header \'%s\'', $content ) ); + break; + case 'date' : + $this->logProcessHeader( 'Date', $name, $content ); + $this->setDate( $content ); + break; + case 'message-id' : + $this->logProcessHeader( 'Message-Id', $name, $content ); + $this->setMessageId( $content ); + break; + default : + // Add it to our grand headers array + $this->logProcessHeader( 'other', $name, $content ); + array_push( $this->headers, array( + 'name' => $name, + 'content' => $content, + ) ); + break; + } + } + + /** + * + * @param mixed $desc + * @param mixed $name + * @param mixed $content + */ + private function logProcessHeader( $desc, $name, $content ) { + $this->logger->debug( 'Processing ' . $desc . ' Header - ' . $name . ': ' . $content ); + } + + /** + * Add attachments to the message + * + * @param Postman_Zend_Mail $mail + */ + public function addAttachmentsToMail( Postman_Zend_Mail $mail ) { + $attachments = $this->attachments; + if ( ! is_array( $attachments ) ) { + // WordPress may a single filename or a newline-delimited string list of multiple filenames + $attArray = explode( PHP_EOL, $attachments ); + } else { + $attArray = $attachments; + } + // otherwise WordPress sends an array + foreach ( $attArray as $file ) { + if ( ! empty( $file ) ) { + $this->logger->debug( 'Adding attachment: ' . $file ); + $at = new Postman_Zend_Mime_Part( file_get_contents( $file ) ); + // $at->type = 'image/gif'; + $at->disposition = Postman_Zend_Mime::DISPOSITION_ATTACHMENT; + $at->encoding = Postman_Zend_Mime::ENCODING_BASE64; + $at->filename = basename( $file ); + $mail->addAttachment( $at ); + } + } + } + function setBody( $body ) { + $this->body = $body; + } + function setBodyTextPart( $bodyTextPart ) { + $this->bodyTextPart = $bodyTextPart; + } + function setBodyHtmlPart( $bodyHtmlPart ) { + $this->bodyHtmlPart = $bodyHtmlPart; + } + function setSubject( $subject ) { + $this->subject = $subject; + } + function setAttachments( $attachments ) { + $this->attachments = $attachments; + } + function setFrom( $email, $name = null ) { + if ( ! empty( $email ) ) { + $this->from = new PostmanEmailAddress( $email, $name ); + } + } + function setReplyTo( $replyTo ) { + if ( ! empty( $replyTo ) ) { + $this->replyTo = new PostmanEmailAddress( $replyTo ); + } + } + function setMessageId( $messageId ) { + $this->messageId = $messageId; + } + function setDate( $date ) { + $this->date = $date; + } + + // return the headers + public function getHeaders() { + return $this->headers; + } + public function getBoundary() { + return $this->boundary; + } + public function getToRecipients() { + return $this->toRecipients; + } + public function getCcRecipients() { + return $this->ccRecipients; + } + public function getBccRecipients() { + return $this->bccRecipients; + } + public function getReplyTo() { + return $this->replyTo; + } + public function getDate() { + return $this->date; + } + public function getMessageId() { + return $this->messageId; + } + public function getSubject() { + return $this->subject; + } + public function getBody() { + return $this->body; + } + public function getBodyTextPart() { + return $this->bodyTextPart; + } + public function getBodyHtmlPart() { + return $this->bodyHtmlPart; + } + public function getAttachments() { + return $this->attachments; + } + + /** + * @todo + * is this right? maybe extending the phpmailer class insted? + */ + + /** + * Add an embedded (inline) attachment from a file. + * This can include images, sounds, and just about any other document type. + * These differ from 'regular' attachments in that they are intended to be + * displayed inline with the message, not just attached for download. + * This is used in HTML messages that embed the images + * the HTML refers to using the $cid value. + * Never use a user-supplied path to a file! + * @param string $path Path to the attachment. + * @param string $cid Content ID of the attachment; Use this to reference + * the content when using an embedded image in HTML. + * @param string $name Overrides the attachment name. + * @param string $encoding File encoding (see $Encoding). + * @param string $type File MIME type. + * @param string $disposition Disposition to use + * @return boolean True on successfully adding an attachment + */ + public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline') { + if (!@is_file($path)) { + return false; + } + + // If a MIME type is not specified, try to work it out from the file name + if ($type == '') { + $type = self::filenameToType($path); + } + + $filename = basename($path); + if ($name == '') { + $name = $filename; + } + + // Append to $attachment array + $this->attachments[] = array( + 0 => $path, + 1 => $filename, + 2 => $name, + 3 => $encoding, + 4 => $type, + 5 => false, // isStringAttachment + 6 => $disposition, + 7 => $cid + ); + + return true; + } + + /** + * Get the MIME type for a file extension. + * @param string $ext File extension + * @access public + * @return string MIME type of file. + * @static + */ + public static function _mime_types($ext = '') + { + $mimes = array( + 'xl' => 'application/excel', + 'js' => 'application/javascript', + 'hqx' => 'application/mac-binhex40', + 'cpt' => 'application/mac-compactpro', + 'bin' => 'application/macbinary', + 'doc' => 'application/msword', + 'word' => 'application/msword', + 'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', + 'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template', + 'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template', + 'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow', + 'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation', + 'sldx' => 'application/vnd.openxmlformats-officedocument.presentationml.slide', + 'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', + 'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template', + 'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12', + 'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12', + 'class' => 'application/octet-stream', + 'dll' => 'application/octet-stream', + 'dms' => 'application/octet-stream', + 'exe' => 'application/octet-stream', + 'lha' => 'application/octet-stream', + 'lzh' => 'application/octet-stream', + 'psd' => 'application/octet-stream', + 'sea' => 'application/octet-stream', + 'so' => 'application/octet-stream', + 'oda' => 'application/oda', + 'pdf' => 'application/pdf', + 'ai' => 'application/postscript', + 'eps' => 'application/postscript', + 'ps' => 'application/postscript', + 'smi' => 'application/smil', + 'smil' => 'application/smil', + 'mif' => 'application/vnd.mif', + 'xls' => 'application/vnd.ms-excel', + 'ppt' => 'application/vnd.ms-powerpoint', + 'wbxml' => 'application/vnd.wap.wbxml', + 'wmlc' => 'application/vnd.wap.wmlc', + 'dcr' => 'application/x-director', + 'dir' => 'application/x-director', + 'dxr' => 'application/x-director', + 'dvi' => 'application/x-dvi', + 'gtar' => 'application/x-gtar', + 'php3' => 'application/x-httpd-php', + 'php4' => 'application/x-httpd-php', + 'php' => 'application/x-httpd-php', + 'phtml' => 'application/x-httpd-php', + 'phps' => 'application/x-httpd-php-source', + 'swf' => 'application/x-shockwave-flash', + 'sit' => 'application/x-stuffit', + 'tar' => 'application/x-tar', + 'tgz' => 'application/x-tar', + 'xht' => 'application/xhtml+xml', + 'xhtml' => 'application/xhtml+xml', + 'zip' => 'application/zip', + 'mid' => 'audio/midi', + 'midi' => 'audio/midi', + 'mp2' => 'audio/mpeg', + 'mp3' => 'audio/mpeg', + 'mpga' => 'audio/mpeg', + 'aif' => 'audio/x-aiff', + 'aifc' => 'audio/x-aiff', + 'aiff' => 'audio/x-aiff', + 'ram' => 'audio/x-pn-realaudio', + 'rm' => 'audio/x-pn-realaudio', + 'rpm' => 'audio/x-pn-realaudio-plugin', + 'ra' => 'audio/x-realaudio', + 'wav' => 'audio/x-wav', + 'bmp' => 'image/bmp', + 'gif' => 'image/gif', + 'jpeg' => 'image/jpeg', + 'jpe' => 'image/jpeg', + 'jpg' => 'image/jpeg', + 'png' => 'image/png', + 'tiff' => 'image/tiff', + 'tif' => 'image/tiff', + 'eml' => 'message/rfc822', + 'css' => 'text/css', + 'html' => 'text/html', + 'htm' => 'text/html', + 'shtml' => 'text/html', + 'log' => 'text/plain', + 'text' => 'text/plain', + 'txt' => 'text/plain', + 'rtx' => 'text/richtext', + 'rtf' => 'text/rtf', + 'vcf' => 'text/vcard', + 'vcard' => 'text/vcard', + 'xml' => 'text/xml', + 'xsl' => 'text/xml', + 'mpeg' => 'video/mpeg', + 'mpe' => 'video/mpeg', + 'mpg' => 'video/mpeg', + 'mov' => 'video/quicktime', + 'qt' => 'video/quicktime', + 'rv' => 'video/vnd.rn-realvideo', + 'avi' => 'video/x-msvideo', + 'movie' => 'video/x-sgi-movie' + ); + if (array_key_exists(strtolower($ext), $mimes)) { + return $mimes[strtolower($ext)]; + } + return 'application/octet-stream'; + } + + /** + * Map a file name to a MIME type. + * Defaults to 'application/octet-stream', i.e.. arbitrary binary data. + * @param string $filename A file name or full path, does not need to exist as a file + * @return string + * @static + */ + public static function filenameToType($filename) + { + // In case the path is a URL, strip any query string before getting extension + $qpos = strpos($filename, '?'); + if (false !== $qpos) { + $filename = substr($filename, 0, $qpos); + } + $pathinfo = self::mb_pathinfo($filename); + return self::_mime_types($pathinfo['extension']); + } + + /** + * Multi-byte-safe pathinfo replacement. + * Drop-in replacement for pathinfo(), but multibyte-safe, cross-platform-safe, old-version-safe. + * Works similarly to the one in PHP >= 5.2.0 + * @link http://www.php.net/manual/en/function.pathinfo.php#107461 + * @param string $path A filename or path, does not need to exist as a file + * @param integer|string $options Either a PATHINFO_* constant, + * or a string name to return only the specified piece, allows 'filename' to work on PHP < 5.2 + * @return string|array + * @static + */ + public static function mb_pathinfo($path, $options = null) + { + $ret = array('dirname' => '', 'basename' => '', 'extension' => '', 'filename' => ''); + $pathinfo = array(); + if (preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $pathinfo)) { + if (array_key_exists(1, $pathinfo)) { + $ret['dirname'] = $pathinfo[1]; + } + if (array_key_exists(2, $pathinfo)) { + $ret['basename'] = $pathinfo[2]; + } + if (array_key_exists(5, $pathinfo)) { + $ret['extension'] = $pathinfo[5]; + } + if (array_key_exists(3, $pathinfo)) { + $ret['filename'] = $pathinfo[3]; + } + } + switch ($options) { + case PATHINFO_DIRNAME: + case 'dirname': + return $ret['dirname']; + case PATHINFO_BASENAME: + case 'basename': + return $ret['basename']; + case PATHINFO_EXTENSION: + case 'extension': + return $ret['extension']; + case PATHINFO_FILENAME: + case 'filename': + return $ret['filename']; + default: + return $ret; + } + } + + } +} |