Mercurial > hg > rc2
diff program/lib/Roundcube/rcube_charset.php @ 0:4681f974d28b
vanilla 1.3.3 distro, I hope
| author | Charlie Root |
|---|---|
| date | Thu, 04 Jan 2018 15:52:31 -0500 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/program/lib/Roundcube/rcube_charset.php Thu Jan 04 15:52:31 2018 -0500 @@ -0,0 +1,910 @@ +<?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 | + | Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org> | + | | + | 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: | + | Provide charset conversion functionality | + +-----------------------------------------------------------------------+ + | Author: Thomas Bruederli <roundcube@gmail.com> | + | Author: Aleksander Machniak <alec@alec.pl> | + +-----------------------------------------------------------------------+ +*/ + +/** + * Character sets conversion functionality + * + * @package Framework + * @subpackage Core + * @author Thomas Bruederli <roundcube@gmail.com> + * @author Aleksander Machniak <alec@alec.pl> + * @author Edmund Grimley Evans <edmundo@rano.org> + */ +class rcube_charset +{ + // Aliases: some of them from HTML5 spec. + static public $aliases = array( + 'USASCII' => 'WINDOWS-1252', + 'ANSIX31101983' => 'WINDOWS-1252', + 'ANSIX341968' => 'WINDOWS-1252', + 'UNKNOWN8BIT' => 'ISO-8859-15', + 'UNKNOWN' => 'ISO-8859-15', + 'USERDEFINED' => 'ISO-8859-15', + 'KSC56011987' => 'EUC-KR', + 'GB2312' => 'GBK', + 'GB231280' => 'GBK', + 'UNICODE' => 'UTF-8', + 'UTF7IMAP' => 'UTF7-IMAP', + 'TIS620' => 'WINDOWS-874', + 'ISO88599' => 'WINDOWS-1254', + 'ISO885911' => 'WINDOWS-874', + 'MACROMAN' => 'MACINTOSH', + '77' => 'MAC', + '128' => 'SHIFT-JIS', + '129' => 'CP949', + '130' => 'CP1361', + '134' => 'GBK', + '136' => 'BIG5', + '161' => 'WINDOWS-1253', + '162' => 'WINDOWS-1254', + '163' => 'WINDOWS-1258', + '177' => 'WINDOWS-1255', + '178' => 'WINDOWS-1256', + '186' => 'WINDOWS-1257', + '204' => 'WINDOWS-1251', + '222' => 'WINDOWS-874', + '238' => 'WINDOWS-1250', + 'MS950' => 'CP950', + 'WINDOWS949' => 'UHC', + ); + + /** + * Windows codepages + * + * @var array + */ + static public $windows_codepages = array( + 37 => 'IBM037', // IBM EBCDIC US-Canada + 437 => 'IBM437', // OEM United States + 500 => 'IBM500', // IBM EBCDIC International + 708 => 'ASMO-708', // Arabic (ASMO 708) + 720 => 'DOS-720', // Arabic (Transparent ASMO); Arabic (DOS) + 737 => 'IBM737', // OEM Greek (formerly 437G); Greek (DOS) + 775 => 'IBM775', // OEM Baltic; Baltic (DOS) + 850 => 'IBM850', // OEM Multilingual Latin 1; Western European (DOS) + 852 => 'IBM852', // OEM Latin 2; Central European (DOS) + 855 => 'IBM855', // OEM Cyrillic (primarily Russian) + 857 => 'IBM857', // OEM Turkish; Turkish (DOS) + 858 => 'IBM00858', // OEM Multilingual Latin 1 + Euro symbol + 860 => 'IBM860', // OEM Portuguese; Portuguese (DOS) + 861 => 'IBM861', // OEM Icelandic; Icelandic (DOS) + 862 => 'DOS-862', // OEM Hebrew; Hebrew (DOS) + 863 => 'IBM863', // OEM French Canadian; French Canadian (DOS) + 864 => 'IBM864', // OEM Arabic; Arabic (864) + 865 => 'IBM865', // OEM Nordic; Nordic (DOS) + 866 => 'cp866', // OEM Russian; Cyrillic (DOS) + 869 => 'IBM869', // OEM Modern Greek; Greek, Modern (DOS) + 870 => 'IBM870', // IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 + 874 => 'windows-874', // ANSI/OEM Thai (ISO 8859-11); Thai (Windows) + 875 => 'cp875', // IBM EBCDIC Greek Modern + 932 => 'shift_jis', // ANSI/OEM Japanese; Japanese (Shift-JIS) + 936 => 'gb2312', // ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) + 950 => 'big5', // ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) + 1026 => 'IBM1026', // IBM EBCDIC Turkish (Latin 5) + 1047 => 'IBM01047', // IBM EBCDIC Latin 1/Open System + 1140 => 'IBM01140', // IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) + 1141 => 'IBM01141', // IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) + 1142 => 'IBM01142', // IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) + 1143 => 'IBM01143', // IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) + 1144 => 'IBM01144', // IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) + 1145 => 'IBM01145', // IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) + 1146 => 'IBM01146', // IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) + 1147 => 'IBM01147', // IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) + 1148 => 'IBM01148', // IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) + 1149 => 'IBM01149', // IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) + 1200 => 'UTF-16', // Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications + 1201 => 'UTF-16BE', // Unicode UTF-16, big endian byte order; available only to managed applications + 1250 => 'windows-1250', // ANSI Central European; Central European (Windows) + 1251 => 'windows-1251', // ANSI Cyrillic; Cyrillic (Windows) + 1252 => 'windows-1252', // ANSI Latin 1; Western European (Windows) + 1253 => 'windows-1253', // ANSI Greek; Greek (Windows) + 1254 => 'windows-1254', // ANSI Turkish; Turkish (Windows) + 1255 => 'windows-1255', // ANSI Hebrew; Hebrew (Windows) + 1256 => 'windows-1256', // ANSI Arabic; Arabic (Windows) + 1257 => 'windows-1257', // ANSI Baltic; Baltic (Windows) + 1258 => 'windows-1258', // ANSI/OEM Vietnamese; Vietnamese (Windows) + 10000 => 'macintosh', // MAC Roman; Western European (Mac) + 12000 => 'UTF-32', // Unicode UTF-32, little endian byte order; available only to managed applications + 12001 => 'UTF-32BE', // Unicode UTF-32, big endian byte order; available only to managed applications + 20127 => 'US-ASCII', // US-ASCII (7-bit) + 20273 => 'IBM273', // IBM EBCDIC Germany + 20277 => 'IBM277', // IBM EBCDIC Denmark-Norway + 20278 => 'IBM278', // IBM EBCDIC Finland-Sweden + 20280 => 'IBM280', // IBM EBCDIC Italy + 20284 => 'IBM284', // IBM EBCDIC Latin America-Spain + 20285 => 'IBM285', // IBM EBCDIC United Kingdom + 20290 => 'IBM290', // IBM EBCDIC Japanese Katakana Extended + 20297 => 'IBM297', // IBM EBCDIC France + 20420 => 'IBM420', // IBM EBCDIC Arabic + 20423 => 'IBM423', // IBM EBCDIC Greek + 20424 => 'IBM424', // IBM EBCDIC Hebrew + 20838 => 'IBM-Thai', // IBM EBCDIC Thai + 20866 => 'koi8-r', // Russian (KOI8-R); Cyrillic (KOI8-R) + 20871 => 'IBM871', // IBM EBCDIC Icelandic + 20880 => 'IBM880', // IBM EBCDIC Cyrillic Russian + 20905 => 'IBM905', // IBM EBCDIC Turkish + 20924 => 'IBM00924', // IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) + 20932 => 'EUC-JP', // Japanese (JIS 0208-1990 and 0212-1990) + 20936 => 'cp20936', // Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) + 20949 => 'cp20949', // Korean Wansung + 21025 => 'cp1025', // IBM EBCDIC Cyrillic Serbian-Bulgarian + 21866 => 'koi8-u', // Ukrainian (KOI8-U); Cyrillic (KOI8-U) + 28591 => 'iso-8859-1', // ISO 8859-1 Latin 1; Western European (ISO) + 28592 => 'iso-8859-2', // ISO 8859-2 Central European; Central European (ISO) + 28593 => 'iso-8859-3', // ISO 8859-3 Latin 3 + 28594 => 'iso-8859-4', // ISO 8859-4 Baltic + 28595 => 'iso-8859-5', // ISO 8859-5 Cyrillic + 28596 => 'iso-8859-6', // ISO 8859-6 Arabic + 28597 => 'iso-8859-7', // ISO 8859-7 Greek + 28598 => 'iso-8859-8', // ISO 8859-8 Hebrew; Hebrew (ISO-Visual) + 28599 => 'iso-8859-9', // ISO 8859-9 Turkish + 28603 => 'iso-8859-13', // ISO 8859-13 Estonian + 28605 => 'iso-8859-15', // ISO 8859-15 Latin 9 + 38598 => 'iso-8859-8-i', // ISO 8859-8 Hebrew; Hebrew (ISO-Logical) + 50220 => 'iso-2022-jp', // ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) + 50221 => 'csISO2022JP', // ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) + 50222 => 'iso-2022-jp', // ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) + 50225 => 'iso-2022-kr', // ISO 2022 Korean + 51932 => 'EUC-JP', // EUC Japanese + 51936 => 'EUC-CN', // EUC Simplified Chinese; Chinese Simplified (EUC) + 51949 => 'EUC-KR', // EUC Korean + 52936 => 'hz-gb-2312', // HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) + 54936 => 'GB18030', // Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) + 65000 => 'UTF-7', + 65001 => 'UTF-8', + ); + + /** + * Catch an error and throw an exception. + * + * @param int $errno Level of the error + * @param string $errstr Error message + */ + public static function error_handler($errno, $errstr) + { + throw new ErrorException($errstr, 0, $errno); + } + + /** + * Parse and validate charset name string (see #1485758). + * Sometimes charset string is malformed, there are also charset aliases + * but we need strict names for charset conversion (specially utf8 class) + * + * @param string $input Input charset name + * + * @return string The validated charset name + */ + public static function parse_charset($input) + { + static $charsets = array(); + $charset = strtoupper($input); + + if (isset($charsets[$input])) { + return $charsets[$input]; + } + + $charset = preg_replace(array( + '/^[^0-9A-Z]+/', // e.g. _ISO-8859-JP$SIO + '/\$.*$/', // e.g. _ISO-8859-JP$SIO + '/UNICODE-1-1-*/', // RFC1641/1642 + '/^X-/', // X- prefix (e.g. X-ROMAN8 => ROMAN8) + ), '', $charset); + + if ($charset == 'BINARY') { + return $charsets[$input] = null; + } + + // allow A-Z and 0-9 only + $str = preg_replace('/[^A-Z0-9]/', '', $charset); + + if (isset(self::$aliases[$str])) { + $result = self::$aliases[$str]; + } + // UTF + else if (preg_match('/U[A-Z][A-Z](7|8|16|32)(BE|LE)*/', $str, $m)) { + $result = 'UTF-' . $m[1] . $m[2]; + } + // ISO-8859 + else if (preg_match('/ISO8859([0-9]{0,2})/', $str, $m)) { + $iso = 'ISO-8859-' . ($m[1] ?: 1); + // some clients sends windows-1252 text as latin1, + // it is safe to use windows-1252 for all latin1 + $result = $iso == 'ISO-8859-1' ? 'WINDOWS-1252' : $iso; + } + // handle broken charset names e.g. WINDOWS-1250HTTP-EQUIVCONTENT-TYPE + else if (preg_match('/(WIN|WINDOWS)([0-9]+)/', $str, $m)) { + $result = 'WINDOWS-' . $m[2]; + } + // LATIN + else if (preg_match('/LATIN(.*)/', $str, $m)) { + $aliases = array('2' => 2, '3' => 3, '4' => 4, '5' => 9, '6' => 10, + '7' => 13, '8' => 14, '9' => 15, '10' => 16, + 'ARABIC' => 6, 'CYRILLIC' => 5, 'GREEK' => 7, 'GREEK1' => 7, 'HEBREW' => 8 + ); + + // some clients sends windows-1252 text as latin1, + // it is safe to use windows-1252 for all latin1 + if ($m[1] == 1) { + $result = 'WINDOWS-1252'; + } + // if iconv is not supported we need ISO labels, it's also safe for iconv + else if (!empty($aliases[$m[1]])) { + $result = 'ISO-8859-'.$aliases[$m[1]]; + } + // iconv requires conversion of e.g. LATIN-1 to LATIN1 + else { + $result = $str; + } + } + else { + $result = $charset; + } + + $charsets[$input] = $result; + + return $result; + } + + /** + * Convert a string from one charset to another. + * Uses mbstring and iconv functions if possible + * + * @param string $str Input string + * @param string $from Suspected charset of the input string + * @param string $to Target charset to convert to; defaults to RCUBE_CHARSET + * + * @return string Converted string + */ + public static function convert($str, $from, $to = null) + { + static $iconv_options = null; + static $mbstring_sc = null; + + $to = empty($to) ? RCUBE_CHARSET : strtoupper($to); + $from = self::parse_charset($from); + + // It is a common case when UTF-16 charset is used with US-ASCII content (#1488654) + // In that case we can just skip the conversion (use UTF-8) + if ($from == 'UTF-16' && !preg_match('/[^\x00-\x7F]/', $str)) { + $from = 'UTF-8'; + } + + if ($from == $to || empty($str) || empty($from)) { + return $str; + } + + if ($iconv_options === null) { + if (function_exists('iconv')) { + // ignore characters not available in output charset + $iconv_options = '//IGNORE'; + if (iconv('', $iconv_options, '') === false) { + // iconv implementation does not support options + $iconv_options = ''; + } + } + else { + $iconv_options = false; + } + } + + // convert charset using iconv module + if ($iconv_options !== false && $from != 'UTF7-IMAP' && $to != 'UTF7-IMAP' + && $from !== 'ISO-2022-JP' + ) { + // throw an exception if iconv reports an illegal character in input + // it means that input string has been truncated + set_error_handler(array('rcube_charset', 'error_handler'), E_NOTICE); + try { + $out = iconv($from, $to . $iconv_options, $str); + } + catch (ErrorException $e) { + $out = false; + } + restore_error_handler(); + + if ($out !== false) { + return $out; + } + } + + if ($mbstring_sc === null) { + $mbstring_sc = extension_loaded('mbstring') ? mb_substitute_character() : false; + } + + // convert charset using mbstring module + if ($mbstring_sc !== false) { + $aliases = array( + 'WINDOWS-1257' => 'ISO-8859-13', + 'US-ASCII' => 'ASCII', + 'ISO-2022-JP' => 'ISO-2022-JP-MS', + ); + + $mb_from = $aliases[$from] ?: $from; + $mb_to = $aliases[$to] ?: $to; + + // Do the same as //IGNORE with iconv + mb_substitute_character('none'); + + // throw an exception if mbstring reports an illegal character in input + // using mb_check_encoding() is much slower + set_error_handler(array('rcube_charset', 'error_handler'), E_WARNING); + try { + $out = mb_convert_encoding($str, $mb_to, $mb_from); + } + catch (ErrorException $e) { + $out = false; + } + restore_error_handler(); + + mb_substitute_character($mbstring_sc); + + if ($out !== false) { + return $out; + } + } + + // convert charset using bundled classes/functions + if ($to == 'UTF-8') { + if ($from == 'UTF7-IMAP') { + if ($out = self::utf7imap_to_utf8($str)) { + return $out; + } + } + else if ($from == 'UTF-7') { + if ($out = self::utf7_to_utf8($str)) { + return $out; + } + } + } + + // encode string for output + if ($from == 'UTF-8') { + // @TODO: we need a function for UTF-7 (RFC2152) conversion + if ($to == 'UTF7-IMAP' || $to == 'UTF-7') { + if ($out = self::utf8_to_utf7imap($str)) { + return $out; + } + } + } + + if (!isset($out)) { + trigger_error("No suitable function found for '$from' to '$to' conversion"); + } + + // return original string + return $str; + } + + /** + * Converts string from standard UTF-7 (RFC 2152) to UTF-8. + * + * @param string $str Input string (UTF-7) + * + * @return string Converted string (UTF-8) + */ + public static function utf7_to_utf8($str) + { + $Index_64 = array( + 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, + 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, + 0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0, + 1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0, + 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, + 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0, + 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, + 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0, + ); + + $u7len = strlen($str); + $str = strval($str); + $res = ''; + + for ($i=0; $u7len > 0; $i++, $u7len--) { + $u7 = $str[$i]; + if ($u7 == '+') { + $i++; + $u7len--; + $ch = ''; + + for (; $u7len > 0; $i++, $u7len--) { + $u7 = $str[$i]; + + if (!$Index_64[ord($u7)]) { + break; + } + + $ch .= $u7; + } + + if ($ch == '') { + if ($u7 == '-') { + $res .= '+'; + } + + continue; + } + + $res .= self::utf16_to_utf8(base64_decode($ch)); + } + else { + $res .= $u7; + } + } + + return $res; + } + + /** + * Converts string from UTF-16 to UTF-8 (helper for utf-7 to utf-8 conversion) + * + * @param string $str Input string + * + * @return string The converted string + */ + public static function utf16_to_utf8($str) + { + $len = strlen($str); + $dec = ''; + + for ($i = 0; $i < $len; $i += 2) { + $c = ord($str[$i]) << 8 | ord($str[$i + 1]); + if ($c >= 0x0001 && $c <= 0x007F) { + $dec .= chr($c); + } + else if ($c > 0x07FF) { + $dec .= chr(0xE0 | (($c >> 12) & 0x0F)); + $dec .= chr(0x80 | (($c >> 6) & 0x3F)); + $dec .= chr(0x80 | (($c >> 0) & 0x3F)); + } + else { + $dec .= chr(0xC0 | (($c >> 6) & 0x1F)); + $dec .= chr(0x80 | (($c >> 0) & 0x3F)); + } + } + + return $dec; + } + + /** + * Convert the data ($str) from RFC 2060's UTF-7 to UTF-8. + * If input data is invalid, return the original input string. + * RFC 2060 obviously intends the encoding to be unique (see + * point 5 in section 5.1.3), so we reject any non-canonical + * form, such as &ACY- (instead of &-) or &AMA-&AMA- (instead + * of &AMAAwA-). + * + * Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com> + * + * @param string $str Input string (UTF7-IMAP) + * + * @return string Output string (UTF-8) + */ + public static function utf7imap_to_utf8($str) + { + $Index_64 = array( + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, 63,-1,-1,-1, + 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1, + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14, + 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1, + -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40, + 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1 + ); + + $u7len = strlen($str); + $str = strval($str); + $p = ''; + $err = ''; + + for ($i=0; $u7len > 0; $i++, $u7len--) { + $u7 = $str[$i]; + if ($u7 == '&') { + $i++; + $u7len--; + $u7 = $str[$i]; + + if ($u7len && $u7 == '-') { + $p .= '&'; + continue; + } + + $ch = 0; + $k = 10; + for (; $u7len > 0; $i++, $u7len--) { + $u7 = $str[$i]; + + if ((ord($u7) & 0x80) || ($b = $Index_64[ord($u7)]) == -1) { + break; + } + + if ($k > 0) { + $ch |= $b << $k; + $k -= 6; + } + else { + $ch |= $b >> (-$k); + if ($ch < 0x80) { + // Printable US-ASCII + if (0x20 <= $ch && $ch < 0x7f) { + return $err; + } + $p .= chr($ch); + } + else if ($ch < 0x800) { + $p .= chr(0xc0 | ($ch >> 6)); + $p .= chr(0x80 | ($ch & 0x3f)); + } + else { + $p .= chr(0xe0 | ($ch >> 12)); + $p .= chr(0x80 | (($ch >> 6) & 0x3f)); + $p .= chr(0x80 | ($ch & 0x3f)); + } + + $ch = ($b << (16 + $k)) & 0xffff; + $k += 10; + } + } + + // Non-zero or too many extra bits + if ($ch || $k < 6) { + return $err; + } + + // BASE64 not properly terminated + if (!$u7len || $u7 != '-') { + return $err; + } + + // Adjacent BASE64 sections + if ($u7len > 2 && $str[$i+1] == '&' && $str[$i+2] != '-') { + return $err; + } + } + // Not printable US-ASCII + else if (ord($u7) < 0x20 || ord($u7) >= 0x7f) { + return $err; + } + else { + $p .= $u7; + } + } + + return $p; + } + + /** + * Convert the data ($str) from UTF-8 to RFC 2060's UTF-7. + * Unicode characters above U+FFFF are replaced by U+FFFE. + * If input data is invalid, return an empty string. + * + * Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com> + * + * @param string $str Input string (UTF-8) + * + * @return string Output string (UTF7-IMAP) + */ + public static function utf8_to_utf7imap($str) + { + $B64Chars = array( + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', + 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', + 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', '+', ',' + ); + + $u8len = strlen($str); + $base64 = 0; + $i = 0; + $p = ''; + $err = ''; + + while ($u8len) { + $u8 = $str[$i]; + $c = ord($u8); + + if ($c < 0x80) { + $ch = $c; + $n = 0; + } + else if ($c < 0xc2) { + return $err; + } + else if ($c < 0xe0) { + $ch = $c & 0x1f; + $n = 1; + } + else if ($c < 0xf0) { + $ch = $c & 0x0f; + $n = 2; + } + else if ($c < 0xf8) { + $ch = $c & 0x07; + $n = 3; + } + else if ($c < 0xfc) { + $ch = $c & 0x03; + $n = 4; + } + else if ($c < 0xfe) { + $ch = $c & 0x01; + $n = 5; + } + else { + return $err; + } + + $i++; + $u8len--; + + if ($n > $u8len) { + return $err; + } + + for ($j=0; $j < $n; $j++) { + $o = ord($str[$i+$j]); + if (($o & 0xc0) != 0x80) { + return $err; + } + $ch = ($ch << 6) | ($o & 0x3f); + } + + if ($n > 1 && !($ch >> ($n * 5 + 1))) { + return $err; + } + + $i += $n; + $u8len -= $n; + + if ($ch < 0x20 || $ch >= 0x7f) { + if (!$base64) { + $p .= '&'; + $base64 = 1; + $b = 0; + $k = 10; + } + if ($ch & ~0xffff) { + $ch = 0xfffe; + } + + $p .= $B64Chars[($b | $ch >> $k)]; + $k -= 6; + for (; $k >= 0; $k -= 6) { + $p .= $B64Chars[(($ch >> $k) & 0x3f)]; + } + + $b = ($ch << (-$k)) & 0x3f; + $k += 16; + } + else { + if ($base64) { + if ($k > 10) { + $p .= $B64Chars[$b]; + } + $p .= '-'; + $base64 = 0; + } + + $p .= chr($ch); + if (chr($ch) == '&') { + $p .= '-'; + } + } + } + + if ($base64) { + if ($k > 10) { + $p .= $B64Chars[$b]; + } + $p .= '-'; + } + + return $p; + } + + /** + * A method to guess character set of a string. + * + * @param string $string String + * @param string $failover Default result for failover + * @param string $language User language + * + * @return string Charset name + */ + public static function detect($string, $failover = null, $language = null) + { + if (substr($string, 0, 4) == "\0\0\xFE\xFF") return 'UTF-32BE'; // Big Endian + if (substr($string, 0, 4) == "\xFF\xFE\0\0") return 'UTF-32LE'; // Little Endian + if (substr($string, 0, 2) == "\xFE\xFF") return 'UTF-16BE'; // Big Endian + if (substr($string, 0, 2) == "\xFF\xFE") return 'UTF-16LE'; // Little Endian + if (substr($string, 0, 3) == "\xEF\xBB\xBF") return 'UTF-8'; + + // heuristics + if ($string[0] == "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-32BE'; + if ($string[0] != "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] == "\0") return 'UTF-32LE'; + if ($string[0] == "\0" && $string[1] != "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-16BE'; + if ($string[0] != "\0" && $string[1] == "\0" && $string[2] != "\0" && $string[3] == "\0") return 'UTF-16LE'; + + if (empty($language)) { + $rcube = rcube::get_instance(); + $language = $rcube->get_user_language(); + } + + // Prioritize charsets according to current language (#1485669) + switch ($language) { + case 'ja_JP': + $prio = array('ISO-2022-JP', 'JIS', 'UTF-8', 'EUC-JP', 'eucJP-win', 'SJIS', 'SJIS-win'); + break; + + case 'zh_CN': + case 'zh_TW': + $prio = array('UTF-8', 'BIG-5', 'GB2312', 'EUC-TW'); + break; + + case 'ko_KR': + $prio = array('UTF-8', 'EUC-KR', 'ISO-2022-KR'); + break; + + case 'ru_RU': + $prio = array('UTF-8', 'WINDOWS-1251', 'KOI8-R'); + break; + + case 'tr_TR': + $prio = array('UTF-8', 'ISO-8859-9', 'WINDOWS-1254'); + break; + } + + // mb_detect_encoding() is not reliable for some charsets (#1490135) + // use mb_check_encoding() to make charset priority lists really working + if ($prio && function_exists('mb_check_encoding')) { + foreach ($prio as $encoding) { + if (mb_check_encoding($string, $encoding)) { + return $encoding; + } + } + } + + if (function_exists('mb_detect_encoding')) { + if (!$prio) { + $prio = array('UTF-8', 'SJIS', 'GB2312', + 'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4', + 'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9', + 'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16', + 'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R', 'BIG-5', + 'ISO-2022-KR', 'ISO-2022-JP', + ); + } + + $encodings = array_unique(array_merge($prio, mb_list_encodings())); + + if ($encoding = mb_detect_encoding($string, $encodings)) { + return $encoding; + } + } + + // No match, check for UTF-8 + // from http://w3.org/International/questions/qa-forms-utf-8.html + if (preg_match('/\A( + [\x09\x0A\x0D\x20-\x7E] + | [\xC2-\xDF][\x80-\xBF] + | \xE0[\xA0-\xBF][\x80-\xBF] + | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} + | \xED[\x80-\x9F][\x80-\xBF] + | \xF0[\x90-\xBF][\x80-\xBF]{2} + | [\xF1-\xF3][\x80-\xBF]{3} + | \xF4[\x80-\x8F][\x80-\xBF]{2} + )*\z/xs', substr($string, 0, 2048)) + ) { + return 'UTF-8'; + } + + return $failover; + } + + /** + * Removes non-unicode characters from input. + * + * @param mixed $input String or array. + * + * @return mixed String or array + */ + public static function clean($input) + { + // handle input of type array + if (is_array($input)) { + foreach ($input as $idx => $val) { + $input[$idx] = self::clean($val); + } + return $input; + } + + if (!is_string($input) || $input == '') { + return $input; + } + + // iconv/mbstring are much faster (especially with long strings) + if (function_exists('mb_convert_encoding')) { + $msch = mb_substitute_character(); + mb_substitute_character('none'); + $res = mb_convert_encoding($input, 'UTF-8', 'UTF-8'); + mb_substitute_character($msch); + + if ($res !== false) { + return $res; + } + } + + if (function_exists('iconv')) { + if (($res = @iconv('UTF-8', 'UTF-8//IGNORE', $input)) !== false) { + return $res; + } + } + + $seq = ''; + $out = ''; + $regexp = '/^('. +// '[\x00-\x7F]'. // UTF8-1 + '|[\xC2-\xDF][\x80-\xBF]'. // UTF8-2 + '|\xE0[\xA0-\xBF][\x80-\xBF]'. // UTF8-3 + '|[\xE1-\xEC][\x80-\xBF][\x80-\xBF]'. // UTF8-3 + '|\xED[\x80-\x9F][\x80-\xBF]'. // UTF8-3 + '|[\xEE-\xEF][\x80-\xBF][\x80-\xBF]'. // UTF8-3 + '|\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF]'. // UTF8-4 + '|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]'.// UTF8-4 + '|\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF]'. // UTF8-4 + ')$/'; + + for ($i = 0, $len = strlen($input); $i < $len; $i++) { + $chr = $input[$i]; + $ord = ord($chr); + + // 1-byte character + if ($ord <= 0x7F) { + if ($seq !== '') { + $out .= preg_match($regexp, $seq) ? $seq : ''; + $seq = ''; + } + + $out .= $chr; + } + // first byte of multibyte sequence + else if ($ord >= 0xC0) { + if ($seq !== '') { + $out .= preg_match($regexp, $seq) ? $seq : ''; + $seq = ''; + } + + $seq = $chr; + } + // next byte of multibyte sequence + else if ($seq !== '') { + $seq .= $chr; + } + } + + if ($seq !== '') { + $out .= preg_match($regexp, $seq) ? $seq : ''; + } + + return $out; + } +}