From 28074f65afd7b42845ac5ce181bf50d6e013e6b7 Mon Sep 17 00:00:00 2001 From: Huong Nguyen Date: Tue, 21 Nov 2023 12:17:51 +0700 Subject: [PATCH] MDL-80207 tool_messageinbound: Add Roundcube Framework 1.6.6 library --- .../roundcube/rcube_charset.php | 615 +++ .../roundcube/rcube_imap_generic.php | 4278 +++++++++++++++++ .../roundcube/rcube_message_header.php | 430 ++ .../messageinbound/roundcube/rcube_mime.php | 992 ++++ .../roundcube/rcube_result_index.php | 446 ++ .../roundcube/rcube_result_thread.php | 699 +++ .../messageinbound/roundcube/rcube_utils.php | 1687 +++++++ .../roundcube/readme_moodle.txt | 24 + admin/tool/messageinbound/thirdpartylibs.xml | 14 + 9 files changed, 9185 insertions(+) create mode 100644 admin/tool/messageinbound/roundcube/rcube_charset.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_imap_generic.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_message_header.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_mime.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_result_index.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_result_thread.php create mode 100644 admin/tool/messageinbound/roundcube/rcube_utils.php create mode 100644 admin/tool/messageinbound/roundcube/readme_moodle.txt create mode 100644 admin/tool/messageinbound/thirdpartylibs.xml diff --git a/admin/tool/messageinbound/roundcube/rcube_charset.php b/admin/tool/messageinbound/roundcube/rcube_charset.php new file mode 100644 index 00000000000..6b67d73ba39 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_charset.php @@ -0,0 +1,615 @@ + | + | | + | 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 | + | Author: Aleksander Machniak | + | Author: Edmund Grimley Evans | + +-----------------------------------------------------------------------+ +*/ + +/** + * Character sets conversion functionality + * + * @package Framework + * @subpackage Core + */ +class rcube_charset +{ + /** + * Character set aliases (some of them from HTML5 spec.) + * + * @var array + */ + static public $aliases = [ + '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', + 'WINDOWS31J' => 'CP932', + 'WINDOWS949' => 'UHC', + 'WINDOWS1257' => 'ISO-8859-13', + 'ISO2022JP' => 'ISO-2022-JP-MS', + ]; + + /** + * Windows codepages + * + * @var array + */ + static public $windows_codepages = [ + 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', + ]; + + /** + * Validate character set identifier. + * + * @param string $input Character set identifier + * + * @return bool True if valid, False if not valid + */ + public static function is_valid($input) + { + return is_string($input) && preg_match('|^[a-zA-Z0-9_./:#-]{2,32}$|', $input) > 0; + } + + /** + * Parse and validate charset name string. + * 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 = []; + + $charset = strtoupper((string) $input); + + if (isset($charsets[$input])) { + return $charsets[$input]; + } + + $charset = preg_replace([ + '/^[^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) + '/\*.*$/' // lang code according to RFC 2231.5 + ], '', $charset); + + if ($charset == 'BINARY') { + return $charsets[$input] = null; + } + + // allow A-Z and 0-9 only + $str = preg_replace('/[^A-Z0-9]/', '', $charset); + + $result = $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] . (!empty($m[2]) ? $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 = ['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'; + } + // we need ISO labels + else if (!empty($aliases[$m[1]])) { + $result = 'ISO-8859-'.$aliases[$m[1]]; + } + } + + $charsets[$input] = $result; + + return $result; + } + + /** + * Convert a string from one charset to another. + * + * @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; + + $to = empty($to) ? RCUBE_CHARSET : self::parse_charset($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; + } + + $out = false; + $error_handler = function() { throw new \Exception(); }; + + // Ignore invalid characters + $mbstring_sc = mb_substitute_character(); + mb_substitute_character('none'); + + // If mbstring reports an illegal character in input via E_WARNING. + // FIXME: Is this really true with substitute character 'none'? + // A warning is thrown in PHP<8 also on unsupported encoding, in PHP>=8 ValueError + // is thrown instead (therefore we catch Throwable below) + set_error_handler($error_handler, E_WARNING); + + try { + $out = mb_convert_encoding($str, $to, $from); + } + catch (Throwable $e) { + $out = false; + } + + restore_error_handler(); + mb_substitute_character($mbstring_sc); + + if ($out !== false) { + return $out; + } + + 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; + } + } + + // Fallback to iconv module, it is slower, but supports much more charsets than mbstring + if ($iconv_options !== false && $from != 'UTF7-IMAP' && $to != 'UTF7-IMAP' + && $from !== 'ISO-2022-JP' + ) { + // If iconv reports an illegal character in input it means that input string + // has been truncated. It's reported as E_NOTICE. + // PHP8 will also throw E_WARNING on unsupported encoding. + set_error_handler($error_handler, E_NOTICE | E_WARNING); + + try { + $out = iconv($from, $to . $iconv_options, $str); + } + catch (Throwable $e) { + $out = false; + } + + restore_error_handler(); + + if ($out !== false) { + return $out; + } + } + + // return the original string + return $str; + } + + /** + * Check if the specified input string matches one of the provided charsets. + * This includes UTF-32, UTF-16, RCUBE_CHARSET and default_charset. + * + * @param string $str Input string + * @param array $charsets Suspected charsets of the input string + * + * @return string|null First matching charset + */ + public static function check($str, $charsets = []) + { + $chunk = strlen($str) > 100 * 1024 ? substr($str, 0, 100 * 1024) : $str; + + // Add dehault charset, system charset and easily detectable charset to the list + if (substr($chunk, 0, 4) == "\0\0\xFE\xFF") $charsets[] = 'UTF-32BE'; + if (substr($chunk, 0, 4) == "\xFF\xFE\0\0") $charsets[] = 'UTF-32LE'; + if (substr($chunk, 0, 2) == "\xFE\xFF") $charsets[] = 'UTF-16BE'; + if (substr($chunk, 0, 2) == "\xFF\xFE") $charsets[] = 'UTF-16LE'; + + // heuristics + if (preg_match('/\x00\x00\x00[^\x00]/', $chunk)) $charsets[] = 'UTF-32BE'; + if (preg_match('/[^\x00]\x00\x00\x00/', $chunk)) $charsets[] = 'UTF-32LE'; + if (preg_match('/\x00[^\x00]\x00[^\x00]/', $chunk)) $charsets[] = 'UTF-16BE'; + if (preg_match('/[^\x00]\x00[^\x00]\x00/', $chunk)) $charsets[] = 'UTF-16LE'; + + $charsets[] = RCUBE_CHARSET; + $charsets[] = (string) rcube::get_instance()->config->get('default_charset'); + + $charsets = array_map(['rcube_charset', 'parse_charset'], $charsets); + $charsets = array_unique(array_filter($charsets)); + + foreach ($charsets as $charset) { + $ret = self::convert($chunk, $charset); + + if ($ret === rcube_charset::clean($ret)) { + return $charset; + } + } + } + + /** + * Converts string from standard UTF-7 (RFC 2152) to UTF-8. + * + * @param string $str Input string (UTF-7) + * + * @return string Converted string (UTF-8) + * @deprecated use self::convert() + */ + public static function utf7_to_utf8($str) + { + return self::convert($str, 'UTF-7', 'UTF-8'); + } + + /** + * 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 + * @deprecated use self::convert() + */ + public static function utf16_to_utf8($str) + { + return self::convert($str, 'UTF-16BE', 'UTF-8'); + } + + /** + * 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-). + * + * @param string $str Input string (UTF7-IMAP) + * + * @return string Output string (UTF-8) + * @deprecated use self::convert() + */ + public static function utf7imap_to_utf8($str) + { + return self::convert($str, 'UTF7-IMAP', 'UTF-8'); + } + + /** + * 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. + * + * @param string $str Input string (UTF-8) + * + * @return string Output string (UTF7-IMAP) + * @deprecated use self::convert() + */ + public static function utf8_to_utf7imap($str) + { + return self::convert($str, 'UTF-8', 'UTF7-IMAP'); + } + + /** + * 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 + * @deprecated + */ + 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 (strlen($string) >= 4) { + 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 the current language (#1485669) + $prio = null; + switch ($language) { + case 'ja_JP': + $prio = ['ISO-2022-JP', 'JIS', 'UTF-8', 'EUC-JP', 'eucJP-win', 'SJIS']; + break; + + case 'zh_CN': + case 'zh_TW': + $prio = ['UTF-8', 'BIG-5', 'EUC-TW', 'GB18030']; + break; + + case 'ko_KR': + $prio = ['UTF-8', 'EUC-KR', 'ISO-2022-KR']; + break; + + case 'ru_RU': + $prio = ['UTF-8', 'WINDOWS-1251', 'KOI8-R']; + break; + + case 'tr_TR': + $prio = ['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 (!empty($prio) && function_exists('mb_check_encoding')) { + foreach ($prio as $encoding) { + if (mb_check_encoding($string, $encoding)) { + return $encoding; + } + } + } + + if (function_exists('mb_detect_encoding')) { + $exclude = 'BASE64,UUENCODE,HTML-ENTITIES,Quoted-Printable,' + . '7bit,8bit,pass,wchar,byte2be,byte2le,byte4be,byte4le,' + . 'UCS-4,UCS-4BE,UCS-4LE,UCS-2,UCS-2BE,UCS-2LE'; + + if (empty($prio)) { + $prio = [ + 'UTF-8', + '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', 'WINDOWS-1254', + 'EUC-JP', 'EUC-TW', 'KOI8-R', 'BIG-5', 'ISO-2022-KR', 'ISO-2022-JP', 'GB18030', + ]; + } + + // We have to remove unwanted/uncommon encodings from the list. + // This is needed especially on PHP >= 8.1 + $all_encodings = array_diff(mb_list_encodings(), explode(',', $exclude)); + + $encodings = array_unique(array_merge($prio, $all_encodings)); + + if ($encoding = mb_detect_encoding($string, $encodings, true)) { + 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. + * If the input is an array, both values and keys will be cleaned up. + * + * @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 (array_keys($input) as $key) { + $k = is_string($key) ? self::clean($key) : $key; + $v = self::clean($input[$key]); + + if ($k !== $key) { + unset($input[$key]); + if (!array_key_exists($k, $input)) { + $input[$k] = $v; + } + } + else { + $input[$k] = $v; + } + } + return $input; + } + + if (!is_string($input) || $input == '') { + return $input; + } + + $msch = mb_substitute_character(); + mb_substitute_character('none'); + $res = mb_convert_encoding($input, 'UTF-8', 'UTF-8'); + mb_substitute_character($msch); + + return $res; + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_imap_generic.php b/admin/tool/messageinbound/roundcube/rcube_imap_generic.php new file mode 100644 index 00000000000..0ef84818f92 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_imap_generic.php @@ -0,0 +1,4278 @@ + | + | Author: Ryo Chijiiwa | + +-----------------------------------------------------------------------+ +*/ + +/** + * PHP based wrapper class to connect to an IMAP server + * + * @package Framework + * @subpackage Storage + */ +class rcube_imap_generic +{ + public $error; + public $errornum; + public $result; + public $resultcode; + public $selected; + public $data = []; + public $flags = [ + 'SEEN' => '\\Seen', + 'DELETED' => '\\Deleted', + 'ANSWERED' => '\\Answered', + 'DRAFT' => '\\Draft', + 'FLAGGED' => '\\Flagged', + 'FORWARDED' => '$Forwarded', + 'MDNSENT' => '$MDNSent', + '*' => '\\*', + ]; + + protected $fp; + protected $host; + protected $user; + protected $cmd_tag; + protected $cmd_num = 0; + protected $resourceid; + protected $extensions_enabled; + protected $prefs = []; + protected $logged = false; + protected $capability = []; + protected $capability_read = false; + protected $debug = false; + protected $debug_handler = false; + + const ERROR_OK = 0; + const ERROR_NO = -1; + const ERROR_BAD = -2; + const ERROR_BYE = -3; + const ERROR_UNKNOWN = -4; + const ERROR_COMMAND = -5; + const ERROR_READONLY = -6; + + const COMMAND_NORESPONSE = 1; + const COMMAND_CAPABILITY = 2; + const COMMAND_LASTLINE = 4; + const COMMAND_ANONYMIZED = 8; + + const DEBUG_LINE_LENGTH = 4098; // 4KB + 2B for \r\n + + + /** + * Send simple (one line) command to the connection stream + * + * @param string $string Command string + * @param bool $endln True if CRLF need to be added at the end of command + * @param bool $anonymized Don't write the given data to log but a placeholder + * + * @return int Number of bytes sent, False on error + */ + protected function putLine($string, $endln = true, $anonymized = false) + { + if (!$this->fp) { + return false; + } + + if ($this->debug) { + // anonymize the sent command for logging + $cut = $endln ? 2 : 0; + if ($anonymized && preg_match('/^(A\d+ (?:[A-Z]+ )+)(.+)/', $string, $m)) { + $log = $m[1] . sprintf('****** [%d]', strlen($m[2]) - $cut); + } + else if ($anonymized) { + $log = sprintf('****** [%d]', strlen($string) - $cut); + } + else { + $log = rtrim($string); + } + + $this->debug('C: ' . $log); + } + + if ($endln) { + $string .= "\r\n"; + } + + $res = fwrite($this->fp, $string); + + if ($res === false) { + $this->closeSocket(); + } + + return $res; + } + + /** + * Send command to the connection stream with Command Continuation + * Requests (RFC3501 7.5) and LITERAL+ (RFC2088) and LITERAL- (RFC7888) support. + * + * @param string $string Command string + * @param bool $endln True if CRLF need to be added at the end of command + * @param bool $anonymized Don't write the given data to log but a placeholder + * + * @return int|bool Number of bytes sent, False on error + */ + protected function putLineC($string, $endln = true, $anonymized = false) + { + if (!$this->fp) { + return false; + } + + if ($endln) { + $string .= "\r\n"; + } + + $res = 0; + if ($parts = preg_split('/(\{[0-9]+\}\r\n)/m', $string, -1, PREG_SPLIT_DELIM_CAPTURE)) { + for ($i = 0, $cnt = count($parts); $i < $cnt; $i++) { + if ($i + 1 < $cnt && preg_match('/^\{([0-9]+)\}\r\n$/', $parts[$i+1], $matches)) { + // LITERAL+/LITERAL- support + $literal_plus = false; + if ( + !empty($this->prefs['literal+']) + || (!empty($this->prefs['literal-']) && $matches[1] <= 4096) + ) { + $parts[$i+1] = sprintf("{%d+}\r\n", $matches[1]); + $literal_plus = true; + } + + $bytes = $this->putLine($parts[$i].$parts[$i+1], false, $anonymized); + if ($bytes === false) { + return false; + } + + $res += $bytes; + + // don't wait if server supports LITERAL+ capability + if (!$literal_plus) { + $line = $this->readLine(1000); + // handle error in command + if (!isset($line[0]) || $line[0] != '+') { + return false; + } + } + + $i++; + } + else { + $bytes = $this->putLine($parts[$i], false, $anonymized); + if ($bytes === false) { + return false; + } + + $res += $bytes; + } + } + } + + return $res; + } + + /** + * Reads line from the connection stream + * + * @param int $size Buffer size + * + * @return string Line of text response + */ + protected function readLine($size = 1024) + { + $line = ''; + + if (!$size) { + $size = 1024; + } + + do { + if ($this->eof()) { + return $line; + } + + $buffer = fgets($this->fp, $size); + + if ($buffer === false) { + $this->closeSocket(); + break; + } + + if ($this->debug) { + $this->debug('S: '. rtrim($buffer)); + } + + $line .= $buffer; + } + while (substr($buffer, -1) != "\n"); + + return $line; + } + + /** + * Reads a line of data from the connection stream including all + * string continuation literals. + * + * @param int $size Buffer size + * + * @return string Line of text response + */ + protected function readFullLine($size = 1024) + { + $line = $this->readLine($size); + + // include all string literals untile the real end of "line" + while (preg_match('/\{([0-9]+)\}\r\n$/', $line, $m)) { + $bytes = $m[1]; + $out = ''; + + while (strlen($out) < $bytes) { + $out = $this->readBytes($bytes); + if ($out === '') { + break; + } + + $line .= $out; + } + + $line .= $this->readLine($size); + } + + return $line; + } + + /** + * Reads more data from the connection stream when provided + * data contain string literal + * + * @param string $line Response text + * @param bool $escape Enables escaping + * + * @return string Line of text response + */ + protected function multLine($line, $escape = false) + { + $line = rtrim($line); + if (preg_match('/\{([0-9]+)\}$/', $line, $m)) { + $out = ''; + $str = substr($line, 0, -strlen($m[0])); + $bytes = $m[1]; + + while (strlen($out) < $bytes) { + $line = $this->readBytes($bytes); + if ($line === '') { + break; + } + + $out .= $line; + } + + $line = $str . ($escape ? $this->escape($out) : $out); + } + + return $line; + } + + /** + * Reads specified number of bytes from the connection stream + * + * @param int $bytes Number of bytes to get + * + * @return string Response text + */ + protected function readBytes($bytes) + { + $data = ''; + $len = 0; + + while ($len < $bytes && !$this->eof()) { + $d = fread($this->fp, $bytes-$len); + if ($this->debug) { + $this->debug('S: '. $d); + } + $data .= $d; + $data_len = strlen($data); + if ($len == $data_len) { + break; // nothing was read -> exit to avoid apache lockups + } + $len = $data_len; + } + + return $data; + } + + /** + * Reads complete response to the IMAP command + * + * @param array $untagged Will be filled with untagged response lines + * + * @return string Response text + */ + protected function readReply(&$untagged = null) + { + while (true) { + $line = trim($this->readLine(1024)); + // store untagged response lines + if (isset($line[0]) && $line[0] == '*') { + $untagged[] = $line; + } + else { + break; + } + } + + if ($untagged) { + $untagged = implode("\n", $untagged); + } + + return $line; + } + + /** + * Response parser. + * + * @param string $string Response text + * @param string $err_prefix Error message prefix + * + * @return int Response status + */ + protected function parseResult($string, $err_prefix = '') + { + if (preg_match('/^[a-z0-9*]+ (OK|NO|BAD|BYE)(.*)$/i', trim($string), $matches)) { + $res = strtoupper($matches[1]); + $str = trim($matches[2]); + + if ($res == 'OK') { + $this->errornum = self::ERROR_OK; + } + else if ($res == 'NO') { + $this->errornum = self::ERROR_NO; + } + else if ($res == 'BAD') { + $this->errornum = self::ERROR_BAD; + } + else if ($res == 'BYE') { + $this->closeSocket(); + $this->errornum = self::ERROR_BYE; + } + + if ($str) { + $str = trim($str); + // get response string and code (RFC5530) + if (preg_match("/^\[([a-z-]+)\]/i", $str, $m)) { + $this->resultcode = strtoupper($m[1]); + $str = trim(substr($str, strlen($m[1]) + 2)); + } + else { + $this->resultcode = null; + // parse response for [APPENDUID 1204196876 3456] + if (preg_match("/^\[APPENDUID [0-9]+ ([0-9]+)\]/i", $str, $m)) { + $this->data['APPENDUID'] = $m[1]; + } + // parse response for [COPYUID 1204196876 3456:3457 123:124] + else if (preg_match("/^\[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $str, $m)) { + $this->data['COPYUID'] = [$m[1], $m[2]]; + } + } + + $this->result = $str; + + if ($this->errornum != self::ERROR_OK) { + $this->error = $err_prefix ? $err_prefix.$str : $str; + } + } + + return $this->errornum; + } + + return self::ERROR_UNKNOWN; + } + + /** + * Checks connection stream state. + * + * @return bool True if connection is closed + */ + protected function eof() + { + if (!$this->fp) { + return true; + } + + // If a connection opened by fsockopen() wasn't closed + // by the server, feof() will hang. + $start = microtime(true); + + if (feof($this->fp) || + ($this->prefs['timeout'] && (microtime(true) - $start > $this->prefs['timeout'])) + ) { + $this->closeSocket(); + return true; + } + + return false; + } + + /** + * Closes connection stream. + */ + protected function closeSocket() + { + if ($this->fp) { + fclose($this->fp); + $this->fp = null; + } + } + + /** + * Error code/message setter. + */ + protected function setError($code, $msg = '') + { + $this->errornum = $code; + $this->error = $msg; + + return $code; + } + + /** + * Checks response status. + * Checks if command response line starts with specified prefix (or * BYE/BAD) + * + * @param string $string Response text + * @param string $match Prefix to match with (case-sensitive) + * @param bool $error Enables BYE/BAD checking + * @param bool $nonempty Enables empty response checking + * + * @return bool True any check is true or connection is closed. + */ + protected function startsWith($string, $match, $error = false, $nonempty = false) + { + if (!$this->fp) { + return true; + } + + if (strncmp($string, $match, strlen($match)) == 0) { + return true; + } + + if ($error && preg_match('/^\* (BYE|BAD) /i', $string, $m)) { + if (strtoupper($m[1]) == 'BYE') { + $this->closeSocket(); + } + return true; + } + + if ($nonempty && !strlen($string)) { + return true; + } + + return false; + } + + /** + * Capabilities checker + */ + protected function hasCapability($name) + { + if (empty($this->capability) || empty($name)) { + return false; + } + + if (in_array($name, $this->capability)) { + return true; + } + else if (strpos($name, '=')) { + return false; + } + + $result = []; + foreach ($this->capability as $cap) { + $entry = explode('=', $cap); + if ($entry[0] == $name) { + $result[] = $entry[1]; + } + } + + return $result ?: false; + } + + /** + * Capabilities checker + * + * @param string $name Capability name + * + * @return mixed Capability values array for key=value pairs, true/false for others + */ + public function getCapability($name) + { + $result = $this->hasCapability($name); + + if (!empty($result)) { + return $result; + } + else if ($this->capability_read) { + return false; + } + + // get capabilities (only once) because initial + // optional CAPABILITY response may differ + $result = $this->execute('CAPABILITY'); + + if ($result[0] == self::ERROR_OK) { + $this->parseCapability($result[1]); + } + + $this->capability_read = true; + + return $this->hasCapability($name); + } + + /** + * Clears detected server capabilities + */ + public function clearCapability() + { + $this->capability = []; + $this->capability_read = false; + } + + /** + * DIGEST-MD5/CRAM-MD5/PLAIN Authentication + * + * @param string $user Username + * @param string $pass Password + * @param string $type Authentication type (PLAIN/CRAM-MD5/DIGEST-MD5) + * + * @return resource|int Connection resource on success, error code on error + */ + protected function authenticate($user, $pass, $type = 'PLAIN') + { + if ($type == 'CRAM-MD5' || $type == 'DIGEST-MD5') { + if ($type == 'DIGEST-MD5' && !class_exists('Auth_SASL')) { + return $this->setError(self::ERROR_BYE, + "The Auth_SASL package is required for DIGEST-MD5 authentication"); + } + + $this->putLine($this->nextTag() . " AUTHENTICATE $type"); + $line = trim($this->readReply()); + + if ($line[0] == '+') { + $challenge = substr($line, 2); + } + else { + return $this->parseResult($line); + } + + if ($type == 'CRAM-MD5') { + // RFC2195: CRAM-MD5 + $ipad = ''; + $opad = ''; + $xor = function($str1, $str2) { + $result = ''; + $size = strlen($str1); + for ($i=0; $i<$size; $i++) { + $result .= chr(ord($str1[$i]) ^ ord($str2[$i])); + } + return $result; + }; + + // initialize ipad, opad + for ($i=0; $i<64; $i++) { + $ipad .= chr(0x36); + $opad .= chr(0x5C); + } + + // pad $pass so it's 64 bytes + $pass = str_pad($pass, 64, chr(0)); + + // generate hash + $hash = md5($xor($pass, $opad) . pack("H*", + md5($xor($pass, $ipad) . base64_decode($challenge)))); + $reply = base64_encode($user . ' ' . $hash); + + // send result + $this->putLine($reply, true, true); + } + else { + // RFC2831: DIGEST-MD5 + // proxy authorization + if (!empty($this->prefs['auth_cid'])) { + $authc = $this->prefs['auth_cid']; + $pass = $this->prefs['auth_pw']; + } + else { + $authc = $user; + $user = ''; + } + + $auth_sasl = new Auth_SASL; + $auth_sasl = $auth_sasl->factory('digestmd5'); + $reply = base64_encode($auth_sasl->getResponse($authc, $pass, + base64_decode($challenge), $this->host, 'imap', $user)); + + // send result + $this->putLine($reply, true, true); + $line = trim($this->readReply()); + + if ($line[0] != '+') { + return $this->parseResult($line); + } + + // check response + $challenge = substr($line, 2); + $challenge = base64_decode($challenge); + if (strpos($challenge, 'rspauth=') === false) { + return $this->setError(self::ERROR_BAD, + "Unexpected response from server to DIGEST-MD5 response"); + } + + $this->putLine(''); + } + + $line = $this->readReply(); + $result = $this->parseResult($line); + } + else if ($type == 'GSSAPI') { + if (!extension_loaded('krb5')) { + return $this->setError(self::ERROR_BYE, + "The krb5 extension is required for GSSAPI authentication"); + } + + if (empty($this->prefs['gssapi_cn'])) { + return $this->setError(self::ERROR_BYE, + "The gssapi_cn parameter is required for GSSAPI authentication"); + } + + if (empty($this->prefs['gssapi_context'])) { + return $this->setError(self::ERROR_BYE, + "The gssapi_context parameter is required for GSSAPI authentication"); + } + + putenv('KRB5CCNAME=' . $this->prefs['gssapi_cn']); + + try { + $ccache = new KRB5CCache(); + $ccache->open($this->prefs['gssapi_cn']); + $gssapicontext = new GSSAPIContext(); + $gssapicontext->acquireCredentials($ccache); + + $token = ''; + $success = $gssapicontext->initSecContext($this->prefs['gssapi_context'], null, null, null, $token); + $token = base64_encode($token); + } + catch (Exception $e) { + trigger_error($e->getMessage(), E_USER_WARNING); + return $this->setError(self::ERROR_BYE, "GSSAPI authentication failed"); + } + + $this->putLine($this->nextTag() . " AUTHENTICATE GSSAPI " . $token); + $line = trim($this->readReply()); + + if ($line[0] != '+') { + return $this->parseResult($line); + } + + try { + $itoken = base64_decode(substr($line, 2)); + + if (!$gssapicontext->unwrap($itoken, $itoken)) { + throw new Exception("GSSAPI SASL input token unwrap failed"); + } + + if (strlen($itoken) < 4) { + throw new Exception("GSSAPI SASL input token invalid"); + } + + // Integrity/encryption layers are not supported. The first bit + // indicates that the server supports "no security layers". + // 0x00 should not occur, but support broken implementations. + $server_layers = ord($itoken[0]); + if ($server_layers && ($server_layers & 0x1) != 0x1) { + throw new Exception("Server requires GSSAPI SASL integrity/encryption"); + } + + // Construct output token. 0x01 in the first octet = SASL layer "none", + // zero in the following three octets = no data follows. + // See https://github.com/cyrusimap/cyrus-sasl/blob/e41cfb986c1b1935770de554872247453fdbb079/plugins/gssapi.c#L1284 + if (!$gssapicontext->wrap(pack("CCCC", 0x1, 0, 0, 0), $otoken, true)) { + throw new Exception("GSSAPI SASL output token wrap failed"); + } + } + catch (Exception $e) { + trigger_error($e->getMessage(), E_USER_WARNING); + return $this->setError(self::ERROR_BYE, "GSSAPI authentication failed"); + } + + $this->putLine(base64_encode($otoken)); + + $line = $this->readReply(); + $result = $this->parseResult($line); + } + else if ($type == 'PLAIN') { + // proxy authorization + if (!empty($this->prefs['auth_cid'])) { + $authc = $this->prefs['auth_cid']; + $pass = $this->prefs['auth_pw']; + } + else { + $authc = $user; + $user = ''; + } + + $reply = base64_encode($user . chr(0) . $authc . chr(0) . $pass); + + // RFC 4959 (SASL-IR): save one round trip + if ($this->getCapability('SASL-IR')) { + list($result, $line) = $this->execute("AUTHENTICATE PLAIN", [$reply], + self::COMMAND_LASTLINE | self::COMMAND_CAPABILITY | self::COMMAND_ANONYMIZED); + } + else { + $this->putLine($this->nextTag() . " AUTHENTICATE PLAIN"); + $line = trim($this->readReply()); + + if ($line[0] != '+') { + return $this->parseResult($line); + } + + // send result, get reply and process it + $this->putLine($reply, true, true); + $line = $this->readReply(); + $result = $this->parseResult($line); + } + } + else if ($type == 'LOGIN') { + $this->putLine($this->nextTag() . " AUTHENTICATE LOGIN"); + + $line = trim($this->readReply()); + if ($line[0] != '+') { + return $this->parseResult($line); + } + + $this->putLine(base64_encode($user), true, true); + + $line = trim($this->readReply()); + if ($line[0] != '+') { + return $this->parseResult($line); + } + + // send result, get reply and process it + $this->putLine(base64_encode($pass), true, true); + + $line = $this->readReply(); + $result = $this->parseResult($line); + } + else if ($type == 'XOAUTH2') { + $auth = base64_encode("user=$user\1auth=$pass\1\1"); + $this->putLine($this->nextTag() . " AUTHENTICATE XOAUTH2 $auth", true, true); + + $line = trim($this->readReply()); + + if ($line[0] == '+') { + // send empty line + $this->putLine('', true, true); + $line = $this->readReply(); + } + + $result = $this->parseResult($line); + } + else { + $line = 'not supported'; + $result = self::ERROR_UNKNOWN; + } + + if ($result === self::ERROR_OK) { + // optional CAPABILITY response + if ($line && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) { + $this->parseCapability($matches[1], true); + } + + return $this->fp; + } + + return $this->setError($result, "AUTHENTICATE $type: $line"); + } + + /** + * LOGIN Authentication + * + * @param string $user Username + * @param string $password Password + * + * @return resource|int Connection resource on success, error code on error + */ + protected function login($user, $password) + { + // Prevent from sending credentials in plain text when connection is not secure + if ($this->getCapability('LOGINDISABLED')) { + return $this->setError(self::ERROR_BAD, "Login disabled by IMAP server"); + } + + list($code, $response) = $this->execute('LOGIN', [$this->escape($user, true), $this->escape($password, true)], + self::COMMAND_CAPABILITY | self::COMMAND_ANONYMIZED); + + // re-set capabilities list if untagged CAPABILITY response provided + if (preg_match('/\* CAPABILITY (.+)/i', $response, $matches)) { + $this->parseCapability($matches[1], true); + } + + if ($code == self::ERROR_OK) { + return $this->fp; + } + + return $code; + } + + /** + * Detects hierarchy delimiter + * + * @return string The delimiter + */ + public function getHierarchyDelimiter() + { + if (!empty($this->prefs['delimiter'])) { + return $this->prefs['delimiter']; + } + + // try (LIST "" ""), should return delimiter (RFC2060 Sec 6.3.8) + list($code, $response) = $this->execute('LIST', [$this->escape(''), $this->escape('')]); + + if ($code == self::ERROR_OK) { + $args = $this->tokenizeResponse($response, 4); + $delimiter = $args[3]; + + if (strlen($delimiter) > 0) { + return ($this->prefs['delimiter'] = $delimiter); + } + } + } + + /** + * NAMESPACE handler (RFC 2342) + * + * @return array Namespace data hash (personal, other, shared) + */ + public function getNamespace() + { + if (array_key_exists('namespace', $this->prefs)) { + return $this->prefs['namespace']; + } + + if (!$this->getCapability('NAMESPACE')) { + return self::ERROR_BAD; + } + + list($code, $response) = $this->execute('NAMESPACE'); + + if ($code == self::ERROR_OK && preg_match('/^\* NAMESPACE /', $response)) { + $response = substr($response, 11); + $data = $this->tokenizeResponse($response); + } + + if (!isset($data) || !is_array($data)) { + return $code; + } + + $this->prefs['namespace'] = [ + 'personal' => $data[0], + 'other' => $data[1], + 'shared' => $data[2], + ]; + + return $this->prefs['namespace']; + } + + /** + * Connects to IMAP server and authenticates. + * + * @param string $host Server hostname or IP + * @param string $user User name + * @param string $password Password + * @param array $options Connection and class options + * + * @return bool True on success, False on failure + */ + public function connect($host, $user, $password, $options = []) + { + // configure + $this->set_prefs($options); + + $this->host = $host; + $this->user = $user; + $this->logged = false; + $this->selected = null; + + // check input + if (empty($host)) { + $this->setError(self::ERROR_BAD, "Empty host"); + return false; + } + + if (empty($user)) { + $this->setError(self::ERROR_NO, "Empty user"); + return false; + } + + if (empty($password) && empty($options['gssapi_cn'])) { + $this->setError(self::ERROR_NO, "Empty password"); + return false; + } + + // Connect + if (!$this->_connect($host)) { + return false; + } + + // Send pre authentication ID info (#7860) + if (!empty($this->prefs['preauth_ident']) && $this->getCapability('ID')) { + $this->data['ID'] = $this->id($this->prefs['preauth_ident']); + } + + $auth_method = $this->prefs['auth_type']; + $auth_methods = []; + $result = null; + + // check for supported auth methods + if (!$auth_method || $auth_method == 'CHECK') { + if ($auth_caps = $this->getCapability('AUTH')) { + $auth_methods = $auth_caps; + } + + // Use best (for security) supported authentication method + $all_methods = ['DIGEST-MD5', 'CRAM-MD5', 'CRAM_MD5', 'PLAIN', 'LOGIN']; + + if (!empty($this->prefs['gssapi_cn'])) { + array_unshift($all_methods, 'GSSAPI'); + } + + foreach ($all_methods as $auth_method) { + if (in_array($auth_method, $auth_methods)) { + break; + } + } + + // Prefer LOGIN over AUTHENTICATE LOGIN for performance reasons + if ($auth_method == 'LOGIN' && !$this->getCapability('LOGINDISABLED')) { + $auth_method = 'IMAP'; + } + } + + // pre-login capabilities can be not complete + $this->capability_read = false; + + // Authenticate + switch ($auth_method) { + case 'CRAM_MD5': + $auth_method = 'CRAM-MD5'; + case 'CRAM-MD5': + case 'DIGEST-MD5': + case 'GSSAPI': + case 'PLAIN': + case 'LOGIN': + case 'XOAUTH2': + $result = $this->authenticate($user, $password, $auth_method); + break; + + case 'IMAP': + $result = $this->login($user, $password); + break; + + default: + $this->setError(self::ERROR_BAD, "Configuration error. Unknown auth method: $auth_method"); + } + + // Connected and authenticated + if (is_resource($result)) { + if (!empty($this->prefs['force_caps'])) { + $this->clearCapability(); + } + + $this->logged = true; + + // Send ID info after authentication to ensure reliable result (#7517) + if (!empty($this->prefs['ident']) && $this->getCapability('ID')) { + $this->data['ID'] = $this->id($this->prefs['ident']); + } + + return true; + } + + $this->closeConnection(); + + return false; + } + + /** + * Connects to IMAP server. + * + * @param string $host Server hostname or IP + * + * @return bool True on success, False on failure + */ + protected function _connect($host) + { + // initialize connection + $this->error = ''; + $this->errornum = self::ERROR_OK; + + $port = empty($this->prefs['port']) ? 143 : $this->prefs['port']; + $ssl_mode = $this->prefs['ssl_mode'] ?? null; + + // check for SSL + if (!empty($ssl_mode) && $ssl_mode != 'tls') { + $host = $ssl_mode . '://' . $host; + } + + if (empty($this->prefs['timeout']) || $this->prefs['timeout'] < 0) { + $this->prefs['timeout'] = max(0, intval(ini_get('default_socket_timeout'))); + } + + if ($this->debug) { + // set connection identifier for debug output + $this->resourceid = strtoupper(substr(md5(microtime() . $host . $this->user), 0, 4)); + + $_host = ($ssl_mode == 'tls' ? 'tls://' : '') . $host . ':' . $port; + $this->debug("Connecting to $_host..."); + } + + if (!empty($this->prefs['socket_options'])) { + $options = array_intersect_key($this->prefs['socket_options'], ['ssl' => 1]); + $context = stream_context_create($options); + $this->fp = stream_socket_client($host . ':' . $port, $errno, $errstr, + $this->prefs['timeout'], STREAM_CLIENT_CONNECT, $context); + } + else { + $this->fp = @fsockopen($host, $port, $errno, $errstr, $this->prefs['timeout']); + } + + if (!$this->fp) { + $this->setError(self::ERROR_BAD, sprintf("Could not connect to %s:%d: %s", + $host, $port, $errstr ?: "Unknown reason")); + + return false; + } + + if ($this->prefs['timeout'] > 0) { + stream_set_timeout($this->fp, $this->prefs['timeout']); + } + + $line = trim(fgets($this->fp, 8192)); + + if ($this->debug && $line) { + $this->debug('S: '. $line); + } + + // Connected to wrong port or connection error? + if (!preg_match('/^\* (OK|PREAUTH)/i', $line)) { + if ($line) { + $error = sprintf("Wrong startup greeting (%s:%d): %s", $host, $port, $line); + } + else { + $error = sprintf("Empty startup greeting (%s:%d)", $host, $port); + } + + $this->setError(self::ERROR_BAD, $error); + $this->closeConnection(); + return false; + } + + $this->data['GREETING'] = trim(preg_replace('/\[[^\]]+\]\s*/', '', $line)); + + // RFC3501 [7.1] optional CAPABILITY response + if (preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) { + $this->parseCapability($matches[1], true); + } + + // TLS connection + if ($ssl_mode == 'tls' && $this->getCapability('STARTTLS')) { + $res = $this->execute('STARTTLS'); + + if (empty($res) || $res[0] != self::ERROR_OK) { + $this->closeConnection(); + return false; + } + + if (isset($this->prefs['socket_options']['ssl']['crypto_method'])) { + $crypto_method = $this->prefs['socket_options']['ssl']['crypto_method']; + } + else { + // There is no flag to enable all TLS methods. Net_SMTP + // handles enabling TLS similarly. + $crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT + | @STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT + | @STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT; + } + + if (!stream_socket_enable_crypto($this->fp, true, $crypto_method)) { + $this->setError(self::ERROR_BAD, "Unable to negotiate TLS"); + $this->closeConnection(); + return false; + } + + // Now we're secure, capabilities need to be reread + $this->clearCapability(); + } + + return true; + } + + /** + * Initializes environment + */ + protected function set_prefs($prefs) + { + // set preferences + if (is_array($prefs)) { + $this->prefs = $prefs; + } + + // set auth method + if (!empty($this->prefs['auth_type'])) { + $this->prefs['auth_type'] = strtoupper($this->prefs['auth_type']); + } + else { + $this->prefs['auth_type'] = 'CHECK'; + } + + // disabled capabilities + if (!empty($this->prefs['disabled_caps'])) { + $this->prefs['disabled_caps'] = array_map('strtoupper', (array)$this->prefs['disabled_caps']); + } + + // additional message flags + if (!empty($this->prefs['message_flags'])) { + $this->flags = array_merge($this->flags, $this->prefs['message_flags']); + unset($this->prefs['message_flags']); + } + } + + /** + * Checks connection status + * + * @return bool True if connection is active and user is logged in, False otherwise. + */ + public function connected() + { + return $this->fp && $this->logged; + } + + /** + * Closes connection with logout. + */ + public function closeConnection() + { + if ($this->logged && $this->putLine($this->nextTag() . ' LOGOUT')) { + $this->readReply(); + } + + $this->closeSocket(); + $this->clearCapability(); + } + + /** + * Executes SELECT command (if mailbox is already not in selected state) + * + * @param string $mailbox Mailbox name + * @param array $qresync_data QRESYNC data (RFC5162) + * + * @return bool True on success, false on error + */ + public function select($mailbox, $qresync_data = null) + { + if (!strlen($mailbox)) { + return false; + } + + if ($this->selected === $mailbox) { + return true; + } + + $params = [$this->escape($mailbox)]; + + // QRESYNC data items + // 0. the last known UIDVALIDITY, + // 1. the last known modification sequence, + // 2. the optional set of known UIDs, and + // 3. an optional parenthesized list of known sequence ranges and their + // corresponding UIDs. + if (!empty($qresync_data)) { + if (!empty($qresync_data[2])) { + $qresync_data[2] = self::compressMessageSet($qresync_data[2]); + } + + $params[] = ['QRESYNC', $qresync_data]; + } + + list($code, $response) = $this->execute('SELECT', $params); + + if ($code == self::ERROR_OK) { + $this->clear_mailbox_cache(); + + $response = explode("\r\n", $response); + foreach ($response as $line) { + if (preg_match('/^\* OK \[/i', $line)) { + $pos = strcspn($line, ' ]', 6); + $token = strtoupper(substr($line, 6, $pos)); + $pos += 7; + + switch ($token) { + case 'UIDNEXT': + case 'UIDVALIDITY': + case 'UNSEEN': + if ($len = strspn($line, '0123456789', $pos)) { + $this->data[$token] = (int) substr($line, $pos, $len); + } + break; + + case 'HIGHESTMODSEQ': + if ($len = strspn($line, '0123456789', $pos)) { + $this->data[$token] = (string) substr($line, $pos, $len); + } + break; + + case 'NOMODSEQ': + $this->data[$token] = true; + break; + + case 'PERMANENTFLAGS': + $start = strpos($line, '(', $pos); + $end = strrpos($line, ')'); + if ($start && $end) { + $flags = substr($line, $start + 1, $end - $start - 1); + $this->data[$token] = explode(' ', $flags); + } + break; + } + } + else if (preg_match('/^\* ([0-9]+) (EXISTS|RECENT|FETCH)/i', $line, $match)) { + $token = strtoupper($match[2]); + switch ($token) { + case 'EXISTS': + case 'RECENT': + $this->data[$token] = (int) $match[1]; + break; + + case 'FETCH': + // QRESYNC FETCH response (RFC5162) + $line = substr($line, strlen($match[0])); + $fetch_data = $this->tokenizeResponse($line, 1); + $data = ['id' => $match[1]]; + + for ($i=0, $size=count($fetch_data); $i<$size; $i+=2) { + $data[strtolower($fetch_data[$i])] = $fetch_data[$i+1]; + } + + $this->data['QRESYNC'][$data['uid']] = $data; + break; + } + } + // QRESYNC VANISHED response (RFC5162) + else if (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) { + $line = substr($line, strlen($match[0])); + $v_data = $this->tokenizeResponse($line, 1); + + $this->data['VANISHED'] = $v_data; + } + } + + $this->data['READ-WRITE'] = $this->resultcode != 'READ-ONLY'; + $this->selected = $mailbox; + + return true; + } + + return false; + } + + /** + * Executes STATUS command + * + * @param string $mailbox Mailbox name + * @param array $items Additional requested item names. By default + * MESSAGES and UNSEEN are requested. Other defined + * in RFC3501: UIDNEXT, UIDVALIDITY, RECENT + * + * @return array Status item-value hash + * @since 0.5-beta + */ + public function status($mailbox, $items = []) + { + if (!strlen($mailbox)) { + return false; + } + + if (!in_array('MESSAGES', $items)) { + $items[] = 'MESSAGES'; + } + if (!in_array('UNSEEN', $items)) { + $items[] = 'UNSEEN'; + } + + list($code, $response) = $this->execute('STATUS', + [$this->escape($mailbox), '(' . implode(' ', $items) . ')'], 0, '/^\* STATUS /i'); + + if ($code == self::ERROR_OK && $response) { + $result = []; + $response = substr($response, 9); // remove prefix "* STATUS " + + list($mbox, $items) = $this->tokenizeResponse($response, 2); + + // Fix for #1487859. Some buggy server returns not quoted + // folder name with spaces. Let's try to handle this situation + if (!is_array($items) && ($pos = strpos($response, '(')) !== false) { + $response = substr($response, $pos); + $items = $this->tokenizeResponse($response, 1); + } + + if (!is_array($items)) { + return $result; + } + + for ($i=0, $len=count($items); $i<$len; $i += 2) { + $result[$items[$i]] = $items[$i+1]; + } + + $this->data['STATUS:'.$mailbox] = $result; + + return $result; + } + + return false; + } + + /** + * Executes EXPUNGE command + * + * @param string $mailbox Mailbox name + * @param string|array $messages Message UIDs to expunge + * + * @return bool True on success, False on error + */ + public function expunge($mailbox, $messages = null) + { + if (!$this->select($mailbox)) { + return false; + } + + if (empty($this->data['READ-WRITE'])) { + $this->setError(self::ERROR_READONLY, "Mailbox is read-only"); + return false; + } + + // Clear internal status cache + $this->clear_status_cache($mailbox); + + if (!empty($messages) && $messages != '*' && $this->hasCapability('UIDPLUS')) { + $messages = self::compressMessageSet($messages); + $result = $this->execute('UID EXPUNGE', [$messages], self::COMMAND_NORESPONSE); + } + else { + $result = $this->execute('EXPUNGE', null, self::COMMAND_NORESPONSE); + } + + if ($result == self::ERROR_OK) { + $this->selected = null; // state has changed, need to reselect + return true; + } + + return false; + } + + /** + * Executes CLOSE command + * + * @return bool True on success, False on error + * @since 0.5 + */ + public function close() + { + $result = $this->execute('CLOSE', null, self::COMMAND_NORESPONSE); + + if ($result == self::ERROR_OK) { + $this->selected = null; + return true; + } + + return false; + } + + /** + * Folder subscription (SUBSCRIBE) + * + * @param string $mailbox Mailbox name + * + * @return bool True on success, False on error + */ + public function subscribe($mailbox) + { + $result = $this->execute('SUBSCRIBE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Folder unsubscription (UNSUBSCRIBE) + * + * @param string $mailbox Mailbox name + * + * @return bool True on success, False on error + */ + public function unsubscribe($mailbox) + { + $result = $this->execute('UNSUBSCRIBE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Folder creation (CREATE) + * + * @param string $mailbox Mailbox name + * @param array $types Optional folder types (RFC 6154) + * + * @return bool True on success, False on error + */ + public function createFolder($mailbox, $types = null) + { + $args = [$this->escape($mailbox)]; + + // RFC 6154: CREATE-SPECIAL-USE + if (!empty($types) && $this->getCapability('CREATE-SPECIAL-USE')) { + $args[] = '(USE (' . implode(' ', $types) . '))'; + } + + $result = $this->execute('CREATE', $args, self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Folder renaming (RENAME) + * + * @param string $from Mailbox name + * @param string $to Mailbox name + * + * @return bool True on success, False on error + */ + public function renameFolder($from, $to) + { + $result = $this->execute('RENAME', [$this->escape($from), $this->escape($to)], self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Executes DELETE command + * + * @param string $mailbox Mailbox name + * + * @return bool True on success, False on error + */ + public function deleteFolder($mailbox) + { + // Unselect the folder to prevent "BYE Fatal error: Mailbox has been (re)moved" on Cyrus IMAP + if ($this->selected === $mailbox && $this->hasCapability('UNSELECT')) { + $this->execute('UNSELECT', [], self::COMMAND_NORESPONSE); + } + + $result = $this->execute('DELETE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Removes all messages in a folder + * + * @param string $mailbox Mailbox name + * + * @return bool True on success, False on error + */ + public function clearFolder($mailbox) + { + if ($this->countMessages($mailbox) > 0) { + $res = $this->flag($mailbox, '1:*', 'DELETED'); + } + else { + return true; + } + + if (!empty($res)) { + if ($this->selected === $mailbox) { + $res = $this->close(); + } + else { + $res = $this->expunge($mailbox); + } + + return $res; + } + + return false; + } + + /** + * Returns list of mailboxes + * + * @param string $ref Reference name + * @param string $mailbox Mailbox name + * @param array $return_opts (see self::_listMailboxes) + * @param array $select_opts (see self::_listMailboxes) + * + * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response + * is requested, False on error. + */ + public function listMailboxes($ref, $mailbox, $return_opts = [], $select_opts = []) + { + return $this->_listMailboxes($ref, $mailbox, false, $return_opts, $select_opts); + } + + /** + * Returns list of subscribed mailboxes + * + * @param string $ref Reference name + * @param string $mailbox Mailbox name + * @param array $return_opts (see self::_listMailboxes) + * + * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response + * is requested, False on error. + */ + public function listSubscribed($ref, $mailbox, $return_opts = []) + { + return $this->_listMailboxes($ref, $mailbox, true, $return_opts, null); + } + + /** + * IMAP LIST/LSUB command + * + * @param string $ref Reference name + * @param string $mailbox Mailbox name + * @param bool $subscribed Enables returning subscribed mailboxes only + * @param array $return_opts List of RETURN options (RFC5819: LIST-STATUS, RFC5258: LIST-EXTENDED) + * Possible: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN, + * MYRIGHTS, SUBSCRIBED, CHILDREN + * @param array $select_opts List of selection options (RFC5258: LIST-EXTENDED) + * Possible: SUBSCRIBED, RECURSIVEMATCH, REMOTE, + * SPECIAL-USE (RFC6154) + * + * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response + * is requested, False on error. + */ + protected function _listMailboxes($ref, $mailbox, $subscribed = false, $return_opts = [], $select_opts = []) + { + if (!strlen($mailbox)) { + $mailbox = '*'; + } + + $lstatus = false; + $args = []; + $rets = []; + + if (!empty($select_opts) && $this->getCapability('LIST-EXTENDED')) { + $select_opts = (array) $select_opts; + + $args[] = '(' . implode(' ', $select_opts) . ')'; + } + + $args[] = $this->escape($ref); + $args[] = $this->escape($mailbox); + + if (!empty($return_opts) && $this->getCapability('LIST-EXTENDED')) { + $ext_opts = ['SUBSCRIBED', 'CHILDREN']; + $rets = array_intersect($return_opts, $ext_opts); + $return_opts = array_diff($return_opts, $rets); + } + + if (!empty($return_opts) && $this->getCapability('LIST-STATUS')) { + $lstatus = true; + $status_opts = ['MESSAGES', 'RECENT', 'UIDNEXT', 'UIDVALIDITY', 'UNSEEN', 'SIZE']; + $opts = array_diff($return_opts, $status_opts); + $status_opts = array_diff($return_opts, $opts); + + if (!empty($status_opts)) { + $rets[] = 'STATUS (' . implode(' ', $status_opts) . ')'; + } + + if (!empty($opts)) { + $rets = array_merge($rets, $opts); + } + } + + if (!empty($rets)) { + $args[] = 'RETURN (' . implode(' ', $rets) . ')'; + } + + list($code, $response) = $this->execute($subscribed ? 'LSUB' : 'LIST', $args); + + if ($code == self::ERROR_OK) { + $folders = []; + $last = 0; + $pos = 0; + $response .= "\r\n"; + + while ($pos = strpos($response, "\r\n", $pos+1)) { + // literal string, not real end-of-command-line + if ($response[$pos-1] == '}') { + continue; + } + + $line = substr($response, $last, $pos - $last); + $last = $pos + 2; + + if (!preg_match('/^\* (LIST|LSUB|STATUS|MYRIGHTS) /i', $line, $m)) { + continue; + } + + $cmd = strtoupper($m[1]); + $line = substr($line, strlen($m[0])); + + // * LIST () + if ($cmd == 'LIST' || $cmd == 'LSUB') { + list($opts, $delim, $mailbox) = $this->tokenizeResponse($line, 3); + + // Remove redundant separator at the end of folder name, UW-IMAP bug? (#1488879) + if ($delim) { + $mailbox = rtrim($mailbox, $delim); + } + + // Make it easier for the client to deal with INBOX folder + // by always returning the word with all capital letters + if (strlen($mailbox) == 5 + && ($mailbox[0] == 'i' || $mailbox[0] == 'I') + && ($mailbox[1] == 'n' || $mailbox[1] == 'N') + && ($mailbox[2] == 'b' || $mailbox[2] == 'B') + && ($mailbox[3] == 'o' || $mailbox[3] == 'O') + && ($mailbox[4] == 'x' || $mailbox[4] == 'X') + ) { + $mailbox = 'INBOX'; + } + + // Add to result array + if (!$lstatus) { + $folders[] = $mailbox; + } + else { + $folders[$mailbox] = []; + } + + // store folder options + if ($cmd == 'LIST') { + // Add to options array + if (empty($this->data['LIST'][$mailbox])) { + $this->data['LIST'][$mailbox] = $opts; + } + else if (!empty($opts)) { + $this->data['LIST'][$mailbox] = array_unique(array_merge( + $this->data['LIST'][$mailbox], $opts)); + } + } + } + else if ($lstatus) { + // * STATUS () + if ($cmd == 'STATUS') { + list($mailbox, $status) = $this->tokenizeResponse($line, 2); + + for ($i=0, $len=count($status); $i<$len; $i += 2) { + list($name, $value) = $this->tokenizeResponse($status, 2); + $folders[$mailbox][$name] = $value; + } + } + // * MYRIGHTS + else if ($cmd == 'MYRIGHTS') { + list($mailbox, $acl) = $this->tokenizeResponse($line, 2); + $folders[$mailbox]['MYRIGHTS'] = $acl; + } + } + } + + return $folders; + } + + return false; + } + + /** + * Returns count of all messages in a folder + * + * @param string $mailbox Mailbox name + * + * @return int Number of messages, False on error + */ + public function countMessages($mailbox) + { + if ($this->selected === $mailbox && isset($this->data['EXISTS'])) { + return $this->data['EXISTS']; + } + + // Check internal cache + if (!empty($this->data['STATUS:'.$mailbox])) { + $cache = $this->data['STATUS:'.$mailbox]; + if (isset($cache['MESSAGES'])) { + return (int) $cache['MESSAGES']; + } + } + + // Try STATUS (should be faster than SELECT) + $counts = $this->status($mailbox); + if (is_array($counts)) { + return (int) $counts['MESSAGES']; + } + + return false; + } + + /** + * Returns count of messages with \Recent flag in a folder + * + * @param string $mailbox Mailbox name + * + * @return int Number of messages, False on error + */ + public function countRecent($mailbox) + { + if ($this->selected === $mailbox && isset($this->data['RECENT'])) { + return $this->data['RECENT']; + } + + // Check internal cache + $cache = $this->data['STATUS:'.$mailbox]; + if (!empty($cache) && isset($cache['RECENT'])) { + return (int) $cache['RECENT']; + } + + // Try STATUS (should be faster than SELECT) + $counts = $this->status($mailbox, ['RECENT']); + if (is_array($counts)) { + return (int) $counts['RECENT']; + } + + return false; + } + + /** + * Returns count of messages without \Seen flag in a specified folder + * + * @param string $mailbox Mailbox name + * + * @return int Number of messages, False on error + */ + public function countUnseen($mailbox) + { + // Check internal cache + if (!empty($this->data['STATUS:'.$mailbox])) { + $cache = $this->data['STATUS:'.$mailbox]; + if (isset($cache['UNSEEN'])) { + return (int) $cache['UNSEEN']; + } + } + + // Try STATUS (should be faster than SELECT+SEARCH) + $counts = $this->status($mailbox); + if (is_array($counts)) { + return (int) $counts['UNSEEN']; + } + + // Invoke SEARCH as a fallback + $index = $this->search($mailbox, 'ALL UNSEEN', false, ['COUNT']); + if (!$index->is_error()) { + return $index->count(); + } + + return false; + } + + /** + * Executes ID command (RFC2971) + * + * @param array $items Client identification information key/value hash + * + * @return array|false Server identification information key/value hash, False on error + * @since 0.6 + */ + public function id($items = []) + { + if (is_array($items) && !empty($items)) { + foreach ($items as $key => $value) { + $args[] = $this->escape($key, true); + $args[] = $this->escape($value, true); + } + } + + list($code, $response) = $this->execute('ID', + [!empty($args) ? '(' . implode(' ', (array) $args) . ')' : $this->escape(null)], + 0, '/^\* ID /i' + ); + + if ($code == self::ERROR_OK && $response) { + $response = substr($response, 5); // remove prefix "* ID " + $items = $this->tokenizeResponse($response, 1); + $result = []; + + if (is_array($items)) { + for ($i=0, $len=count($items); $i<$len; $i += 2) { + $result[$items[$i]] = $items[$i+1]; + } + } + + return $result; + } + + return false; + } + + /** + * Executes ENABLE command (RFC5161) + * + * @param mixed $extension Extension name to enable (or array of names) + * + * @return array|bool List of enabled extensions, False on error + * @since 0.6 + */ + public function enable($extension) + { + if (empty($extension)) { + return false; + } + + if (!$this->hasCapability('ENABLE')) { + return false; + } + + if (!is_array($extension)) { + $extension = [$extension]; + } + + if (!empty($this->extensions_enabled)) { + // check if all extensions are already enabled + $diff = array_diff($extension, $this->extensions_enabled); + + if (empty($diff)) { + return $extension; + } + + // Make sure the mailbox isn't selected, before enabling extension(s) + if ($this->selected !== null) { + $this->close(); + } + } + + list($code, $response) = $this->execute('ENABLE', $extension, 0, '/^\* ENABLED /i'); + + if ($code == self::ERROR_OK && $response) { + $response = substr($response, 10); // remove prefix "* ENABLED " + $result = (array) $this->tokenizeResponse($response); + + $this->extensions_enabled = array_unique(array_merge((array)$this->extensions_enabled, $result)); + + return $this->extensions_enabled; + } + + return false; + } + + /** + * Executes SORT command + * + * @param string $mailbox Mailbox name + * @param string $field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO) + * @param string $criteria Searching criteria + * @param bool $return_uid Enables UID SORT usage + * @param string $encoding Character set + * + * @return rcube_result_index Response data + */ + public function sort($mailbox, $field = 'ARRIVAL', $criteria = '', $return_uid = false, $encoding = 'US-ASCII') + { + $old_sel = $this->selected; + $supported = ['ARRIVAL', 'CC', 'DATE', 'FROM', 'SIZE', 'SUBJECT', 'TO']; + $field = strtoupper($field); + + if ($field == 'INTERNALDATE') { + $field = 'ARRIVAL'; + } + + if (!in_array($field, $supported)) { + return new rcube_result_index($mailbox); + } + + if (!$this->select($mailbox)) { + return new rcube_result_index($mailbox); + } + + // return empty result when folder is empty and we're just after SELECT + if ($old_sel != $mailbox && empty($this->data['EXISTS'])) { + return new rcube_result_index($mailbox, '* SORT'); + } + + // RFC 5957: SORT=DISPLAY + if (($field == 'FROM' || $field == 'TO') && $this->getCapability('SORT=DISPLAY')) { + $field = 'DISPLAY' . $field; + } + + $encoding = $encoding ? trim($encoding) : 'US-ASCII'; + $criteria = $criteria ? 'ALL ' . trim($criteria) : 'ALL'; + + list($code, $response) = $this->execute($return_uid ? 'UID SORT' : 'SORT', + ["($field)", $encoding, $criteria]); + + if ($code != self::ERROR_OK) { + $response = null; + } + + return new rcube_result_index($mailbox, $response); + } + + /** + * Executes THREAD command + * + * @param string $mailbox Mailbox name + * @param string $algorithm Threading algorithm (ORDEREDSUBJECT, REFERENCES, REFS) + * @param string $criteria Searching criteria + * @param bool $return_uid Enables UIDs in result instead of sequence numbers + * @param string $encoding Character set + * + * @return rcube_result_thread Thread data + */ + public function thread($mailbox, $algorithm = 'REFERENCES', $criteria = '', $return_uid = false, $encoding = 'US-ASCII') + { + $old_sel = $this->selected; + + if (!$this->select($mailbox)) { + return new rcube_result_thread($mailbox); + } + + // return empty result when folder is empty and we're just after SELECT + if ($old_sel != $mailbox && !$this->data['EXISTS']) { + return new rcube_result_thread($mailbox, '* THREAD'); + } + + $encoding = $encoding ? trim($encoding) : 'US-ASCII'; + $algorithm = $algorithm ? trim($algorithm) : 'REFERENCES'; + $criteria = $criteria ? 'ALL '.trim($criteria) : 'ALL'; + + list($code, $response) = $this->execute($return_uid ? 'UID THREAD' : 'THREAD', + [$algorithm, $encoding, $criteria]); + + if ($code != self::ERROR_OK) { + $response = null; + } + + return new rcube_result_thread($mailbox, $response); + } + + /** + * Executes SEARCH command + * + * @param string $mailbox Mailbox name + * @param string $criteria Searching criteria + * @param bool $return_uid Enable UID in result instead of sequence ID + * @param array $items Return items (MIN, MAX, COUNT, ALL) + * + * @return rcube_result_index Result data + */ + public function search($mailbox, $criteria, $return_uid = false, $items = []) + { + $old_sel = $this->selected; + + if (!$this->select($mailbox)) { + return new rcube_result_index($mailbox); + } + + // return empty result when folder is empty and we're just after SELECT + if ($old_sel != $mailbox && !$this->data['EXISTS']) { + return new rcube_result_index($mailbox, '* SEARCH'); + } + + // If ESEARCH is supported always use ALL + // but not when items are specified or using simple id2uid search + if (empty($items) && preg_match('/[^0-9]/', $criteria)) { + $items = ['ALL']; + } + + $esearch = empty($items) ? false : $this->getCapability('ESEARCH'); + $criteria = trim($criteria); + $params = ''; + + // RFC4731: ESEARCH + if (!empty($items) && $esearch) { + $params .= 'RETURN (' . implode(' ', $items) . ')'; + } + + if (!empty($criteria)) { + $params .= ($params ? ' ' : '') . $criteria; + } + else { + $params .= 'ALL'; + } + + list($code, $response) = $this->execute($return_uid ? 'UID SEARCH' : 'SEARCH', [$params]); + + if ($code != self::ERROR_OK) { + $response = null; + } + + return new rcube_result_index($mailbox, $response); + } + + /** + * Simulates SORT command by using FETCH and sorting. + * + * @param string $mailbox Mailbox name + * @param string|array $message_set Searching criteria (list of messages to return) + * @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO) + * @param bool $skip_deleted Makes that DELETED messages will be skipped + * @param bool $uidfetch Enables UID FETCH usage + * @param bool $return_uid Enables returning UIDs instead of IDs + * + * @return rcube_result_index Response data + */ + public function index($mailbox, $message_set, $index_field = '', $skip_deleted = true, + $uidfetch = false, $return_uid = false) + { + $msg_index = $this->fetchHeaderIndex($mailbox, $message_set, + $index_field, $skip_deleted, $uidfetch, $return_uid); + + if (!empty($msg_index)) { + asort($msg_index); // ASC + $msg_index = array_keys($msg_index); + $msg_index = '* SEARCH ' . implode(' ', $msg_index); + } + else { + $msg_index = is_array($msg_index) ? '* SEARCH' : null; + } + + return new rcube_result_index($mailbox, $msg_index); + } + + /** + * Fetches specified header/data value for a set of messages. + * + * @param string $mailbox Mailbox name + * @param string|array $message_set Searching criteria (list of messages to return) + * @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO) + * @param bool $skip_deleted Makes that DELETED messages will be skipped + * @param bool $uidfetch Enables UID FETCH usage + * @param bool $return_uid Enables returning UIDs instead of IDs + * + * @return array|bool List of header values or False on failure + */ + public function fetchHeaderIndex($mailbox, $message_set, $index_field = '', $skip_deleted = true, + $uidfetch = false, $return_uid = false) + { + // Validate input + if (is_array($message_set)) { + if (!($message_set = $this->compressMessageSet($message_set))) { + return false; + } + } + else if (empty($message_set)) { + return false; + } + else if (strpos($message_set, ':')) { + list($from_idx, $to_idx) = explode(':', $message_set); + if ($to_idx != '*' && (int) $from_idx > (int) $to_idx) { + return false; + } + } + + $index_field = empty($index_field) ? 'DATE' : strtoupper($index_field); + + $supported = [ + 'DATE' => 1, + 'INTERNALDATE' => 4, + 'ARRIVAL' => 4, + 'FROM' => 1, + 'REPLY-TO' => 1, + 'SENDER' => 1, + 'TO' => 1, + 'CC' => 1, + 'SUBJECT' => 1, + 'UID' => 2, + 'SIZE' => 2, + 'SEEN' => 3, + 'RECENT' => 3, + 'DELETED' => 3, + ]; + + if (empty($supported[$index_field])) { + return false; + } + + $mode = $supported[$index_field]; + + // Select the mailbox + if (!$this->select($mailbox)) { + return false; + } + + // build FETCH command string + $key = $this->nextTag(); + $cmd = $uidfetch ? 'UID FETCH' : 'FETCH'; + $fields = []; + + if ($return_uid) { + $fields[] = 'UID'; + } + if ($skip_deleted) { + $fields[] = 'FLAGS'; + } + + if ($mode == 1) { + if ($index_field == 'DATE') { + $fields[] = 'INTERNALDATE'; + } + $fields[] = "BODY.PEEK[HEADER.FIELDS ($index_field)]"; + } + else if ($mode == 2) { + if ($index_field == 'SIZE') { + $fields[] = 'RFC822.SIZE'; + } + else if (!$return_uid || $index_field != 'UID') { + $fields[] = $index_field; + } + } + else if ($mode == 3 && !$skip_deleted) { + $fields[] = 'FLAGS'; + } + else if ($mode == 4) { + $fields[] = 'INTERNALDATE'; + } + + $request = "$key $cmd $message_set (" . implode(' ', $fields) . ")"; + + if (!$this->putLine($request)) { + $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command"); + return false; + } + + $result = []; + + do { + $line = rtrim($this->readLine(200)); + $line = $this->multLine($line); + + if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) { + $id = $m[1]; + $flags = null; + + if ($return_uid) { + if (preg_match('/UID ([0-9]+)/', $line, $matches)) { + $id = (int) $matches[1]; + } + else { + continue; + } + } + + if ($skip_deleted && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) { + $flags = explode(' ', strtoupper($matches[1])); + if (in_array('\\DELETED', $flags)) { + continue; + } + } + + if ($mode == 1 && $index_field == 'DATE') { + if (preg_match('/BODY\[HEADER\.FIELDS \("*DATE"*\)\] (.*)/', $line, $matches)) { + $value = preg_replace(['/^"*[a-z]+:/i'], '', $matches[1]); + $value = trim($value); + $result[$id] = rcube_utils::strtotime($value); + } + // non-existent/empty Date: header, use INTERNALDATE + if (empty($result[$id])) { + if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) { + $result[$id] = rcube_utils::strtotime($matches[1]); + } + else { + $result[$id] = 0; + } + } + } + else if ($mode == 1) { + if (preg_match('/BODY\[HEADER\.FIELDS \("?(FROM|REPLY-TO|SENDER|TO|SUBJECT)"?\)\] (.*)/', $line, $matches)) { + $value = preg_replace(['/^"*[a-z]+:/i', '/\s+$/sm'], ['', ''], $matches[2]); + $result[$id] = trim($value); + } + else { + $result[$id] = ''; + } + } + else if ($mode == 2) { + if (preg_match('/' . $index_field . ' ([0-9]+)/', $line, $matches)) { + $result[$id] = trim($matches[1]); + } + else { + $result[$id] = 0; + } + } + else if ($mode == 3) { + if (!$flags && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) { + $flags = explode(' ', $matches[1]); + } + $result[$id] = in_array("\\".$index_field, (array) $flags) ? 1 : 0; + } + else if ($mode == 4) { + if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) { + $result[$id] = rcube_utils::strtotime($matches[1]); + } + else { + $result[$id] = 0; + } + } + } + } + while (!$this->startsWith($line, $key, true, true)); + + return $result; + } + + /** + * Returns message sequence identifier + * + * @param string $mailbox Mailbox name + * @param int $uid Message unique identifier (UID) + * + * @return int Message sequence identifier + */ + public function UID2ID($mailbox, $uid) + { + if ($uid > 0) { + $index = $this->search($mailbox, "UID $uid"); + + if ($index->count() == 1) { + $arr = $index->get(); + return (int) $arr[0]; + } + } + } + + /** + * Returns message unique identifier (UID) + * + * @param string $mailbox Mailbox name + * @param int $id Message sequence identifier + * + * @return int Message unique identifier + */ + public function ID2UID($mailbox, $id) + { + if (empty($id) || $id < 0) { + return null; + } + + if (!$this->select($mailbox)) { + return null; + } + + if (!empty($this->data['UID-MAP'][$id])) { + return $this->data['UID-MAP'][$id]; + } + + if (isset($this->data['EXISTS']) && $id > $this->data['EXISTS']) { + return null; + } + + $index = $this->search($mailbox, $id, true); + + if ($index->count() == 1) { + $arr = $index->get(); + return $this->data['UID-MAP'][$id] = (int) $arr[0]; + } + } + + /** + * Sets flag of the message(s) + * + * @param string $mailbox Mailbox name + * @param string|array $messages Message UID(s) + * @param string $flag Flag name + * + * @return bool True on success, False on failure + */ + public function flag($mailbox, $messages, $flag) + { + return $this->modFlag($mailbox, $messages, $flag, '+'); + } + + /** + * Unsets flag of the message(s) + * + * @param string $mailbox Mailbox name + * @param string|array $messages Message UID(s) + * @param string $flag Flag name + * + * @return bool True on success, False on failure + */ + public function unflag($mailbox, $messages, $flag) + { + return $this->modFlag($mailbox, $messages, $flag, '-'); + } + + /** + * Changes flag of the message(s) + * + * @param string $mailbox Mailbox name + * @param string|array $messages Message UID(s) + * @param string $flag Flag name + * @param string $mod Modifier [+|-]. Default: "+". + * + * @return bool True on success, False on failure + */ + protected function modFlag($mailbox, $messages, $flag, $mod = '+') + { + if (!$flag) { + return false; + } + + if (!$this->select($mailbox)) { + return false; + } + + if (empty($this->data['READ-WRITE'])) { + $this->setError(self::ERROR_READONLY, "Mailbox is read-only"); + return false; + } + + if (!empty($this->flags[strtoupper($flag)])) { + $flag = $this->flags[strtoupper($flag)]; + } + + // if PERMANENTFLAGS is not specified all flags are allowed + if (!empty($this->data['PERMANENTFLAGS']) + && !in_array($flag, (array) $this->data['PERMANENTFLAGS']) + && !in_array('\\*', (array) $this->data['PERMANENTFLAGS']) + ) { + return false; + } + + // Clear internal status cache + if ($flag == 'SEEN') { + unset($this->data['STATUS:'.$mailbox]['UNSEEN']); + } + + if ($mod != '+' && $mod != '-') { + $mod = '+'; + } + + $result = $this->execute('UID STORE', + [$this->compressMessageSet($messages), $mod . 'FLAGS.SILENT', "($flag)"], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + /** + * Copies message(s) from one folder to another + * + * @param string|array $messages Message UID(s) + * @param string $from Mailbox name + * @param string $to Destination mailbox name + * + * @return bool True on success, False on failure + */ + public function copy($messages, $from, $to) + { + // Clear last COPYUID data + unset($this->data['COPYUID']); + + if (!$this->select($from)) { + return false; + } + + // Clear internal status cache + unset($this->data['STATUS:'.$to]); + + $result = $this->execute('UID COPY', + [$this->compressMessageSet($messages), $this->escape($to)], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + /** + * Moves message(s) from one folder to another. + * + * @param string|array $messages Message UID(s) + * @param string $from Mailbox name + * @param string $to Destination mailbox name + * + * @return bool True on success, False on failure + */ + public function move($messages, $from, $to) + { + if (!$this->select($from)) { + return false; + } + + if (empty($this->data['READ-WRITE'])) { + $this->setError(self::ERROR_READONLY, "Mailbox is read-only"); + return false; + } + + // use MOVE command (RFC 6851) + if ($this->hasCapability('MOVE')) { + // Clear last COPYUID data + unset($this->data['COPYUID']); + + // Clear internal status cache + unset($this->data['STATUS:'.$to]); + $this->clear_status_cache($from); + + $result = $this->execute('UID MOVE', + [$this->compressMessageSet($messages), $this->escape($to)], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + // use COPY + STORE +FLAGS.SILENT \Deleted + EXPUNGE + $result = $this->copy($messages, $from, $to); + + if ($result) { + // Clear internal status cache + unset($this->data['STATUS:'.$from]); + + $result = $this->flag($from, $messages, 'DELETED'); + + if ($messages == '*') { + // CLOSE+SELECT should be faster than EXPUNGE + $this->close(); + } + else { + $this->expunge($from, $messages); + } + } + + return $result; + } + + /** + * FETCH command (RFC3501) + * + * @param string $mailbox Mailbox name + * @param mixed $message_set Message(s) sequence identifier(s) or UID(s) + * @param bool $is_uid True if $message_set contains UIDs + * @param array $query_items FETCH command data items + * @param string $mod_seq Modification sequence for CHANGEDSINCE (RFC4551) query + * @param bool $vanished Enables VANISHED parameter (RFC5162) for CHANGEDSINCE query + * + * @return array List of rcube_message_header elements, False on error + * @since 0.6 + */ + public function fetch($mailbox, $message_set, $is_uid = false, $query_items = [], + $mod_seq = null, $vanished = false) + { + if (!$this->select($mailbox)) { + return false; + } + + $message_set = $this->compressMessageSet($message_set); + $result = []; + + $key = $this->nextTag(); + $cmd = ($is_uid ? 'UID ' : '') . 'FETCH'; + $request = "$key $cmd $message_set (" . implode(' ', $query_items) . ")"; + + if ($mod_seq !== null && $this->hasCapability('CONDSTORE')) { + $request .= " (CHANGEDSINCE $mod_seq" . ($vanished ? " VANISHED" : '') .")"; + } + + if (!$this->putLine($request)) { + $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command"); + return false; + } + + do { + $line = $this->readFullLine(4096); + + if (!$line) { + break; + } + + // Sample reply line: + // * 321 FETCH (UID 2417 RFC822.SIZE 2730 FLAGS (\Seen) + // INTERNALDATE "16-Nov-2008 21:08:46 +0100" BODYSTRUCTURE (...) + // BODY[HEADER.FIELDS ... + + if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) { + $id = intval($m[1]); + + $result[$id] = new rcube_message_header; + $result[$id]->id = $id; + $result[$id]->subject = ''; + $result[$id]->messageID = 'mid:' . $id; + + $headers = null; + $line = substr($line, strlen($m[0]) + 2); + + // Tokenize response and assign to object properties + while (($tokens = $this->tokenizeResponse($line, 2)) && count($tokens) == 2) { + list($name, $value) = $tokens; + if ($name == 'UID') { + $result[$id]->uid = intval($value); + } + else if ($name == 'RFC822.SIZE') { + $result[$id]->size = intval($value); + } + else if ($name == 'RFC822.TEXT') { + $result[$id]->body = $value; + } + else if ($name == 'INTERNALDATE') { + $result[$id]->internaldate = $value; + $result[$id]->date = $value; + $result[$id]->timestamp = rcube_utils::strtotime($value); + } + else if ($name == 'FLAGS') { + if (!empty($value)) { + foreach ((array)$value as $flag) { + $flag = str_replace(['$', "\\"], '', $flag); + $flag = strtoupper($flag); + + $result[$id]->flags[$flag] = true; + } + } + } + else if ($name == 'MODSEQ') { + $result[$id]->modseq = $value[0]; + } + else if ($name == 'ENVELOPE') { + $result[$id]->envelope = $value; + } + else if ($name == 'BODYSTRUCTURE' || ($name == 'BODY' && count($value) > 2)) { + if (!is_array($value[0]) && (strtolower($value[0]) == 'message' && strtolower($value[1]) == 'rfc822')) { + $value = [$value]; + } + $result[$id]->bodystructure = $value; + } + else if ($name == 'RFC822') { + $result[$id]->body = $value; + } + else if (stripos($name, 'BODY[') === 0) { + $name = str_replace(']', '', substr($name, 5)); + + if ($name == 'HEADER.FIELDS') { + // skip ']' after headers list + $this->tokenizeResponse($line, 1); + $headers = $this->tokenizeResponse($line, 1); + } + else if (strlen($name)) { + $result[$id]->bodypart[$name] = $value; + } + else { + $result[$id]->body = $value; + } + } + } + + // create array with header field:data + if (!empty($headers)) { + $headers = explode("\n", trim($headers)); + $lines = []; + $ln = 0; + + foreach ($headers as $resln) { + if (!isset($resln[0]) || ord($resln[0]) <= 32) { + $lines[$ln] = ($lines[$ln] ?? '') . (empty($lines[$ln]) ? '' : "\n") . trim($resln); + } + else { + $lines[++$ln] = trim($resln); + } + } + + foreach ($lines as $str) { + if (strpos($str, ':') === false) { + continue; + } + + list($field, $string) = explode(':', $str, 2); + + $field = strtolower($field); + $string = preg_replace('/\n[\t\s]*/', ' ', trim($string)); + + switch ($field) { + case 'date'; + $string = substr($string, 0, 128); + $result[$id]->date = $string; + $result[$id]->timestamp = rcube_utils::strtotime($string); + break; + case 'to': + $result[$id]->to = preg_replace('/undisclosed-recipients:[;,]*/', '', $string); + break; + case 'from': + case 'subject': + $string = substr($string, 0, 2048); + case 'cc': + case 'bcc': + case 'references': + $result[$id]->{$field} = $string; + break; + case 'reply-to': + $result[$id]->replyto = $string; + break; + case 'content-transfer-encoding': + $result[$id]->encoding = substr($string, 0, 32); + break; + case 'content-type': + $ctype_parts = preg_split('/[; ]+/', $string); + $result[$id]->ctype = strtolower(array_shift($ctype_parts)); + if (preg_match('/charset\s*=\s*"?([a-z0-9\-\.\_]+)"?/i', $string, $regs)) { + $result[$id]->charset = $regs[1]; + } + break; + case 'in-reply-to': + $result[$id]->in_reply_to = str_replace(["\n", '<', '>'], '', $string); + break; + case 'disposition-notification-to': + case 'x-confirm-reading-to': + $result[$id]->mdn_to = substr($string, 0, 2048); + break; + case 'message-id': + $result[$id]->messageID = substr($string, 0, 2048); + break; + case 'x-priority': + if (preg_match('/^(\d+)/', $string, $matches)) { + $result[$id]->priority = intval($matches[1]); + } + break; + default: + if (strlen($field) < 3) { + break; + } + if (!empty($result[$id]->others[$field])) { + $string = array_merge((array) $result[$id]->others[$field], (array) $string); + } + $result[$id]->others[$field] = $string; + } + } + } + } + // VANISHED response (QRESYNC RFC5162) + // Sample: * VANISHED (EARLIER) 300:310,405,411 + else if (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) { + $line = substr($line, strlen($match[0])); + $v_data = $this->tokenizeResponse($line, 1); + + $this->data['VANISHED'] = $v_data; + } + } + while (!$this->startsWith($line, $key, true)); + + return $result; + } + + /** + * Returns message(s) data (flags, headers, etc.) + * + * @param string $mailbox Mailbox name + * @param mixed $message_set Message(s) sequence identifier(s) or UID(s) + * @param bool $is_uid True if $message_set contains UIDs + * @param bool $bodystr Enable to add BODYSTRUCTURE data to the result + * @param array $add_headers List of additional headers + * + * @return bool|array List of rcube_message_header elements, False on error + */ + public function fetchHeaders($mailbox, $message_set, $is_uid = false, $bodystr = false, $add_headers = []) + { + $query_items = ['UID', 'RFC822.SIZE', 'FLAGS', 'INTERNALDATE']; + $headers = ['DATE', 'FROM', 'TO', 'SUBJECT', 'CONTENT-TYPE', 'CC', 'REPLY-TO', + 'LIST-POST', 'DISPOSITION-NOTIFICATION-TO', 'X-PRIORITY']; + + if (!empty($add_headers)) { + $add_headers = array_map('strtoupper', $add_headers); + $headers = array_unique(array_merge($headers, $add_headers)); + } + + if ($bodystr) { + $query_items[] = 'BODYSTRUCTURE'; + } + + $query_items[] = 'BODY.PEEK[HEADER.FIELDS (' . implode(' ', $headers) . ')]'; + + return $this->fetch($mailbox, $message_set, $is_uid, $query_items); + } + + /** + * Returns message data (flags, headers, etc.) + * + * @param string $mailbox Mailbox name + * @param int $id Message sequence identifier or UID + * @param bool $is_uid True if $id is an UID + * @param bool $bodystr Enable to add BODYSTRUCTURE data to the result + * @param array $add_headers List of additional headers + * + * @return bool|rcube_message_header Message data, False on error + */ + public function fetchHeader($mailbox, $id, $is_uid = false, $bodystr = false, $add_headers = []) + { + $a = $this->fetchHeaders($mailbox, $id, $is_uid, $bodystr, $add_headers); + + if (is_array($a)) { + return array_shift($a); + } + + return false; + } + + /** + * Sort messages by specified header field + * + * @param array $messages Array of rcube_message_header objects + * @param string $field Name of the property to sort by + * @param string $order Sorting order (ASC|DESC) + * + * @return array Sorted input array + */ + public static function sortHeaders($messages, $field, $order = 'ASC') + { + $field = empty($field) ? 'uid' : strtolower($field); + $order = empty($order) ? 'ASC' : strtoupper($order); + $index = []; + + reset($messages); + + // Create an index + foreach ($messages as $key => $headers) { + switch ($field) { + case 'arrival': + $field = 'internaldate'; + // no-break + case 'date': + case 'internaldate': + case 'timestamp': + $value = rcube_utils::strtotime($headers->$field); + if (!$value && $field != 'timestamp') { + $value = $headers->timestamp; + } + + break; + + default: + // @TODO: decode header value, convert to UTF-8 + $value = $headers->$field; + if (is_string($value)) { + $value = str_replace('"', '', $value); + + if ($field == 'subject') { + $value = rcube_utils::remove_subject_prefix($value); + } + } + } + + $index[$key] = $value; + } + + $sort_order = $order == 'ASC' ? SORT_ASC : SORT_DESC; + $sort_flags = SORT_STRING | SORT_FLAG_CASE; + + if (in_array($field, ['arrival', 'date', 'internaldate', 'timestamp', 'size', 'uid', 'id'])) { + $sort_flags = SORT_NUMERIC; + } + + array_multisort($index, $sort_order, $sort_flags, $messages); + + return $messages; + } + + /** + * Fetch MIME headers of specified message parts + * + * @param string $mailbox Mailbox name + * @param int $uid Message UID + * @param array $parts Message part identifiers + * @param bool $mime Use MIME instead of HEADER + * + * @return array|bool Array containing headers string for each specified body + * False on failure. + */ + public function fetchMIMEHeaders($mailbox, $uid, $parts, $mime = true) + { + if (!$this->select($mailbox)) { + return false; + } + + $parts = (array) $parts; + $key = $this->nextTag(); + $peeks = []; + $type = $mime ? 'MIME' : 'HEADER'; + + // format request + foreach ($parts as $part) { + $peeks[] = "BODY.PEEK[$part.$type]"; + } + + $request = "$key UID FETCH $uid (" . implode(' ', $peeks) . ')'; + + // send request + if (!$this->putLine($request)) { + $this->setError(self::ERROR_COMMAND, "Failed to send UID FETCH command"); + return false; + } + + $result = []; + + do { + $line = $this->readLine(1024); + if (preg_match('/^\* [0-9]+ FETCH [0-9UID( ]+/', $line, $m)) { + $line = ltrim(substr($line, strlen($m[0]))); + while (preg_match('/^\s*BODY\[([0-9\.]+)\.'.$type.'\]/', $line, $matches)) { + $line = substr($line, strlen($matches[0])); + $result[$matches[1]] = trim($this->multLine($line)); + $line = $this->readLine(1024); + } + } + } + while (!$this->startsWith($line, $key, true)); + + return $result; + } + + /** + * Fetches message part header + */ + public function fetchPartHeader($mailbox, $id, $is_uid = false, $part = null) + { + $part = empty($part) ? 'HEADER' : $part.'.MIME'; + + return $this->handlePartBody($mailbox, $id, $is_uid, $part); + } + + /** + * Fetches body of the specified message part + */ + public function handlePartBody($mailbox, $id, $is_uid = false, $part = '', $encoding = null, $print = null, + $file = null, $formatted = false, $max_bytes = 0) + { + if (!$this->select($mailbox)) { + return false; + } + + $binary = true; + $initiated = false; + + do { + if (!$initiated) { + switch ($encoding) { + case 'base64': + $mode = 1; + break; + case 'quoted-printable': + $mode = 2; + break; + case 'x-uuencode': + case 'x-uue': + case 'uue': + case 'uuencode': + $mode = 3; + break; + default: + $mode = $formatted ? 4 : 0; + } + + // Use BINARY extension when possible (and safe) + $binary = $binary && $mode && preg_match('/^[0-9.]+$/', (string) $part) && $this->hasCapability('BINARY'); + $fetch_mode = $binary ? 'BINARY' : 'BODY'; + $partial = $max_bytes ? sprintf('<0.%d>', $max_bytes) : ''; + + // format request + $key = $this->nextTag(); + $cmd = ($is_uid ? 'UID ' : '') . 'FETCH'; + $request = "$key $cmd $id ($fetch_mode.PEEK[$part]$partial)"; + $result = false; + $found = false; + $initiated = true; + + // send request + if (!$this->putLine($request)) { + $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command"); + return false; + } + + if ($binary) { + // WARNING: Use $formatted argument with care, this may break binary data stream + $mode = -1; + } + } + + $line = trim($this->readLine(1024)); + + if (!$line) { + break; + } + + // handle UNKNOWN-CTE response - RFC 3516, try again with standard BODY request + if ($binary && !$found && preg_match('/^' . $key . ' NO \[(UNKNOWN-CTE|PARSE)\]/i', $line)) { + $binary = $initiated = false; + continue; + } + + // skip irrelevant untagged responses (we have a result already) + if ($found || !preg_match('/^\* ([0-9]+) FETCH (.*)$/', $line, $m)) { + continue; + } + + $line = $m[2]; + + // handle one line response + if ($line[0] == '(' && substr($line, -1) == ')') { + // tokenize content inside brackets + // the content can be e.g.: (UID 9844 BODY[2.4] NIL) + $line = preg_replace('/(^\(|\)$)/', '', $line); + $tokens = $this->tokenizeResponse($line); + + for ($i=0; $ireadLine(1024)); // the OK response line + continue; + } + + if ($result !== false) { + $result = $this->decodeContent($result, $mode, true); + } + } + // response with string literal + else if (preg_match('/\{([0-9]+)\}$/', $line, $m)) { + $bytes = (int) $m[1]; + $prev = ''; + $found = true; + $chunkSize = 1024 * 1024; + + // empty body + if (!$bytes) { + $result = ''; + } + // An optimal path for a case when we need the body as-is in a string + else if (!$mode && !$file && !$print) { + $result = $this->readBytes($bytes); + } + else while ($bytes > 0) { + $chunk = $this->readBytes($bytes > $chunkSize ? $chunkSize : $bytes); + + if ($chunk === '') { + break; + } + + $len = strlen($chunk); + + if ($len > $bytes) { + $chunk = substr($chunk, 0, $bytes); + $len = strlen($chunk); + } + $bytes -= $len; + + $chunk = $this->decodeContent($chunk, $mode, $bytes <= 0, $prev); + + if ($file) { + if (fwrite($file, $chunk) === false) { + break; + } + } + else if ($print) { + echo $chunk; + } + else { + $result .= $chunk; + } + } + } + } + while (!$this->startsWith($line, $key, true) || !$initiated); + + if ($result !== false) { + if ($file) { + return fwrite($file, $result); + } + else if ($print) { + echo $result; + return true; + } + + return $result; + } + + return false; + } + + /** + * Decodes a chunk of a message part content from a FETCH response. + * + * @param string $chunk Content + * @param int $mode Encoding mode + * @param bool $is_last Whether it is a last chunk of data + * @param string $prev Extra content from the previous chunk + * + * @return string Encoded string + */ + protected static function decodeContent($chunk, $mode, $is_last = false, &$prev = '') + { + // BASE64 + if ($mode == 1) { + $chunk = $prev . preg_replace('|[^a-zA-Z0-9+=/]|', '', $chunk); + + // create chunks with proper length for base64 decoding + $length = strlen($chunk); + + if ($length % 4) { + $length = floor($length / 4) * 4; + $prev = substr($chunk, $length); + $chunk = substr($chunk, 0, $length); + } + else { + $prev = ''; + } + + return base64_decode($chunk); + } + + // QUOTED-PRINTABLE + if ($mode == 2) { + if (!self::decodeContentChunk($chunk, $prev, $is_last)) { + return ''; + } + + $chunk = preg_replace('/[\t\r\0\x0B]+\n/', "\n", $chunk); + + return quoted_printable_decode($chunk); + } + + // X-UUENCODE + if ($mode == 3) { + if (!self::decodeContentChunk($chunk, $prev, $is_last)) { + return ''; + } + + $chunk = preg_replace( + ['/\r?\n/', '/(^|\n)end$/', '/^begin\s+[0-7]{3,4}\s+[^\n]+\n/'], + ["\n", '', ''], + $chunk + ); + + if (!strlen($chunk)) { + return ''; + } + + return convert_uudecode($chunk); + } + + // Plain text formatted + // TODO: Formatting should be handled outside of this class + if ($mode == 4) { + if (!self::decodeContentChunk($chunk, $prev, $is_last)) { + return ''; + } + + if ($is_last) { + $chunk = rtrim($chunk, "\t\r\n\0\x0B"); + } + + return preg_replace('/[\t\r\0\x0B]+\n/', "\n", $chunk); + } + + return $chunk; + } + + /** + * A helper for a new-line aware parsing. See self::decodeContent(). + */ + private static function decodeContentChunk(&$chunk, &$prev, $is_last) + { + $chunk = $prev . $chunk; + $prev = ''; + + if (!$is_last) { + if (($pos = strrpos($chunk, "\n")) !== false) { + $prev = substr($chunk, $pos + 1); + $chunk = substr($chunk, 0, $pos + 1); + } else { + $prev = $chunk; + return false; + } + } + + return true; + } + + /** + * Handler for IMAP APPEND command + * + * @param string $mailbox Mailbox name + * @param string|array $message The message source string or array (of strings and file pointers) + * @param array $flags Message flags + * @param string $date Message internal date + * @param bool $binary Enable BINARY append (RFC3516) + * + * @return string|bool On success APPENDUID response (if available) or True, False on failure + */ + public function append($mailbox, &$message, $flags = [], $date = null, $binary = false) + { + unset($this->data['APPENDUID']); + + if ($mailbox === null || $mailbox === '') { + return false; + } + + $binary = $binary && $this->getCapability('BINARY'); + $literal_plus = !$binary && !empty($this->prefs['literal+']); + $len = 0; + $msg = is_array($message) ? $message : [&$message]; + $chunk_size = 512000; + + for ($i=0, $cnt=count($msg); $i<$cnt; $i++) { + if (is_resource($msg[$i])) { + $stat = fstat($msg[$i]); + if ($stat === false) { + return false; + } + $len += $stat['size']; + } + else { + if (!$binary) { + $msg[$i] = str_replace("\r", '', $msg[$i]); + $msg[$i] = str_replace("\n", "\r\n", $msg[$i]); + } + + $len += strlen($msg[$i]); + } + } + + if (!$len) { + return false; + } + + // build APPEND command + $key = $this->nextTag(); + $request = "$key APPEND " . $this->escape($mailbox) . ' (' . $this->flagsToStr($flags) . ')'; + if (!empty($date)) { + $request .= ' ' . $this->escape($date); + } + $request .= ' ' . ($binary ? '~' : '') . '{' . $len . ($literal_plus ? '+' : '') . '}'; + + // send APPEND command + if (!$this->putLine($request)) { + $this->setError(self::ERROR_COMMAND, "Failed to send APPEND command"); + return false; + } + + // Do not wait when LITERAL+ is supported + if (!$literal_plus) { + $line = $this->readReply(); + + if ($line[0] != '+') { + $this->parseResult($line, 'APPEND: '); + return false; + } + } + + foreach ($msg as $msg_part) { + // file pointer + if (is_resource($msg_part)) { + rewind($msg_part); + while (!feof($msg_part) && $this->fp) { + $buffer = fread($msg_part, $chunk_size); + $this->putLine($buffer, false); + } + fclose($msg_part); + } + // string + else { + $size = strlen($msg_part); + + // Break up the data by sending one chunk (up to 512k) at a time. + // This approach reduces our peak memory usage + for ($offset = 0; $offset < $size; $offset += $chunk_size) { + $chunk = substr($msg_part, $offset, $chunk_size); + if (!$this->putLine($chunk, false)) { + return false; + } + } + } + } + + if (!$this->putLine('')) { // \r\n + return false; + } + + do { + $line = $this->readLine(); + } while (!$this->startsWith($line, $key, true, true)); + + // Clear internal status cache + unset($this->data['STATUS:'.$mailbox]); + + if ($this->parseResult($line, 'APPEND: ') != self::ERROR_OK) { + return false; + } + + if (!empty($this->data['APPENDUID'])) { + return $this->data['APPENDUID']; + } + + return true; + } + + /** + * Handler for IMAP APPEND command. + * + * @param string $mailbox Mailbox name + * @param string $path Path to the file with message body + * @param string $headers Message headers + * @param array $flags Message flags + * @param string $date Message internal date + * @param bool $binary Enable BINARY append (RFC3516) + * + * @return string|bool On success APPENDUID response (if available) or True, False on failure + */ + public function appendFromFile($mailbox, $path, $headers = null, $flags = [], $date = null, $binary = false) + { + // open message file + if (file_exists(realpath($path))) { + $fp = fopen($path, 'r'); + } + + if (empty($fp)) { + $this->setError(self::ERROR_UNKNOWN, "Couldn't open $path for reading"); + return false; + } + + $message = []; + if ($headers) { + $message[] = trim($headers, "\r\n") . "\r\n\r\n"; + } + $message[] = $fp; + + return $this->append($mailbox, $message, $flags, $date, $binary); + } + + /** + * Returns QUOTA information + * + * @param string $mailbox Mailbox name + * + * @return array|false Quota information, False on error + */ + public function getQuota($mailbox = null) + { + if ($mailbox === null || $mailbox === '') { + $mailbox = 'INBOX'; + } + + // a0001 GETQUOTAROOT INBOX + // * QUOTAROOT INBOX user/sample + // * QUOTA user/sample (STORAGE 654 9765) + // a0001 OK Completed + + list($code, $response) = $this->execute('GETQUOTAROOT', [$this->escape($mailbox)], 0, '/^\* QUOTA /i'); + + if ($code != self::ERROR_OK) { + return false; + } + + $min_free = PHP_INT_MAX; + $result = []; + $all = []; + + foreach (explode("\n", $response) as $line) { + $tokens = $this->tokenizeResponse($line, 3); + $quota_root = $tokens[2] ?? null; + $quotas = $this->tokenizeResponse($line, 1); + + if (empty($quotas)) { + continue; + } + + foreach (array_chunk($quotas, 3) as $quota) { + list($type, $used, $total) = $quota; + $type = strtolower($type); + + if ($type && $total) { + $all[$quota_root][$type]['used'] = intval($used); + $all[$quota_root][$type]['total'] = intval($total); + } + } + + if (empty($all[$quota_root]['storage'])) { + continue; + } + + $used = $all[$quota_root]['storage']['used']; + $total = $all[$quota_root]['storage']['total']; + $free = $total - $used; + + // calculate lowest available space from all storage quotas + if ($free < $min_free) { + $min_free = $free; + $result['used'] = $used; + $result['total'] = $total; + $result['percent'] = min(100, round(($used/max(1,$total))*100)); + $result['free'] = 100 - $result['percent']; + } + } + + if (!empty($result)) { + $result['all'] = $all; + } + + return $result; + } + + /** + * Send the SETACL command (RFC4314) + * + * @param string $mailbox Mailbox name + * @param string $user User name + * @param mixed $acl ACL string or array + * + * @return bool True on success, False on failure + * + * @since 0.5-beta + */ + public function setACL($mailbox, $user, $acl) + { + if (is_array($acl)) { + $acl = implode('', $acl); + } + + $result = $this->execute('SETACL', + [$this->escape($mailbox), $this->escape($user), strtolower($acl)], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + /** + * Send the DELETEACL command (RFC4314) + * + * @param string $mailbox Mailbox name + * @param string $user User name + * + * @return bool True on success, False on failure + * + * @since 0.5-beta + */ + public function deleteACL($mailbox, $user) + { + $result = $this->execute('DELETEACL', + [$this->escape($mailbox), $this->escape($user)], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + /** + * Send the GETACL command (RFC4314) + * + * @param string $mailbox Mailbox name + * + * @return array User-rights array on success, NULL on error + * @since 0.5-beta + */ + public function getACL($mailbox) + { + list($code, $response) = $this->execute('GETACL', [$this->escape($mailbox)], 0, '/^\* ACL /i'); + + if ($code == self::ERROR_OK && $response) { + // Parse server response (remove "* ACL ") + $response = substr($response, 6); + $ret = $this->tokenizeResponse($response); + $mbox = array_shift($ret); + $size = count($ret); + + // Create user-rights hash array + // @TODO: consider implementing fixACL() method according to RFC4314.2.1.1 + // so we could return only standard rights defined in RFC4314, + // excluding 'c' and 'd' defined in RFC2086. + if ($size % 2 == 0) { + for ($i=0; $i<$size; $i++) { + $ret[$ret[$i]] = str_split($ret[++$i]); + unset($ret[$i-1]); + unset($ret[$i]); + } + return $ret; + } + + $this->setError(self::ERROR_COMMAND, "Incomplete ACL response"); + } + } + + /** + * Send the LISTRIGHTS command (RFC4314) + * + * @param string $mailbox Mailbox name + * @param string $user User name + * + * @return array List of user rights + * @since 0.5-beta + */ + public function listRights($mailbox, $user) + { + list($code, $response) = $this->execute('LISTRIGHTS', + [$this->escape($mailbox), $this->escape($user)], 0, '/^\* LISTRIGHTS /i'); + + if ($code == self::ERROR_OK && $response) { + // Parse server response (remove "* LISTRIGHTS ") + $response = substr($response, 13); + + $ret_mbox = $this->tokenizeResponse($response, 1); + $ret_user = $this->tokenizeResponse($response, 1); + $granted = $this->tokenizeResponse($response, 1); + $optional = trim($response); + + return [ + 'granted' => str_split($granted), + 'optional' => explode(' ', $optional), + ]; + } + } + + /** + * Send the MYRIGHTS command (RFC4314) + * + * @param string $mailbox Mailbox name + * + * @return array MYRIGHTS response on success, NULL on error + * @since 0.5-beta + */ + public function myRights($mailbox) + { + list($code, $response) = $this->execute('MYRIGHTS', [$this->escape($mailbox)], 0, '/^\* MYRIGHTS /i'); + + if ($code == self::ERROR_OK && $response) { + // Parse server response (remove "* MYRIGHTS ") + $response = substr($response, 11); + + $ret_mbox = $this->tokenizeResponse($response, 1); + $rights = $this->tokenizeResponse($response, 1); + + return str_split($rights); + } + } + + /** + * Send the SETMETADATA command (RFC5464) + * + * @param string $mailbox Mailbox name + * @param array $entries Entry-value array (use NULL value as NIL) + * + * @return bool True on success, False on failure + * @since 0.5-beta + */ + public function setMetadata($mailbox, $entries) + { + if (!is_array($entries) || empty($entries)) { + $this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command"); + return false; + } + + foreach ($entries as $name => $value) { + $entries[$name] = $this->escape($name) . ' ' . $this->escape($value, true); + } + + $entries = implode(' ', $entries); + $result = $this->execute('SETMETADATA', + [$this->escape($mailbox), '(' . $entries . ')'], + self::COMMAND_NORESPONSE + ); + + return $result == self::ERROR_OK; + } + + /** + * Send the SETMETADATA command with NIL values (RFC5464) + * + * @param string $mailbox Mailbox name + * @param array $entries Entry names array + * + * @return bool True on success, False on failure + * + * @since 0.5-beta + */ + public function deleteMetadata($mailbox, $entries) + { + if (!is_array($entries) && !empty($entries)) { + $entries = explode(' ', $entries); + } + + if (empty($entries)) { + $this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command"); + return false; + } + + $data = []; + foreach ($entries as $entry) { + $data[$entry] = null; + } + + return $this->setMetadata($mailbox, $data); + } + + /** + * Send the GETMETADATA command (RFC5464) + * + * @param string $mailbox Mailbox name + * @param array $entries Entries + * @param array $options Command options (with MAXSIZE and DEPTH keys) + * + * @return array GETMETADATA result on success, NULL on error + * + * @since 0.5-beta + */ + public function getMetadata($mailbox, $entries, $options = []) + { + if (!is_array($entries)) { + $entries = [$entries]; + } + + $args = []; + + // create options string + if (is_array($options)) { + $options = array_change_key_case($options, CASE_UPPER); + $opts = []; + + if (!empty($options['MAXSIZE'])) { + $opts[] = 'MAXSIZE '.intval($options['MAXSIZE']); + } + + if (isset($options['DEPTH'])) { + $opts[] = 'DEPTH ' . $this->escape($options['DEPTH']); + } + + if (!empty($opts)) { + $args[] = $opts; + } + } + + $args[] = $this->escape($mailbox); + $args[] = array_map([$this, 'escape'], $entries); + + list($code, $response) = $this->execute('GETMETADATA', $args); + + if ($code == self::ERROR_OK) { + $result = []; + $data = $this->tokenizeResponse($response); + + // The METADATA response can contain multiple entries in a single + // response or multiple responses for each entry or group of entries + for ($i = 0, $size = count($data); $i < $size; $i++) { + if ($data[$i] === '*' + && $data[++$i] === 'METADATA' + && is_string($mbox = $data[++$i]) + && is_array($data[++$i]) + ) { + for ($x = 0, $size2 = count($data[$i]); $x < $size2; $x += 2) { + if ($data[$i][$x+1] !== null) { + $result[$mbox][$data[$i][$x]] = $data[$i][$x+1]; + } + } + } + } + + return $result; + } + } + + /** + * Send the SETANNOTATION command (draft-daboo-imap-annotatemore) + * + * @param string $mailbox Mailbox name + * @param array $data Data array where each item is an array with + * three elements: entry name, attribute name, value + * + * @return bool True on success, False on failure + * @since 0.5-beta + */ + public function setAnnotation($mailbox, $data) + { + if (!is_array($data) || empty($data)) { + $this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command"); + return false; + } + + foreach ($data as $entry) { + // ANNOTATEMORE drafts before version 08 require quoted parameters + $entries[] = sprintf('%s (%s %s)', $this->escape($entry[0], true), + $this->escape($entry[1], true), $this->escape($entry[2], true)); + } + + $entries = implode(' ', $entries); + $result = $this->execute('SETANNOTATION', [$this->escape($mailbox), $entries], self::COMMAND_NORESPONSE); + + return $result == self::ERROR_OK; + } + + /** + * Send the SETANNOTATION command with NIL values (draft-daboo-imap-annotatemore) + * + * @param string $mailbox Mailbox name + * @param array $data Data array where each item is an array with + * two elements: entry name and attribute name + * + * @return bool True on success, False on failure + * + * @since 0.5-beta + */ + public function deleteAnnotation($mailbox, $data) + { + if (!is_array($data) || empty($data)) { + $this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command"); + return false; + } + + return $this->setAnnotation($mailbox, $data); + } + + /** + * Send the GETANNOTATION command (draft-daboo-imap-annotatemore) + * + * @param string $mailbox Mailbox name + * @param array $entries Entries names + * @param array $attribs Attribs names + * + * @return array Annotations result on success, NULL on error + * + * @since 0.5-beta + */ + public function getAnnotation($mailbox, $entries, $attribs) + { + if (!is_array($entries)) { + $entries = [$entries]; + } + + // create entries string + // ANNOTATEMORE drafts before version 08 require quoted parameters + foreach ($entries as $idx => $name) { + $entries[$idx] = $this->escape($name, true); + } + $entries = '(' . implode(' ', $entries) . ')'; + + if (!is_array($attribs)) { + $attribs = [$attribs]; + } + + // create attributes string + foreach ($attribs as $idx => $name) { + $attribs[$idx] = $this->escape($name, true); + } + $attribs = '(' . implode(' ', $attribs) . ')'; + + list($code, $response) = $this->execute('GETANNOTATION', [$this->escape($mailbox), $entries, $attribs]); + + if ($code == self::ERROR_OK) { + $result = []; + $data = $this->tokenizeResponse($response); + $last_entry = null; + + // Here we returns only data compatible with METADATA result format + if (!empty($data) && ($size = count($data))) { + for ($i=0; $i<$size; $i++) { + $entry = $data[$i]; + if (isset($mbox) && is_array($entry)) { + $attribs = $entry; + $entry = $last_entry; + } + else if ($entry == '*') { + if ($data[$i+1] == 'ANNOTATION') { + $mbox = $data[$i+2]; + unset($data[$i]); // "*" + unset($data[++$i]); // "ANNOTATION" + unset($data[++$i]); // Mailbox + } + // get rid of other untagged responses + else { + unset($mbox); + unset($data[$i]); + } + continue; + } + else if (isset($mbox)) { + $attribs = $data[++$i]; + } + else { + unset($data[$i]); + continue; + } + + if (!empty($attribs)) { + for ($x=0, $len=count($attribs); $x<$len;) { + $attr = $attribs[$x++]; + $value = $attribs[$x++]; + if ($attr == 'value.priv' && $value !== null) { + $result[$mbox]['/private' . $entry] = $value; + } + else if ($attr == 'value.shared' && $value !== null) { + $result[$mbox]['/shared' . $entry] = $value; + } + } + } + + $last_entry = $entry; + unset($data[$i]); + } + } + + return $result; + } + } + + /** + * Returns BODYSTRUCTURE for the specified message. + * + * @param string $mailbox Folder name + * @param int $id Message sequence number or UID + * @param bool $is_uid True if $id is an UID + * + * @return array|bool Body structure array or False on error. + * @since 0.6 + */ + public function getStructure($mailbox, $id, $is_uid = false) + { + $result = $this->fetch($mailbox, $id, $is_uid, ['BODYSTRUCTURE']); + + if (is_array($result) && !empty($result)) { + $result = array_shift($result); + return $result->bodystructure; + } + + return false; + } + + /** + * Returns data of a message part according to specified structure. + * + * @param array $structure Message structure (getStructure() result) + * @param string $part Message part identifier + * + * @return array Part data as hash array (type, encoding, charset, size) + */ + public static function getStructurePartData($structure, $part) + { + $part_a = self::getStructurePartArray($structure, $part); + $data = []; + + if (empty($part_a)) { + return $data; + } + + // content-type + if (is_array($part_a[0])) { + $data['type'] = 'multipart'; + } + else { + $data['type'] = strtolower($part_a[0]); + $data['subtype'] = strtolower($part_a[1]); + $data['encoding'] = strtolower($part_a[5]); + + // charset + if (is_array($part_a[2])) { + foreach ($part_a[2] as $key => $val) { + if (strcasecmp($val, 'charset') == 0) { + $data['charset'] = $part_a[2][$key+1]; + break; + } + } + } + } + + // size + $data['size'] = intval($part_a[6]); + + return $data; + } + + public static function getStructurePartArray($a, $part) + { + if (!is_array($a)) { + return false; + } + + if (empty($part)) { + return $a; + } + + $ctype = is_string($a[0]) && is_string($a[1]) ? $a[0] . '/' . $a[1] : ''; + + if (strcasecmp($ctype, 'message/rfc822') == 0) { + $a = $a[8]; + } + + if (strpos($part, '.') > 0) { + $orig_part = $part; + $pos = strpos($part, '.'); + $rest = substr($orig_part, $pos+1); + $part = substr($orig_part, 0, $pos); + + return self::getStructurePartArray($a[$part-1], $rest); + } + else if ($part > 0) { + return is_array($a[$part-1]) ? $a[$part-1] : $a; + } + } + + /** + * Creates next command identifier (tag) + * + * @return string Command identifier + * @since 0.5-beta + */ + public function nextTag() + { + $this->cmd_num++; + $this->cmd_tag = sprintf('A%04d', $this->cmd_num); + + return $this->cmd_tag; + } + + /** + * Sends IMAP command and parses result + * + * @param string $command IMAP command + * @param array $arguments Command arguments + * @param int $options Execution options + * @param string $filter Line filter (regexp) + * + * @return mixed Response code or list of response code and data + * @since 0.5-beta + */ + public function execute($command, $arguments = [], $options = 0, $filter = null) + { + $tag = $this->nextTag(); + $query = $tag . ' ' . $command; + $noresp = ($options & self::COMMAND_NORESPONSE); + $response = $noresp ? null : ''; + + if (!empty($arguments)) { + foreach ($arguments as $arg) { + $query .= ' ' . self::r_implode($arg); + } + } + + // Send command + if (!$this->putLineC($query, true, ($options & self::COMMAND_ANONYMIZED))) { + preg_match('/^[A-Z0-9]+ ((UID )?[A-Z]+)/', $query, $matches); + $cmd = $matches[1] ?: 'UNKNOWN'; + $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command"); + + return $noresp ? self::ERROR_COMMAND : [self::ERROR_COMMAND, '']; + } + + // Parse response + do { + $line = $this->readFullLine(4096); + + if ($response !== null) { + if (!$filter || preg_match($filter, $line)) { + $response .= $line; + } + } + + // parse untagged response for [COPYUID 1204196876 3456:3457 123:124] (RFC6851) + if ($line && $command == 'UID MOVE') { + if (preg_match("/^\* OK \[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $line, $m)) { + $this->data['COPYUID'] = [$m[1], $m[2]]; + } + } + } + while (!$this->startsWith($line, $tag . ' ', true, true)); + + $code = $this->parseResult($line, $command . ': '); + + // Remove last line from response + if ($response) { + if (!$filter) { + $line_len = min(strlen($response), strlen($line)); + $response = substr($response, 0, -$line_len); + } + + $response = rtrim($response, "\r\n"); + } + + // optional CAPABILITY response + if (($options & self::COMMAND_CAPABILITY) && $code == self::ERROR_OK + && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches) + ) { + $this->parseCapability($matches[1], true); + } + + // return last line only (without command tag, result and response code) + if ($line && ($options & self::COMMAND_LASTLINE)) { + $response = preg_replace("/^$tag (OK|NO|BAD|BYE|PREAUTH)?\s*(\[[a-z-]+\])?\s*/i", '', trim($line)); + } + + return $noresp ? $code : [$code, $response]; + } + + /** + * Splits IMAP response into string tokens + * + * @param string &$str The IMAP's server response + * @param int $num Number of tokens to return + * + * @return mixed Tokens array or string if $num=1 + * @since 0.5-beta + */ + public static function tokenizeResponse(&$str, $num=0) + { + $result = []; + + while (!$num || count($result) < $num) { + // remove spaces from the beginning of the string + $str = ltrim($str); + + // empty string + if ($str === '' || $str === null) { + break; + } + + switch ($str[0]) { + + // String literal + case '{': + if (($epos = strpos($str, "}\r\n", 1)) == false) { + // error + } + if (!is_numeric(($bytes = substr($str, 1, $epos - 1)))) { + // error + } + + $result[] = $bytes ? substr($str, $epos + 3, $bytes) : ''; + $str = substr($str, $epos + 3 + $bytes); + break; + + // Quoted string + case '"': + $len = strlen($str); + + for ($pos=1; $pos<$len; $pos++) { + if ($str[$pos] == '"') { + break; + } + if ($str[$pos] == "\\") { + if ($str[$pos + 1] == '"' || $str[$pos + 1] == "\\") { + $pos++; + } + } + } + + // we need to strip slashes for a quoted string + $result[] = stripslashes(substr($str, 1, $pos - 1)); + $str = substr($str, $pos + 1); + break; + + // Parenthesized list + case '(': + $str = substr($str, 1); + $result[] = self::tokenizeResponse($str); + break; + + case ')': + $str = substr($str, 1); + return $result; + + // String atom, number, astring, NIL, *, % + default: + // excluded chars: SP, CTL, ), DEL + // we do not exclude [ and ] (#1489223) + if (preg_match('/^([^\x00-\x20\x29\x7F]+)/', $str, $m)) { + $result[] = $m[1] == 'NIL' ? null : $m[1]; + $str = substr($str, strlen($m[1])); + } + + break; + } + } + + return $num == 1 ? ($result[0] ?? '') : $result; + } + + /** + * Joins IMAP command line elements (recursively) + */ + protected static function r_implode($element) + { + if (!is_array($element)) { + return $element; + } + + reset($element); + + $string = ''; + + foreach ($element as $value) { + $string .= ' ' . self::r_implode($value); + } + + return '(' . trim($string) . ')'; + } + + /** + * Converts message identifiers array into sequence-set syntax + * + * @param array $messages Message identifiers + * @param bool $force Forces compression of any size + * + * @return string Compressed sequence-set + */ + public static function compressMessageSet($messages, $force = false) + { + // given a comma delimited list of independent mid's, + // compresses by grouping sequences together + if (!is_array($messages)) { + // if less than 255 bytes long, let's not bother + if (!$force && strlen($messages) < 255) { + return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages; + } + + // see if it's already been compressed + if (strpos($messages, ':') !== false) { + return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages; + } + + // separate, then sort + $messages = explode(',', $messages); + } + + sort($messages); + + $result = []; + $start = $prev = $messages[0]; + + foreach ($messages as $id) { + $incr = $id - $prev; + if ($incr > 1) { // found a gap + if ($start == $prev) { + $result[] = $prev; // push single id + } + else { + $result[] = $start . ':' . $prev; // push sequence as start_id:end_id + } + $start = $id; // start of new sequence + } + $prev = $id; + } + + // handle the last sequence/id + if ($start == $prev) { + $result[] = $prev; + } + else { + $result[] = $start.':'.$prev; + } + + // return as comma separated string + $result = implode(',', $result); + + return preg_match('/[^0-9:,*]/', $result) ? 'INVALID' : $result; + } + + /** + * Converts message sequence-set into array + * + * @param string $messages Message identifiers + * + * @return array List of message identifiers + */ + public static function uncompressMessageSet($messages) + { + if (empty($messages)) { + return []; + } + + $result = []; + $messages = explode(',', $messages); + + foreach ($messages as $idx => $part) { + $items = explode(':', $part); + + if (!empty($items[1]) && $items[1] > $items[0]) { + $max = $items[1]; + } + else { + $max = $items[0]; + } + + for ($x = $items[0]; $x <= $max; $x++) { + $result[] = (int) $x; + } + + unset($messages[$idx]); + } + + return $result; + } + + /** + * Clear internal status cache + */ + protected function clear_status_cache($mailbox) + { + unset($this->data['STATUS:' . $mailbox]); + + $keys = ['EXISTS', 'RECENT', 'UNSEEN', 'UID-MAP']; + + foreach ($keys as $key) { + unset($this->data[$key]); + } + } + + /** + * Clear internal cache of the current mailbox + */ + protected function clear_mailbox_cache() + { + $this->clear_status_cache($this->selected); + + $keys = ['UIDNEXT', 'UIDVALIDITY', 'HIGHESTMODSEQ', 'NOMODSEQ', + 'PERMANENTFLAGS', 'QRESYNC', 'VANISHED', 'READ-WRITE']; + + foreach ($keys as $key) { + unset($this->data[$key]); + } + } + + /** + * Converts flags array into string for inclusion in IMAP command + * + * @param array $flags Flags (see self::flags) + * + * @return string Space-separated list of flags + */ + protected function flagsToStr($flags) + { + foreach ((array) $flags as $idx => $flag) { + if ($flag = $this->flags[strtoupper($flag)]) { + $flags[$idx] = $flag; + } + } + + return implode(' ', (array) $flags); + } + + /** + * CAPABILITY response parser + */ + protected function parseCapability($str, $trusted=false) + { + $str = preg_replace('/^\* CAPABILITY /i', '', $str); + + $this->capability = explode(' ', strtoupper($str)); + + if (!empty($this->prefs['disabled_caps'])) { + $this->capability = array_diff($this->capability, $this->prefs['disabled_caps']); + } + + if (!isset($this->prefs['literal+']) && in_array('LITERAL+', $this->capability)) { + $this->prefs['literal+'] = true; + } + else if (!isset($this->prefs['literal-']) && in_array('LITERAL-', $this->capability)) { + $this->prefs['literal-'] = true; + } + + if ($trusted) { + $this->capability_read = true; + } + } + + /** + * Escapes a string when it contains special characters (RFC3501) + * + * @param string $string IMAP string + * @param bool $force_quotes Forces string quoting (for atoms) + * + * @return string String atom, quoted-string or string literal + * @todo lists + */ + public static function escape($string, $force_quotes = false) + { + if ($string === null) { + return 'NIL'; + } + + if ($string === '') { + return '""'; + } + + // atom-string (only safe characters) + if (!$force_quotes && !preg_match('/[\x00-\x20\x22\x25\x28-\x2A\x5B-\x5D\x7B\x7D\x80-\xFF]/', $string)) { + return $string; + } + + // quoted-string + if (!preg_match('/[\r\n\x00\x80-\xFF]/', $string)) { + return '"' . addcslashes($string, '\\"') . '"'; + } + + // literal-string + return sprintf("{%d}\r\n%s", strlen($string), $string); + } + + /** + * Set the value of the debugging flag. + * + * @param bool $debug New value for the debugging flag. + * @param callable $handler Logging handler function + * + * @since 0.5-stable + */ + public function setDebug($debug, $handler = null) + { + $this->debug = $debug; + $this->debug_handler = $handler; + } + + /** + * Write the given debug text to the current debug output handler. + * + * @param string $message Debug message text. + * + * @since 0.5-stable + */ + protected function debug($message) + { + if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) { + $diff = $len - self::DEBUG_LINE_LENGTH; + $message = substr($message, 0, self::DEBUG_LINE_LENGTH) + . "... [truncated $diff bytes]"; + } + + if ($this->resourceid) { + $message = sprintf('[%s] %s', $this->resourceid, $message); + } + + if ($this->debug_handler) { + call_user_func_array($this->debug_handler, [$this, $message]); + } + else { + echo "DEBUG: $message\n"; + } + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_message_header.php b/admin/tool/messageinbound/roundcube/rcube_message_header.php new file mode 100644 index 00000000000..28b95fa69b3 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_message_header.php @@ -0,0 +1,430 @@ + | + +-----------------------------------------------------------------------+ +*/ + +/** + * Struct representing an e-mail message header + * + * @package Framework + * @subpackage Storage + */ +class rcube_message_header +{ + /** + * Message sequence number + * + * @var int + */ + public $id; + + /** + * Message unique identifier + * + * @var int + */ + public $uid; + + /** + * Message subject + * + * @var string + */ + public $subject; + + /** + * Message sender (From) + * + * @var string + */ + public $from; + + /** + * Message recipient (To) + * + * @var string + */ + public $to; + + /** + * Message additional recipients (Cc) + * + * @var string + */ + public $cc; + + /** + * Message hidden recipients (Bcc) + * + * @var string + */ + public $bcc; + + /** + * Message Reply-To header + * + * @var string + */ + public $replyto; + + /** + * Message In-Reply-To header + * + * @var string + */ + public $in_reply_to; + + /** + * Message date (Date) + * + * @var string + */ + public $date; + + /** + * Message identifier (Message-ID) + * + * @var string + */ + public $messageID; + + /** + * Message size + * + * @var int + */ + public $size; + + /** + * Message encoding + * + * @var string + */ + public $encoding; + + /** + * Message charset + * + * @var string + */ + public $charset; + + /** + * Message Content-type + * + * @var string + */ + public $ctype; + + /** + * Message timestamp (based on message date) + * + * @var int + */ + public $timestamp; + + /** + * IMAP bodystructure string + * + * @var string + */ + public $bodystructure; + + /** + * IMAP body (RFC822.TEXT) + * + * @var string + */ + public $body; + + /** + * IMAP part bodies + * + * @var array + */ + public $bodypart = []; + + /** + * IMAP internal date + * + * @var string + */ + public $internaldate; + + /** + * Message References header + * + * @var string + */ + public $references; + + /** + * Message priority (X-Priority) + * + * @var int + */ + public $priority; + + /** + * Message receipt recipient + * + * @var string + */ + public $mdn_to; + + /** + * IMAP folder this message is stored in + * + * @var string + */ + public $folder; + + /** + * Other message headers + * + * @var array + */ + public $others = []; + + /** + * Message flags + * + * @var array + */ + public $flags = []; + + /** + * Extra flags (for the messages list) + * + * @var array + * @deprecated Use $flags + */ + public $list_flags = []; + + /** + * Extra columns content (for the messages list) + * + * @var array + */ + public $list_cols = []; + + /** + * Message structure + * + * @var rcube_message_part + */ + public $structure; + + /** + * Message thread depth + * + * @var int + */ + public $depth; + + /** + * Whether the message has references in the thread + * + * @var bool + */ + public $has_children; + + /** + * Number of flagged children (in a thread) + * + * @var int + */ + public $flagged_children; + + /** + * Number of unread children (in a thread) + * + * @var int + */ + public $unread_children; + + /** + * UID of the message parent (in a thread) + * + * @var int + */ + public $parent_uid; + + /** + * IMAP MODSEQ value + * + * @var int + */ + public $modseq; + + /** + * IMAP ENVELOPE + * + * @var string + */ + public $envelope; + + /** + * Header name to rcube_message_header object property map + * + * @var array + */ + private $obj_headers = [ + 'date' => 'date', + 'from' => 'from', + 'to' => 'to', + 'subject' => 'subject', + 'reply-to' => 'replyto', + 'cc' => 'cc', + 'bcc' => 'bcc', + 'mbox' => 'folder', + 'folder' => 'folder', + 'content-transfer-encoding' => 'encoding', + 'in-reply-to' => 'in_reply_to', + 'content-type' => 'ctype', + 'charset' => 'charset', + 'references' => 'references', + 'disposition-notification-to' => 'mdn_to', + 'x-confirm-reading-to' => 'mdn_to', + 'message-id' => 'messageID', + 'x-priority' => 'priority', + ]; + + /** + * Returns header value + * + * @param string $name Header name + * @param bool $decode Decode the header content + * + * @return string|null Header content + */ + public function get($name, $decode = true) + { + $name = strtolower($name); + $value = null; + + if (isset($this->obj_headers[$name]) && isset($this->{$this->obj_headers[$name]})) { + $value = $this->{$this->obj_headers[$name]}; + } + else if (isset($this->others[$name])) { + $value = $this->others[$name]; + } + + if ($decode && $value !== null) { + if (is_array($value)) { + foreach ($value as $key => $val) { + $val = rcube_mime::decode_header($val, $this->charset); + $value[$key] = rcube_charset::clean($val); + } + } + else { + $value = rcube_mime::decode_header($value, $this->charset); + $value = rcube_charset::clean($value); + } + } + + return $value; + } + + /** + * Sets header value + * + * @param string $name Header name + * @param string $value Header content + */ + public function set($name, $value) + { + $name = strtolower($name); + + if (isset($this->obj_headers[$name])) { + $this->{$this->obj_headers[$name]} = $value; + } + else { + $this->others[$name] = $value; + } + } + + /** + * Factory method to instantiate headers from a data array + * + * @param array $arr Hash array with header values + * + * @return rcube_message_header instance filled with headers values + */ + public static function from_array($arr) + { + $obj = new rcube_message_header; + foreach ($arr as $k => $v) { + $obj->set($k, $v); + } + + return $obj; + } +} + + +/** + * Class for sorting an array of rcube_message_header objects in a predetermined order. + * + * @package Framework + * @subpackage Storage + */ +class rcube_message_header_sorter +{ + /** @var array Message UIDs */ + private $uids = []; + + + /** + * Set the predetermined sort order. + * + * @param array $index Numerically indexed array of IMAP UIDs + */ + function set_index($index) + { + $index = array_flip($index); + + $this->uids = $index; + } + + /** + * Sort the array of header objects + * + * @param array $headers Array of rcube_message_header objects indexed by UID + */ + function sort_headers(&$headers) + { + uksort($headers, [$this, "compare_uids"]); + } + + /** + * Sort method called by uksort() + * + * @param int $a Array key (UID) + * @param int $b Array key (UID) + */ + function compare_uids($a, $b) + { + // then find each sequence number in my ordered list + $posa = isset($this->uids[$a]) ? intval($this->uids[$a]) : -1; + $posb = isset($this->uids[$b]) ? intval($this->uids[$b]) : -1; + + // return the relative position as the comparison value + return $posa - $posb; + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_mime.php b/admin/tool/messageinbound/roundcube/rcube_mime.php new file mode 100644 index 00000000000..d0b2cbca80c --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_mime.php @@ -0,0 +1,992 @@ + | + | Author: Aleksander Machniak | + +-----------------------------------------------------------------------+ +*/ + +/** + * Class for parsing MIME messages + * + * @package Framework + * @subpackage Storage + */ +class rcube_mime +{ + private static $default_charset; + + + /** + * Object constructor. + */ + function __construct($default_charset = null) + { + self::$default_charset = $default_charset; + } + + /** + * Returns message/object character set name + * + * @return string Character set name + */ + public static function get_charset() + { + if (self::$default_charset) { + return self::$default_charset; + } + + if ($charset = rcube::get_instance()->config->get('default_charset')) { + return $charset; + } + + return RCUBE_CHARSET; + } + + /** + * Parse the given raw message source and return a structure + * of rcube_message_part objects. + * + * It makes use of the rcube_mime_decode library + * + * @param string $raw_body The message source + * + * @return object rcube_message_part The message structure + */ + public static function parse_message($raw_body) + { + $conf = [ + 'include_bodies' => true, + 'decode_bodies' => true, + 'decode_headers' => false, + 'default_charset' => self::get_charset(), + ]; + + $mime = new rcube_mime_decode($conf); + + return $mime->decode($raw_body); + } + + /** + * Split an address list into a structured array list + * + * @param string|array $input Input string (or list of strings) + * @param int $max List only this number of addresses + * @param bool $decode Decode address strings + * @param string $fallback Fallback charset if none specified + * @param bool $addronly Return flat array with e-mail addresses only + * + * @return array Indexed list of addresses + */ + static function decode_address_list($input, $max = null, $decode = true, $fallback = null, $addronly = false) + { + // A common case when the same header is used many times in a mail message + if (is_array($input)) { + $input = implode(', ', $input); + } + + $a = self::parse_address_list((string) $input, $decode, $fallback); + $out = []; + $j = 0; + + // Special chars as defined by RFC 822 need to in quoted string (or escaped). + $special_chars = '[\(\)\<\>\\\.\[\]@,;:"]'; + + if (!is_array($a)) { + return $out; + } + + foreach ($a as $val) { + $j++; + $address = trim($val['address']); + + if ($addronly) { + $out[$j] = $address; + } + else { + $name = trim($val['name']); + $string = ''; + + if ($name && $address && $name != $address) { + $string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address); + } + else if ($address) { + $string = $address; + } + else if ($name) { + $string = $name; + } + + $out[$j] = ['name' => $name, 'mailto' => $address, 'string' => $string]; + } + + if ($max && $j == $max) { + break; + } + } + + return $out; + } + + /** + * Decode a message header value + * + * @param string $input Header value + * @param string $fallback Fallback charset if none specified + * + * @return string Decoded string + */ + public static function decode_header($input, $fallback = null) + { + $str = self::decode_mime_string((string)$input, $fallback); + + return $str; + } + + /** + * Decode a mime-encoded string to internal charset + * + * @param string $input Header value + * @param string $fallback Fallback charset if none specified + * + * @return string Decoded string + */ + public static function decode_mime_string($input, $fallback = null) + { + $default_charset = $fallback ?: self::get_charset(); + + // rfc: all line breaks or other characters not found + // in the Base64 Alphabet must be ignored by decoding software + // delete all blanks between MIME-lines, differently we can + // receive unnecessary blanks and broken utf-8 symbols + $input = preg_replace("/\?=\s+=\?/", '?==?', $input); + + // encoded-word regexp + $re = '/=\?([^?]+)\?([BbQq])\?([^\n]*?)\?=/'; + + // Find all RFC2047's encoded words + if (preg_match_all($re, $input, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) { + // Initialize variables + $tmp = []; + $out = ''; + $start = 0; + + foreach ($matches as $idx => $m) { + $pos = $m[0][1]; + $charset = $m[1][0]; + $encoding = $m[2][0]; + $text = $m[3][0]; + $length = strlen($m[0][0]); + + // Append everything that is before the text to be decoded + if ($start != $pos) { + $substr = substr($input, $start, $pos-$start); + $out .= rcube_charset::convert($substr, $default_charset); + $start = $pos; + } + $start += $length; + + // Per RFC2047, each string part "MUST represent an integral number + // of characters . A multi-octet character may not be split across + // adjacent encoded-words." However, some mailers break this, so we + // try to handle characters spanned across parts anyway by iterating + // through and aggregating sequential encoded parts with the same + // character set and encoding, then perform the decoding on the + // aggregation as a whole. + + $tmp[] = $text; + if (!empty($matches[$idx+1]) && ($next_match = $matches[$idx+1])) { + if ($next_match[0][1] == $start + && $next_match[1][0] == $charset + && $next_match[2][0] == $encoding + ) { + continue; + } + } + + $count = count($tmp); + $text = ''; + + // Decode and join encoded-word's chunks + if ($encoding == 'B' || $encoding == 'b') { + $rest = ''; + // base64 must be decoded a segment at a time. + // However, there are broken implementations that continue + // in the following word, we'll handle that (#6048) + for ($i=0; $i<$count; $i++) { + $chunk = $rest . $tmp[$i]; + $length = strlen($chunk); + if ($length % 4) { + $length = floor($length / 4) * 4; + $rest = substr($chunk, $length); + $chunk = substr($chunk, 0, $length); + } + + $text .= base64_decode($chunk); + } + } + else { // if ($encoding == 'Q' || $encoding == 'q') { + // quoted printable can be combined and processed at once + for ($i=0; $i<$count; $i++) { + $text .= $tmp[$i]; + } + + $text = str_replace('_', ' ', $text); + $text = quoted_printable_decode($text); + } + + $out .= rcube_charset::convert($text, $charset); + $tmp = []; + } + + // add the last part of the input string + if ($start != strlen($input)) { + $out .= rcube_charset::convert(substr($input, $start), $default_charset); + } + + // return the results + return $out; + } + + // no encoding information, use fallback + return rcube_charset::convert($input, $default_charset); + } + + /** + * Decode a mime part + * + * @param string $input Input string + * @param string $encoding Part encoding + * + * @return string Decoded string + */ + public static function decode($input, $encoding = '7bit') + { + switch (strtolower($encoding)) { + case 'quoted-printable': + return quoted_printable_decode($input); + case 'base64': + return base64_decode($input); + case 'x-uuencode': + case 'x-uue': + case 'uue': + case 'uuencode': + return convert_uudecode($input); + case '7bit': + default: + return $input; + } + } + + /** + * Split RFC822 header string into an associative array + */ + public static function parse_headers($headers) + { + $result = []; + $headers = preg_replace('/\r?\n(\t| )+/', ' ', $headers); + $lines = explode("\n", $headers); + $count = count($lines); + + for ($i=0; $i<$count; $i++) { + if ($p = strpos($lines[$i], ': ')) { + $field = strtolower(substr($lines[$i], 0, $p)); + $value = trim(substr($lines[$i], $p+1)); + if (!empty($value)) { + $result[$field] = $value; + } + } + } + + return $result; + } + + /** + * E-mail address list parser + */ + private static function parse_address_list($str, $decode = true, $fallback = null) + { + // remove any newlines and carriage returns before + $str = preg_replace('/\r?\n(\s|\t)?/', ' ', $str); + + // extract list items, remove comments + $str = self::explode_header_string(',;', $str, true); + + // simplified regexp, supporting quoted local part + $email_rx = '([^\s:]+|("\s*(?:[^"\f\n\r\t\v\b\s]+\s*)+"))@\S+'; + + $result = []; + + foreach ($str as $key => $val) { + $name = ''; + $address = ''; + $val = trim($val); + + // First token might be a group name, ignore it + $tokens = self::explode_header_string(' ', $val); + if (isset($tokens[0]) && $tokens[0][strlen($tokens[0])-1] == ':') { + $val = substr($val, strlen($tokens[0])); + } + + if (preg_match('/(.*)<('.$email_rx.')$/', $val, $m)) { + // Note: There are cases like "Test'); + $name = trim($m[1]); + } + else if (preg_match('/^('.$email_rx.')$/', $val, $m)) { + $address = $m[1]; + $name = ''; + } + // special case (#1489092) + else if (preg_match('/(\s*)$/', $val, $m)) { + $address = 'MAILER-DAEMON'; + $name = substr($val, 0, -strlen($m[1])); + } + else if (preg_match('/('.$email_rx.')/', $val, $m)) { + $name = $m[1]; + } + else { + $name = $val; + } + + // unquote and/or decode name + if ($name) { + // An unquoted name ending with colon is a address group name, ignore it + if ($name[strlen($name)-1] == ':') { + $name = ''; + } + + if (strlen($name) > 1 && $name[0] == '"' && $name[strlen($name)-1] == '"') { + $name = substr($name, 1, -1); + $name = stripslashes($name); + } + + if ($decode) { + $name = self::decode_header($name, $fallback); + // some clients encode addressee name with quotes around it + if (strlen($name) > 1 && $name[0] == '"' && $name[strlen($name)-1] == '"') { + $name = substr($name, 1, -1); + } + } + } + + if (!$address && $name) { + $address = $name; + $name = ''; + } + + if ($address) { + $address = self::fix_email($address); + $result[$key] = ['name' => $name, 'address' => $address]; + } + } + + return $result; + } + + /** + * Explodes header (e.g. address-list) string into array of strings + * using specified separator characters with proper handling + * of quoted-strings and comments (RFC2822) + * + * @param string $separator String containing separator characters + * @param string $str Header string + * @param bool $remove_comments Enable to remove comments + * + * @return array Header items + */ + public static function explode_header_string($separator, $str, $remove_comments = false) + { + $length = strlen($str); + $result = []; + $quoted = false; + $comment = 0; + $out = ''; + + for ($i=0; $i<$length; $i++) { + // we're inside a quoted string + if ($quoted) { + if ($str[$i] == '"') { + $quoted = false; + } + else if ($str[$i] == "\\") { + if ($comment <= 0) { + $out .= "\\"; + } + $i++; + } + } + // we are inside a comment string + else if ($comment > 0) { + if ($str[$i] == ')') { + $comment--; + } + else if ($str[$i] == '(') { + $comment++; + } + else if ($str[$i] == "\\") { + $i++; + } + continue; + } + // separator, add to result array + else if (strpos($separator, $str[$i]) !== false) { + if ($out) { + $result[] = $out; + } + $out = ''; + continue; + } + // start of quoted string + else if ($str[$i] == '"') { + $quoted = true; + } + // start of comment + else if ($remove_comments && $str[$i] == '(') { + $comment++; + } + + if ($comment <= 0) { + $out .= $str[$i]; + } + } + + if ($out && $comment <= 0) { + $result[] = $out; + } + + return $result; + } + + /** + * Interpret a format=flowed message body according to RFC 2646 + * + * @param string $text Raw body formatted as flowed text + * @param string $mark Mark each flowed line with specified character + * @param bool $delsp Remove the trailing space of each flowed line + * + * @return string Interpreted text with unwrapped lines and stuffed space removed + */ + public static function unfold_flowed($text, $mark = null, $delsp = false) + { + $text = preg_split('/\r?\n/', $text); + $last = -1; + $q_level = 0; + $marks = []; + + foreach ($text as $idx => $line) { + if ($q = strspn($line, '>')) { + // remove quote chars + $line = substr($line, $q); + // remove (optional) space-staffing + if (isset($line[0]) && $line[0] === ' ') { + $line = substr($line, 1); + } + + // The same paragraph (We join current line with the previous one) when: + // - the same level of quoting + // - previous line was flowed + // - previous line contains more than only one single space (and quote char(s)) + if ($q == $q_level + && isset($text[$last]) && $text[$last][strlen($text[$last])-1] == ' ' + && !preg_match('/^>+ {0,1}$/', $text[$last]) + ) { + if ($delsp) { + $text[$last] = substr($text[$last], 0, -1); + } + $text[$last] .= $line; + unset($text[$idx]); + + if ($mark) { + $marks[$last] = true; + } + } + else { + $last = $idx; + } + } + else { + if ($line == '-- ') { + $last = $idx; + } + else { + // remove space-stuffing + if (isset($line[0]) && $line[0] === ' ') { + $line = substr($line, 1); + } + + $last_len = isset($text[$last]) ? strlen($text[$last]) : 0; + + if ( + $last_len && $line && !$q_level && $text[$last] != '-- ' + && isset($text[$last][$last_len-1]) && $text[$last][$last_len-1] == ' ' + ) { + if ($delsp) { + $text[$last] = substr($text[$last], 0, -1); + } + $text[$last] .= $line; + unset($text[$idx]); + + if ($mark) { + $marks[$last] = true; + } + } + else { + $text[$idx] = $line; + $last = $idx; + } + } + } + $q_level = $q; + } + + if (!empty($marks)) { + foreach (array_keys($marks) as $mk) { + $text[$mk] = $mark . $text[$mk]; + } + } + + return implode("\r\n", $text); + } + + /** + * Wrap the given text to comply with RFC 2646 + * + * @param string $text Text to wrap + * @param int $length Length + * @param string $charset Character encoding of $text + * + * @return string Wrapped text + */ + public static function format_flowed($text, $length = 72, $charset = null) + { + $text = preg_split('/\r?\n/', $text); + + foreach ($text as $idx => $line) { + if ($line != '-- ') { + if ($level = strspn($line, '>')) { + // remove quote chars + $line = substr($line, $level); + // remove (optional) space-staffing and spaces before the line end + $line = rtrim($line, ' '); + if (isset($line[0]) && $line[0] === ' ') { + $line = substr($line, 1); + } + + $prefix = str_repeat('>', $level) . ' '; + $line = $prefix . self::wordwrap($line, $length - $level - 2, " \r\n$prefix", false, $charset); + } + else if ($line) { + $line = self::wordwrap(rtrim($line), $length - 2, " \r\n", false, $charset); + // space-stuffing + $line = preg_replace('/(^|\r\n)(From| |>)/', '\\1 \\2', $line); + } + + $text[$idx] = $line; + } + } + + return implode("\r\n", $text); + } + + /** + * Improved wordwrap function with multibyte support. + * The code is based on Zend_Text_MultiByte::wordWrap(). + * + * @param string $string Text to wrap + * @param int $width Line width + * @param string $break Line separator + * @param bool $cut Enable to cut word + * @param string $charset Charset of $string + * @param bool $wrap_quoted When enabled quoted lines will not be wrapped + * + * @return string Text + */ + public static function wordwrap($string, $width = 75, $break = "\n", $cut = false, $charset = null, $wrap_quoted = true) + { + // Note: Never try to use iconv instead of mbstring functions here + // Iconv's substr/strlen are 100x slower (#1489113) + + if ($charset && $charset != RCUBE_CHARSET) { + $charset = rcube_charset::parse_charset($charset); + mb_internal_encoding($charset); + } + + // Convert \r\n to \n, this is our line-separator + $string = str_replace("\r\n", "\n", $string); + $separator = "\n"; // must be 1 character length + $result = []; + + while (($stringLength = mb_strlen($string)) > 0) { + $breakPos = mb_strpos($string, $separator, 0); + + // quoted line (do not wrap) + if ($wrap_quoted && $string[0] == '>') { + if ($breakPos === $stringLength - 1 || $breakPos === false) { + $subString = $string; + $cutLength = null; + } + else { + $subString = mb_substr($string, 0, $breakPos); + $cutLength = $breakPos + 1; + } + } + // next line found and current line is shorter than the limit + else if ($breakPos !== false && $breakPos < $width) { + if ($breakPos === $stringLength - 1) { + $subString = $string; + $cutLength = null; + } + else { + $subString = mb_substr($string, 0, $breakPos); + $cutLength = $breakPos + 1; + } + } + else { + $subString = mb_substr($string, 0, $width); + + // last line + if ($breakPos === false && $subString === $string) { + $cutLength = null; + } + else { + $nextChar = mb_substr($string, $width, 1); + + if ($nextChar === ' ' || $nextChar === $separator) { + $afterNextChar = mb_substr($string, $width + 1, 1); + + // Note: mb_substr() does never return False + if ($afterNextChar === false || $afterNextChar === '') { + $subString .= $nextChar; + } + + $cutLength = mb_strlen($subString) + 1; + } + else { + $spacePos = mb_strrpos($subString, ' ', 0); + + if ($spacePos !== false) { + $subString = mb_substr($subString, 0, $spacePos); + $cutLength = $spacePos + 1; + } + else if ($cut === false) { + $spacePos = mb_strpos($string, ' ', 0); + + if ($spacePos !== false && ($breakPos === false || $spacePos < $breakPos)) { + $subString = mb_substr($string, 0, $spacePos); + $cutLength = $spacePos + 1; + } + else if ($breakPos === false) { + $subString = $string; + $cutLength = null; + } + else { + $subString = mb_substr($string, 0, $breakPos); + $cutLength = $breakPos + 1; + } + } + else { + $cutLength = $width; + } + } + } + } + + $result[] = $subString; + + if ($cutLength !== null) { + $string = mb_substr($string, $cutLength, ($stringLength - $cutLength)); + } + else { + break; + } + } + + if ($charset && $charset != RCUBE_CHARSET) { + mb_internal_encoding(RCUBE_CHARSET); + } + + return implode($break, $result); + } + + /** + * A method to guess the mime_type of an attachment. + * + * @param string $path Path to the file or file contents + * @param string $name File name (with suffix) + * @param string $failover Mime type supplied for failover + * @param bool $is_stream Set to True if $path contains file contents + * @param bool $skip_suffix Set to True if the config/mimetypes.php map should be ignored + * + * @return string + * @author Till Klampaeckel + * @see http://de2.php.net/manual/en/ref.fileinfo.php + * @see http://de2.php.net/mime_content_type + */ + public static function file_content_type($path, $name, $failover = 'application/octet-stream', $is_stream = false, $skip_suffix = false) + { + $mime_type = null; + $config = rcube::get_instance()->config; + + // Detect mimetype using filename extension + if (!$skip_suffix) { + $mime_type = self::file_ext_type($name); + } + + // try fileinfo extension if available + if (!$mime_type && function_exists('finfo_open')) { + $mime_magic = $config->get('mime_magic'); + // null as a 2nd argument should be the same as no argument + // this however is not true on all systems/versions + if ($mime_magic) { + $finfo = finfo_open(FILEINFO_MIME, $mime_magic); + } + else { + $finfo = finfo_open(FILEINFO_MIME); + } + + if ($finfo) { + $func = $is_stream ? 'finfo_buffer' : 'finfo_file'; + $mime_type = $func($finfo, $path, FILEINFO_MIME_TYPE); + finfo_close($finfo); + } + } + + // try PHP's mime_content_type + if (!$mime_type && !$is_stream && function_exists('mime_content_type')) { + $mime_type = @mime_content_type($path); + } + + // fall back to user-submitted string + if (!$mime_type) { + $mime_type = $failover; + } + + return $mime_type; + } + + /** + * File type detection based on file name only. + * + * @param string $filename Path to the file or file contents + * + * @return string|null Mimetype label + */ + public static function file_ext_type($filename) + { + static $mime_ext = []; + + if (empty($mime_ext)) { + foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) { + $mime_ext = array_merge($mime_ext, (array) @include($fpath)); + } + } + + // use file name suffix with hard-coded mime-type map + if (!empty($mime_ext) && $filename) { + $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION)); + if ($ext && !empty($mime_ext[$ext])) { + return $mime_ext[$ext]; + } + } + } + + /** + * Get mimetype => file extension mapping + * + * @param string $mimetype Mime-Type to get extensions for + * + * @return array List of extensions matching the given mimetype or a hash array + * with ext -> mimetype mappings if $mimetype is not given + */ + public static function get_mime_extensions($mimetype = null) + { + static $mime_types, $mime_extensions; + + // return cached data + if (is_array($mime_types)) { + return $mimetype ? (isset($mime_types[$mimetype]) ? $mime_types[$mimetype] : []) : $mime_extensions; + } + + // load mapping file + $file_paths = []; + + if ($mime_types = rcube::get_instance()->config->get('mime_types')) { + $file_paths[] = $mime_types; + } + + // try common locations + if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') { + $file_paths[] = 'C:/xampp/apache/conf/mime.types'; + } + else { + $file_paths[] = '/etc/mime.types'; + $file_paths[] = '/etc/httpd/mime.types'; + $file_paths[] = '/etc/httpd2/mime.types'; + $file_paths[] = '/etc/apache/mime.types'; + $file_paths[] = '/etc/apache2/mime.types'; + $file_paths[] = '/etc/nginx/mime.types'; + $file_paths[] = '/usr/local/etc/httpd/conf/mime.types'; + $file_paths[] = '/usr/local/etc/apache/conf/mime.types'; + $file_paths[] = '/usr/local/etc/apache24/mime.types'; + } + + $mime_types = []; + $mime_extensions = []; + $lines = []; + $regex = "/([\w\+\-\.\/]+)\s+([\w\s]+)/i"; + + foreach ($file_paths as $fp) { + if (@is_readable($fp)) { + $lines = file($fp, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES); + break; + } + } + + foreach ($lines as $line) { + // skip comments or mime types w/o any extensions + if ($line[0] == '#' || !preg_match($regex, $line, $matches)) { + continue; + } + + $mime = $matches[1]; + + foreach (explode(' ', $matches[2]) as $ext) { + $ext = trim($ext); + $mime_types[$mime][] = $ext; + $mime_extensions[$ext] = $mime; + } + } + + // fallback to some well-known types most important for daily emails + if (empty($mime_types)) { + foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) { + $mime_extensions = array_merge($mime_extensions, (array) @include($fpath)); + } + + foreach ($mime_extensions as $ext => $mime) { + $mime_types[$mime][] = $ext; + } + } + + // Add some known aliases that aren't included by some mime.types (#1488891) + // the order is important here so standard extensions have higher prio + $aliases = [ + 'image/gif' => ['gif'], + 'image/png' => ['png'], + 'image/x-png' => ['png'], + 'image/jpeg' => ['jpg', 'jpeg', 'jpe'], + 'image/jpg' => ['jpg', 'jpeg', 'jpe'], + 'image/pjpeg' => ['jpg', 'jpeg', 'jpe'], + 'image/tiff' => ['tif'], + 'image/bmp' => ['bmp'], + 'image/x-ms-bmp' => ['bmp'], + 'message/rfc822' => ['eml'], + 'text/x-mail' => ['eml'], + ]; + + foreach ($aliases as $mime => $exts) { + if (isset($mime_types[$mime])) { + $mime_types[$mime] = array_unique(array_merge((array) $mime_types[$mime], $exts)); + } + else { + $mime_types[$mime] = $exts; + } + + foreach ($exts as $ext) { + if (!isset($mime_extensions[$ext])) { + $mime_extensions[$ext] = $mime; + } + } + } + + if ($mimetype) { + return !empty($mime_types[$mimetype]) ? $mime_types[$mimetype] : []; + } + + return $mime_extensions; + } + + /** + * Detect image type of the given binary data by checking magic numbers. + * + * @param string $data Binary file content + * + * @return string Detected mime-type or jpeg as fallback + */ + public static function image_content_type($data) + { + $type = 'jpeg'; + if (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png'; + else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif'; + else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico'; + // else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg'; + + return 'image/' . $type; + } + + /** + * Try to fix invalid email addresses + */ + public static function fix_email($email) + { + $parts = rcube_utils::explode_quoted_string('@', $email); + + foreach ($parts as $idx => $part) { + // remove redundant quoting (#1490040) + if (isset($part[0]) && $part[0] == '"' && preg_match('/^"([a-zA-Z0-9._+=-]+)"$/', $part, $m)) { + $parts[$idx] = $m[1]; + } + } + + return implode('@', $parts); + } + + /** + * Fix mimetype name. + * + * @param string $type Mimetype + * + * @return string Mimetype + */ + public static function fix_mimetype($type) + { + $type = strtolower(trim($type)); + $aliases = [ + 'image/x-ms-bmp' => 'image/bmp', // #4771 + 'pdf' => 'application/pdf', // #6816 + ]; + + if (!empty($aliases[$type])) { + return $aliases[$type]; + } + + // Some versions of Outlook create garbage Content-Type: + // application/pdf.A520491B_3BF7_494D_8855_7FAC2C6C0608 + if (preg_match('/^application\/pdf.+/', $type)) { + return 'application/pdf'; + } + + // treat image/pjpeg (image/pjpg, image/jpg) as image/jpeg (#4196) + if (preg_match('/^image\/p?jpe?g$/', $type)) { + return 'image/jpeg'; + } + + return $type; + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_result_index.php b/admin/tool/messageinbound/roundcube/rcube_result_index.php new file mode 100644 index 00000000000..8ef164e0129 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_result_index.php @@ -0,0 +1,446 @@ + | + | Author: Aleksander Machniak | + +-----------------------------------------------------------------------+ +*/ + +/** + * Class for accessing IMAP's SORT/SEARCH/ESEARCH result + * + * @package Framework + * @subpackage Storage + */ +class rcube_result_index +{ + public $incomplete = false; + + protected $raw_data; + protected $mailbox; + protected $meta = []; + protected $params = []; + protected $order = 'ASC'; + + const SEPARATOR_ELEMENT = ' '; + + + /** + * Object constructor. + */ + public function __construct($mailbox = null, $data = null, $order = null) + { + $this->mailbox = $mailbox; + $this->order = $order == 'DESC' ? 'DESC' : 'ASC'; + $this->init($data); + } + + /** + * Initializes object with SORT command response + * + * @param string $data IMAP response string + */ + public function init($data = null) + { + $this->meta = []; + + $data = explode('*', (string)$data); + + // ...skip unilateral untagged server responses + for ($i=0, $len=count($data); $i<$len; $i++) { + $data_item = &$data[$i]; + if (preg_match('/^ SORT/i', $data_item)) { + // valid response, initialize raw_data for is_error() + $this->raw_data = ''; + $data_item = substr($data_item, 5); + break; + } + else if (preg_match('/^ (E?SEARCH)/i', $data_item, $m)) { + // valid response, initialize raw_data for is_error() + $this->raw_data = ''; + $data_item = substr($data_item, strlen($m[0])); + + if (strtoupper($m[1]) == 'ESEARCH') { + $data_item = trim($data_item); + // remove MODSEQ response + if (preg_match('/\(MODSEQ ([0-9]+)\)$/i', $data_item, $m)) { + $data_item = substr($data_item, 0, -strlen($m[0])); + $this->params['MODSEQ'] = $m[1]; + } + // remove TAG response part + if (preg_match('/^\(TAG ["a-z0-9]+\)\s*/i', $data_item, $m)) { + $data_item = substr($data_item, strlen($m[0])); + } + // remove UID + $data_item = preg_replace('/^UID\s*/i', '', $data_item); + + // ESEARCH parameters + while (preg_match('/^([a-z]+) ([0-9:,]+)\s*/i', $data_item, $m)) { + $param = strtoupper($m[1]); + $value = $m[2]; + + $this->params[$param] = $value; + $data_item = substr($data_item, strlen($m[0])); + + if (in_array($param, ['COUNT', 'MIN', 'MAX'])) { + $this->meta[strtolower($param)] = (int) $value; + } + } + +// @TODO: Implement compression using compressMessageSet() in __sleep() and __wakeup() ? +// @TODO: work with compressed result?! + if (isset($this->params['ALL'])) { + $data_item = implode(self::SEPARATOR_ELEMENT, + rcube_imap_generic::uncompressMessageSet($this->params['ALL'])); + } + } + + break; + } + + unset($data[$i]); + } + + $data = array_filter($data); + + if (empty($data)) { + return; + } + + $data = array_shift($data); + $data = trim($data); + $data = preg_replace('/[\r\n]/', '', $data); + $data = preg_replace('/\s+/', ' ', $data); + + $this->raw_data = $data; + } + + /** + * Checks the result from IMAP command + * + * @return bool True if the result is an error, False otherwise + */ + public function is_error() + { + return $this->raw_data === null; + } + + /** + * Checks if the result is empty + * + * @return bool True if the result is empty, False otherwise + */ + public function is_empty() + { + return empty($this->raw_data) + && empty($this->meta['max']) && empty($this->meta['min']) && empty($this->meta['count']); + } + + /** + * Returns number of elements in the result + * + * @return int Number of elements + */ + public function count() + { + if (isset($this->meta['count'])) { + return $this->meta['count']; + } + + if (empty($this->raw_data)) { + $this->meta['count'] = 0; + $this->meta['length'] = 0; + } + else { + $this->meta['count'] = 1 + substr_count($this->raw_data, self::SEPARATOR_ELEMENT); + } + + return $this->meta['count']; + } + + /** + * Returns number of elements in the result. + * Alias for count() for compatibility with rcube_result_thread + * + * @return int Number of elements + */ + public function count_messages() + { + return $this->count(); + } + + /** + * Returns maximal message identifier in the result + * + * @return int|null Maximal message identifier + */ + public function max() + { + if ($this->is_empty()) { + return null; + } + + if (!isset($this->meta['max'])) { + $this->meta['max'] = null; + $all = $this->get(); + if (!empty($all)) { + $this->meta['max'] = (int) max($all); + } + } + + return $this->meta['max']; + } + + /** + * Returns minimal message identifier in the result + * + * @return int|null Minimal message identifier + */ + public function min() + { + if ($this->is_empty()) { + return null; + } + + if (!isset($this->meta['min'])) { + $this->meta['min'] = null; + $all = $this->get(); + if (!empty($all)) { + $this->meta['min'] = (int) min($all); + } + } + + return $this->meta['min']; + } + + /** + * Slices data set. + * + * @param int $offset Offset (as for PHP's array_slice()) + * @param int $length Number of elements (as for PHP's array_slice()) + */ + public function slice($offset, $length) + { + $data = $this->get(); + $data = array_slice($data, $offset, $length); + + $this->meta = []; + $this->meta['count'] = count($data); + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data); + } + + /** + * Filters data set. Removes elements not listed in $ids list. + * + * @param array $ids List of IDs to remove. + */ + public function filter($ids = []) + { + $data = $this->get(); + $data = array_intersect($data, $ids); + + $this->meta = []; + $this->meta['count'] = count($data); + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data); + } + + /** + * Reverts order of elements in the result + */ + public function revert() + { + $this->order = $this->order == 'ASC' ? 'DESC' : 'ASC'; + + if (empty($this->raw_data)) { + return; + } + + $data = $this->get(); + $data = array_reverse($data); + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data); + + $this->meta['pos'] = []; + } + + /** + * Check if the given message ID exists in the object + * + * @param int $msgid Message ID + * @param bool $get_index When enabled element's index will be returned. + * Elements are indexed starting with 0 + * + * @return mixed False if message ID doesn't exist, True if exists or + * index of the element if $get_index=true + */ + public function exists($msgid, $get_index = false) + { + if (empty($this->raw_data)) { + return false; + } + + $msgid = (int) $msgid; + $begin = implode('|', ['^', preg_quote(self::SEPARATOR_ELEMENT, '/')]); + $end = implode('|', ['$', preg_quote(self::SEPARATOR_ELEMENT, '/')]); + + if (preg_match("/($begin)$msgid($end)/", $this->raw_data, $m, + $get_index ? PREG_OFFSET_CAPTURE : 0) + ) { + if ($get_index) { + $idx = 0; + if (!empty($m[0][1])) { + $idx = 1 + substr_count($this->raw_data, self::SEPARATOR_ELEMENT, 0, $m[0][1]); + } + // cache position of this element, so we can use it in get_element() + $this->meta['pos'][$idx] = (int)$m[0][1]; + + return $idx; + } + + return true; + } + + return false; + } + + /** + * Return all messages in the result. + * + * @return array List of message IDs + */ + public function get() + { + if (empty($this->raw_data)) { + return []; + } + + return explode(self::SEPARATOR_ELEMENT, $this->raw_data); + } + + /** + * Return all messages in the result. + * + * @return array List of message IDs + */ + public function get_compressed() + { + if (empty($this->raw_data)) { + return ''; + } + + return rcube_imap_generic::compressMessageSet($this->get()); + } + + /** + * Return result element at specified index + * + * @param int|string $index Element's index or "FIRST" or "LAST" + * + * @return int|null Element value + */ + public function get_element($index) + { + if (empty($this->raw_data)) { + return null; + } + + $count = $this->count(); + + // first element + if ($index === 0 || $index === '0' || $index === 'FIRST') { + $pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT); + if ($pos === false) { + $result = (int) $this->raw_data; + } + else { + $result = (int) substr($this->raw_data, 0, $pos); + } + + return $result; + } + + // last element + if ($index === 'LAST' || $index == $count-1) { + $pos = strrpos($this->raw_data, self::SEPARATOR_ELEMENT); + if ($pos === false) { + $result = (int) $this->raw_data; + } + else { + $result = (int) substr($this->raw_data, $pos); + } + + return $result; + } + + // do we know the position of the element or the neighbour of it? + if (!empty($this->meta['pos'])) { + if (isset($this->meta['pos'][$index])) { + $pos = $this->meta['pos'][$index]; + } + else if (isset($this->meta['pos'][$index-1])) { + $pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT, + $this->meta['pos'][$index-1] + 1); + } + else if (isset($this->meta['pos'][$index+1])) { + $pos = strrpos($this->raw_data, self::SEPARATOR_ELEMENT, + $this->meta['pos'][$index+1] - $this->length() - 1); + } + + if (isset($pos) && preg_match('/([0-9]+)/', $this->raw_data, $m, 0, $pos)) { + return (int) $m[1]; + } + } + + // Finally use less effective method + $data = explode(self::SEPARATOR_ELEMENT, $this->raw_data); + + return (int) $data[$index]; + } + + /** + * Returns response parameters, e.g. ESEARCH's MIN/MAX/COUNT/ALL/MODSEQ + * or internal data e.g. MAILBOX, ORDER + * + * @param ?string $param Parameter name + * + * @return array|string Response parameters or parameter value + */ + public function get_parameters($param = null) + { + $params = $this->params; + $params['MAILBOX'] = $this->mailbox; + $params['ORDER'] = $this->order; + + if ($param !== null) { + return $params[$param] ?? null; + } + + return $params; + } + + /** + * Returns length of internal data representation + * + * @return int Data length + */ + protected function length() + { + if (!isset($this->meta['length'])) { + $this->meta['length'] = strlen($this->raw_data); + } + + return $this->meta['length']; + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_result_thread.php b/admin/tool/messageinbound/roundcube/rcube_result_thread.php new file mode 100644 index 00000000000..df759d1bfbf --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_result_thread.php @@ -0,0 +1,699 @@ + | + | Author: Aleksander Machniak | + +-----------------------------------------------------------------------+ +*/ + +/** + * Class for accessing IMAP's THREAD result + * + * @package Framework + * @subpackage Storage + */ +class rcube_result_thread +{ + public $incomplete = false; + + protected $raw_data; + protected $mailbox; + protected $meta = []; + protected $order = 'ASC'; + + const SEPARATOR_ELEMENT = ' '; + const SEPARATOR_ITEM = '~'; + const SEPARATOR_LEVEL = ':'; + + + /** + * Object constructor. + */ + public function __construct($mailbox = null, $data = null) + { + $this->mailbox = $mailbox; + $this->init($data); + } + + /** + * Initializes object with IMAP command response + * + * @param string $data IMAP response string + */ + public function init($data = null) + { + $this->meta = []; + + $data = explode('*', (string) $data); + + // ...skip unilateral untagged server responses + for ($i = 0, $len = count($data); $i < $len; $i++) { + if (preg_match('/^ THREAD/i', $data[$i])) { + // valid response, initialize raw_data for is_error() + $this->raw_data = ''; + $data[$i] = substr($data[$i], 7); + break; + } + + unset($data[$i]); + } + + if (empty($data)) { + return; + } + + $data = array_shift($data); + $data = trim($data); + $data = preg_replace('/[\r\n]/', '', $data); + $data = preg_replace('/\s+/', ' ', $data); + + $this->raw_data = empty($data) ? '' : $this->parse_thread($data); + } + + /** + * Checks the result from IMAP command + * + * @return bool True if the result is an error, False otherwise + */ + public function is_error() + { + return $this->raw_data === null; + } + + /** + * Checks if the result is empty + * + * @return bool True if the result is empty, False otherwise + */ + public function is_empty() + { + return empty($this->raw_data); + } + + /** + * Returns number of elements (threads) in the result + * + * @return int Number of elements + */ + public function count() + { + if (isset($this->meta['count'])) { + return $this->meta['count']; + } + + if (empty($this->raw_data)) { + $this->meta['count'] = 0; + } + else { + $this->meta['count'] = 1 + substr_count($this->raw_data, self::SEPARATOR_ELEMENT); + } + + if (!$this->meta['count']) { + $this->meta['messages'] = 0; + } + + return $this->meta['count']; + } + + /** + * Returns number of all messages in the result + * + * @return int Number of elements + */ + public function count_messages() + { + if (isset($this->meta['messages'])) { + return $this->meta['messages']; + } + + if (empty($this->raw_data)) { + $this->meta['messages'] = 0; + } + else { + $this->meta['messages'] = 1 + + substr_count($this->raw_data, self::SEPARATOR_ELEMENT) + + substr_count($this->raw_data, self::SEPARATOR_ITEM); + } + + if ($this->meta['messages'] == 0 || $this->meta['messages'] == 1) { + $this->meta['count'] = $this->meta['messages']; + } + + return $this->meta['messages']; + } + + /** + * Returns maximum message identifier in the result + * + * @return int|null Maximum message identifier + */ + public function max() + { + if ($this->is_empty()) { + return null; + } + + if (!isset($this->meta['max'])) { + $this->meta['max'] = (int) @max($this->get()); + } + + return $this->meta['max']; + } + + /** + * Returns minimum message identifier in the result + * + * @return int|null Minimum message identifier + */ + public function min() + { + if ($this->is_empty()) { + return null; + } + + if (!isset($this->meta['min'])) { + $this->meta['min'] = (int) @min($this->get()); + } + + return $this->meta['min']; + } + + /** + * Slices data set. + * + * @param int $offset Offset (as for PHP's array_slice()) + * @param int $length Number of elements (as for PHP's array_slice()) + */ + public function slice($offset, $length) + { + $data = explode(self::SEPARATOR_ELEMENT, $this->raw_data); + $data = array_slice($data, $offset, $length); + + $this->meta = []; + $this->meta['count'] = count($data); + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data); + } + + /** + * Filters data set. Removes threads not listed in $roots list. + * + * @param array $roots List of IDs of thread roots. + */ + public function filter($roots) + { + $datalen = strlen($this->raw_data); + $roots = array_flip($roots); + $result = ''; + $start = 0; + + $this->meta = ['count' => 0]; + + while ($start < $datalen + && (($pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT, $start)) !== false + || ($pos = $datalen)) + ) { + $len = $pos - $start; + $elem = substr($this->raw_data, $start, $len); + $start = $pos + 1; + + // extract root message ID + if ($npos = strpos($elem, self::SEPARATOR_ITEM)) { + $root = (int) substr($elem, 0, $npos); + } + else { + $root = $elem; + } + + if (isset($roots[$root])) { + $this->meta['count']++; + $result .= self::SEPARATOR_ELEMENT . $elem; + } + } + + $this->raw_data = ltrim($result, self::SEPARATOR_ELEMENT); + } + + /** + * Reverts order of elements in the result + */ + public function revert() + { + $this->order = $this->order == 'ASC' ? 'DESC' : 'ASC'; + + if (empty($this->raw_data)) { + return; + } + + $data = explode(self::SEPARATOR_ELEMENT, $this->raw_data); + $data = array_reverse($data); + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data); + + $this->meta['pos'] = []; + } + + /** + * Check if the given message ID exists in the object + * + * @param int $msgid Message ID + * @param bool $get_index When enabled element's index will be returned. + * Elements are indexed starting with 0 + * + * @return bool True on success, False if message ID doesn't exist + */ + public function exists($msgid, $get_index = false) + { + $msgid = (int) $msgid; + $begin = implode('|', [ + '^', + preg_quote(self::SEPARATOR_ELEMENT, '/'), + preg_quote(self::SEPARATOR_LEVEL, '/'), + ]); + $end = implode('|', [ + '$', + preg_quote(self::SEPARATOR_ELEMENT, '/'), + preg_quote(self::SEPARATOR_ITEM, '/'), + ]); + + if (preg_match("/($begin)$msgid($end)/", $this->raw_data, $m, + $get_index ? PREG_OFFSET_CAPTURE : 0) + ) { + if ($get_index) { + $idx = 0; + if ($m[0][1]) { + $idx = substr_count($this->raw_data, self::SEPARATOR_ELEMENT, 0, $m[0][1]+1) + + substr_count($this->raw_data, self::SEPARATOR_ITEM, 0, $m[0][1]+1); + } + // cache position of this element, so we can use it in get_element() + $this->meta['pos'][$idx] = (int)$m[0][1]; + + return $idx; + } + return true; + } + + return false; + } + + /** + * Return IDs of all messages in the result. Threaded data will be flattened. + * + * @return array List of message identifiers + */ + public function get() + { + if (empty($this->raw_data)) { + return []; + } + + $regexp = '/(' . preg_quote(self::SEPARATOR_ELEMENT, '/') + . '|' . preg_quote(self::SEPARATOR_ITEM, '/') . '[0-9]+' . preg_quote(self::SEPARATOR_LEVEL, '/') + .')/'; + + return preg_split($regexp, $this->raw_data); + } + + /** + * Return all messages in the result. + * + * @return array List of message identifiers + */ + public function get_compressed() + { + if (empty($this->raw_data)) { + return ''; + } + + return rcube_imap_generic::compressMessageSet($this->get()); + } + + /** + * Return result element at specified index (all messages, not roots) + * + * @param int|string $index Element's index or "FIRST" or "LAST" + * + * @return int Element value + */ + public function get_element($index) + { + $count = $this->count(); + + if (!$count) { + return null; + } + + // first element + if ($index === 0 || $index === '0' || $index === 'FIRST') { + preg_match('/^([0-9]+)/', $this->raw_data, $m); + $result = (int) $m[1]; + return $result; + } + + // last element + if ($index === 'LAST' || $index == $count-1) { + preg_match('/([0-9]+)$/', $this->raw_data, $m); + $result = (int) $m[1]; + return $result; + } + + // do we know the position of the element or the neighbour of it? + if (!empty($this->meta['pos'])) { + $element = preg_quote(self::SEPARATOR_ELEMENT, '/'); + $item = preg_quote(self::SEPARATOR_ITEM, '/') . '[0-9]+' . preg_quote(self::SEPARATOR_LEVEL, '/') .'?'; + $regexp = '(' . $element . '|' . $item . ')'; + + if (isset($this->meta['pos'][$index])) { + if (preg_match('/([0-9]+)/', $this->raw_data, $m, null, $this->meta['pos'][$index])) { + $result = $m[1]; + } + } + else if (isset($this->meta['pos'][$index-1])) { + // get chunk of data after previous element + $data = substr($this->raw_data, $this->meta['pos'][$index-1]+1, 50); + $data = preg_replace('/^[0-9]+/', '', $data); // remove UID at $index position + $data = preg_replace("/^$regexp/", '', $data); // remove separator + if (preg_match('/^([0-9]+)/', $data, $m)) { + $result = $m[1]; + } + } + else if (isset($this->meta['pos'][$index+1])) { + // get chunk of data before next element + $pos = max(0, $this->meta['pos'][$index+1] - 50); + $len = min(50, $this->meta['pos'][$index+1]); + $data = substr($this->raw_data, $pos, $len); + $data = preg_replace("/$regexp\$/", '', $data); // remove separator + + if (preg_match('/([0-9]+)$/', $data, $m)) { + $result = $m[1]; + } + } + + if (isset($result)) { + return (int) $result; + } + } + + // Finally use less effective method + $data = $this->get(); + + return $data[$index] ?? null; + } + + /** + * Returns response parameters e.g. MAILBOX, ORDER + * + * @param string $param Parameter name + * + * @return array|string Response parameters or parameter value + */ + public function get_parameters($param=null) + { + $params = [ + 'MAILBOX' => $this->mailbox, + 'ORDER' => $this->order, + ]; + + if ($param !== null) { + return $params[$param]; + } + + return $params; + } + + /** + * THREAD=REFS sorting implementation (based on provided index) + * + * @param rcube_result_index $index Sorted message identifiers + */ + public function sort($index) + { + $this->order = $index->get_parameters('ORDER'); + + if (empty($this->raw_data)) { + return; + } + + // when sorting search result it's good to make the index smaller + if ($index->count() != $this->count_messages()) { + $index->filter($this->get()); + } + + $result = array_fill_keys($index->get(), null); + $datalen = strlen($this->raw_data); + $start = 0; + + // Here we're parsing raw_data twice, we want only one big array + // in memory at a time + + // Assign roots + while ( + ($start < $datalen && ($pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT, $start))) + || ($start < $datalen && ($pos = $datalen)) + ) { + $len = $pos - $start; + $elem = substr($this->raw_data, $start, $len); + $start = $pos + 1; + + $items = explode(self::SEPARATOR_ITEM, $elem); + $root = (int) array_shift($items); + + if ($root) { + $result[$root] = $root; + foreach ($items as $item) { + list($lv, $id) = explode(self::SEPARATOR_LEVEL, $item); + $result[$id] = $root; + } + } + } + + // get only unique roots + $result = array_filter($result); // make sure there are no nulls + $result = array_unique($result); + + // Re-sort raw data + $result = array_fill_keys($result, null); + $start = 0; + + while ( + ($start < $datalen && ($pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT, $start))) + || ($start < $datalen && ($pos = $datalen)) + ) { + $len = $pos - $start; + $elem = substr($this->raw_data, $start, $len); + $start = $pos + 1; + + $npos = strpos($elem, self::SEPARATOR_ITEM); + $root = (int) ($npos ? substr($elem, 0, $npos) : $elem); + + $result[$root] = $elem; + } + + $this->raw_data = implode(self::SEPARATOR_ELEMENT, $result); + } + + /** + * Returns data as tree + * + * @return array Data tree + */ + public function get_tree() + { + $datalen = strlen($this->raw_data); + $result = []; + $start = 0; + + while ($start < $datalen + && (($pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT, $start)) !== false + || ($pos = $datalen)) + ) { + $len = $pos - $start; + $elem = substr($this->raw_data, $start, $len); + $items = explode(self::SEPARATOR_ITEM, $elem); + $result[array_shift($items)] = $this->build_thread($items); + $start = $pos + 1; + } + + return $result; + } + + /** + * Returns thread depth and children data + * + * @return array Thread data + */ + public function get_thread_data() + { + $data = $this->get_tree(); + $depth = []; + $children = []; + + $this->build_thread_data($data, $depth, $children); + + return [$depth, $children]; + } + + /** + * Creates 'depth' and 'children' arrays from stored thread 'tree' data. + */ + protected function build_thread_data($data, &$depth, &$children, $level = 0) + { + foreach ((array)$data as $key => $val) { + $empty = empty($val) || !is_array($val); + $children[$key] = !$empty; + $depth[$key] = $level; + if (!$empty) { + $this->build_thread_data($val, $depth, $children, $level + 1); + } + } + } + + /** + * Converts part of the raw thread into an array + */ + protected function build_thread($items, $level = 1, &$pos = 0) + { + $result = []; + + for ($len=count($items); $pos < $len; $pos++) { + list($lv, $id) = explode(self::SEPARATOR_LEVEL, $items[$pos]); + if ($level == $lv) { + $pos++; + $result[$id] = $this->build_thread($items, $level+1, $pos); + } + else { + $pos--; + break; + } + } + + return $result; + } + + /** + * IMAP THREAD response parser + */ + protected function parse_thread($str, $begin = 0, $end = 0, $depth = 0) + { + // Don't be tempted to change $str to pass by reference to speed this up - it will slow it down by about + // 7 times instead :-) See comments on http://uk2.php.net/references and this article: + // http://derickrethans.nl/files/phparch-php-variables-article.pdf + $node = ''; + if (!$end) { + $end = strlen($str); + } + + // Let's try to store data in max. compacted structure as a string, + // arrays handling is much more expensive + // For the following structure: THREAD (2)(3 6 (4 23)(44 7 96))((11)(12)) + // -- 2 + // -- 3 + // \-- 6 + // |-- 4 + // | \-- 23 + // | + // \-- 44 + // \-- 7 + // \-- 96 + // -- 11 + // \-- 12 + // + // The output will be: 2 3~1:6~2:4~3:23~2:44~3:7~4:96 11~1:12 + // Note: The "11" thread has no root, we use the first message as root + + if ($str[$begin] != '(') { + // find next bracket + $stop = $begin + strcspn($str, '()', $begin, $end - $begin); + $messages = explode(' ', trim(substr($str, $begin, $stop - $begin))); + + if (empty($messages)) { + return $node; + } + + foreach ($messages as $msg) { + if ($msg) { + $node .= ($depth ? self::SEPARATOR_ITEM.$depth.self::SEPARATOR_LEVEL : '').$msg; + if (isset($this->meta['messages'])) { + $this->meta['messages']++; + } + else { + $this->meta['messages'] = 1; + } + $depth++; + } + } + + if ($stop < $end) { + $node .= $this->parse_thread($str, $stop, $end, $depth); + } + } + else { + $off = $begin; + while ($off < $end) { + $start = $off; + $off++; + $n = 1; + while ($n > 0) { + $p = strpos($str, ')', $off); + if ($p === false) { + // error, wrong structure, mismatched brackets in IMAP THREAD response + // @TODO: write error to the log or maybe set $this->raw_data = null; + return $node; + } + + $p1 = strpos($str, '(', $off); + if ($p1 !== false && $p1 < $p) { + $off = $p1 + 1; + $n++; + } + else { + $off = $p + 1; + $n--; + } + } + + // Handle threads with missing parent by using first message as root + if (substr_compare($str, '((', $start, 2) === 0) { + // Extract the current thread, e.g. "((1)(2))" + $thread = substr($str, $start, $off - $start); + // Length of the first token, e.g. "(1)" + $len = strspn($thread, '(0123456789', 1) + 1; + // Extract the token and modify it to look like a thread root + $token = substr($thread, 1, $len); + // Warning: The order is important + $token = str_replace('(', '', $token); + $token = str_replace(' ', ' (', $token); + $token = str_replace(')', ' ', $token); + $thread = substr_replace($thread, $token, 1, $len); + // Parse the thread + $thread = $this->parse_thread($thread, 0, 0, $depth); + } + else { + $thread = $this->parse_thread($str, $start + 1, $off - 1, $depth); + } + + if ($thread) { + if (!$depth) { + if ($node) { + $node .= self::SEPARATOR_ELEMENT; + } + } + $node .= $thread; + } + } + } + + return $node; + } +} diff --git a/admin/tool/messageinbound/roundcube/rcube_utils.php b/admin/tool/messageinbound/roundcube/rcube_utils.php new file mode 100644 index 00000000000..ba058eee3b0 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/rcube_utils.php @@ -0,0 +1,1687 @@ + | + | Author: Aleksander Machniak | + +-----------------------------------------------------------------------+ +*/ + +/** + * Utility class providing common functions + * + * @package Framework + * @subpackage Utils + */ +class rcube_utils +{ + // define constants for input reading + const INPUT_GET = 1; + const INPUT_POST = 2; + const INPUT_COOKIE = 4; + const INPUT_GP = 3; // GET + POST + const INPUT_GPC = 7; // GET + POST + COOKIE + + + /** + * A wrapper for PHP's explode() that does not throw a warning + * when the separator does not exist in the string + * + * @param string $separator Separator string + * @param string $string The string to explode + * + * @return array Exploded string. Still an array if there's no separator in the string + */ + public static function explode($separator, $string) + { + if (strpos($string, $separator) !== false) { + return explode($separator, $string); + } + + return [$string, null]; + } + + /** + * Helper method to set a cookie with the current path and host settings + * + * @param string $name Cookie name + * @param string $value Cookie value + * @param int $exp Expiration time + * @param bool $http_only HTTP Only + */ + public static function setcookie($name, $value, $exp = 0, $http_only = true) + { + if (headers_sent()) { + return; + } + + $attrib = session_get_cookie_params(); + $attrib['expires'] = $exp; + $attrib['secure'] = $attrib['secure'] || self::https_check(); + $attrib['httponly'] = $http_only; + + // session_get_cookie_params() return includes 'lifetime' but setcookie() does not use it, instead it uses 'expires' + unset($attrib['lifetime']); + + setcookie($name, $value, $attrib); + } + + /** + * E-mail address validation. + * + * @param string $email Email address + * @param bool $dns_check True to check dns + * + * @return bool True on success, False if address is invalid + */ + public static function check_email($email, $dns_check = true) + { + // Check for invalid (control) characters + if (preg_match('/\p{Cc}/u', $email)) { + return false; + } + + // Check for length limit specified by RFC 5321 (#1486453) + if (strlen($email) > 254) { + return false; + } + + $pos = strrpos($email, '@'); + if (!$pos) { + return false; + } + + $domain_part = substr($email, $pos + 1); + $local_part = substr($email, 0, $pos); + + // quoted-string, make sure all backslashes and quotes are + // escaped + if (substr($local_part, 0, 1) == '"') { + $local_quoted = preg_replace('/\\\\(\\\\|\")/','', substr($local_part, 1, -1)); + if (preg_match('/\\\\|"/', $local_quoted)) { + return false; + } + } + // dot-atom portion, make sure there's no prohibited characters + else if (preg_match('/(^\.|\.\.|\.$)/', $local_part) + || preg_match('/[\\ ",:;<>@]/', $local_part) + ) { + return false; + } + + // Validate domain part + if (preg_match('/^\[((IPv6:[0-9a-f:.]+)|([0-9.]+))\]$/i', $domain_part, $matches)) { + return self::check_ip(preg_replace('/^IPv6:/i', '', $matches[1])); // valid IPv4 or IPv6 address + } + else { + // If not an IP address + $domain_array = explode('.', $domain_part); + // Not enough parts to be a valid domain + if (count($domain_array) < 2) { + return false; + } + + foreach ($domain_array as $part) { + if (!preg_match('/^((xn--)?([A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9])|([A-Za-z0-9]))$/', $part)) { + return false; + } + } + + // last domain part (allow extended TLD) + $last_part = array_pop($domain_array); + if (strpos($last_part, 'xn--') !== 0 + && (preg_match('/[^a-zA-Z0-9]/', $last_part) || preg_match('/^[0-9]+$/', $last_part)) + ) { + return false; + } + + $rcube = rcube::get_instance(); + + if (!$dns_check || !function_exists('checkdnsrr') || !$rcube->config->get('email_dns_check')) { + return true; + } + + // Check DNS record(s) + // Note: We can't use ANY (#6581) + foreach (['A', 'MX', 'CNAME', 'AAAA'] as $type) { + if (checkdnsrr($domain_part, $type)) { + return true; + } + } + } + + return false; + } + + /** + * Validates IPv4 or IPv6 address + * + * @param string $ip IP address in v4 or v6 format + * + * @return bool True if the address is valid + */ + public static function check_ip($ip) + { + return filter_var($ip, FILTER_VALIDATE_IP) !== false; + } + + /** + * Replacing specials characters to a specific encoding type + * + * @param string $str Input string + * @param string $enctype Encoding type: text|html|xml|js|url + * @param string $mode Replace mode for tags: show|remove|strict + * @param bool $newlines Convert newlines + * + * @return string The quoted string + */ + public static function rep_specialchars_output($str, $enctype = '', $mode = '', $newlines = true) + { + static $html_encode_arr = false; + static $js_rep_table = false; + static $xml_rep_table = false; + + if (!is_string($str)) { + $str = strval($str); + } + + // encode for HTML output + if ($enctype == 'html') { + if (!$html_encode_arr) { + $html_encode_arr = get_html_translation_table(HTML_SPECIALCHARS); + unset($html_encode_arr['?']); + } + + $encode_arr = $html_encode_arr; + + if ($mode == 'remove') { + $str = strip_tags($str); + } + else if ($mode != 'strict') { + // don't replace quotes and html tags + $ltpos = strpos($str, '<'); + if ($ltpos !== false && strpos($str, '>', $ltpos) !== false) { + unset($encode_arr['"']); + unset($encode_arr['<']); + unset($encode_arr['>']); + unset($encode_arr['&']); + } + } + + $out = strtr($str, $encode_arr); + + return $newlines ? nl2br($out) : $out; + } + + // if the replace tables for XML and JS are not yet defined + if ($js_rep_table === false) { + $js_rep_table = $xml_rep_table = []; + $xml_rep_table['&'] = '&'; + + // can be increased to support more charsets + for ($c=160; $c<256; $c++) { + $xml_rep_table[chr($c)] = "&#$c;"; + } + + $xml_rep_table['"'] = '"'; + $js_rep_table['"'] = '\\"'; + $js_rep_table["'"] = "\\'"; + $js_rep_table["\\"] = "\\\\"; + // Unicode line and paragraph separators (#1486310) + $js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A8'))] = '
'; + $js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A9'))] = '
'; + } + + // encode for javascript use + if ($enctype == 'js') { + return preg_replace(["/\r?\n/", "/\r/", '/<\\//'], ['\n', '\n', '<\\/'], strtr($str, $js_rep_table)); + } + + // encode for plaintext + if ($enctype == 'text') { + return str_replace("\r\n", "\n", $mode == 'remove' ? strip_tags($str) : $str); + } + + if ($enctype == 'url') { + return rawurlencode($str); + } + + // encode for XML + if ($enctype == 'xml') { + return strtr($str, $xml_rep_table); + } + + // no encoding given -> return original string + return $str; + } + + /** + * Read input value and make sure it is a string. + * + * @param string $fname Field name to read + * @param int $source Source to get value from (see self::INPUT_*) + * @param bool $allow_html Allow HTML tags in field value + * @param string $charset Charset to convert into + * + * @return string Request parameter value + * @see self::get_input_value() + */ + public static function get_input_string($fname, $source, $allow_html = false, $charset = null) + { + $value = self::get_input_value($fname, $source, $allow_html, $charset); + + return is_string($value) ? $value : ''; + } + + /** + * Read request parameter value and convert it for internal use + * Performs stripslashes() and charset conversion if necessary + * + * @param string $fname Field name to read + * @param int $source Source to get value from (see self::INPUT_*) + * @param bool $allow_html Allow HTML tags in field value + * @param string $charset Charset to convert into + * + * @return string|array|null Request parameter value or NULL if not set + */ + public static function get_input_value($fname, $source, $allow_html = false, $charset = null) + { + $value = null; + + if (($source & self::INPUT_GET) && isset($_GET[$fname])) { + $value = $_GET[$fname]; + } + + if (($source & self::INPUT_POST) && isset($_POST[$fname])) { + $value = $_POST[$fname]; + } + + if (($source & self::INPUT_COOKIE) && isset($_COOKIE[$fname])) { + $value = $_COOKIE[$fname]; + } + + return self::parse_input_value($value, $allow_html, $charset); + } + + /** + * Parse/validate input value. See self::get_input_value() + * Performs stripslashes() and charset conversion if necessary + * + * @param string $value Input value + * @param bool $allow_html Allow HTML tags in field value + * @param string $charset Charset to convert into + * + * @return string Parsed value + */ + public static function parse_input_value($value, $allow_html = false, $charset = null) + { + if (empty($value)) { + return $value; + } + + if (is_array($value)) { + foreach ($value as $idx => $val) { + $value[$idx] = self::parse_input_value($val, $allow_html, $charset); + } + + return $value; + } + + // remove HTML tags if not allowed + if (!$allow_html) { + $value = strip_tags($value); + } + + $rcube = rcube::get_instance(); + $output_charset = is_object($rcube->output) ? $rcube->output->get_charset() : null; + + // remove invalid characters (#1488124) + if ($output_charset == 'UTF-8') { + $value = rcube_charset::clean($value); + } + + // convert to internal charset + if ($charset && $output_charset) { + $value = rcube_charset::convert($value, $output_charset, $charset); + } + + return $value; + } + + /** + * Convert array of request parameters (prefixed with _) + * to a regular array with non-prefixed keys. + * + * @param int $mode Source to get value from (GPC) + * @param string $ignore PCRE expression to skip parameters by name + * @param bool $allow_html Allow HTML tags in field value + * + * @return array Hash array with all request parameters + */ + public static function request2param($mode = null, $ignore = 'task|action', $allow_html = false) + { + $out = []; + $src = $mode == self::INPUT_GET ? $_GET : ($mode == self::INPUT_POST ? $_POST : $_REQUEST); + + foreach (array_keys($src) as $key) { + $fname = $key[0] == '_' ? substr($key, 1) : $key; + if ($ignore && !preg_match('/^(' . $ignore . ')$/', $fname)) { + $out[$fname] = self::get_input_value($key, $mode, $allow_html); + } + } + + return $out; + } + + /** + * Convert the given string into a valid HTML identifier + * Same functionality as done in app.js with rcube_webmail.html_identifier() + * + * @param string $str String input + * @param bool $encode Use base64 encoding + * + * @return string Valid HTML identifier + */ + public static function html_identifier($str, $encode = false) + { + if ($encode) { + return rtrim(strtr(base64_encode($str), '+/', '-_'), '='); + } + + return asciiwords($str, true, '_'); + } + + /** + * Replace all css definitions with #container [def] + * and remove css-inlined scripting, make position style safe + * + * @param string $source CSS source code + * @param string $container_id Container ID to use as prefix + * @param bool $allow_remote Allow remote content + * @param string $prefix Prefix to be added to id/class identifier + * + * @return string Modified CSS source + */ + public static function mod_css_styles($source, $container_id, $allow_remote = false, $prefix = '') + { + $last_pos = 0; + $replacements = new rcube_string_replacer; + + // ignore the whole block if evil styles are detected + $source = self::xss_entity_decode($source); + $stripped = preg_replace('/[^a-z\(:;]/i', '', $source); + $evilexpr = 'expression|behavior|javascript:|import[^a]' . (!$allow_remote ? '|url\((?!data:image)' : ''); + + if (preg_match("/$evilexpr/i", $stripped)) { + return '/* evil! */'; + } + + $strict_url_regexp = '!url\s*\(\s*["\']?(https?:)//[a-z0-9/._+-]+["\']?\s*\)!Uims'; + + // remove html comments + $source = preg_replace('/(^\s*<\!--)|(-->\s*$)/m', '', $source); + + // cut out all contents between { and } + while (($pos = strpos($source, '{', $last_pos)) && ($pos2 = strpos($source, '}', $pos))) { + $nested = strpos($source, '{', $pos+1); + if ($nested && $nested < $pos2) { // when dealing with nested blocks (e.g. @media), take the inner one + $pos = $nested; + } + $length = $pos2 - $pos - 1; + $styles = substr($source, $pos+1, $length); + $output = ''; + + // check every css rule in the style block... + foreach (self::parse_css_block($styles) as $rule) { + // Remove 'page' attributes (#7604) + if ($rule[0] == 'page') { + continue; + } + + // Convert position:fixed to position:absolute (#5264) + if ($rule[0] == 'position' && strcasecmp($rule[1], 'fixed') === 0) { + $rule[1] = 'absolute'; + } + else if ($allow_remote) { + $stripped = preg_replace('/[^a-z\(:;]/i', '', $rule[1]); + + // allow data:image and strict url() values only + if ( + stripos($stripped, 'url(') !== false + && stripos($stripped, 'url(data:image') === false + && !preg_match($strict_url_regexp, $rule[1]) + ) { + $rule[1] = '/* evil! */'; + } + } + + $output .= sprintf(" %s: %s;", $rule[0] , $rule[1]); + } + + $key = $replacements->add($output . ' '); + $repl = $replacements->get_replacement($key); + $source = substr_replace($source, $repl, $pos+1, $length); + $last_pos = $pos2 - ($length - strlen($repl)); + } + + // add #container to each tag selector and prefix to id/class identifiers + if ($container_id || $prefix) { + // Exclude rcube_string_replacer pattern matches, this is needed + // for cases like @media { body { position: fixed; } } (#5811) + $excl = '(?!' . substr($replacements->pattern, 1, -1) . ')'; + $regexp = '/(^\s*|,\s*|\}\s*|\{\s*)(' . $excl . ':?[a-z0-9\._#\*\[][a-z0-9\._:\(\)#=~ \[\]"\|\>\+\$\^-]*)/im'; + $callback = function($matches) use ($container_id, $prefix) { + $replace = $matches[2]; + + if (stripos($replace, ':root') === 0) { + $replace = substr($replace, 5); + } + + if ($prefix) { + $replace = str_replace(['.', '#'], [".$prefix", "#$prefix"], $replace); + } + + if ($container_id) { + $replace = "#$container_id " . $replace; + } + + // Remove redundant spaces (for simpler testing) + $replace = preg_replace('/\s+/', ' ', $replace); + + return str_replace($matches[2], $replace, $matches[0]); + }; + + $source = preg_replace_callback($regexp, $callback, $source); + } + + // replace body definition because we also stripped off the tag + if ($container_id) { + $regexp = '/#' . preg_quote($container_id, '/') . '\s+body/i'; + $source = preg_replace($regexp, "#$container_id", $source); + } + + // put block contents back in + $source = $replacements->resolve($source); + + return $source; + } + + /** + * Explode css style. Property names will be lower-cased and trimmed. + * Values will be trimmed. Invalid entries will be skipped. + * + * @param string $style CSS style + * + * @return array List of CSS rule pairs, e.g. [['color', 'red'], ['top', '0']] + */ + public static function parse_css_block($style) + { + $pos = 0; + + // first remove comments + while (($pos = strpos($style, '/*', $pos)) !== false) { + $end = strpos($style, '*/', $pos+2); + + if ($end === false) { + $style = substr($style, 0, $pos); + } + else { + $style = substr_replace($style, '', $pos, $end - $pos + 2); + } + } + + // Replace new lines with spaces + $style = preg_replace('/[\r\n]+/', ' ', $style); + + $style = trim($style); + $length = strlen($style); + $result = []; + $pos = 0; + + while ($pos < $length && ($colon_pos = strpos($style, ':', $pos))) { + // Property name + $name = strtolower(trim(substr($style, $pos, $colon_pos - $pos))); + + // get the property value + $q = $s = false; + for ($i = $colon_pos + 1; $i < $length; $i++) { + if (($style[$i] == "\"" || $style[$i] == "'") && ($i == 0 || $style[$i-1] != "\\")) { + if ($q == $style[$i]) { + $q = false; + } + else if ($q === false) { + $q = $style[$i]; + } + } + else if ($style[$i] == "(" && !$q && ($i == 0 || $style[$i-1] != "\\")) { + $q = "("; + } + else if ($style[$i] == ")" && $q == "(" && $style[$i-1] != "\\") { + $q = false; + } + + if ($q === false && (($s = $style[$i] == ';') || $i == $length - 1)) { + break; + } + } + + $value_length = $i - $colon_pos - ($s ? 1 : 0); + $value = trim(substr($style, $colon_pos + 1, $value_length)); + + if (strlen($name) && !preg_match('/[^a-z-]/', $name) && strlen($value) && $value !== ';') { + $result[] = [$name, $value]; + } + + $pos = $i + 1; + } + + return $result; + } + + /** + * Generate CSS classes from mimetype and filename extension + * + * @param string $mimetype Mimetype + * @param string $filename Filename + * + * @return string CSS classes separated by space + */ + public static function file2class($mimetype, $filename) + { + $mimetype = strtolower($mimetype); + $filename = strtolower($filename); + + list($primary, $secondary) = rcube_utils::explode('/', $mimetype); + + $classes = [$primary ?: 'unknown']; + + if (!empty($secondary)) { + $classes[] = $secondary; + } + + if (preg_match('/\.([a-z0-9]+)$/', $filename, $m)) { + if (!in_array($m[1], $classes)) { + $classes[] = $m[1]; + } + } + + return implode(' ', $classes); + } + + /** + * Decode escaped entities used by known XSS exploits. + * See http://downloads.securityfocus.com/vulnerabilities/exploits/26800.eml for examples + * + * @param string $content CSS content to decode + * + * @return string Decoded string + */ + public static function xss_entity_decode($content) + { + $callback = function($matches) { return chr(hexdec($matches[1])); }; + + $out = html_entity_decode(html_entity_decode($content)); + $out = trim(preg_replace('/(^$)/', '', trim($out))); + $out = preg_replace_callback('/\\\([0-9a-f]{2,6})\s*/i', $callback, $out); + $out = preg_replace('/\\\([^0-9a-f])/i', '\\1', $out); + $out = preg_replace('#/\*.*\*/#Ums', '', $out); + $out = strip_tags($out); + + return $out; + } + + /** + * Check if we can process not exceeding memory_limit + * + * @param int $need Required amount of memory + * + * @return bool True if memory won't be exceeded, False otherwise + */ + public static function mem_check($need) + { + $mem_limit = parse_bytes(ini_get('memory_limit')); + $memory = function_exists('memory_get_usage') ? memory_get_usage() : 16*1024*1024; // safe value: 16MB + + return $mem_limit > 0 && $memory + $need > $mem_limit ? false : true; + } + + /** + * Check if working in SSL mode + * + * @param int $port HTTPS port number + * @param bool $use_https Enables 'use_https' option checking + * + * @return bool True in SSL mode, False otherwise + */ + public static function https_check($port = null, $use_https = true) + { + if (!empty($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) != 'off') { + return true; + } + + if (!empty($_SERVER['HTTP_X_FORWARDED_PROTO']) + && strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) == 'https' + && self::check_proxy_whitelist_ip() + ) { + return true; + } + + if ($port && isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] == $port) { + return true; + } + + if ($use_https && rcube::get_instance()->config->get('use_https')) { + return true; + } + + return false; + } + + /** + * Check if the reported REMOTE_ADDR is in the 'proxy_whitelist' config option + */ + public static function check_proxy_whitelist_ip() { + return in_array($_SERVER['REMOTE_ADDR'], (array) rcube::get_instance()->config->get('proxy_whitelist', [])); + } + + /** + * Replaces hostname variables. + * + * @param string $name Hostname + * @param string $host Optional IMAP hostname + * + * @return string Hostname + */ + public static function parse_host($name, $host = '') + { + if (!is_string($name)) { + return $name; + } + + // %n - host + $n = self::server_name(); + // %t - host name without first part, e.g. %n=mail.domain.tld, %t=domain.tld + // If %n=domain.tld then %t=domain.tld as well (remains valid) + $t = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $n); + // %d - domain name without first part (up to domain.tld) + $d = preg_replace('/^[^.]+\.(?![^.]+$)/', '', self::server_name('HTTP_HOST')); + // %h - IMAP host + $h = !empty($_SESSION['storage_host']) ? $_SESSION['storage_host'] : $host; + // %z - IMAP domain without first part, e.g. %h=imap.domain.tld, %z=domain.tld + // If %h=domain.tld then %z=domain.tld as well (remains valid) + $z = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $h); + // %s - domain name after the '@' from e-mail address provided at login screen. + // Returns FALSE if an invalid email is provided + $s = ''; + if (strpos($name, '%s') !== false) { + $user_email = self::idn_to_ascii(self::get_input_value('_user', self::INPUT_POST)); + $matches = preg_match('/(.*)@([a-z0-9\.\-\[\]\:]+)/i', $user_email, $s); + if ($matches < 1 || filter_var($s[1]."@".$s[2], FILTER_VALIDATE_EMAIL) === false) { + return false; + } + $s = $s[2]; + } + + return str_replace(['%n', '%t', '%d', '%h', '%z', '%s'], [$n, $t, $d, $h, $z, $s], $name); + } + + /** + * Parse host specification URI. + * + * @param string $host Host URI + * @param int $plain_port Plain port number + * @param int $ssl_port SSL port number + * + * @return array An array with three elements (hostname, scheme, port) + */ + public static function parse_host_uri($host, $plain_port = null, $ssl_port = null) + { + if (preg_match('#^(unix|ldapi)://#i', $host, $matches)) { + return [$host, $matches[1], -1]; + } + + $url = parse_url($host); + $port = $plain_port; + $scheme = null; + + if (!empty($url['host'])) { + $host = $url['host']; + $scheme = $url['scheme'] ?? null; + + if (!empty($url['port'])) { + $port = $url['port']; + } + else if ( + $scheme + && $ssl_port + && ($scheme === 'ssl' || ($scheme != 'tls' && $scheme[strlen($scheme) - 1] === 's')) + ) { + // assign SSL port to ssl://, imaps://, ldaps://, but not tls:// + $port = $ssl_port; + } + } + + return [$host, $scheme, $port]; + } + + /** + * Returns the server name after checking it against trusted hostname patterns. + * + * Returns 'localhost' and logs a warning when the hostname is not trusted. + * + * @param string $type The $_SERVER key, e.g. 'HTTP_HOST', Default: 'SERVER_NAME'. + * @param bool $strip_port Strip port from the host name + * + * @return string Server name + */ + public static function server_name($type = null, $strip_port = true) + { + if (!$type) { + $type = 'SERVER_NAME'; + } + + $name = $_SERVER[$type] ?? ''; + $rcube = rcube::get_instance(); + $patterns = (array) $rcube->config->get('trusted_host_patterns'); + + if (!empty($name)) { + if ($strip_port) { + $name = preg_replace('/:\d+$/', '', $name); + } + + if (empty($patterns)) { + return $name; + } + + foreach ($patterns as $pattern) { + // the pattern might be a regular expression or just a host/domain name + if (preg_match('/[^a-zA-Z0-9.:-]/', $pattern)) { + if (preg_match("/$pattern/", $name)) { + return $name; + } + } + else if (strtolower($name) === strtolower($pattern)) { + return $name; + } + } + + $rcube->raise_error([ + 'file' => __FILE__, 'line' => __LINE__, + 'message' => "Specified host is not trusted. Using 'localhost'." + ] + , true, false + ); + } + + return 'localhost'; + } + + /** + * Returns remote IP address and forwarded addresses if found + * + * @return string Remote IP address(es) + */ + public static function remote_ip() + { + $address = $_SERVER['REMOTE_ADDR'] ?? ''; + + // append the NGINX X-Real-IP header, if set + if (!empty($_SERVER['HTTP_X_REAL_IP']) && $_SERVER['HTTP_X_REAL_IP'] != $address) { + $remote_ip[] = 'X-Real-IP: ' . $_SERVER['HTTP_X_REAL_IP']; + } + + // append the X-Forwarded-For header, if set + if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) { + $remote_ip[] = 'X-Forwarded-For: ' . $_SERVER['HTTP_X_FORWARDED_FOR']; + } + + if (!empty($remote_ip)) { + $address .= ' (' . implode(',', $remote_ip) . ')'; + } + + return $address; + } + + /** + * Returns the real remote IP address + * + * @return string Remote IP address + */ + public static function remote_addr() + { + // Check if any of the headers are set first to improve performance + if (!empty($_SERVER['HTTP_X_FORWARDED_FOR']) || !empty($_SERVER['HTTP_X_REAL_IP'])) { + $proxy_whitelist = (array) rcube::get_instance()->config->get('proxy_whitelist', []); + if (in_array($_SERVER['REMOTE_ADDR'], $proxy_whitelist)) { + if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) { + foreach (array_reverse(explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'])) as $forwarded_ip) { + $forwarded_ip = trim($forwarded_ip); + if (!in_array($forwarded_ip, $proxy_whitelist)) { + return $forwarded_ip; + } + } + } + + if (!empty($_SERVER['HTTP_X_REAL_IP'])) { + return $_SERVER['HTTP_X_REAL_IP']; + } + } + } + + if (!empty($_SERVER['REMOTE_ADDR'])) { + return $_SERVER['REMOTE_ADDR']; + } + + return ''; + } + + /** + * Read a specific HTTP request header. + * + * @param string $name Header name + * + * @return string|null Header value or null if not available + */ + public static function request_header($name) + { + if (function_exists('apache_request_headers')) { + $headers = apache_request_headers(); + $key = strtoupper($name); + } + else { + $headers = $_SERVER; + $key = 'HTTP_' . strtoupper(strtr($name, '-', '_')); + } + + if (!empty($headers)) { + $headers = array_change_key_case($headers, CASE_UPPER); + + return $headers[$key] ?? null; + } + } + + /** + * Explode quoted string + * + * @param string $delimiter Delimiter expression string for preg_match() + * @param string $string Input string + * + * @return array String items + */ + public static function explode_quoted_string($delimiter, $string) + { + $result = []; + $strlen = strlen($string); + + for ($q=$p=$i=0; $i < $strlen; $i++) { + if ($string[$i] == "\"" && (!isset($string[$i-1]) || $string[$i-1] != "\\")) { + $q = $q ? false : true; + } + else if (!$q && preg_match("/$delimiter/", $string[$i])) { + $result[] = substr($string, $p, $i - $p); + $p = $i + 1; + } + } + + $result[] = (string) substr($string, $p); + + return $result; + } + + /** + * Improved equivalent to strtotime() + * + * @param string $date Date string + * @param DateTimeZone $timezone Timezone to use for DateTime object + * + * @return int Unix timestamp + */ + public static function strtotime($date, $timezone = null) + { + $date = self::clean_datestr($date); + $tzname = $timezone ? ' ' . $timezone->getName() : ''; + + // unix timestamp + if (is_numeric($date)) { + return (int) $date; + } + + // It can be very slow when provided string is not a date and very long + if (strlen($date) > 128) { + $date = substr($date, 0, 128); + } + + // if date parsing fails, we have a date in non-rfc format. + // remove token from the end and try again + while (($ts = @strtotime($date . $tzname)) === false || $ts < 0) { + if (($pos = strrpos($date, ' ')) === false) { + break; + } + + $date = rtrim(substr($date, 0, $pos)); + } + + return (int) $ts; + } + + /** + * Date parsing function that turns the given value into a DateTime object + * + * @param string $date Date string + * @param DateTimeZone $timezone Timezone to use for DateTime object + * + * @return DateTime|false DateTime object or False on failure + */ + public static function anytodatetime($date, $timezone = null) + { + if ($date instanceof DateTime) { + return $date; + } + + $dt = false; + $date = self::clean_datestr($date); + + // try to parse string with DateTime first + if (!empty($date)) { + try { + $_date = preg_match('/^[0-9]+$/', $date) ? "@$date" : $date; + $dt = $timezone ? new DateTime($_date, $timezone) : new DateTime($_date); + } + catch (Exception $e) { + // ignore + } + } + + // try our advanced strtotime() method + if (!$dt && ($timestamp = self::strtotime($date, $timezone))) { + try { + $dt = new DateTime("@".$timestamp); + if ($timezone) { + $dt->setTimezone($timezone); + } + } + catch (Exception $e) { + // ignore + } + } + + return $dt; + } + + /** + * Clean up date string for strtotime() input + * + * @param string $date Date string + * + * @return string Date string + */ + public static function clean_datestr($date) + { + $date = trim((string) $date); + + // check for MS Outlook vCard date format YYYYMMDD + if (preg_match('/^([12][90]\d\d)([01]\d)([0123]\d)$/', $date, $m)) { + return sprintf('%04d-%02d-%02d 00:00:00', intval($m[1]), intval($m[2]), intval($m[3])); + } + + // Clean malformed data + $date = preg_replace( + [ + '/\(.*\)/', // remove RFC comments + '/GMT\s*([+-][0-9]+)/', // support non-standard "GMTXXXX" literal + '/[^a-z0-9\x20\x09:\/\.+-]/i', // remove any invalid characters + '/\s*(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s*/i', // remove weekday names + ], + [ + '', + '\\1', + '', + '', + ], + $date + ); + + $date = trim($date); + + // try to fix dd/mm vs. mm/dd discrepancy, we can't do more here + if (preg_match('/^(\d{1,2})[.\/-](\d{1,2})[.\/-](\d{4})(\s.*)?$/', $date, $m)) { + $mdy = $m[2] > 12 && $m[1] <= 12; + $day = $mdy ? $m[2] : $m[1]; + $month = $mdy ? $m[1] : $m[2]; + $date = sprintf('%04d-%02d-%02d%s', $m[3], $month, $day, $m[4] ?? ' 00:00:00'); + } + // I've found that YYYY.MM.DD is recognized wrong, so here's a fix + else if (preg_match('/^(\d{4})\.(\d{1,2})\.(\d{1,2})(\s.*)?$/', $date, $m)) { + $date = sprintf('%04d-%02d-%02d%s', $m[1], $m[2], $m[3], $m[4] ?? ' 00:00:00'); + } + + return $date; + } + + /** + * Turns the given date-only string in defined format into YYYY-MM-DD format. + * + * Supported formats: 'Y/m/d', 'Y.m.d', 'd-m-Y', 'd/m/Y', 'd.m.Y', 'j.n.Y' + * + * @param string $date Date string + * @param string $format Input date format + * + * @return string Date string in YYYY-MM-DD format, or the original string + * if format is not supported + */ + public static function format_datestr($date, $format) + { + $format_items = preg_split('/[.-\/\\\\]/', $format); + $date_items = preg_split('/[.-\/\\\\]/', $date); + $iso_format = '%04d-%02d-%02d'; + + if (count($format_items) == 3 && count($date_items) == 3) { + if ($format_items[0] == 'Y') { + $date = sprintf($iso_format, $date_items[0], $date_items[1], $date_items[2]); + } + else if (strpos('dj', $format_items[0]) !== false) { + $date = sprintf($iso_format, $date_items[2], $date_items[1], $date_items[0]); + } + else if (strpos('mn', $format_items[0]) !== false) { + $date = sprintf($iso_format, $date_items[2], $date_items[0], $date_items[1]); + } + } + + return $date; + } + + /** + * Wrapper for idn_to_ascii with support for e-mail address. + * + * Warning: Domain names may be lowercase'd. + * Warning: An empty string may be returned on invalid domain. + * + * @param string $str Decoded e-mail address + * + * @return string Encoded e-mail address + */ + public static function idn_to_ascii($str) + { + return self::idn_convert($str, true); + } + + /** + * Wrapper for idn_to_utf8 with support for e-mail address + * + * @param string $str Decoded e-mail address + * + * @return string Encoded e-mail address + */ + public static function idn_to_utf8($str) + { + return self::idn_convert($str, false); + } + + /** + * Convert a string to ascii or utf8 (using IDNA standard) + * + * @param string $input Decoded e-mail address + * @param bool $is_utf Convert by idn_to_ascii if true and idn_to_utf8 if false + * + * @return string Encoded e-mail address + */ + public static function idn_convert($input, $is_utf = false) + { + if ($at = strpos($input, '@')) { + $user = substr($input, 0, $at); + $domain = substr($input, $at + 1); + } + else { + $user = ''; + $domain = $input; + } + + // Note that in PHP 7.2/7.3 calling idn_to_* functions with default arguments + // throws a warning, so we have to set the variant explicitly (#6075) + $variant = INTL_IDNA_VARIANT_UTS46; + $options = 0; + + // Because php-intl extension lowercases domains and return false + // on invalid input (#6224), we skip conversion when not needed + + if ($is_utf) { + if (preg_match('/[^\x20-\x7E]/', $domain)) { + $options = IDNA_NONTRANSITIONAL_TO_ASCII; + $domain = idn_to_ascii($domain, $options, $variant); + } + } + else if (preg_match('/(^|\.)xn--/i', $domain)) { + $options = IDNA_NONTRANSITIONAL_TO_UNICODE; + $domain = idn_to_utf8($domain, $options, $variant); + } + + if ($domain === false) { + return ''; + } + + return $at ? $user . '@' . $domain : $domain; + } + + /** + * Split the given string into word tokens + * + * @param string $str Input to tokenize + * @param int $minlen Minimum length of a single token + * + * @return array List of tokens + */ + public static function tokenize_string($str, $minlen = 2) + { + if (!is_string($str)) { + return []; + } + + $expr = ['/[\s;,"\'\/+-]+/ui', '/(\d)[-.\s]+(\d)/u']; + $repl = [' ', '\\1\\2']; + + if ($minlen > 1) { + $minlen--; + $expr[] = "/(^|\s+)\w{1,$minlen}(\s+|$)/u"; + $repl[] = ' '; + } + + $str = preg_replace($expr, $repl, $str); + + return is_string($str) ? array_filter(explode(" ", $str)) : []; + } + + /** + * Normalize the given string for fulltext search. + * Currently only optimized for ISO-8859-1 and ISO-8859-2 characters; to be extended + * + * @param string $str Input string (UTF-8) + * @param bool $as_array True to return list of words as array + * @param int $minlen Minimum length of tokens + * + * @return string|array Normalized string or a list of normalized tokens + */ + public static function normalize_string($str, $as_array = false, $minlen = 2) + { + // replace 4-byte unicode characters with '?' character, + // these are not supported in default utf-8 charset on mysql, + // the chance we'd need them in searching is very low + $str = preg_replace('/(' + . '\xF0[\x90-\xBF][\x80-\xBF]{2}' + . '|[\xF1-\xF3][\x80-\xBF]{3}' + . '|\xF4[\x80-\x8F][\x80-\xBF]{2}' + . ')/', '?', $str); + + // split by words + $arr = self::tokenize_string($str, $minlen); + + // detect character set + if (rcube_charset::convert(rcube_charset::convert($str, 'UTF-8', 'ISO-8859-1'), 'ISO-8859-1', 'UTF-8') == $str) { + // ISO-8859-1 (or ASCII) + preg_match_all('/./u', 'äâàåáãæçéêëèïîìíñöôòøõóüûùúýÿ', $keys); + preg_match_all('/./', 'aaaaaaaceeeeiiiinoooooouuuuyy', $values); + + $mapping = array_combine($keys[0], $values[0]); + $mapping = array_merge($mapping, ['ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u']); + } + else if (rcube_charset::convert(rcube_charset::convert($str, 'UTF-8', 'ISO-8859-2'), 'ISO-8859-2', 'UTF-8') == $str) { + // ISO-8859-2 + preg_match_all('/./u', 'ąáâäćçčéęëěíîłľĺńňóôöŕřśšşťţůúűüźžżý', $keys); + preg_match_all('/./', 'aaaaccceeeeiilllnnooorrsssttuuuuzzzy', $values); + + $mapping = array_combine($keys[0], $values[0]); + $mapping = array_merge($mapping, ['ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u']); + } + + foreach ($arr as $i => $part) { + $part = mb_strtolower($part); + + if (!empty($mapping)) { + $part = strtr($part, $mapping); + } + + $arr[$i] = $part; + } + + return $as_array ? $arr : implode(' ', $arr); + } + + /** + * Compare two strings for matching words (order not relevant) + * + * @param string $haystack Haystack + * @param string $needle Needle + * + * @return bool True if match, False otherwise + */ + public static function words_match($haystack, $needle) + { + $a_needle = self::tokenize_string($needle, 1); + $_haystack = implode(' ', self::tokenize_string($haystack, 1)); + $valid = strlen($_haystack) > 0; + $hits = 0; + + foreach ($a_needle as $w) { + if ($valid) { + if (stripos($_haystack, $w) !== false) { + $hits++; + } + } + else if (stripos($haystack, $w) !== false) { + $hits++; + } + } + + return $hits >= count($a_needle); + } + + /** + * Parse commandline arguments into a hash array + * + * @param array $aliases Argument alias names + * + * @return array Argument values hash + */ + public static function get_opt($aliases = []) + { + $args = []; + $bool = []; + + // find boolean (no value) options + foreach ($aliases as $key => $alias) { + if ($pos = strpos($alias, ':')) { + $aliases[$key] = substr($alias, 0, $pos); + $bool[] = $key; + $bool[] = $aliases[$key]; + } + } + + for ($i=1; $i < count($_SERVER['argv']); $i++) { + $arg = $_SERVER['argv'][$i]; + $value = true; + $key = null; + + if (strlen($arg) && $arg[0] == '-') { + $key = preg_replace('/^-+/', '', $arg); + $sp = strpos($arg, '='); + + if ($sp > 0) { + $key = substr($key, 0, $sp - 2); + $value = substr($arg, $sp+1); + } + else if (in_array($key, $bool)) { + $value = true; + } + else if ( + isset($_SERVER['argv'][$i + 1]) + && strlen($_SERVER['argv'][$i + 1]) + && $_SERVER['argv'][$i + 1][0] != '-' + ) { + $value = $_SERVER['argv'][++$i]; + } + + $args[$key] = is_string($value) ? preg_replace(['/^["\']/', '/["\']$/'], '', $value) : $value; + } + else { + $args[] = $arg; + } + + if (!empty($aliases[$key])) { + $alias = $aliases[$key]; + $args[$alias] = $args[$key]; + } + } + + return $args; + } + + /** + * Safe password prompt for command line + * from http://blogs.sitepoint.com/2009/05/01/interactive-cli-password-prompt-in-php/ + * + * @param string $prompt Prompt text + * + * @return string Password + */ + public static function prompt_silent($prompt = "Password:") + { + if (preg_match('/^win/i', PHP_OS)) { + $vbscript = sys_get_temp_dir() . 'prompt_password.vbs'; + $vbcontent = 'wscript.echo(InputBox("' . addslashes($prompt) . '", "", "password here"))'; + file_put_contents($vbscript, $vbcontent); + + $command = "cscript //nologo " . escapeshellarg($vbscript); + $password = rtrim(shell_exec($command)); + unlink($vbscript); + + return $password; + } + + $command = "/usr/bin/env bash -c 'echo OK'"; + + if (rtrim(shell_exec($command)) !== 'OK') { + echo $prompt; + $pass = trim(fgets(STDIN)); + echo chr(8)."\r" . $prompt . str_repeat("*", strlen($pass))."\n"; + + return $pass; + } + + $command = "/usr/bin/env bash -c 'read -s -p \"" . addslashes($prompt) . "\" mypassword && echo \$mypassword'"; + $password = rtrim(shell_exec($command)); + echo "\n"; + + return $password; + } + + /** + * Find out if the string content means true or false + * + * @param string $str Input value + * + * @return bool Boolean value + */ + public static function get_boolean($str) + { + $str = strtolower((string) $str); + + return !in_array($str, ['false', '0', 'no', 'off', 'nein', ''], true); + } + + /** + * OS-dependent absolute path detection + * + * @param string $path File path + * + * @return bool True if the path is absolute, False otherwise + */ + public static function is_absolute_path($path) + { + if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') { + return (bool) preg_match('!^[a-z]:[\\\\/]!i', $path); + } + + return isset($path[0]) && $path[0] == '/'; + } + + /** + * Resolve relative URL + * + * @param string $url Relative URL + * + * @return string Absolute URL + */ + public static function resolve_url($url) + { + // prepend protocol://hostname:port + if (!preg_match('|^https?://|', $url)) { + $schema = 'http'; + $default_port = 80; + + if (self::https_check()) { + $schema = 'https'; + $default_port = 443; + } + + $host = $_SERVER['HTTP_HOST'] ?? ''; + $port = $_SERVER['SERVER_PORT'] ?? 0; + + $prefix = $schema . '://' . preg_replace('/:\d+$/', '', $host); + if ($port && $port != $default_port && $port != 80) { + $prefix .= ':' . $port; + } + + $url = $prefix . ($url[0] == '/' ? '' : '/') . $url; + } + + return $url; + } + + /** + * Generate a random string + * + * @param int $length String length + * @param bool $raw Return RAW data instead of ascii + * + * @return string The generated random string + */ + public static function random_bytes($length, $raw = false) + { + // Use PHP7 true random generator + if ($raw) { + return random_bytes($length); + } + + $hextab = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + $tabsize = strlen($hextab); + + $result = ''; + while ($length-- > 0) { + $result .= $hextab[random_int(0, $tabsize - 1)]; + } + + return $result; + } + + /** + * Convert binary data into readable form (containing a-zA-Z0-9 characters) + * + * @param string $input Binary input + * + * @return string Readable output (Base62) + * @deprecated since 1.3.1 + */ + public static function bin2ascii($input) + { + $hextab = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + $result = ''; + + for ($x = 0; $x < strlen($input); $x++) { + $result .= $hextab[ord($input[$x]) % 62]; + } + + return $result; + } + + /** + * Format current date according to specified format. + * This method supports microseconds (u). + * + * @param string $format Date format (default: 'd-M-Y H:i:s O') + * + * @return string Formatted date + */ + public static function date_format($format = null) + { + if (empty($format)) { + $format = 'd-M-Y H:i:s O'; + } + + if (strpos($format, 'u') !== false) { + $dt = number_format(microtime(true), 6, '.', ''); + + try { + $date = date_create_from_format('U.u', $dt); + $date->setTimeZone(new DateTimeZone(date_default_timezone_get())); + + return $date->format($format); + } + catch (Exception $e) { + // ignore, fallback to date() + } + } + + return date($format); + } + + /** + * Parses socket options and returns options for specified hostname. + * + * @param array &$options Configured socket options + * @param string $host Hostname + */ + public static function parse_socket_options(&$options, $host = null) + { + if (empty($host) || empty($options)) { + return; + } + + // get rid of schema and port from the hostname + $host_url = parse_url($host); + if (isset($host_url['host'])) { + $host = $host_url['host']; + } + + // find per-host options + if ($host && array_key_exists($host, $options)) { + $options = $options[$host]; + } + } + + /** + * Get maximum upload size + * + * @return int Maximum size in bytes + */ + public static function max_upload_size() + { + // find max filesize value + $max_filesize = parse_bytes(ini_get('upload_max_filesize')); + $max_postsize = parse_bytes(ini_get('post_max_size')); + + if ($max_postsize && $max_postsize < $max_filesize) { + $max_filesize = $max_postsize; + } + + return $max_filesize; + } + + /** + * Detect and log last PREG operation error + * + * @param array $error Error data (line, file, code, message) + * @param bool $terminate Stop script execution + * + * @return bool True on error, False otherwise + */ + public static function preg_error($error = [], $terminate = false) + { + if (($preg_error = preg_last_error()) != PREG_NO_ERROR) { + $errstr = "PCRE Error: $preg_error."; + + if (function_exists('preg_last_error_msg')) { + $errstr .= ' ' . preg_last_error_msg(); + } + + if ($preg_error == PREG_BACKTRACK_LIMIT_ERROR) { + $errstr .= " Consider raising pcre.backtrack_limit!"; + } + if ($preg_error == PREG_RECURSION_LIMIT_ERROR) { + $errstr .= " Consider raising pcre.recursion_limit!"; + } + + $error = array_merge(['code' => 620, 'line' => __LINE__, 'file' => __FILE__], $error); + + if (!empty($error['message'])) { + $error['message'] .= ' ' . $errstr; + } + else { + $error['message'] = $errstr; + } + + rcube::raise_error($error, true, $terminate); + + return true; + } + + return false; + } + + /** + * Generate a temporary file path in the Roundcube temp directory + * + * @param string $file_name String identifier for the type of temp file + * @param bool $unique Generate unique file names based on $file_name + * @param bool $create Create the temp file or not + * + * @return string temporary file path + */ + public static function temp_filename($file_name, $unique = true, $create = true) + { + $temp_dir = rcube::get_instance()->config->get('temp_dir'); + + // Fall back to system temp dir if configured dir is not writable + if (!is_writable($temp_dir)) { + $temp_dir = sys_get_temp_dir(); + } + + // On Windows tempnam() uses only the first three characters of prefix so use uniqid() and manually add the prefix + // Full prefix is required for garbage collection to recognise the file + $temp_file = $unique ? str_replace('.', '', uniqid($file_name, true)) : $file_name; + $temp_path = unslashify($temp_dir) . '/' . RCUBE_TEMP_FILE_PREFIX . $temp_file; + + // Sanity check for unique file name + if ($unique && file_exists($temp_path)) { + return self::temp_filename($file_name, $unique, $create); + } + + // Create the file to prevent possible race condition like tempnam() does + if ($create) { + touch($temp_path); + } + + return $temp_path; + } + + /** + * Clean the subject from reply and forward prefix + * + * @param string $subject Subject to clean + * @param string $mode Mode of cleaning : reply, forward or both + * + * @return string Cleaned subject + */ + public static function remove_subject_prefix($subject, $mode = 'both') + { + $config = rcmail::get_instance()->config; + + // Clean subject prefix for reply, forward or both + if ($mode == 'both') { + $reply_prefixes = $config->get('subject_reply_prefixes', ['Re:']); + $forward_prefixes = $config->get('subject_forward_prefixes', ['Fwd:', 'Fw:']); + $prefixes = array_merge($reply_prefixes, $forward_prefixes); + } + else if ($mode == 'reply') { + $prefixes = $config->get('subject_reply_prefixes', ['Re:']); + // replace (was: ...) (#1489375) + $subject = preg_replace('/\s*\([wW]as:[^\)]+\)\s*$/', '', $subject); + } + else if ($mode == 'forward') { + $prefixes = $config->get('subject_forward_prefixes', ['Fwd:', 'Fw:']); + } + + // replace Re:, Re[x]:, Re-x (#1490497) + $pieces = array_map(function($prefix) { + $prefix = strtolower(str_replace(':', '', $prefix)); + return "$prefix:|$prefix\[\d\]:|$prefix-\d:"; + }, $prefixes); + $pattern = '/^('.implode('|', $pieces).')\s*/i'; + do { + $subject = preg_replace($pattern, '', $subject, -1, $count); + } + while ($count); + + return trim($subject); + } +} diff --git a/admin/tool/messageinbound/roundcube/readme_moodle.txt b/admin/tool/messageinbound/roundcube/readme_moodle.txt new file mode 100644 index 00000000000..571c6f90238 --- /dev/null +++ b/admin/tool/messageinbound/roundcube/readme_moodle.txt @@ -0,0 +1,24 @@ +Description of Roundcube Framework 1.6.6 library import into Moodle + +We now use the client part of Roundcube Framework as a library in Moodle. +This library is used to receive emails from Moodle. +This library is not used to send emails. + +For more information on this version of Roundcube Framework, check out https://github.com/roundcube/roundcubemail/releases/tag/1.6.6 + +To upgrade this library: +1. Download the latest release of Roundcube Framework (roundcube-framework-xxx-tar.gz) in https://github.com/roundcube/roundcubemail/releases. +2. Extract the contents of the release archive to a temp folder. +3. Copy the following files from the temp folder to the Moodle folder admin/tool/messageinbound/roundcube: + - rcube_charset.php + - rcube_imap_generic.php + - rcube_message_header.php + - rcube_mime.php + - rcube_result_index.php + - rcube_result_thread.php + - rcube_utils.php +4. Find and replace all array_first() calls with array_shift() in the following files: + - rcube_imap_generic.php + - rcube_result_index.php + - rcube_result_thread.php +5. Update admin/tool/messageinbound/thirdpartylibs.xml. diff --git a/admin/tool/messageinbound/thirdpartylibs.xml b/admin/tool/messageinbound/thirdpartylibs.xml new file mode 100644 index 00000000000..e8be5ba5ee7 --- /dev/null +++ b/admin/tool/messageinbound/thirdpartylibs.xml @@ -0,0 +1,14 @@ + + + + roundcube + Roundcube Framework + GPL + 3.0+ + 1.6.6 + https://github.com/roundcube/roundcubemail + + The Roundcube Dev Team + + +