githubFork/roundcubemail.git

Aleksander Machniak

2016-05-16 0b7e26c1bf6bc7a684eb3a214d92d3927306cd8a

commit \| author \| age
1c4f23	1	<?php
A	2
a95874	3	/**
1c4f23	4	+-----------------------------------------------------------------------+
A	5	\| This file is part of the Roundcube Webmail client \|
3d0d5d	6	\| Copyright (C) 2005-2016, The Roundcube Dev Team \|
AM	7	\| Copyright (C) 2011-2016, Kolab Systems AG \|
7fe381	8	\| \|
T	9	\| Licensed under the GNU General Public License version 3 or \|
	10	\| any later version with exceptions for skins & plugins. \|
	11	\| See the README file for a full license statement. \|
1c4f23	12	\| \|
A	13	\| PURPOSE: \|
	14	\| MIME message parsing utilities \|
	15	+-----------------------------------------------------------------------+
	16	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	17	\| Author: Aleksander Machniak <alec@alec.pl> \|
	18	+-----------------------------------------------------------------------+
	19	*/
	20
	21	/**
	22	* Class for parsing MIME messages
	23	*
9ab346	24	* @package Framework
AM	25	* @subpackage Storage
	26	* @author Thomas Bruederli <roundcube@gmail.com>
	27	* @author Aleksander Machniak <alec@alec.pl>
1c4f23	28	*/
A	29	class rcube_mime
	30	{
eede51	31	private static $default_charset;
1c4f23	32
A	33
	34	/**
	35	* Object constructor.
	36	*/
	37	function __construct($default_charset = null)
	38	{
eede51	39	self::$default_charset = $default_charset;
0f5dee	40	}
AM	41
	42	/**
	43	* Returns message/object character set name
	44	*
	45	* @return string Characted set name
	46	*/
	47	public static function get_charset()
	48	{
	49	if (self::$default_charset) {
	50	return self::$default_charset;
1c4f23	51	}
0f5dee	52
AM	53	if ($charset = rcube::get_instance()->config->get('default_charset')) {
	54	return $charset;
	55	}
	56
a92beb	57	return RCUBE_CHARSET;
1c4f23	58	}
A	59
	60	/**
8b92d2	61	* Parse the given raw message source and return a structure
T	62	* of rcube_message_part objects.
	63	*
f7427f	64	* It makes use of the rcube_mime_decode library
8b92d2	65	*
f7427f	66	* @param string $raw_body The message source
AM	67	*
8b92d2	68	* @return object rcube_message_part The message structure
T	69	*/
	70	public static function parse_message($raw_body)
	71	{
f7427f	72	$conf = array(
AM	73	'include_bodies' => true,
	74	'decode_bodies' => true,
	75	'decode_headers' => false,
	76	'default_charset' => self::get_charset(),
	77	);
8b92d2	78
f7427f	79	$mime = new rcube_mime_decode($conf);
8b92d2	80
f7427f	81	return $mime->decode($raw_body);
8b92d2	82	}
T	83
	84	/**
1c4f23	85	* Split an address list into a structured array list
A	86	*
	87	* @param string $input Input string
	88	* @param int $max List only this number of addresses
	89	* @param boolean $decode Decode address strings
	90	* @param string $fallback Fallback charset if none specified
d2dff5	91	* @param boolean $addronly Return flat array with e-mail addresses only
1c4f23	92	*
d2dff5	93	* @return array Indexed list of addresses
1c4f23	94	*/
d2dff5	95	static function decode_address_list($input, $max = null, $decode = true, $fallback = null, $addronly = false)
1c4f23	96	{
A	97	$a = self::parse_address_list($input, $decode, $fallback);
	98	$out = array();
	99	$j = 0;
	100
	101	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	102	$special_chars = '[\<\>\\\.\[\]@,;:"]';
	103
3d0d5d	104	if (!is_array($a)) {
1c4f23	105	return $out;
3d0d5d	106	}
1c4f23	107
A	108	foreach ($a as $val) {
	109	$j++;
	110	$address = trim($val['address']);
	111
d2dff5	112	if ($addronly) {
AM	113	$out[$j] = $address;
	114	}
	115	else {
	116	$name = trim($val['name']);
	117	if ($name && $address && $name != $address)
	118	$string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address);
	119	else if ($address)
	120	$string = $address;
	121	else if ($name)
	122	$string = $name;
1c4f23	123
d2dff5	124	$out[$j] = array('name' => $name, 'mailto' => $address, 'string' => $string);
AM	125	}
1c4f23	126
A	127	if ($max && $j==$max)
	128	break;
	129	}
	130
	131	return $out;
	132	}
	133
	134	/**
	135	* Decode a message header value
	136	*
a03233	137	* @param string $input Header value
AM	138	* @param string $fallback Fallback charset if none specified
1c4f23	139	*
A	140	* @return string Decoded string
	141	*/
	142	public static function decode_header($input, $fallback = null)
	143	{
	144	$str = self::decode_mime_string((string)$input, $fallback);
	145
	146	return $str;
	147	}
	148
	149	/**
	150	* Decode a mime-encoded string to internal charset
	151	*
	152	* @param string $input Header value
	153	* @param string $fallback Fallback charset if none specified
	154	*
	155	* @return string Decoded string
	156	*/
	157	public static function decode_mime_string($input, $fallback = null)
	158	{
7e3298	159	$default_charset = $fallback ?: self::get_charset();
1c4f23	160
A	161	// rfc: all line breaks or other characters not found
	162	// in the Base64 Alphabet must be ignored by decoding software
	163	// delete all blanks between MIME-lines, differently we can
	164	// receive unnecessary blanks and broken utf-8 symbols
	165	$input = preg_replace("/\?=\s+=\?/", '?==?', $input);
	166
	167	// encoded-word regexp
	168	$re = '/=\?([^?]+)\?([BbQq])\?([^\n]*?)\?=/';
	169
	170	// Find all RFC2047's encoded words
	171	if (preg_match_all($re, $input, $matches, PREG_OFFSET_CAPTURE \| PREG_SET_ORDER)) {
	172	// Initialize variables
	173	$tmp = array();
	174	$out = '';
	175	$start = 0;
	176
	177	foreach ($matches as $idx => $m) {
	178	$pos = $m[0][1];
	179	$charset = $m[1][0];
	180	$encoding = $m[2][0];
	181	$text = $m[3][0];
	182	$length = strlen($m[0][0]);
	183
	184	// Append everything that is before the text to be decoded
	185	if ($start != $pos) {
	186	$substr = substr($input, $start, $pos-$start);
eebd44	187	$out .= rcube_charset::convert($substr, $default_charset);
1c4f23	188	$start = $pos;
A	189	}
	190	$start += $length;
	191
	192	// Per RFC2047, each string part "MUST represent an integral number
	193	// of characters . A multi-octet character may not be split across
	194	// adjacent encoded-words." However, some mailers break this, so we
	195	// try to handle characters spanned across parts anyway by iterating
	196	// through and aggregating sequential encoded parts with the same
	197	// character set and encoding, then perform the decoding on the
	198	// aggregation as a whole.
	199
	200	$tmp[] = $text;
	201	if ($next_match = $matches[$idx+1]) {
	202	if ($next_match[0][1] == $start
	203	&& $next_match[1][0] == $charset
	204	&& $next_match[2][0] == $encoding
	205	) {
	206	continue;
	207	}
	208	}
	209
	210	$count = count($tmp);
	211	$text = '';
	212
	213	// Decode and join encoded-word's chunks
	214	if ($encoding == 'B' \|\| $encoding == 'b') {
	215	// base64 must be decoded a segment at a time
	216	for ($i=0; $i<$count; $i++)
	217	$text .= base64_decode($tmp[$i]);
	218	}
	219	else { //if ($encoding == 'Q' \|\| $encoding == 'q') {
	220	// quoted printable can be combined and processed at once
	221	for ($i=0; $i<$count; $i++)
	222	$text .= $tmp[$i];
	223
	224	$text = str_replace('_', ' ', $text);
	225	$text = quoted_printable_decode($text);
	226	}
	227
eebd44	228	$out .= rcube_charset::convert($text, $charset);
1c4f23	229	$tmp = array();
A	230	}
	231
	232	// add the last part of the input string
	233	if ($start != strlen($input)) {
eebd44	234	$out .= rcube_charset::convert(substr($input, $start), $default_charset);
1c4f23	235	}
A	236
	237	// return the results
	238	return $out;
	239	}
	240
	241	// no encoding information, use fallback
eebd44	242	return rcube_charset::convert($input, $default_charset);
1c4f23	243	}
A	244
	245	/**
	246	* Decode a mime part
	247	*
	248	* @param string $input Input string
	249	* @param string $encoding Part encoding
96a7f6	250	*
1c4f23	251	* @return string Decoded string
A	252	*/
	253	public static function decode($input, $encoding = '7bit')
	254	{
	255	switch (strtolower($encoding)) {
	256	case 'quoted-printable':
	257	return quoted_printable_decode($input);
	258	case 'base64':
	259	return base64_decode($input);
	260	case 'x-uuencode':
	261	case 'x-uue':
	262	case 'uue':
	263	case 'uuencode':
	264	return convert_uudecode($input);
	265	case '7bit':
	266	default:
	267	return $input;
	268	}
	269	}
	270
	271	/**
	272	* Split RFC822 header string into an associative array
	273	*/
	274	public static function parse_headers($headers)
	275	{
	276	$a_headers = array();
3d0d5d	277	$headers = preg_replace('/\r?\n(\t\| )+/', ' ', $headers);
AM	278	$lines = explode("\n", $headers);
	279	$count = count($lines);
1c4f23	280
3d0d5d	281	for ($i=0; $i<$count; $i++) {
1c4f23	282	if ($p = strpos($lines[$i], ': ')) {
A	283	$field = strtolower(substr($lines[$i], 0, $p));
	284	$value = trim(substr($lines[$i], $p+1));
3d0d5d	285	if (!empty($value)) {
1c4f23	286	$a_headers[$field] = $value;
3d0d5d	287	}
1c4f23	288	}
A	289	}
	290
	291	return $a_headers;
	292	}
	293
	294	/**
a03233	295	* E-mail address list parser
1c4f23	296	*/
A	297	private static function parse_address_list($str, $decode = true, $fallback = null)
	298	{
	299	// remove any newlines and carriage returns before
	300	$str = preg_replace('/\r?\n(\s\|\t)?/', ' ', $str);
	301
	302	// extract list items, remove comments
	303	$str = self::explode_header_string(',;', $str, true);
	304	$result = array();
	305
	306	// simplified regexp, supporting quoted local part
	307	$email_rx = '(\S+\|("\s(?:[^"\f\n\r\t\v\b\s]+\s)+"))@\S+';
	308
	309	foreach ($str as $key => $val) {
	310	$name = '';
	311	$address = '';
	312	$val = trim($val);
	313
	314	if (preg_match('/(.*)<('.$email_rx.')>$/', $val, $m)) {
	315	$address = $m[2];
	316	$name = trim($m[1]);
	317	}
	318	else if (preg_match('/^('.$email_rx.')$/', $val, $m)) {
	319	$address = $m[1];
	320	$name = '';
	321	}
fd0fd3	322	// special case (#1489092)
AM	323	else if (preg_match('/(\s*<MAILER-DAEMON>)$/', $val, $m)) {
	324	$address = 'MAILER-DAEMON';
	325	$name = substr($val, 0, -strlen($m[1]));
	326	}
2b8f03	327	else if (preg_match('/('.$email_rx.')/', $val, $m)) {
AM	328	$name = $m[1];
	329	}
1c4f23	330	else {
A	331	$name = $val;
	332	}
	333
	334	// dequote and/or decode name
	335	if ($name) {
	336	if ($name[0] == '"' && $name[strlen($name)-1] == '"') {
	337	$name = substr($name, 1, -1);
	338	$name = stripslashes($name);
	339	}
	340	if ($decode) {
	341	$name = self::decode_header($name, $fallback);
5140c3	342	// some clients encode addressee name with quotes around it
AM	343	if ($name[0] == '"' && $name[strlen($name)-1] == '"') {
	344	$name = substr($name, 1, -1);
	345	}
1c4f23	346	}
A	347	}
	348
	349	if (!$address && $name) {
	350	$address = $name;
2b8f03	351	$name = '';
1c4f23	352	}
A	353
	354	if ($address) {
f01666	355	$address = self::fix_email($address);
1c4f23	356	$result[$key] = array('name' => $name, 'address' => $address);
A	357	}
	358	}
	359
	360	return $result;
	361	}
	362
	363	/**
	364	* Explodes header (e.g. address-list) string into array of strings
	365	* using specified separator characters with proper handling
	366	* of quoted-strings and comments (RFC2822)
	367	*
	368	* @param string $separator String containing separator characters
	369	* @param string $str Header string
	370	* @param bool $remove_comments Enable to remove comments
	371	*
	372	* @return array Header items
	373	*/
	374	public static function explode_header_string($separator, $str, $remove_comments = false)
	375	{
	376	$length = strlen($str);
	377	$result = array();
	378	$quoted = false;
	379	$comment = 0;
	380	$out = '';
	381
	382	for ($i=0; $i<$length; $i++) {
	383	// we're inside a quoted string
	384	if ($quoted) {
	385	if ($str[$i] == '"') {
	386	$quoted = false;
	387	}
	388	else if ($str[$i] == "\\") {
	389	if ($comment <= 0) {
	390	$out .= "\\";
	391	}
	392	$i++;
	393	}
	394	}
	395	// we are inside a comment string
	396	else if ($comment > 0) {
	397	if ($str[$i] == ')') {
	398	$comment--;
	399	}
	400	else if ($str[$i] == '(') {
	401	$comment++;
	402	}
	403	else if ($str[$i] == "\\") {
	404	$i++;
	405	}
	406	continue;
	407	}
	408	// separator, add to result array
	409	else if (strpos($separator, $str[$i]) !== false) {
	410	if ($out) {
	411	$result[] = $out;
	412	}
	413	$out = '';
	414	continue;
	415	}
	416	// start of quoted string
	417	else if ($str[$i] == '"') {
	418	$quoted = true;
	419	}
	420	// start of comment
	421	else if ($remove_comments && $str[$i] == '(') {
	422	$comment++;
	423	}
	424
	425	if ($comment <= 0) {
	426	$out .= $str[$i];
	427	}
	428	}
	429
	430	if ($out && $comment <= 0) {
	431	$result[] = $out;
	432	}
	433
	434	return $result;
	435	}
	436
	437	/**
	438	* Interpret a format=flowed message body according to RFC 2646
	439	*
eda92e	440	* @param string $text Raw body formatted as flowed text
AM	441	* @param string $mark Mark each flowed line with specified character
1c4f23	442	*
A	443	* @return string Interpreted text with unwrapped lines and stuffed space removed
	444	*/
eda92e	445	public static function unfold_flowed($text, $mark = null)
1c4f23	446	{
96a7f6	447	$text = preg_split('/\r?\n/', $text);
AM	448	$last = -1;
1c4f23	449	$q_level = 0;
96a7f6	450	$marks = array();
1c4f23	451
A	452	foreach ($text as $idx => $line) {
3d0d5d	453	if ($q = strspn($line, '>')) {
b92ec5	454	// remove quote chars
3d0d5d	455	$line = substr($line, $q);
7ebed1	456	// remove (optional) space-staffing
3d0d5d	457	if ($line[0] === ' ') $line = substr($line, 1);
1c4f23	458
aabd62	459	// The same paragraph (We join current line with the previous one) when:
AM	460	// - the same level of quoting
	461	// - previous line was flowed
	462	// - previous line contains more than only one single space (and quote char(s))
6d41d8	463	if ($q == $q_level
aabd62	464	&& isset($text[$last]) && $text[$last][strlen($text[$last])-1] == ' '
AM	465	&& !preg_match('/^>+ {0,1}$/', $text[$last])
1c4f23	466	) {
A	467	$text[$last] .= $line;
	468	unset($text[$idx]);
eda92e	469
AM	470	if ($mark) {
	471	$marks[$last] = true;
	472	}
1c4f23	473	}
A	474	else {
	475	$last = $idx;
	476	}
	477	}
	478	else {
	479	if ($line == '-- ') {
	480	$last = $idx;
	481	}
	482	else {
	483	// remove space-stuffing
3d0d5d	484	if ($line[0] === ' ') $line = substr($line, 1);
1c4f23	485
13e0a6	486	if (isset($text[$last]) && $line && !$q_level
1c4f23	487	&& $text[$last] != '-- '
A	488	&& $text[$last][strlen($text[$last])-1] == ' '
	489	) {
	490	$text[$last] .= $line;
	491	unset($text[$idx]);
eda92e	492
AM	493	if ($mark) {
	494	$marks[$last] = true;
	495	}
1c4f23	496	}
A	497	else {
	498	$text[$idx] = $line;
	499	$last = $idx;
	500	}
	501	}
	502	}
	503	$q_level = $q;
	504	}
	505
eda92e	506	if (!empty($marks)) {
AM	507	foreach (array_keys($marks) as $mk) {
	508	$text[$mk] = $mark . $text[$mk];
	509	}
	510	}
	511
1c4f23	512	return implode("\r\n", $text);
A	513	}
	514
	515	/**
	516	* Wrap the given text to comply with RFC 2646
	517	*
96a7f6	518	* @param string $text Text to wrap
AM	519	* @param int $length Length
c72a96	520	* @param string $charset Character encoding of $text
1c4f23	521	*
A	522	* @return string Wrapped text
	523	*/
c72a96	524	public static function format_flowed($text, $length = 72, $charset=null)
1c4f23	525	{
A	526	$text = preg_split('/\r?\n/', $text);
	527
	528	foreach ($text as $idx => $line) {
	529	if ($line != '-- ') {
3d0d5d	530	if ($level = strspn($line, '>')) {
b92ec5	531	// remove quote chars
3d0d5d	532	$line = substr($line, $level);
87a968	533	// remove (optional) space-staffing and spaces before the line end
3d0d5d	534	$line = rtrim($line, ' ');
AM	535	if ($line[0] === ' ') $line = substr($line, 1);
	536
42b8a6	537	$prefix = str_repeat('>', $level) . ' ';
AM	538	$line = $prefix . self::wordwrap($line, $length - $level - 2, " \r\n$prefix", false, $charset);
1c4f23	539	}
A	540	else if ($line) {
c72a96	541	$line = self::wordwrap(rtrim($line), $length - 2, " \r\n", false, $charset);
1c4f23	542	// space-stuffing
A	543	$line = preg_replace('/(^\|\r\n)(From\| \|>)/', '\\1 \\2', $line);
	544	}
	545
	546	$text[$idx] = $line;
	547	}
	548	}
	549
	550	return implode("\r\n", $text);
	551	}
b6a182	552
A	553	/**
7439d3	554	* Improved wordwrap function with multibyte support.
AM	555	* The code is based on Zend_Text_MultiByte::wordWrap().
b6a182	556	*
7439d3	557	* @param string $string Text to wrap
AM	558	* @param int $width Line width
	559	* @param string $break Line separator
	560	* @param bool $cut Enable to cut word
	561	* @param string $charset Charset of $string
	562	* @param bool $wrap_quoted When enabled quoted lines will not be wrapped
b6a182	563	*
A	564	* @return string Text
	565	*/
7439d3	566	public static function wordwrap($string, $width=75, $break="\n", $cut=false, $charset=null, $wrap_quoted=true)
b6a182	567	{
581a52	568	// Note: Never try to use iconv instead of mbstring functions here
AM	569	// Iconv's substr/strlen are 100x slower (#1489113)
c72a96	570
8447ba	571	if ($charset && $charset != RCUBE_CHARSET) {
581a52	572	mb_internal_encoding($charset);
AM	573	}
b6a182	574
7439d3	575	// Convert \r\n to \n, this is our line-separator
AM	576	$string = str_replace("\r\n", "\n", $string);
	577	$separator = "\n"; // must be 1 character length
	578	$result = array();
b6a182	579
581a52	580	while (($stringLength = mb_strlen($string)) > 0) {
AM	581	$breakPos = mb_strpos($string, $separator, 0);
b6a182	582
7439d3	583	// quoted line (do not wrap)
AM	584	if ($wrap_quoted && $string[0] == '>') {
	585	if ($breakPos === $stringLength - 1 \|\| $breakPos === false) {
	586	$subString = $string;
	587	$cutLength = null;
b6a182	588	}
A	589	else {
581a52	590	$subString = mb_substr($string, 0, $breakPos);
7439d3	591	$cutLength = $breakPos + 1;
AM	592	}
	593	}
	594	// next line found and current line is shorter than the limit
	595	else if ($breakPos !== false && $breakPos < $width) {
	596	if ($breakPos === $stringLength - 1) {
	597	$subString = $string;
	598	$cutLength = null;
	599	}
	600	else {
581a52	601	$subString = mb_substr($string, 0, $breakPos);
7439d3	602	$cutLength = $breakPos + 1;
AM	603	}
	604	}
	605	else {
581a52	606	$subString = mb_substr($string, 0, $width);
7439d3	607
AM	608	// last line
1041aa	609	if ($breakPos === false && $subString === $string) {
7439d3	610	$cutLength = null;
AM	611	}
	612	else {
581a52	613	$nextChar = mb_substr($string, $width, 1);
7439d3	614
AM	615	if ($nextChar === ' ' \|\| $nextChar === $separator) {
581a52	616	$afterNextChar = mb_substr($string, $width + 1, 1);
7439d3	617
0f1521	618	// Note: mb_substr() does never return False
AM	619	if ($afterNextChar === false \|\| $afterNextChar === '') {
7439d3	620	$subString .= $nextChar;
AM	621	}
	622
581a52	623	$cutLength = mb_strlen($subString) + 1;
7439d3	624	}
AM	625	else {
581a52	626	$spacePos = mb_strrpos($subString, ' ', 0);
7439d3	627
AM	628	if ($spacePos !== false) {
581a52	629	$subString = mb_substr($subString, 0, $spacePos);
7439d3	630	$cutLength = $spacePos + 1;
AM	631	}
	632	else if ($cut === false) {
581a52	633	$spacePos = mb_strpos($string, ' ', 0);
7439d3	634
0f1521	635	if ($spacePos !== false && ($breakPos === false \|\| $spacePos < $breakPos)) {
581a52	636	$subString = mb_substr($string, 0, $spacePos);
7439d3	637	$cutLength = $spacePos + 1;
0f1521	638	}
AM	639	else if ($breakPos === false) {
	640	$subString = $string;
	641	$cutLength = null;
7439d3	642	}
AM	643	else {
581a52	644	$subString = mb_substr($string, 0, $breakPos);
2ce019	645	$cutLength = $breakPos + 1;
b6a182	646	}
A	647	}
	648	else {
7439d3	649	$cutLength = $width;
b6a182	650	}
A	651	}
	652	}
	653	}
	654
7439d3	655	$result[] = $subString;
AM	656
	657	if ($cutLength !== null) {
581a52	658	$string = mb_substr($string, $cutLength, ($stringLength - $cutLength));
7439d3	659	}
AM	660	else {
	661	break;
b6a182	662	}
A	663	}
	664
8447ba	665	if ($charset && $charset != RCUBE_CHARSET) {
581a52	666	mb_internal_encoding(RCUBE_CHARSET);
AM	667	}
	668
7439d3	669	return implode($break, $result);
b6a182	670	}
A	671
	672	/**
	673	* A method to guess the mime_type of an attachment.
	674	*
a03233	675	* @param string $path Path to the file or file contents
AM	676	* @param string $name File name (with suffix)
	677	* @param string $failover Mime type supplied for failover
0a8397	678	* @param boolean $is_stream Set to True if $path contains file contents
TB	679	* @param boolean $skip_suffix Set to True if the config/mimetypes.php mappig should be ignored
b6a182	680	*
A	681	* @return string
	682	* @author Till Klampaeckel <till@php.net>
	683	* @see http://de2.php.net/manual/en/ref.fileinfo.php
	684	* @see http://de2.php.net/mime_content_type
	685	*/
0a8397	686	public static function file_content_type($path, $name, $failover = 'application/octet-stream', $is_stream = false, $skip_suffix = false)
b6a182	687	{
9e9d62	688	static $mime_ext = array();
TB	689
96a7f6	690	$mime_type = null;
AM	691	$config = rcube::get_instance()->config;
9e9d62	692	$mime_magic = $config->get('mime_magic');
TB	693
	694	if (!$skip_suffix && empty($mime_ext)) {
	695	foreach ($config->resolve_paths('mimetypes.php') as $fpath) {
	696	$mime_ext = array_merge($mime_ext, (array) @include($fpath));
	697	}
	698	}
b6a182	699
A	700	// use file name suffix with hard-coded mime-type map
9e9d62	701	if (!$skip_suffix && is_array($mime_ext) && $name) {
b6a182	702	if ($suffix = substr($name, strrpos($name, '.')+1)) {
A	703	$mime_type = $mime_ext[strtolower($suffix)];
	704	}
	705	}
	706
	707	// try fileinfo extension if available
	708	if (!$mime_type && function_exists('finfo_open')) {
4f693e	709	// null as a 2nd argument should be the same as no argument
AM	710	// this however is not true on all systems/versions
	711	if ($mime_magic) {
	712	$finfo = finfo_open(FILEINFO_MIME, $mime_magic);
	713	}
	714	else {
	715	$finfo = finfo_open(FILEINFO_MIME);
	716	}
	717
	718	if ($finfo) {
b6a182	719	if ($is_stream)
A	720	$mime_type = finfo_buffer($finfo, $path);
	721	else
	722	$mime_type = finfo_file($finfo, $path);
	723	finfo_close($finfo);
	724	}
	725	}
	726
	727	// try PHP's mime_content_type
	728	if (!$mime_type && !$is_stream && function_exists('mime_content_type')) {
	729	$mime_type = @mime_content_type($path);
	730	}
	731
	732	// fall back to user-submitted string
	733	if (!$mime_type) {
	734	$mime_type = $failover;
	735	}
	736	else {
	737	// Sometimes (PHP-5.3?) content-type contains charset definition,
	738	// Remove it (#1487122) also "charset=binary" is useless
	739	$mime_type = array_shift(preg_split('/[; ]/', $mime_type));
	740	}
	741
	742	return $mime_type;
	743	}
	744
	745	/**
0a8397	746	* Get mimetype => file extension mapping
TB	747	*
96a7f6	748	* @param string Mime-Type to get extensions for
AM	749	*
	750	* @return array List of extensions matching the given mimetype or a hash array
	751	* with ext -> mimetype mappings if $mimetype is not given
0a8397	752	*/
TB	753	public static function get_mime_extensions($mimetype = null)
	754	{
	755	static $mime_types, $mime_extensions;
	756
	757	// return cached data
	758	if (is_array($mime_types)) {
	759	return $mimetype ? $mime_types[$mimetype] : $mime_extensions;
	760	}
	761
	762	// load mapping file
	763	$file_paths = array();
	764
02c9c9	765	if ($mime_types = rcube::get_instance()->config->get('mime_types')) {
0a8397	766	$file_paths[] = $mime_types;
02c9c9	767	}
0a8397	768
TB	769	// try common locations
02c9c9	770	if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
AM	771	$file_paths[] = 'C:/xampp/apache/conf/mime.types.';
	772	}
	773	else {
	774	$file_paths[] = '/etc/mime.types';
	775	$file_paths[] = '/etc/httpd/mime.types';
	776	$file_paths[] = '/etc/httpd2/mime.types';
	777	$file_paths[] = '/etc/apache/mime.types';
	778	$file_paths[] = '/etc/apache2/mime.types';
d75334	779	$file_paths[] = '/etc/nginx/mime.types';
02c9c9	780	$file_paths[] = '/usr/local/etc/httpd/conf/mime.types';
AM	781	$file_paths[] = '/usr/local/etc/apache/conf/mime.types';
	782	}
0a8397	783
TB	784	foreach ($file_paths as $fp) {
c16bd5	785	if (@is_readable($fp)) {
02c9c9	786	$lines = file($fp, FILE_IGNORE_NEW_LINES \| FILE_SKIP_EMPTY_LINES);
0a8397	787	break;
TB	788	}
	789	}
	790
	791	$mime_types = $mime_extensions = array();
1ece73	792	$regex = "/([\w\+\-\.\/]+)\s+([\w\s]+)/i";
0a8397	793	foreach((array)$lines as $line) {
TB	794	// skip comments or mime types w/o any extensions
	795	if ($line[0] == '#' \|\| !preg_match($regex, $line, $matches))
	796	continue;
	797
	798	$mime = $matches[1];
	799	foreach (explode(' ', $matches[2]) as $ext) {
	800	$ext = trim($ext);
	801	$mime_types[$mime][] = $ext;
	802	$mime_extensions[$ext] = $mime;
	803	}
	804	}
	805
	806	// fallback to some well-known types most important for daily emails
	807	if (empty($mime_types)) {
9e9d62	808	foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) {
TB	809	$mime_extensions = array_merge($mime_extensions, (array) @include($fpath));
	810	}
0a8397	811
99cfba	812	foreach ($mime_extensions as $ext => $mime) {
0a8397	813	$mime_types[$mime][] = $ext;
99cfba	814	}
AM	815	}
	816
	817	// Add some known aliases that aren't included by some mime.types (#1488891)
	818	// the order is important here so standard extensions have higher prio
	819	$aliases = array(
	820	'image/gif' => array('gif'),
	821	'image/png' => array('png'),
	822	'image/x-png' => array('png'),
	823	'image/jpeg' => array('jpg', 'jpeg', 'jpe'),
	824	'image/jpg' => array('jpg', 'jpeg', 'jpe'),
	825	'image/pjpeg' => array('jpg', 'jpeg', 'jpe'),
	826	'image/tiff' => array('tif'),
	827	'message/rfc822' => array('eml'),
	828	'text/x-mail' => array('eml'),
	829	);
	830
	831	foreach ($aliases as $mime => $exts) {
	832	$mime_types[$mime] = array_unique(array_merge((array) $mime_types[$mime], $exts));
	833
	834	foreach ($exts as $ext) {
	835	if (!isset($mime_extensions[$ext])) {
	836	$mime_extensions[$ext] = $mime;
	837	}
	838	}
0a8397	839	}
TB	840
	841	return $mimetype ? $mime_types[$mimetype] : $mime_extensions;
	842	}
	843
	844	/**
b6a182	845	* Detect image type of the given binary data by checking magic numbers.
A	846	*
	847	* @param string $data Binary file content
	848	*
	849	* @return string Detected mime-type or jpeg as fallback
	850	*/
	851	public static function image_content_type($data)
	852	{
	853	$type = 'jpeg';
	854	if (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png';
	855	else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif';
	856	else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico';
	857	// else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg';
	858
	859	return 'image/' . $type;
	860	}
	861
f01666	862	/**
AM	863	* Try to fix invalid email addresses
	864	*/
	865	public static function fix_email($email)
	866	{
	867	$parts = rcube_utils::explode_quoted_string('@', $email);
	868	foreach ($parts as $idx => $part) {
	869	// remove redundant quoting (#1490040)
	870	if ($part[0] == '"' && preg_match('/^"([a-zA-Z0-9._+=-]+)"$/', $part, $m)) {
	871	$parts[$idx] = $m[1];
	872	}
	873	}
	874
	875	return implode('@', $parts);
	876	}
1c4f23	877	}