API tools faq
paste
Guest User

Untitled

a guest
Apr 2nd, 2019
221
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 33.82 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2.  
  3. /**
  4.  +-----------------------------------------------------------------------+
  5.  | This file is part of the Roundcube Webmail client                     |
  6.  | Copyright (C) 2005-2012, The Roundcube Dev Team                       |
  7.  | Copyright (C) 2011-2012, Kolab Systems AG                             |
  8.  | Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org>            |
  9.  |                                                                       |
  10.  | Licensed under the GNU General Public License version 3 or            |
  11.  | any later version with exceptions for skins & plugins.                |
  12.  | See the README file for a full license statement.                     |
  13.  |                                                                       |
  14.  | PURPOSE:                                                              |
  15.  |   Provide charset conversion functionality                            |
  16.  +-----------------------------------------------------------------------+
  17.  | Author: Thomas Bruederli <roundcube@gmail.com>                        |
  18.  | Author: Aleksander Machniak <alec@alec.pl>                            |
  19.  +-----------------------------------------------------------------------+
  20. */
  21.  
  22. /**
  23.  * Character sets conversion functionality
  24.  *
  25.  * @package    Framework
  26.  * @subpackage Core
  27.  * @author     Thomas Bruederli <roundcube@gmail.com>
  28.  * @author     Aleksander Machniak <alec@alec.pl>
  29.  * @author     Edmund Grimley Evans <edmundo@rano.org>
  30.  */
  31. class rcube_charset
  32. {
  33.     // Aliases: some of them from HTML5 spec.
  34.     static public $aliases = array(
  35.         'USASCII'       => 'WINDOWS-1252',
  36.         'ANSIX31101983' => 'WINDOWS-1252',
  37.         'ANSIX341968'   => 'WINDOWS-1252',
  38.         'UNKNOWN8BIT'   => 'ISO-8859-15',
  39.         'UNKNOWN'       => 'ISO-8859-15',
  40.         'USERDEFINED'   => 'ISO-8859-15',
  41.         'KSC56011987'   => 'EUC-KR',
  42.         'GB2312'        => 'GBK',
  43.         'GB231280'      => 'GBK',
  44.         'UNICODE'       => 'UTF-8',
  45.         'UTF7IMAP'      => 'UTF7-IMAP',
  46.         'TIS620'        => 'WINDOWS-874',
  47.         'ISO88599'      => 'WINDOWS-1254',
  48.         'ISO885911'     => 'WINDOWS-874',
  49.         'MACROMAN'      => 'MACINTOSH',
  50.         '77'            => 'MAC',
  51.         '128'           => 'SHIFT-JIS',
  52.         '129'           => 'CP949',
  53.         '130'           => 'CP1361',
  54.         '134'           => 'GBK',
  55.         '136'           => 'BIG5',
  56.         '161'           => 'WINDOWS-1253',
  57.         '162'           => 'WINDOWS-1254',
  58.         '163'           => 'WINDOWS-1258',
  59.         '177'           => 'WINDOWS-1255',
  60.         '178'           => 'WINDOWS-1256',
  61.         '186'           => 'WINDOWS-1257',
  62.         '204'           => 'WINDOWS-1251',
  63.         '222'           => 'WINDOWS-874',
  64.         '238'           => 'WINDOWS-1250',
  65.         'MS950'         => 'CP950',
  66.         'WINDOWS949'    => 'UHC',
  67.     );
  68.  
  69.     /**
  70.      * Windows codepages
  71.      *
  72.      * @var array
  73.      */
  74.     static public $windows_codepages = array(
  75.          37 => 'IBM037',    // IBM EBCDIC US-Canada
  76.         437 => 'IBM437',    // OEM United States
  77.         500 => 'IBM500',    // IBM EBCDIC International
  78.         708 => 'ASMO-708',  // Arabic (ASMO 708)
  79.         720 => 'DOS-720',   // Arabic (Transparent ASMO); Arabic (DOS)
  80.         737 => 'IBM737',    // OEM Greek (formerly 437G); Greek (DOS)
  81.         775 => 'IBM775',    // OEM Baltic; Baltic (DOS)
  82.         850 => 'IBM850',    // OEM Multilingual Latin 1; Western European (DOS)
  83.         852 => 'IBM852',    // OEM Latin 2; Central European (DOS)
  84.         855 => 'IBM855',    // OEM Cyrillic (primarily Russian)
  85.         857 => 'IBM857',    // OEM Turkish; Turkish (DOS)
  86.         858 => 'IBM00858',  // OEM Multilingual Latin 1 + Euro symbol
  87.         860 => 'IBM860',    // OEM Portuguese; Portuguese (DOS)
  88.         861 => 'IBM861',    // OEM Icelandic; Icelandic (DOS)
  89.         862 => 'DOS-862',   // OEM Hebrew; Hebrew (DOS)
  90.         863 => 'IBM863',    // OEM French Canadian; French Canadian (DOS)
  91.         864 => 'IBM864',    // OEM Arabic; Arabic (864)
  92.         865 => 'IBM865',    // OEM Nordic; Nordic (DOS)
  93.         866 => 'cp866',     // OEM Russian; Cyrillic (DOS)
  94.         869 => 'IBM869',    // OEM Modern Greek; Greek, Modern (DOS)
  95.         870 => 'IBM870',    // IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2
  96.         874 => 'windows-874',  // ANSI/OEM Thai (ISO 8859-11); Thai (Windows)
  97.         875 => 'cp875',     // IBM EBCDIC Greek Modern
  98.         932 => 'shift_jis', // ANSI/OEM Japanese; Japanese (Shift-JIS)
  99.         936 => 'gb2312',    // ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
  100.         950 => 'big5',      // ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5)
  101.         1026 => 'IBM1026',      // IBM EBCDIC Turkish (Latin 5)
  102.         1047 => 'IBM01047',     // IBM EBCDIC Latin 1/Open System
  103.         1140 => 'IBM01140',     // IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro)
  104.         1141 => 'IBM01141',     // IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro)
  105.         1142 => 'IBM01142',     // IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro)
  106.         1143 => 'IBM01143',     // IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro)
  107.         1144 => 'IBM01144',     // IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro)
  108.         1145 => 'IBM01145',     // IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro)
  109.         1146 => 'IBM01146',     // IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro)
  110.         1147 => 'IBM01147',     // IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro)
  111.         1148 => 'IBM01148',     // IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro)
  112.         1149 => 'IBM01149',     // IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro)
  113.         1200 => 'UTF-16',       // Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications
  114.         1201 => 'UTF-16BE',     // Unicode UTF-16, big endian byte order; available only to managed applications
  115.         1250 => 'windows-1250', // ANSI Central European; Central European (Windows)
  116.         1251 => 'windows-1251', // ANSI Cyrillic; Cyrillic (Windows)
  117.         1252 => 'windows-1252', // ANSI Latin 1; Western European (Windows)
  118.         1253 => 'windows-1253', // ANSI Greek; Greek (Windows)
  119.         1254 => 'windows-1254', // ANSI Turkish; Turkish (Windows)
  120.         1255 => 'windows-1255', // ANSI Hebrew; Hebrew (Windows)
  121.         1256 => 'windows-1256', // ANSI Arabic; Arabic (Windows)
  122.         1257 => 'windows-1257', // ANSI Baltic; Baltic (Windows)
  123.         1258 => 'windows-1258', // ANSI/OEM Vietnamese; Vietnamese (Windows)
  124.         10000 => 'macintosh',   // MAC Roman; Western European (Mac)
  125.         12000 => 'UTF-32',      // Unicode UTF-32, little endian byte order; available only to managed applications
  126.         12001 => 'UTF-32BE',    // Unicode UTF-32, big endian byte order; available only to managed applications
  127.         20127 => 'US-ASCII',    // US-ASCII (7-bit)
  128.         20273 => 'IBM273',      // IBM EBCDIC Germany
  129.         20277 => 'IBM277',      // IBM EBCDIC Denmark-Norway
  130.         20278 => 'IBM278',      // IBM EBCDIC Finland-Sweden
  131.         20280 => 'IBM280',      // IBM EBCDIC Italy
  132.         20284 => 'IBM284',      // IBM EBCDIC Latin America-Spain
  133.         20285 => 'IBM285',      // IBM EBCDIC United Kingdom
  134.         20290 => 'IBM290',      // IBM EBCDIC Japanese Katakana Extended
  135.         20297 => 'IBM297',      // IBM EBCDIC France
  136.         20420 => 'IBM420',      // IBM EBCDIC Arabic
  137.         20423 => 'IBM423',      // IBM EBCDIC Greek
  138.         20424 => 'IBM424',      // IBM EBCDIC Hebrew
  139.         20838 => 'IBM-Thai',    // IBM EBCDIC Thai
  140.         20866 => 'koi8-r',      // Russian (KOI8-R); Cyrillic (KOI8-R)
  141.         20871 => 'IBM871',      // IBM EBCDIC Icelandic
  142.         20880 => 'IBM880',      // IBM EBCDIC Cyrillic Russian
  143.         20905 => 'IBM905',      // IBM EBCDIC Turkish
  144.         20924 => 'IBM00924',    // IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)
  145.         20932 => 'EUC-JP',      // Japanese (JIS 0208-1990 and 0212-1990)
  146.         20936 => 'cp20936',     // Simplified Chinese (GB2312); Chinese Simplified (GB2312-80)
  147.         20949 => 'cp20949',     // Korean Wansung
  148.         21025 => 'cp1025',      // IBM EBCDIC Cyrillic Serbian-Bulgarian
  149.         21866 => 'koi8-u',      // Ukrainian (KOI8-U); Cyrillic (KOI8-U)
  150.         28591 => 'iso-8859-1',  // ISO 8859-1 Latin 1; Western European (ISO)
  151.         28592 => 'iso-8859-2',  // ISO 8859-2 Central European; Central European (ISO)
  152.         28593 => 'iso-8859-3',  // ISO 8859-3 Latin 3
  153.         28594 => 'iso-8859-4',  // ISO 8859-4 Baltic
  154.         28595 => 'iso-8859-5',  // ISO 8859-5 Cyrillic
  155.         28596 => 'iso-8859-6',  // ISO 8859-6 Arabic
  156.         28597 => 'iso-8859-7',  // ISO 8859-7 Greek
  157.         28598 => 'iso-8859-8',  // ISO 8859-8 Hebrew; Hebrew (ISO-Visual)
  158.         28599 => 'iso-8859-9',  // ISO 8859-9 Turkish
  159.         28603 => 'iso-8859-13', // ISO 8859-13 Estonian
  160.         28605 => 'iso-8859-15', // ISO 8859-15 Latin 9
  161.         38598 => 'iso-8859-8-i', // ISO 8859-8 Hebrew; Hebrew (ISO-Logical)
  162.         50220 => 'iso-2022-jp', // ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
  163.         50221 => 'csISO2022JP', // ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana)
  164.         50222 => 'iso-2022-jp', // ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI)
  165.         50225 => 'iso-2022-kr', // ISO 2022 Korean
  166.         51932 => 'EUC-JP',      // EUC Japanese
  167.         51936 => 'EUC-CN',      // EUC Simplified Chinese; Chinese Simplified (EUC)
  168.         51949 => 'EUC-KR',      // EUC Korean
  169.         52936 => 'hz-gb-2312',  // HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)
  170.         54936 => 'GB18030',     // Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030)
  171.         65000 => 'UTF-7',
  172.         65001 => 'UTF-8',
  173.     );
  174.  
  175.     /**
  176.      * Catch an error and throw an exception.
  177.      *
  178.      * @param int    $errno  Level of the error
  179.      * @param string $errstr Error message
  180.      */
  181.     public static function error_handler($errno, $errstr)
  182.     {
  183.         throw new ErrorException($errstr, 0, $errno);
  184.     }
  185.  
  186.     /**
  187.      * Parse and validate charset name string (see #1485758).
  188.      * Sometimes charset string is malformed, there are also charset aliases
  189.      * but we need strict names for charset conversion (specially utf8 class)
  190.      *
  191.      * @param string $input Input charset name
  192.      *
  193.      * @return string The validated charset name
  194.      */
  195.     public static function parse_charset($input)
  196.     {
  197.         static $charsets = array();
  198.         $charset = strtoupper($input);
  199.  
  200.         if (isset($charsets[$input])) {
  201.             return $charsets[$input];
  202.         }
  203.  
  204.         $charset = preg_replace(array(
  205.             '/^[^0-9A-Z]+/',    // e.g. _ISO-8859-JP$SIO
  206.             '/\$.*$/',          // e.g. _ISO-8859-JP$SIO
  207.             '/UNICODE-1-1-*/',  // RFC1641/1642
  208.             '/^X-/',            // X- prefix (e.g. X-ROMAN8 => ROMAN8)
  209.         ), '', $charset);
  210.  
  211.         if ($charset == 'BINARY') {
  212.             return $charsets[$input] = null;
  213.         }
  214.  
  215.         // allow A-Z and 0-9 only
  216.         $str = preg_replace('/[^A-Z0-9]/', '', $charset);
  217.  
  218.         if (isset(self::$aliases[$str])) {
  219.             $result = self::$aliases[$str];
  220.         }
  221.         // UTF
  222.         else if (preg_match('/U[A-Z][A-Z](7|8|16|32)(BE|LE)*/', $str, $m)) {
  223.             $result = 'UTF-' . $m[1] . $m[2];
  224.         }
  225.         // ISO-8859
  226.         else if (preg_match('/ISO8859([0-9]{0,2})/', $str, $m)) {
  227.             $iso = 'ISO-8859-' . ($m[1] ?: 1);
  228.             // some clients sends windows-1252 text as latin1,
  229.             // it is safe to use windows-1252 for all latin1
  230.             $result = $iso == 'ISO-8859-1' ? 'WINDOWS-1252' : $iso;
  231.         }
  232.         // handle broken charset names e.g. WINDOWS-1250HTTP-EQUIVCONTENT-TYPE
  233.         else if (preg_match('/(WIN|WINDOWS)([0-9]+)/', $str, $m)) {
  234.             $result = 'WINDOWS-' . $m[2];
  235.         }
  236.         // LATIN
  237.         else if (preg_match('/LATIN(.*)/', $str, $m)) {
  238.             $aliases = array('2' => 2, '3' => 3, '4' => 4, '5' => 9, '6' => 10,
  239.                 '7' => 13, '8' => 14, '9' => 15, '10' => 16,
  240.                 'ARABIC' => 6, 'CYRILLIC' => 5, 'GREEK' => 7, 'GREEK1' => 7, 'HEBREW' => 8
  241.             );
  242.  
  243.             // some clients sends windows-1252 text as latin1,
  244.             // it is safe to use windows-1252 for all latin1
  245.             if ($m[1] == 1) {
  246.                 $result = 'WINDOWS-1252';
  247.             }
  248.             // if iconv is not supported we need ISO labels, it's also safe for iconv
  249.             else if (!empty($aliases[$m[1]])) {
  250.                 $result = 'ISO-8859-'.$aliases[$m[1]];
  251.             }
  252.             // iconv requires conversion of e.g. LATIN-1 to LATIN1
  253.             else {
  254.                 $result = $str;
  255.             }
  256.         }
  257.         else {
  258.             $result = $charset;
  259.         }
  260.  
  261.         $charsets[$input] = $result;
  262.  
  263.         return $result;
  264.     }
  265.  
  266.     /**
  267.      * Convert a string from one charset to another.
  268.      * Uses mbstring and iconv functions if possible
  269.      *
  270.      * @param string $str  Input string
  271.      * @param string $from Suspected charset of the input string
  272.      * @param string $to   Target charset to convert to; defaults to RCUBE_CHARSET
  273.      *
  274.      * @return string Converted string
  275.      */
  276.     public static function convert($str, $from, $to = null)
  277.     {
  278.         static $iconv_options = null;
  279.         static $mbstring_sc   = null;
  280.  
  281.         $to   = empty($to) ? RCUBE_CHARSET : strtoupper($to);
  282.         $from = self::parse_charset($from);
  283.  
  284.         // It is a common case when UTF-16 charset is used with US-ASCII content (#1488654)
  285.         // In that case we can just skip the conversion (use UTF-8)
  286.         if ($from == 'UTF-16' && !preg_match('/[^\x00-\x7F]/', $str)) {
  287.             $from = 'UTF-8';
  288.         }
  289.  
  290.         if ($from == $to || empty($str) || empty($from)) {
  291.             return $str;
  292.         }
  293.  
  294.         if ($iconv_options === null) {
  295.             if (function_exists('iconv')) {
  296.                 // ignore characters not available in output charset
  297.                 $iconv_options = '//IGNORE';
  298.                 if (iconv('', $iconv_options, '') === false) {
  299.                     // iconv implementation does not support options
  300.                     $iconv_options = '';
  301.                 }
  302.             }
  303.             else {
  304.                 $iconv_options = false;
  305.             }
  306.         }
  307.  
  308.         // convert charset using iconv module
  309.         if ($iconv_options !== false && $from != 'UTF7-IMAP' && $to != 'UTF7-IMAP'
  310.             && $from !== 'ISO-2022-JP'
  311.         ) {
  312.             // throw an exception if iconv reports an illegal character in input
  313.             // it means that input string has been truncated
  314.             set_error_handler(array('rcube_charset', 'error_handler'), E_NOTICE);
  315.             try {
  316.                 $out = iconv($from, $to . $iconv_options, $str);
  317.             }
  318.             catch (ErrorException $e) {
  319.                 $out = false;
  320.             }
  321.             restore_error_handler();
  322.  
  323.             if ($out !== false) {
  324.                 return $out;
  325.             }
  326.         }
  327.  
  328.         if ($mbstring_sc === null) {
  329.             $mbstring_sc = extension_loaded('mbstring') ? mb_substitute_character() : false;
  330.         }
  331.  
  332.         // convert charset using mbstring module
  333.         if ($mbstring_sc !== false) {
  334.             $aliases = array(
  335.                 'WINDOWS-1257' => 'ISO-8859-13',
  336.                 'US-ASCII'     => 'ASCII',
  337.                 'ISO-2022-JP'  => 'ISO-2022-JP-MS',
  338.             );
  339.  
  340.             $mb_from = $aliases[$from] ?: $from;
  341.             $mb_to   = $aliases[$to] ?: $to;
  342.  
  343.             // Do the same as //IGNORE with iconv
  344.             mb_substitute_character('none');
  345.  
  346.             // throw an exception if mbstring reports an illegal character in input
  347.             // using mb_check_encoding() is much slower
  348.             set_error_handler(array('rcube_charset', 'error_handler'), E_WARNING);
  349.             try {
  350.                 $out = mb_convert_encoding($str, $mb_to, $mb_from);
  351.             }
  352.             catch (ErrorException $e) {
  353.                 $out = false;
  354.             }
  355.             restore_error_handler();
  356.  
  357.             mb_substitute_character($mbstring_sc);
  358.  
  359.             if ($out !== false) {
  360.                 return $out;
  361.             }
  362.         }
  363.  
  364.         // convert charset using bundled classes/functions
  365.         if ($to == 'UTF-8') {
  366.             if ($from == 'UTF7-IMAP') {
  367.                 if ($out = self::utf7imap_to_utf8($str)) {
  368.                     return $out;
  369.                 }
  370.             }
  371.             else if ($from == 'UTF-7') {
  372.                 if ($out = self::utf7_to_utf8($str)) {
  373.                     return $out;
  374.                 }
  375.             }
  376.         }
  377.  
  378.         // encode string for output
  379.         if ($from == 'UTF-8') {
  380.             // @TODO: we need a function for UTF-7 (RFC2152) conversion
  381.             if ($to == 'UTF7-IMAP' || $to == 'UTF-7') {
  382.                 if ($out = self::utf8_to_utf7imap($str)) {
  383.                     return $out;
  384.                 }
  385.             }
  386.         }
  387.  
  388.         if (!isset($out)) {
  389.             trigger_error("No suitable function found for '$from' to '$to' conversion");
  390.         }
  391.  
  392.         // return original string
  393.         return $str;
  394.     }
  395.  
  396.     /**
  397.      * Converts string from standard UTF-7 (RFC 2152) to UTF-8.
  398.      *
  399.      * @param string $str Input string (UTF-7)
  400.      *
  401.      * @return string Converted string (UTF-8)
  402.      */
  403.     public static function utf7_to_utf8($str)
  404.     {
  405.         $Index_64 = array(
  406.             0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  407.             0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  408.             0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0,
  409.             1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0,
  410.             0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
  411.             1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
  412.             0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
  413.             1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
  414.         );
  415.  
  416.         $u7len = strlen($str);
  417.         $str   = strval($str);
  418.         $res   = '';
  419.  
  420.         for ($i=0; $u7len > 0; $i++, $u7len--) {
  421.             $u7 = $str[$i];
  422.             if ($u7 == '+') {
  423.                 $i++;
  424.                 $u7len--;
  425.                 $ch = '';
  426.  
  427.                 for (; $u7len > 0; $i++, $u7len--) {
  428.                     $u7 = $str[$i];
  429.  
  430.                     if (!$Index_64[ord($u7)]) {
  431.                         break;
  432.                     }
  433.  
  434.                     $ch .= $u7;
  435.                 }
  436.  
  437.                 if ($ch == '') {
  438.                     if ($u7 == '-') {
  439.                         $res .= '+';
  440.                     }
  441.  
  442.                     continue;
  443.                 }
  444.  
  445.                 $res .= self::utf16_to_utf8(base64_decode($ch));
  446.             }
  447.             else {
  448.                 $res .= $u7;
  449.             }
  450.         }
  451.  
  452.         return $res;
  453.     }
  454.  
  455.     /**
  456.      * Converts string from UTF-16 to UTF-8 (helper for utf-7 to utf-8 conversion)
  457.      *
  458.      * @param string $str Input string
  459.      *
  460.      * @return string The converted string
  461.      */
  462.     public static function utf16_to_utf8($str)
  463.     {
  464.         $len = strlen($str);
  465.         $dec = '';
  466.  
  467.         for ($i = 0; $i < $len; $i += 2) {
  468.             $c = ord($str[$i]) << 8 | ord($str[$i + 1]);
  469.             if ($c >= 0x0001 && $c <= 0x007F) {
  470.                 $dec .= chr($c);
  471.             }
  472.             else if ($c > 0x07FF) {
  473.                 $dec .= chr(0xE0 | (($c >> 12) & 0x0F));
  474.                 $dec .= chr(0x80 | (($c >>  6) & 0x3F));
  475.                 $dec .= chr(0x80 | (($c >>  0) & 0x3F));
  476.             }
  477.             else {
  478.                 $dec .= chr(0xC0 | (($c >>  6) & 0x1F));
  479.                 $dec .= chr(0x80 | (($c >>  0) & 0x3F));
  480.             }
  481.         }
  482.  
  483.         return $dec;
  484.     }
  485.  
  486.     /**
  487.      * Convert the data ($str) from RFC 2060's UTF-7 to UTF-8.
  488.      * If input data is invalid, return the original input string.
  489.      * RFC 2060 obviously intends the encoding to be unique (see
  490.      * point 5 in section 5.1.3), so we reject any non-canonical
  491.      * form, such as &ACY- (instead of &-) or &AMA-&AMA- (instead
  492.      * of &AMAAwA-).
  493.      *
  494.      * Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com>
  495.      *
  496.      * @param string $str Input string (UTF7-IMAP)
  497.      *
  498.      * @return string Output string (UTF-8)
  499.      */
  500.     public static function utf7imap_to_utf8($str)
  501.     {
  502.         $Index_64 = array(
  503.             -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  504.             -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  505.             -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, 63,-1,-1,-1,
  506.             52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
  507.             -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  508.             15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
  509.             -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  510.             41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
  511.         );
  512.  
  513.         $u7len = strlen($str);
  514.         $str   = strval($str);
  515.         $p     = '';
  516.         $err   = '';
  517.  
  518.         for ($i=0; $u7len > 0; $i++, $u7len--) {
  519.             $u7 = $str[$i];
  520.             if ($u7 == '&') {
  521.                 $i++;
  522.                 $u7len--;
  523.                 $u7 = $str[$i];
  524.  
  525.                 if ($u7len && $u7 == '-') {
  526.                     $p .= '&';
  527.                     continue;
  528.                 }
  529.  
  530.                 $ch = 0;
  531.                 $k = 10;
  532.                 for (; $u7len > 0; $i++, $u7len--) {
  533.                     $u7 = $str[$i];
  534.  
  535.                     if ((ord($u7) & 0x80) || ($b = $Index_64[ord($u7)]) == -1) {
  536.                         break;
  537.                     }
  538.  
  539.                     if ($k > 0) {
  540.                         $ch |= $b << $k;
  541.                         $k -= 6;
  542.                     }
  543.                     else {
  544.                         $ch |= $b >> (-$k);
  545.                         if ($ch < 0x80) {
  546.                             // Printable US-ASCII
  547.                             if (0x20 <= $ch && $ch < 0x7f) {
  548.                                 return $err;
  549.                             }
  550.                             $p .= chr($ch);
  551.                         }
  552.                         else if ($ch < 0x800) {
  553.                             $p .= chr(0xc0 | ($ch >> 6));
  554.                             $p .= chr(0x80 | ($ch & 0x3f));
  555.                         }
  556.                         else {
  557.                             $p .= chr(0xe0 | ($ch >> 12));
  558.                             $p .= chr(0x80 | (($ch >> 6) & 0x3f));
  559.                             $p .= chr(0x80 | ($ch & 0x3f));
  560.                         }
  561.  
  562.                         $ch = ($b << (16 + $k)) & 0xffff;
  563.                         $k += 10;
  564.                     }
  565.                 }
  566.  
  567.                 // Non-zero or too many extra bits
  568.                 if ($ch || $k < 6) {
  569.                     return $err;
  570.                 }
  571.  
  572.                 // BASE64 not properly terminated
  573.                 if (!$u7len || $u7 != '-') {
  574.                     return $err;
  575.                 }
  576.  
  577.                 // Adjacent BASE64 sections
  578.                 if ($u7len > 2 && $str[$i+1] == '&' && $str[$i+2] != '-') {
  579.                     return $err;
  580.                 }
  581.             }
  582.             // Not printable US-ASCII
  583.             else if (ord($u7) < 0x20 || ord($u7) >= 0x7f) {
  584.                 return $err;
  585.             }
  586.             else {
  587.                 $p .= $u7;
  588.             }
  589.         }
  590.  
  591.         return $p;
  592.     }
  593.  
  594.     /**
  595.      * Convert the data ($str) from UTF-8 to RFC 2060's UTF-7.
  596.      * Unicode characters above U+FFFF are replaced by U+FFFE.
  597.      * If input data is invalid, return an empty string.
  598.      *
  599.      * Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com>
  600.      *
  601.      * @param string $str Input string (UTF-8)
  602.      *
  603.      * @return string Output string (UTF7-IMAP)
  604.      */
  605.     public static function utf8_to_utf7imap($str)
  606.     {
  607.         $B64Chars = array(
  608.             'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  609.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  610.             'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
  611.             't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  612.             '8', '9', '+', ','
  613.         );
  614.  
  615.         $u8len  = strlen($str);
  616.         $base64 = 0;
  617.         $i      = 0;
  618.         $p      = '';
  619.         $err    = '';
  620.  
  621.         while ($u8len) {
  622.             $u8 = $str[$i];
  623.             $c  = ord($u8);
  624.  
  625.             if ($c < 0x80) {
  626.                 $ch = $c;
  627.                 $n  = 0;
  628.             }
  629.             else if ($c < 0xc2) {
  630.                 return $err;
  631.             }
  632.             else if ($c < 0xe0) {
  633.                 $ch = $c & 0x1f;
  634.                 $n  = 1;
  635.             }
  636.             else if ($c < 0xf0) {
  637.                 $ch = $c & 0x0f;
  638.                 $n  = 2;
  639.             }
  640.             else if ($c < 0xf8) {
  641.                 $ch = $c & 0x07;
  642.                 $n  = 3;
  643.             }
  644.             else if ($c < 0xfc) {
  645.                 $ch = $c & 0x03;
  646.                 $n  = 4;
  647.             }
  648.             else if ($c < 0xfe) {
  649.                 $ch = $c & 0x01;
  650.                 $n  = 5;
  651.             }
  652.             else {
  653.                 return $err;
  654.             }
  655.  
  656.             $i++;
  657.             $u8len--;
  658.  
  659.             if ($n > $u8len) {
  660.                 return $err;
  661.             }
  662.  
  663.             for ($j=0; $j < $n; $j++) {
  664.                 $o = ord($str[$i+$j]);
  665.                 if (($o & 0xc0) != 0x80) {
  666.                     return $err;
  667.                 }
  668.                 $ch = ($ch << 6) | ($o & 0x3f);
  669.             }
  670.  
  671.             if ($n > 1 && !($ch >> ($n * 5 + 1))) {
  672.                 return $err;
  673.             }
  674.  
  675.             $i += $n;
  676.             $u8len -= $n;
  677.  
  678.             if ($ch < 0x20 || $ch >= 0x7f) {
  679.                 if (!$base64) {
  680.                     $p .= '&';
  681.                     $base64 = 1;
  682.                     $b = 0;
  683.                     $k = 10;
  684.                 }
  685.                 if ($ch & ~0xffff) {
  686.                     $ch = 0xfffe;
  687.                 }
  688.  
  689.                 $p .= $B64Chars[($b | $ch >> $k)];
  690.                 $k -= 6;
  691.                 for (; $k >= 0; $k -= 6) {
  692.                     $p .= $B64Chars[(($ch >> $k) & 0x3f)];
  693.                 }
  694.  
  695.                 $b = ($ch << (-$k)) & 0x3f;
  696.                 $k += 16;
  697.             }
  698.             else {
  699.                 if ($base64) {
  700.                     if ($k > 10) {
  701.                         $p .= $B64Chars[$b];
  702.                     }
  703.                     $p .= '-';
  704.                     $base64 = 0;
  705.                 }
  706.  
  707.                 $p .= chr($ch);
  708.                 if (chr($ch) == '&') {
  709.                     $p .= '-';
  710.                 }
  711.             }
  712.         }
  713.  
  714.         if ($base64) {
  715.             if ($k > 10) {
  716.                 $p .= $B64Chars[$b];
  717.             }
  718.             $p .= '-';
  719.         }
  720.  
  721.         return $p;
  722.     }
  723.  
  724.     /**
  725.      * A method to guess character set of a string.
  726.      *
  727.      * @param string $string   String
  728.      * @param string $failover Default result for failover
  729.      * @param string $language User language
  730.      *
  731.      * @return string Charset name
  732.      */
  733.     public static function detect($string, $failover = null, $language = null)
  734.     {
  735.         if (substr($string, 0, 4) == "\0\0\xFE\xFF") return 'UTF-32BE';  // Big Endian
  736.         if (substr($string, 0, 4) == "\xFF\xFE\0\0") return 'UTF-32LE';  // Little Endian
  737.         if (substr($string, 0, 2) == "\xFE\xFF")     return 'UTF-16BE';  // Big Endian
  738.         if (substr($string, 0, 2) == "\xFF\xFE")     return 'UTF-16LE';  // Little Endian
  739.         if (substr($string, 0, 3) == "\xEF\xBB\xBF") return 'UTF-8';
  740.  
  741.         // heuristics
  742.         if ($string[0] == "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-32BE';
  743.         if ($string[0] != "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] == "\0") return 'UTF-32LE';
  744.         if ($string[0] == "\0" && $string[1] != "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-16BE';
  745.         if ($string[0] != "\0" && $string[1] == "\0" && $string[2] != "\0" && $string[3] == "\0") return 'UTF-16LE';
  746.  
  747.         if (empty($language)) {
  748.             $rcube    = rcube::get_instance();
  749.             $language = $rcube->get_user_language();
  750.         }
  751.  
  752.         // Prioritize charsets according to current language (#1485669)
  753.         switch ($language) {
  754.         case 'ja_JP':
  755.             $prio = array('ISO-2022-JP', 'JIS', 'UTF-8', 'EUC-JP', 'eucJP-win', 'SJIS', 'SJIS-win');
  756.             break;
  757.  
  758.         case 'zh_CN':
  759.         case 'zh_TW':
  760.             $prio = array('UTF-8', 'BIG-5', 'GB2312', 'EUC-TW');
  761.             break;
  762.  
  763.         case 'ko_KR':
  764.             $prio = array('UTF-8', 'EUC-KR', 'ISO-2022-KR');
  765.             break;
  766.  
  767.         case 'ru_RU':
  768.             $prio = array('UTF-8', 'WINDOWS-1251', 'KOI8-R');
  769.             break;
  770.  
  771.         case 'tr_TR':
  772.             $prio = array('UTF-8', 'ISO-8859-9', 'WINDOWS-1254');
  773.             break;
  774.         }
  775.  
  776.         // mb_detect_encoding() is not reliable for some charsets (#1490135)
  777.         // use mb_check_encoding() to make charset priority lists really working
  778.         if ($prio && function_exists('mb_check_encoding')) {
  779.             foreach ($prio as $encoding) {
  780.                 if (mb_check_encoding($string, $encoding)) {
  781.                     return $encoding;
  782.                 }
  783.             }
  784.         }
  785.  
  786.         if (function_exists('mb_detect_encoding')) {
  787.             if (!$prio) {
  788.                 $prio = array('UTF-8', 'SJIS', 'GB2312',
  789.                     'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
  790.                     'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9',
  791.                     'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16',
  792.                     'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R', 'BIG-5',
  793.                     'ISO-2022-KR', 'ISO-2022-JP',
  794.                 );
  795.             }
  796.  
  797.             $encodings = array_unique(array_merge($prio, mb_list_encodings()));
  798.  
  799.             if ($encoding = mb_detect_encoding($string, $encodings)) {
  800.                 return $encoding;
  801.             }
  802.         }
  803.  
  804.         // No match, check for UTF-8
  805.         // from http://w3.org/International/questions/qa-forms-utf-8.html
  806.         if (preg_match('/\A(
  807.            [\x09\x0A\x0D\x20-\x7E]
  808.            | [\xC2-\xDF][\x80-\xBF]
  809.            | \xE0[\xA0-\xBF][\x80-\xBF]
  810.            | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}
  811.            | \xED[\x80-\x9F][\x80-\xBF]
  812.            | \xF0[\x90-\xBF][\x80-\xBF]{2}
  813.            | [\xF1-\xF3][\x80-\xBF]{3}
  814.            | \xF4[\x80-\x8F][\x80-\xBF]{2}
  815.            )*\z/xs', substr($string, 0, 2048))
  816.         ) {
  817.             return 'UTF-8';
  818.         }
  819.  
  820.         return $failover;
  821.     }
  822.  
  823.     /**
  824.      * Removes non-unicode characters from input.
  825.      *
  826.      * @param mixed $input String or array.
  827.      *
  828.      * @return mixed String or array
  829.      */
  830.     public static function clean($input)
  831.     {
  832.         // handle input of type array
  833.         if (is_array($input)) {
  834.             foreach ($input as $idx => $val) {
  835.                 $input[$idx] = self::clean($val);
  836.             }
  837.             return $input;
  838.         }
  839.  
  840.         if (!is_string($input) || $input == '') {
  841.             return $input;
  842.         }
  843.  
  844.         // iconv/mbstring are much faster (especially with long strings)
  845.         if (function_exists('mb_convert_encoding')) {
  846.             $msch = mb_substitute_character();
  847.             mb_substitute_character('none');
  848.             $res = mb_convert_encoding($input, 'UTF-8', 'UTF-8');
  849.             mb_substitute_character($msch);
  850.  
  851.             if ($res !== false) {
  852.                 return $res;
  853.             }
  854.         }
  855.  
  856.         if (function_exists('iconv')) {
  857.             if (($res = @iconv('UTF-8', 'UTF-8//IGNORE', $input)) !== false) {
  858.                 return $res;
  859.             }
  860.         }
  861.  
  862.         $seq    = '';
  863.         $out    = '';
  864.         $regexp = '/^('.
  865. //          '[\x00-\x7F]'.                                  // UTF8-1
  866.             '|[\xC2-\xDF][\x80-\xBF]'.                      // UTF8-2
  867.             '|\xE0[\xA0-\xBF][\x80-\xBF]'.                  // UTF8-3
  868.             '|[\xE1-\xEC][\x80-\xBF][\x80-\xBF]'.           // UTF8-3
  869.             '|\xED[\x80-\x9F][\x80-\xBF]'.                  // UTF8-3
  870.             '|[\xEE-\xEF][\x80-\xBF][\x80-\xBF]'.           // UTF8-3
  871.             '|\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF]'.       // UTF8-4
  872.             '|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]'.// UTF8-4
  873.             '|\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF]'.       // UTF8-4
  874.             ')$/';
  875.  
  876.         for ($i = 0, $len = strlen($input); $i < $len; $i++) {
  877.             $chr = $input[$i];
  878.             $ord = ord($chr);
  879.  
  880.             // 1-byte character
  881.             if ($ord <= 0x7F) {
  882.                 if ($seq !== '') {
  883.                     $out .= preg_match($regexp, $seq) ? $seq : '';
  884.                     $seq = '';
  885.                 }
  886.  
  887.                 $out .= $chr;
  888.             }
  889.             // first byte of multibyte sequence
  890.             else if ($ord >= 0xC0) {
  891.                 if ($seq !== '') {
  892.                     $out .= preg_match($regexp, $seq) ? $seq : '';
  893.                     $seq = '';
  894.                 }
  895.  
  896.                 $seq = $chr;
  897.             }
  898.             // next byte of multibyte sequence
  899.             else if ($seq !== '') {
  900.                 $seq .= $chr;
  901.             }
  902.         }
  903.  
  904.         if ($seq !== '') {
  905.             $out .= preg_match($regexp, $seq) ? $seq : '';
  906.         }
  907.  
  908.         return $out;
  909.     }
  910. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!