PHP rcube_charset::convert方法代码示例

 /**
  *
  */
 public function import($csv)
 {
     // convert to UTF-8
     $head = substr($csv, 0, 4096);
     $charset = rcube_charset::detect($head, RCUBE_CHARSET);
     $csv = rcube_charset::convert($csv, $charset);
     $head = '';
     $this->map = array();
     // Parse file
     foreach (preg_split("/[\r\n]+/", $csv) as $line) {
         $elements = $this->parse_line($line);
         if (empty($elements)) {
             continue;
         }
         // Parse header
         if (empty($this->map)) {
             $this->parse_header($elements);
             if (empty($this->map)) {
                 break;
             }
         } else {
             $this->csv_to_vcard($elements);
         }
     }
 }

 /**
  *
  */
 public function import($csv)
 {
     // convert to UTF-8
     $head = substr($csv, 0, 4096);
     $fallback = rcube::get_instance()->config->get('default_charset', 'ISO-8859-1');
     // fallback to Latin-1?
     $charset = rcube_charset::detect($head, RCUBE_CHARSET);
     $csv = rcube_charset::convert($csv, $charset);
     $head = '';
     $this->map = array();
     // Parse file
     foreach (preg_split("/[\r\n]+/", $csv) as $i => $line) {
         $elements = $this->parse_line($line);
         if (empty($elements)) {
             continue;
         }
         // Parse header
         if (empty($this->map)) {
             $this->parse_header($elements);
             if (empty($this->map)) {
                 break;
             }
         } else {
             $this->csv_to_vcard($elements);
         }
     }
 }

 /**
  * Load config from local config file
  *
  * @todo Remove global $CONFIG
  */
 private function load()
 {
     // load main config file
     if (!$this->load_from_file(RCMAIL_CONFIG_DIR . '/main.inc.php')) {
         $this->errors[] = 'main.inc.php was not found.';
     }
     // load database config
     if (!$this->load_from_file(RCMAIL_CONFIG_DIR . '/db.inc.php')) {
         $this->errors[] = 'db.inc.php was not found.';
     }
     // load host-specific configuration
     $this->load_host_config();
     // set skin (with fallback to old 'skin_path' property)
     if (empty($this->prop['skin'])) {
         if (!empty($this->prop['skin_path'])) {
             $this->prop['skin'] = str_replace('skins/', '', unslashify($this->prop['skin_path']));
         } else {
             $this->prop['skin'] = 'default';
         }
     }
     // fix paths
     $this->prop['log_dir'] = $this->prop['log_dir'] ? realpath(unslashify($this->prop['log_dir'])) : INSTALL_PATH . 'logs';
     $this->prop['temp_dir'] = $this->prop['temp_dir'] ? realpath(unslashify($this->prop['temp_dir'])) : INSTALL_PATH . 'temp';
     // fix default imap folders encoding
     foreach (array('drafts_mbox', 'junk_mbox', 'sent_mbox', 'trash_mbox') as $folder) {
         $this->prop[$folder] = rcube_charset::convert($this->prop[$folder], RCMAIL_CHARSET, 'UTF7-IMAP');
     }
     if (!empty($this->prop['default_folders'])) {
         foreach ($this->prop['default_folders'] as $n => $folder) {
             $this->prop['default_folders'][$n] = rcube_charset::convert($folder, RCMAIL_CHARSET, 'UTF7-IMAP');
         }
     }
     // set PHP error logging according to config
     if ($this->prop['debug_level'] & 1) {
         ini_set('log_errors', 1);
         if ($this->prop['log_driver'] == 'syslog') {
             ini_set('error_log', 'syslog');
         } else {
             ini_set('error_log', $this->prop['log_dir'] . '/errors');
         }
     }
     // enable display_errors in 'show' level, but not for ajax requests
     ini_set('display_errors', intval(empty($_REQUEST['_remote']) && $this->prop['debug_level'] & 4));
     // set timezone auto settings values
     if ($this->prop['timezone'] == 'auto') {
         $this->prop['_timezone_value'] = $this->client_timezone();
     } else {
         if (is_numeric($this->prop['timezone'])) {
             $this->prop['timezone'] = timezone_name_from_abbr("", $this->prop['timezone'] * 3600, 0);
         }
     }
     // remove deprecated properties
     unset($this->prop['dst_active']);
     // export config data
     $GLOBALS['CONFIG'] =& $this->prop;
 }

 /**
  * Read available calendars for the current user and store them internally
  */
 private function _read_lists($force = false)
 {
     // already read sources
     if (isset($this->lists) && !$force) {
         return $this->lists;
     }
     // get all folders that have type "task"
     $this->folders = kolab_storage::get_folders('task');
     $this->lists = array();
     // convert to UTF8 and sort
     $names = array();
     $default_folder = null;
     foreach ($this->folders as $folder) {
         $names[$folder->name] = rcube_charset::convert($folder->name, 'UTF7-IMAP');
         $this->folders[$folder->name] = $folder;
         if ($folder->default) {
             $default_folder = $folder->name;
         }
     }
     asort($names, SORT_LOCALE_STRING);
     // put default folder (aka INBOX) on top of the list
     if ($default_folder) {
         $default_name = $names[$default_folder];
         unset($names[$default_folder]);
         $names = array_merge(array($default_folder => $default_name), $names);
     }
     $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
     $listnames = array();
     $prefs = $this->rc->config->get('kolab_tasklists', array());
     foreach ($names as $utf7name => $name) {
         $folder = $this->folders[$utf7name];
         $path_imap = explode($delim, $name);
         $editname = array_pop($path_imap);
         // pop off raw name part
         $path_imap = join($delim, $path_imap);
         $name = kolab_storage::folder_displayname(kolab_storage::object_name($utf7name), $listnames);
         if ($folder->get_namespace() == 'personal') {
             $readonly = false;
             $alarms = true;
         } else {
             $alarms = false;
             $readonly = true;
             if (($rights = $folder->get_myrights()) && !PEAR::isError($rights)) {
                 if (strpos($rights, 'i') !== false) {
                     $readonly = false;
                 }
             }
         }
         $list_id = kolab_storage::folder_id($utf7name);
         $tasklist = array('id' => $list_id, 'name' => $name, 'editname' => $editname, 'color' => $folder->get_color('0000CC'), 'showalarms' => isset($prefs[$list_id]['showalarms']) ? $prefs[$list_id]['showalarms'] : $alarms, 'editable' => !$readonly, 'active' => $folder->is_active(), 'parentfolder' => $path_imap, 'default' => $folder->default, 'children' => true, 'class_name' => trim($folder->get_namespace() . ($folder->default ? ' default' : '')));
         $this->lists[$tasklist['id']] = $tasklist;
         $this->folders[$tasklist['id']] = $folder;
     }
 }

 /**
  *
  */
 public function import($csv)
 {
     // convert to UTF-8
     $head = substr($csv, 0, 4096);
     $charset = rcube_charset::detect($head, RCUBE_CHARSET);
     $csv = rcube_charset::convert($csv, $charset);
     $csv = preg_replace(array('/^[\\xFE\\xFF]{2}/', '/^\\xEF\\xBB\\xBF/', '/^\\x00+/'), '', $csv);
     // also remove BOM
     $head = '';
     $prev_line = false;
     $this->map = array();
     $this->gmail_map = array();
     // Parse file
     foreach (preg_split("/[\r\n]+/", $csv) as $line) {
         if (!empty($prev_line)) {
             $line = '"' . $line;
         }
         $elements = $this->parse_line($line);
         if (empty($elements)) {
             continue;
         }
         // Parse header
         if (empty($this->map)) {
             $this->parse_header($elements);
             if (empty($this->map)) {
                 break;
             }
         } else {
             // handle multiline elements (e.g. Gmail)
             if (!empty($prev_line)) {
                 $first = array_shift($elements);
                 if ($first[0] == '"') {
                     $prev_line[count($prev_line) - 1] = '"' . $prev_line[count($prev_line) - 1] . "\n" . substr($first, 1);
                 } else {
                     $prev_line[count($prev_line) - 1] .= "\n" . $first;
                 }
                 $elements = array_merge($prev_line, $elements);
             }
             $last_element = $elements[count($elements) - 1];
             if ($last_element[0] == '"') {
                 $elements[count($elements) - 1] = substr($last_element, 1);
                 $prev_line = $elements;
                 continue;
             }
             $this->csv_to_vcard($elements);
             $prev_line = false;
         }
     }
 }

 /**
  * Factory method to import a vcard file
  *
  * @param string vCard file content
  * @return array List of rcube_vcard objects
  */
 public static function import($data)
 {
     $out = array();
     // check if charsets are specified (usually vcard version < 3.0 but this is not reliable)
     if (preg_match('/charset=/i', substr($data, 0, 2048))) {
         $charset = null;
     } else {
         if (($charset = self::detect_encoding($data)) && $charset != RCMAIL_CHARSET) {
             $data = rcube_charset::convert($data, $charset);
             $data = preg_replace(array('/^[\\xFE\\xFF]{2}/', '/^\\xEF\\xBB\\xBF/', '/^\\x00+/'), '', $data);
             // also remove BOM
             $charset = RCMAIL_CHARSET;
         }
     }
     $vcard_block = '';
     $in_vcard_block = false;
     foreach (preg_split("/[\r\n]+/", $data) as $i => $line) {
         if ($in_vcard_block && !empty($line)) {
             $vcard_block .= $line . "\n";
         }
         $line = trim($line);
         if (preg_match('/^END:VCARD$/i', $line)) {
             // parse vcard
             $obj = new rcube_vcard(self::cleanup($vcard_block), $charset, true, self::$fieldmap);
             if (!empty($obj->displayname) || !empty($obj->email)) {
                 $out[] = $obj;
             }
             $in_vcard_block = false;
         } else {
             if (preg_match('/^BEGIN:VCARD$/i', $line)) {
                 $vcard_block = $line . "\n";
                 $in_vcard_block = true;
             }
         }
     }
     return $out;
 }

 /**
  * Recursive method to convert a Mail_mimeDecode part into a rcube_message_part object
  *
  * @param object  A message part struct
  * @param int     Part count
  * @param string  Parent MIME ID
  *
  * @return object rcube_message_part
  */
 private static function structure_part($part, $count = 0, $parent = '')
 {
     $struct = new rcube_message_part();
     $struct->mime_id = $part->mime_id ? $part->mime_id : (empty($parent) ? (string) $count : "{$parent}.{$count}");
     $struct->headers = $part->headers;
     $struct->ctype_primary = $part->ctype_primary;
     $struct->ctype_secondary = $part->ctype_secondary;
     $struct->mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
     $struct->ctype_parameters = $part->ctype_parameters;
     if ($part->headers['content-transfer-encoding']) {
         $struct->encoding = $part->headers['content-transfer-encoding'];
     }
     if ($part->ctype_parameters['charset']) {
         $struct->charset = $part->ctype_parameters['charset'];
     }
     $part_charset = $struct->charset ? $struct->charset : self::get_charset();
     // determine filename
     if (($filename = $part->d_parameters['filename']) || ($filename = $part->ctype_parameters['name'])) {
         $struct->filename = rcube_mime::decode_mime_string($filename, $part_charset);
     }
     // copy part body and convert it to UTF-8 if necessary
     $struct->body = $part->ctype_primary == 'text' || !$part->ctype_parameters['charset'] ? rcube_charset::convert($part->body, $part_charset) : $part->body;
     $struct->size = strlen($part->body);
     $struct->disposition = $part->disposition;
     foreach ((array) $part->parts as $child_part) {
         $struct->parts[] = self::structure_part($child_part, ++$count, $struct->mime_id);
     }
     return $struct;
 }

 public function localize_folderpath($path)
 {
     $protect_folders = $this->config->get('protect_default_folders');
     $delimiter = $this->storage->get_hierarchy_delimiter();
     $path = explode($delimiter, $path);
     $result = array();
     foreach ($path as $idx => $dir) {
         $directory = implode($delimiter, array_slice($path, 0, $idx + 1));
         if ($protect_folders && $this->storage->is_special_folder($directory)) {
             unset($result);
             $result[] = $this->localize_foldername($directory);
         } else {
             $result[] = rcube_charset::convert($dir, 'UTF7-IMAP');
         }
     }
     return implode($delimiter, $result);
 }

 /**
  * Process template and write to stdOut
  *
  * @param string HTML template
  * @param string Base for absolute paths
  */
 public function _write($templ = '', $base_path = '')
 {
     $output = trim($templ);
     if (empty($output)) {
         $output = $this->default_template;
         $is_empty = true;
     }
     // set default page title
     if (empty($this->pagetitle)) {
         $this->pagetitle = 'Roundcube Mail';
     }
     // replace specialchars in content
     $page_title = html::quote($this->pagetitle);
     $page_header = '';
     $page_footer = '';
     // include meta tag with charset
     if (!empty($this->charset)) {
         if (!headers_sent()) {
             header('Content-Type: text/html; charset=' . $this->charset);
         }
         $page_header = '<meta http-equiv="content-type"';
         $page_header .= ' content="text/html; charset=';
         $page_header .= $this->charset . '" />' . "\n";
     }
     // definition of the code to be placed in the document header and footer
     if (is_array($this->script_files['head'])) {
         foreach ($this->script_files['head'] as $file) {
             $page_header .= html::script($file);
         }
     }
     $head_script = $this->scripts['head_top'] . $this->scripts['head'];
     if (!empty($head_script)) {
         $page_header .= html::script(array(), $head_script);
     }
     if (!empty($this->header)) {
         $page_header .= $this->header;
     }
     // put docready commands into page footer
     if (!empty($this->scripts['docready'])) {
         $this->add_script('$(document).ready(function(){ ' . $this->scripts['docready'] . "\n});", 'foot');
     }
     if (is_array($this->script_files['foot'])) {
         foreach ($this->script_files['foot'] as $file) {
             $page_footer .= html::script($file);
         }
     }
     if (!empty($this->footer)) {
         $page_footer .= $this->footer . "\n";
     }
     if (!empty($this->scripts['foot'])) {
         $page_footer .= html::script(array(), $this->scripts['foot']);
     }
     // find page header
     if ($hpos = stripos($output, '</head>')) {
         $page_header .= "\n";
     } else {
         if (!is_numeric($hpos)) {
             $hpos = stripos($output, '<body');
         }
         if (!is_numeric($hpos) && ($hpos = stripos($output, '<html'))) {
             while ($output[$hpos] != '>') {
                 $hpos++;
             }
             $hpos++;
         }
         $page_header = "<head>\n<title>{$page_title}</title>\n{$page_header}\n</head>\n";
     }
     // add page hader
     if ($hpos) {
         $output = substr_replace($output, $page_header, $hpos, 0);
     } else {
         $output = $page_header . $output;
     }
     // add page footer
     if (($fpos = strripos($output, '</body>')) || ($fpos = strripos($output, '</html>'))) {
         $output = substr_replace($output, $page_footer . "\n", $fpos, 0);
     } else {
         $output .= "\n" . $page_footer;
     }
     // add css files in head, before scripts, for speed up with parallel downloads
     if (!empty($this->css_files) && !$is_empty && (($pos = stripos($output, '<script ')) || ($pos = stripos($output, '</head>')))) {
         $css = '';
         foreach ($this->css_files as $file) {
             $css .= html::tag('link', array('rel' => 'stylesheet', 'type' => 'text/css', 'href' => $file, 'nl' => true));
         }
         $output = substr_replace($output, $css, $pos, 0);
     }
     $output = $this->parse_with_globals($this->fix_paths($output));
     // trigger hook with final HTML content to be sent
     $hook = $this->app->plugins->exec_hook("send_page", array('content' => $output));
     if (!$hook['abort']) {
         if ($this->charset != RCUBE_CHARSET) {
             echo rcube_charset::convert($hook['content'], RCUBE_CHARSET, $this->charset);
         } else {
//.........这里部分代码省略.........

 /**
  * Normalize the given string for fulltext search.
  * Currently only optimized for ISO-8859-1 and ISO-8859-2 characters; to be extended
  *
  * @param string  Input string (UTF-8)
  * @param boolean True to return list of words as array
  *
  * @return mixed  Normalized string or a list of normalized tokens
  */
 public static function normalize_string($str, $as_array = false)
 {
     // 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);
     // detect character set
     if (utf8_encode(utf8_decode($str)) == $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, array('ß' => '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, array('ß' => '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 : join(" ", $arr);
 }

 /**
  * Fix attachment name encoding if needed/possible
  */
 protected function fix_attachment_name($name, $part)
 {
     if ($name == rcube_charset::clean($name)) {
         return $name;
     }
     // find charset from part or its parent(s)
     if ($part->charset) {
         $charsets[] = $part->charset;
     } else {
         // check first part (common case)
         $n = strpos($part->mime_id, '.') ? preg_replace('/\\.[0-9]+$/', '', $part->mime_id) . '.1' : 1;
         if (($_part = $this->mime_parts[$n]) && $_part->charset) {
             $charsets[] = $_part->charset;
         }
         // check parents' charset
         $items = explode('.', $part->mime_id);
         for ($i = count($items) - 1; $i > 0; $i--) {
             $last = array_pop($items);
             $parent = $this->mime_parts[join('.', $items)];
             if ($parent && $parent->charset) {
                 $charsets[] = $parent->charset;
             }
         }
     }
     if ($this->headers->charset) {
         $charsets[] = $this->headers->charset;
     }
     if (empty($charsets)) {
         $rcube = rcube::get_instance();
         $charsets[] = rcube_charset::detect($name, $rcube->config->get('default_charset', RCUBE_CHARSET));
     }
     foreach (array_unique($charsets) as $charset) {
         $_name = rcube_charset::convert($name, $charset);
         if ($_name == rcube_charset::clean($_name)) {
             if (!$part->charset) {
                 $part->charset = $charset;
             }
             return $_name;
         }
     }
     return $name;
 }

//.........这里部分代码省略.........
                     $salt = substr(pack("H*", sha1($salt . $password)), 0, 4);
                     $crypted = sha1($password . $salt, true);
                 } else {
                     if (function_exists('hash')) {
                         $salt = substr(pack("H*", hash('sha1', $salt . $password)), 0, 4);
                         $crypted = hash('sha1', $password . $salt, true);
                     } else {
                         rcube::raise_error(array('code' => 600, 'file' => __FILE__, 'line' => __LINE__, 'message' => "Password plugin: Your PHP install does not have the mhash()/hash() nor sha1() function"), true, true);
                     }
                 }
             }
             $crypted = base64_encode($crypted . $salt);
             $prefix = '{SSHA}';
             break;
         case 'smd5':
             $salt = substr(pack('h*', md5(mt_rand())), 0, 8);
             if (function_exists('mhash') && function_exists('mhash_keygen_s2k')) {
                 $salt = mhash_keygen_s2k(MHASH_MD5, $password, $salt, 4);
                 $crypted = mhash(MHASH_MD5, $password . $salt);
             } else {
                 if (function_exists('hash')) {
                     $salt = substr(pack("H*", hash('md5', $salt . $password)), 0, 4);
                     $crypted = hash('md5', $password . $salt, true);
                 } else {
                     $salt = substr(pack("H*", md5($salt . $password)), 0, 4);
                     $crypted = md5($password . $salt, true);
                 }
             }
             $crypted = base64_encode($crypted . $salt);
             $prefix = '{SMD5}';
             break;
         case 'samba':
             if (function_exists('hash')) {
                 $crypted = hash('md4', rcube_charset::convert($password, RCUBE_CHARSET, 'UTF-16LE'));
                 $crypted = strtoupper($crypted_password);
             } else {
                 rcube::raise_error(array('code' => 600, 'file' => __FILE__, 'line' => __LINE__, 'message' => "Password plugin: Your PHP install does not have hash() function"), true, true);
             }
             break;
         case 'ad':
             $crypted = rcube_charset::convert('"' . $password . '"', RCUBE_CHARSET, 'UTF-16LE');
             break;
         case 'cram-md5':
             // deprecated
             require_once __DIR__ . '/../helpers/dovecot_hmacmd5.php';
             $crypted = dovecot_hmacmd5($password);
             $prefix = '{CRAM-MD5}';
             break;
         case 'dovecot':
             if (!($dovecotpw = $rcmail->config->get('password_dovecotpw'))) {
                 $dovecotpw = 'dovecotpw';
             }
             if (!($method = $rcmail->config->get('password_dovecotpw_method'))) {
                 $method = 'CRAM-MD5';
             }
             // use common temp dir
             $tmp_dir = $rcmail->config->get('temp_dir');
             $tmpfile = tempnam($tmp_dir, 'roundcube-');
             $pipe = popen("{$dovecotpw} -s '{$method}' > '{$tmpfile}'", "w");
             if (!$pipe) {
                 unlink($tmpfile);
                 return false;
             } else {
                 fwrite($pipe, $passwd . "\n", 1 + strlen($passwd));
                 usleep(1000);
                 fwrite($pipe, $passwd . "\n", 1 + strlen($passwd));

function rcube_charset_convert($str, $from, $to = NULL)
{
    return rcube_charset::convert($str, $from, $to);
}

 private function convert_charset($str, $charset = null)
 {
     if (!$charset) {
         return utf8_encode($sig);
     }
     return rcube_charset::convert($str, $charset, RCMAIL_CHARSET);
 }

 protected function _rcmail_get_identity($id)
 {
     $rcmail = rcube::get_instance();
     if ($sql_arr = $rcmail->user->get_identity($id)) {
         $out = $sql_arr;
         $out['mailto'] = $sql_arr['email'];
         $out['string'] = format_email_recipient($sql_arr['email'], rcube_charset::convert($sql_arr['name'], RCUBE_CHARSET, $this->api->output->get_charset()));
         if ($rcmail->config->get('sieverules_from_format', 0) == 1) {
             $out['disp_string'] = $out['string'];
             $out['val_string'] = $out['string'];
         } else {
             $out['disp_string'] = $out['mailto'];
             $out['val_string'] = $out['mailto'];
         }
         return $out;
     }
     return false;
 }