githubFork/roundcubemail.git

			@@ -1,13 +1,16 @@
			<?php

			/**
			/*
			+-----------------------------------------------------------------------+
			\| program/include/rcube_mime.php \|
			\| \|
			\| This file is part of the Roundcube Webmail client \|
			\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
			\| Copyright (C) 2011-2012, Kolab Systems AG \|
			\| Licensed under the GNU GPL \|
			\| \|
			\| Licensed under the GNU General Public License version 3 or \|
			\| any later version with exceptions for skins & plugins. \|
			\| See the README file for a full license statement. \|
			\| \|
			\| PURPOSE: \|
			\| MIME message parsing utilities \|
			@@ -43,8 +46,69 @@
			self::$default_charset = $default_charset;
			}
			else {
			self::$default_charset = rcmail::get_instance()->config->get('default_charset', RCMAIL_CHARSET);
			self::$default_charset = rcube::get_instance()->config->get('default_charset', RCMAIL_CHARSET);
			}
			}


			/**
			* Parse the given raw message source and return a structure
			* of rcube_message_part objects.
			*
			* It makes use of the PEAR:Mail_mimeDecode library
			*
			* @param string The message source
			* @return object rcube_message_part The message structure
			*/
			public static function parse_message($raw_body)
			{
			$mime = new Mail_mimeDecode($raw_body);
			$struct = $mime->decode(array('include_bodies' => true, 'decode_bodies' => true));
			return self::structure_part($struct);
			}


			/**
			* Recursive method to convert a Mail_mimeDecode part into a rcube_message_part object
			*
			* @param object A message part struct
			* @param int Part count
			* @param string Parent MIME ID
			*
			* @return object rcube_message_part
			*/
			private static function structure_part($part, $count=0, $parent='')
			{
			$struct = new rcube_message_part;
			$struct->mime_id = $part->mime_id ? $part->mime_id : (empty($parent) ? (string)$count : "$parent.$count");
			$struct->headers = $part->headers;
			$struct->ctype_primary = $part->ctype_primary;
			$struct->ctype_secondary = $part->ctype_secondary;
			$struct->mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
			$struct->ctype_parameters = $part->ctype_parameters;

			if ($part->headers['content-transfer-encoding'])
			$struct->encoding = $part->headers['content-transfer-encoding'];
			if ($part->ctype_parameters['charset'])
			$struct->charset = $part->ctype_parameters['charset'];

			$part_charset = $struct->charset ? $struct->charset : self::$default_charset;

			// determine filename
			if (($filename = $part->d_parameters['filename']) \|\| ($filename = $part->ctype_parameters['name'])) {
			$struct->filename = rcube_mime::decode_mime_string($filename, $part_charset);
			}

			// copy part body and convert it to UTF-8 if necessary
			$struct->body = $part->ctype_primary == 'text' \|\| !$part->ctype_parameters['charset'] ? rcube_charset::convert($part->body, $part_charset) : $part->body;
			$struct->size = strlen($part->body);
			$struct->disposition = $part->disposition;

			foreach ((array)$part->parts as $child_part) {
			$struct->parts[] = self::structure_part($child_part, ++$count, $struct->mime_id);
			}

			return $struct;
			}


			@@ -481,4 +545,149 @@
			return implode("\r\n", $text);
			}


			/**
			* Improved wordwrap function.
			*
			* @param string $string Text to wrap
			* @param int $width Line width
			* @param string $break Line separator
			* @param bool $cut Enable to cut word
			*
			* @return string Text
			*/
			public static function wordwrap($string, $width=75, $break="\n", $cut=false)
			{
			$para = explode($break, $string);
			$string = '';

			while (count($para)) {
			$line = array_shift($para);
			if ($line[0] == '>') {
			$string .= $line.$break;
			continue;
			}

			$list = explode(' ', $line);
			$len = 0;
			while (count($list)) {
			$line = array_shift($list);
			$l = mb_strlen($line);
			$newlen = $len + $l + ($len ? 1 : 0);

			if ($newlen <= $width) {
			$string .= ($len ? ' ' : '').$line;
			$len += (1 + $l);
			}
			else {
			if ($l > $width) {
			if ($cut) {
			$start = 0;
			while ($l) {
			$str = mb_substr($line, $start, $width);
			$strlen = mb_strlen($str);
			$string .= ($len ? $break : '').$str;
			$start += $strlen;
			$l -= $strlen;
			$len = $strlen;
			}
			}
			else {
			$string .= ($len ? $break : '').$line;
			if (count($list)) {
			$string .= $break;
			}
			$len = 0;
			}
			}
			else {
			$string .= $break.$line;
			$len = $l;
			}
			}
			}

			if (count($para)) {
			$string .= $break;
			}
			}

			return $string;
			}


			/**
			* A method to guess the mime_type of an attachment.
			*
			* @param string $path Path to the file.
			* @param string $name File name (with suffix)
			* @param string $failover Mime type supplied for failover.
			* @param string $is_stream Set to True if $path contains file body
			*
			* @return string
			* @author Till Klampaeckel <till@php.net>
			* @see http://de2.php.net/manual/en/ref.fileinfo.php
			* @see http://de2.php.net/mime_content_type
			*/
			public static function file_content_type($path, $name, $failover = 'application/octet-stream', $is_stream = false)
			{
			$mime_type = null;
			$mime_magic = rcube::get_instance()->config->get('mime_magic');
			$mime_ext = @include RCMAIL_CONFIG_DIR . '/mimetypes.php';

			// use file name suffix with hard-coded mime-type map
			if (is_array($mime_ext) && $name) {
			if ($suffix = substr($name, strrpos($name, '.')+1)) {
			$mime_type = $mime_ext[strtolower($suffix)];
			}
			}

			// try fileinfo extension if available
			if (!$mime_type && function_exists('finfo_open')) {
			if ($finfo = finfo_open(FILEINFO_MIME, $mime_magic)) {
			if ($is_stream)
			$mime_type = finfo_buffer($finfo, $path);
			else
			$mime_type = finfo_file($finfo, $path);
			finfo_close($finfo);
			}
			}

			// try PHP's mime_content_type
			if (!$mime_type && !$is_stream && function_exists('mime_content_type')) {
			$mime_type = @mime_content_type($path);
			}

			// fall back to user-submitted string
			if (!$mime_type) {
			$mime_type = $failover;
			}
			else {
			// Sometimes (PHP-5.3?) content-type contains charset definition,
			// Remove it (#1487122) also "charset=binary" is useless
			$mime_type = array_shift(preg_split('/[; ]/', $mime_type));
			}

			return $mime_type;
			}


			/**
			* Detect image type of the given binary data by checking magic numbers.
			*
			* @param string $data Binary file content
			*
			* @return string Detected mime-type or jpeg as fallback
			*/
			public static function image_content_type($data)
			{
			$type = 'jpeg';
			if (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png';
			else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif';
			else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico';
			// else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg';

			return 'image/' . $type;
			}

			}