PHP importer_charset函数代码示例

/**
 * Déclarations de fonctions
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Fonctions
 **/
function svp_importer_charset($texte)
{
    if ($GLOBALS['meta']['charset'] == 'utf-8') {
        return $texte;
    }
    return importer_charset($texte, 'utf-8');
}

function contenu_document($arg, $charset = '')
{
    if (is_numeric($arg)) {
        $r = sql_fetsel("fichier,distant", "spip_documents", "id_document=" . intval($arg));
        if (!$r) {
            return '';
        }
        $f = $r['fichier'];
        $f = $r['distant'] == 'oui' ? _DIR_RACINE . copie_locale($f) : get_spip_doc($f);
    } else {
        if (!@file_exists($f = $arg)) {
            if (!($f = copie_locale($f))) {
                return '';
            }
            $f = _DIR_RACINE . $f;
        }
    }
    $r = spip_file_get_contents($f);
    if ($charset) {
        include_spip('inc/charset');
        if ($charset !== 'auto') {
            $r = importer_charset($r, $charset);
        } elseif ($GLOBALS['meta']['charset'] == 'utf-8' and !is_utf8($r)) {
            $r = importer_charset($r, CHARSET_JOINT);
        }
    }
    return $r;
}

/**
 * Importer le charset d'une ligne
 *
 * @param unknown_type $texte
 * @return array
 */
function importer_csv_importcharset($texte){
	// le plus frequent, en particulier avec les trucs de ms@@@
	$charset_source = 'iso-8859-1';
	// mais open-office sait faire mieux, donc mefiance !
	if (is_utf8($texte))
		$charset_source = 'utf-8';
	return importer_charset($texte,$charset_source);
}

function post_crayons() {
    $results = array();
    if (isset($_POST['crayons']) AND is_array($_POST['crayons']))
    foreach ($_POST['crayons'] as $crayon) {

        $name = $_POST['name_'.$crayon];
        $content = array();
        if ($_POST['fields_'.$crayon]) {
          foreach (explode(',', $_POST['fields_'.$crayon]) as $field) {
            // cas particulier d'un envoi de fichier
            if (isset($_FILES['content_'.$crayon.'_'.$field])) {
            	if ($_FILES['content_'.$crayon.'_'.$field]['size']>0)
            		$content[$field] = $_FILES['content_'.$crayon.'_'.$field];
            	else
            		$content[$field] = false;
            		# cf. valeur passee dans crayon->md5() : false ou filemtime() du logo
            } else {
            	$content[$field] = is_array($_POST['content_'.$crayon.'_'.$field])?implode(',',$_POST['content_'.$crayon.'_'.$field]):$_POST['content_'.$crayon.'_'.$field];
            	// Compatibilite charset autre que utf8 ; en effet on recoit
            	// obligatoirement les donnees en utf-8, par la magie d'ajax
            	// ... sauf dans le cas d'un envoi de fichier !
            	if ($GLOBALS['meta']['charset']!='utf-8' AND !count($_FILES)) {
            	    include_spip('inc/charsets');
            	    $content[$field] = importer_charset($content[$field], 'utf-8');
            	}
            }
          }
        }

        // Si les donnees POSTees ne correspondent pas a leur md5,
        // il faut les traiter
        if (isset($name)
        AND md5(serialize($content)) != $_POST['md5_'.$crayon]) {
            if (!isset($_POST['secu_'.$crayon])
            OR verif_secu($name, $_POST['secu_'.$crayon])) {
                $results[] = array($name, $content, $_POST['md5_'.$crayon], $crayon);
            }
            else {
                return false; // erreur secu
            }
        }
        // cas inchange
        else
            $results[] = array($name, $content, false, $crayon);
    }

    return $results;
}

/**
 * Renvoie le `$_GET` ou le `$_POST` émis par l'utilisateur
 * ou pioché dans un tableau transmis
 *
 * @api
 * @param string $var
 *     Clé souhaitée
 * @param bool|array $c
 *     Tableau transmis (sinon cherche dans GET ou POST)
 * @return mixed|null
 *     - null si la clé n'a pas été trouvée
 *     - la valeur de la clé sinon.
**/
function _request($var, $c = false)
{
    if (is_array($c)) {
        return isset($c[$var]) ? $c[$var] : NULL;
    }
    if (isset($_GET[$var])) {
        $a = $_GET[$var];
    } elseif (isset($_POST[$var])) {
        $a = $_POST[$var];
    } else {
        return NULL;
    }
    // Si on est en ajax et en POST tout a ete encode
    // via encodeURIComponent, il faut donc repasser
    // dans le charset local...
    if (defined('_AJAX') and _AJAX and isset($GLOBALS['meta']['charset']) and $GLOBALS['meta']['charset'] != 'utf-8' and is_string($a) and preg_match(',[\\x80-\\xFF],', $a) and include_spip('inc/charsets') and is_utf8($a)) {
        return importer_charset($a, 'utf-8');
    }
    return $a;
}

function recuperer_fragments($id_objet, $objet, $id_version)
{
    $fragments = array();
    if ($id_version == 0) {
        return array();
    }
    $result = sql_select("id_fragment, version_min, version_max, compress, fragment", "spip_versions_fragments", "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND version_min<={$id_version} AND version_max>={$id_version}");
    while ($row = sql_fetch($result)) {
        $id_fragment = $row['id_fragment'];
        $version_min = $row['version_min'];
        $fragment = $row['fragment'];
        if ($row['compress'] > 0) {
            $fragment_ = @gzuncompress($fragment);
            if (strlen($fragment) && $fragment_ === false) {
                $fragment = serialize(array($row['version_max'] => "[" . _T('forum_titre_erreur') . $id_fragment . "]"));
            } else {
                $fragment = $fragment_;
            }
        }
        $fragment_ = unserialize($fragment);
        if (strlen($fragment) && $fragment_ === false) {
            $fragment = array($row['version_max'] => "[" . _T('forum_titre_erreur') . $id_fragment . "]");
        } else {
            $fragment = $fragment_;
        }
        for ($i = $id_version; $i >= $version_min; $i--) {
            if (isset($fragment[$i])) {
                ## hack destine a sauver les archives des sites iso-8859-1
                ## convertis en utf-8 (les archives ne sont pas converties
                ## mais ce code va les nettoyer ; pour les autres charsets
                ## la situation n'est pas meilleure ni pire qu'avant)
                if ($GLOBALS['meta']['charset'] == 'utf-8' and include_spip('inc/charsets') and !is_utf8($fragment[$i])) {
                    $fragment[$i] = importer_charset($fragment[$i], 'iso-8859-1');
                }
                $fragments[$id_fragment] = $fragment[$i];
                break;
            }
        }
    }
    return $fragments;
}

/**
 * Retrouver un dn
 * @param string $dn
 * @param array $desc
 * @param string $serveur
 * @return array
 */
function auth_ldap_retrouver($dn, $desc = array(), $serveur = '')
{
    // Lire les infos sur l'utilisateur a partir de son DN depuis LDAP
    if (!($ldap = spip_connect_ldap($serveur))) {
        spip_log("ldap {$serveur} injoignable");
        return array();
    }
    $ldap_link = $ldap['link'];
    if (!$desc) {
        $desc = $ldap['attributes'] ? $ldap['attributes'] : $GLOBALS['ldap_attributes'];
        unset($desc['login']);
    }
    $result = @ldap_read($ldap_link, $dn, "objectClass=*", array_values($desc));
    if (!$result) {
        return array();
    }
    // Recuperer les donnees du premier (unique?) compte de l'auteur
    $val = @ldap_get_entries($ldap_link, $result);
    if (!is_array($val) or !is_array($val[0])) {
        return array();
    }
    $val = $val[0];
    // Convertir depuis UTF-8 (jeu de caracteres par defaut)
    include_spip('inc/charsets');
    foreach ($desc as $k => $v) {
        $desc[$k] = importer_charset($val[strtolower($v)][0], 'utf-8');
    }
    return $desc;
}

function install_etape_3b_dist()
{
    $login = _request('login');
    $email = _request('email');
    $nom = _request('nom');
    $pass = _request('pass');
    $pass_verif = _request('pass_verif');
    $server_db = defined('_INSTALL_SERVER_DB') ? _INSTALL_SERVER_DB : _request('server_db');
    if (!defined('_PASS_LONGUEUR_MINI')) {
        define('_PASS_LONGUEUR_MINI', 6);
    }
    if (!defined('_LOGIN_TROP_COURT')) {
        define('_LOGIN_TROP_COURT', 4);
    }
    if ($login) {
        $echec = $pass != $pass_verif ? _T('info_passes_identiques') : (strlen($pass) < _PASS_LONGUEUR_MINI ? _T('info_passe_trop_court_car_pluriel', array('nb' => _PASS_LONGUEUR_MINI)) : (strlen($login) < _LOGIN_TROP_COURT ? _T('info_login_trop_court') : ''));
        include_spip('inc/filtres');
        if (!$echec and $email and !email_valide($email)) {
            $echec = _T('form_email_non_valide');
        }
        if ($echec) {
            echo minipres('AUTO', info_progression_etape(3, 'etape_', 'install/', true) . "<div class='error'><h3>{$echec}</h3>\n" . "<p>" . _T('avis_connexion_echec_2') . "</p>" . "</div>");
            exit;
        }
    }
    if (@file_exists(_FILE_CHMOD_TMP)) {
        include _FILE_CHMOD_TMP;
    } else {
        redirige_url_ecrire('install');
    }
    if (!@file_exists(_FILE_CONNECT_TMP)) {
        redirige_url_ecrire('install');
    }
    # maintenant on connait le vrai charset du site s'il est deja configure
    # sinon par defaut lire_meta reglera _DEFAULT_CHARSET
    # (les donnees arrivent de toute facon postees en _DEFAULT_CHARSET)
    lire_metas();
    if ($login) {
        include_spip('inc/charsets');
        $nom = importer_charset($nom, _DEFAULT_CHARSET);
        $login = importer_charset($login, _DEFAULT_CHARSET);
        $email = importer_charset($email, _DEFAULT_CHARSET);
        # pour le passwd, bizarrement il faut le convertir comme s'il avait
        # ete tape en iso-8859-1 ; car c'est en fait ce que voit md5.js
        $pass = unicode2charset(utf_8_to_unicode($pass), 'iso-8859-1');
        include_spip('auth/sha256.inc');
        include_spip('inc/acces');
        $htpass = generer_htpass($pass);
        $alea_actuel = creer_uniqid();
        $alea_futur = creer_uniqid();
        $shapass = _nano_sha256($alea_actuel . $pass);
        // prelablement, creer le champ webmestre si il n'existe pas (install neuve
        // sur une vieille base
        $t = sql_showtable("spip_auteurs", true);
        if (!isset($t['field']['webmestre'])) {
            @sql_alter("TABLE spip_auteurs ADD webmestre varchar(3)  DEFAULT 'non' NOT NULL");
        }
        $id_auteur = sql_getfetsel("id_auteur", "spip_auteurs", "login=" . sql_quote($login));
        if ($id_auteur !== null) {
            sql_updateq('spip_auteurs', array("nom" => $nom, 'email' => $email, 'login' => $login, 'pass' => $shapass, 'alea_actuel' => $alea_actuel, 'alea_futur' => $alea_futur, 'htpass' => $htpass, 'statut' => '0minirezo'), "id_auteur={$id_auteur}");
        } else {
            $id_auteur = sql_insertq('spip_auteurs', array('nom' => $nom, 'email' => $email, 'login' => $login, 'pass' => $shapass, 'htpass' => $htpass, 'alea_actuel' => $alea_actuel, 'alea_futur' => $alea_futur, 'statut' => '0minirezo'));
        }
        // le passer webmestre separrement du reste, au cas ou l'alter n'aurait pas fonctionne
        @sql_updateq('spip_auteurs', array('webmestre' => 'oui'), "id_auteur={$id_auteur}");
        // inserer email comme email webmaster principal
        // (sauf s'il est vide: cas de la re-installation)
        if ($email) {
            ecrire_meta('email_webmaster', $email);
        }
        // Connecter directement celui qui vient de (re)donner son login
        // mais sans cookie d'admin ni connexion longue
        include_spip('inc/auth');
        if (!($auteur = auth_identifier_login($login, $pass)) or !auth_loger($auteur, true)) {
            spip_log("login automatique impossible {$auth_spip} {$session}" . count($row));
        }
    }
    // installer les metas
    $config = charger_fonction('config', 'inc');
    $config();
    // activer les plugins
    // leur installation ne peut pas se faire sur le meme hit, il faudra donc
    // poursuivre au hit suivant
    include_spip('inc/plugin');
    actualise_plugins_actifs();
    include_spip('inc/distant');
    redirige_par_entete(parametre_url(self(), 'etape', '4', '&'));
}

/**
 * Retrouver les mots cles de recherche dans une url de referer
 *
 * Adaptees du code des "Visiteurs",
 * par Jean-Paul Dezelus (http://www.phpinfo.net/applis/visiteurs/)
 *
 * http://code.spip.net/@stats_show_keywords
 *
 * @param string $kw_referer
 * @return array
 */
function stats_show_keywords($kw_referer)
{
    static $arr_engines = '';
    static $url_site;
    if (!is_array($arr_engines)) {
        // Charger les moteurs de recherche
        $arr_engines = stats_load_engines();
        // initialiser la recherche interne
        $url_site = $GLOBALS['meta']['adresse_site'];
        $url_site = preg_replace(",^((https?|ftp):?/?/?)?(www\\.)?,", "", strtolower($url_site));
    }
    if ($url = @parse_url($kw_referer)) {
        $query = isset($url['query']) ? $url['query'] : "";
        $host = strtolower($url['host']);
        $path = $url['path'];
        $scheme = $url['scheme'];
    } else {
        $scheme = $query = $host = $path = '';
    }
    // construire un array des variables directement depuis la query-string
    parse_str($query, $Tquery);
    $keywords = '';
    $found = false;
    if (!empty($url_site)) {
        if (strpos('-' . $kw_referer, $url_site) !== false) {
            if (preg_match(",(s|search|r|recherche)=([^&]+),i", $kw_referer, $regs)) {
                $keywords = urldecode($regs[2]);
            } else {
                return array('host' => '');
            }
        } else {
            for ($cnt = 0; $cnt < sizeof($arr_engines) && !$found; $cnt++) {
                if ($found = preg_match(',' . $arr_engines[$cnt][2] . ',', $host) or $found = preg_match(',' . $arr_engines[$cnt][2] . ',', $path)) {
                    $kw_referer_host = $arr_engines[$cnt][0];
                    if (strpos($arr_engines[$cnt][1], '=') !== false) {
                        // Fonctionnement simple: la variable existe dans l'array
                        $v = str_replace('=', '', $arr_engines[$cnt][1]);
                        $keywords = isset($Tquery[$v]) ? $Tquery[$v] : "";
                        // Si on a defini le nom de la variable en expression reguliere, chercher la bonne variable
                        if (!strlen($keywords) > 0) {
                            if (preg_match("," . $arr_engines[$cnt][1] . "([^\\&]*),", $query, $vals)) {
                                $keywords = urldecode($vals[2]);
                            }
                        }
                    } else {
                        $keywords = "";
                    }
                    if ($kw_referer_host == "Google" || $kw_referer_host == "AOL" && strpos($query, 'enc=iso') === false || $kw_referer_host == "MSN") {
                        include_spip('inc/charsets');
                        if (!isset($ie) or !($cset = $ie)) {
                            $cset = 'utf-8';
                        }
                        $keywords = importer_charset($keywords, $cset);
                    }
                    $buffer["hostname"] = $kw_referer_host;
                }
            }
        }
    }
    $buffer["host"] = $host;
    $buffer["scheme"] = $scheme;
    if (!isset($buffer["hostname"]) or !$buffer["hostname"]) {
        $buffer["hostname"] = $host;
    }
    $buffer["path"] = substr($path, 1, strlen($path));
    $buffer["query"] = $query;
    if ($keywords != '') {
        if (strlen($keywords) > 150) {
            $keywords = spip_substr($keywords, 0, 148);
            // supprimer l'eventuelle entite finale mal coupee
            $keywords = preg_replace('/&#?[a-z0-9]*$/', '', $keywords);
        }
        $buffer["keywords"] = trim(entites_html(urldecode(stripslashes($keywords))));
    }
    return $buffer;
}

function inc_import_1_2_dist($f, $request, $gz='fread') {
  global $import_ok;
	static $field_desc = array ();

	static $tables, $a_importer;
	if (!$tables) {
		$init = $request['init'];
		$a_importer = $init($request);
		$tables = array(
		'article' => 'spip_articles',
		'auteur' => 'spip_auteurs',
		'breve' => 'spip_breves',
		'document' => 'spip_documents',
		'forum' => 'spip_forum',
		'groupe_mots' => 'spip_groupes_mots',
		'message' => 'spip_messages',
		'mot' => 'spip_mots',
		'petition' => 'spip_petitions',
		'rubrique' => 'spip_rubriques',
		'signature' => 'spip_signatures',
		'syndic' => 'spip_syndic',
		'syndic_article' => 'spip_syndic_articles',
		'type_document' => 'spip_types_documents'
		);
	}
	$import_ok = false;
	$b = false;
	// Lire le type d'objet
	if (!($type = xml_fetch_tag($f, $b, $gz))) return false;
	if ($type == '/SPIP') return !($import_ok = true);
	$id = "id_$type";
	$id_objet = 0;

	$table = isset($tables[$type]) ? $tables[$type] : $type;
	if (in_array($table, $a_importer) AND !isset($field_desc[$table])) {
		// recuperer la description de la table pour connaitre ses champs valides
		$desc = description_table($table);

		if (isset($desc['field']))
			$field_desc[$table] = $desc['field'];
		else
			$field_desc[$table] = NULL;
	}
	$fields = $field_desc[$table];

	$char = $GLOBALS['meta']['charset_insertion'];
	if ($char == $GLOBALS['meta']['charset_restauration']) $char = '';

	$values = array();
	// Lire les champs de l'objet
	for (;;) {
		$b = false;
		if (!($col = xml_fetch_tag($f, $b, $gz))) return false;
		if ($col == '/'.$type) break;
		$value = true;
		if (!xml_fetch_tag($f, $value, $gz)) return false;
		if (substr($col, 0, 5) == 'lien:') {
			$type_lien = substr($col, 5);
			$liens[$type_lien][] = '('.$id_objet.','.$value.')';
		}
		else if ($col != 'maj') {
			// tentative de restauration d'une base sauvegardee avec le champ 'images' ; d'experience, ca arrive...
			// mieux vaut accepter que canner silencieusement...
			if (($type == 'article') && ($col == 'images'))
			{
				if ($value) {		// ne pas afficher de message si on a un champ suppl mais vide
					echo "--><br /><span style='color: red; font-weight: bold;'>"._T('avis_erreur_sauvegarde', array('type' => $type, 'id_objet' => $id_objet))."</span>\n<span style='color: black'>"._T('avis_colonne_inexistante', array('col' => $col));
					if ($col == 'images') echo _T('info_verifier_image');
					echo "</span>\n<!--";
					$GLOBALS['erreur_restauration'] = true;
				}
			}
			else if ($fields==NULL or isset($fields[$col])) {
				if ($char) 
					$value = importer_charset($value, $char);
				$values[$col] = $value;
				if ($col == $id) $id_objet = $value;
			}
		}
	}
   if ($values) {
	if (!sql_replace($table, $values, $desc)) {
		echo "--><br /><span style='color: red; font-weight: bold;'>"._T('avis_erreur_mysql')."</span>\n<span style='color: black'><tt>".sql_error()."</tt></span>\n<!--";
		$GLOBALS['erreur_restauration'] = true;
	}

	if ($type == 'article') {
		sql_delete("spip_auteurs_articles", "id_article=$id_objet");
		sql_delete("spip_documents_articles", "id_article=$id_objet");
	}
	else if ($type == 'rubrique') {
		sql_delete("spip_auteurs_rubriques", "id_rubrique=$id_objet");
		sql_delete("spip_documents_rubriques", "id_rubrique=$id_objet");
	}
	else if ($type == 'breve') {
		sql_delete("spip_documents_breves", "id_breve=$id_objet");
	}
	else if ($type == 'mot') {
		sql_delete("spip_mots_articles", "id_mot=$id_objet");
		sql_delete("spip_mots_breves", "id_mot=$id_objet");
//.........这里部分代码省略.........

/**
 * Parse une chaine XML donnée et retourne un tableau.
 *
 * @see spip_xml_aplatit() pour l'inverse
 *
 * @param string $texte
 *     Texte XML
 * @param bool $strict
 *     true pour râler si une balise n'est pas correctement fermée, false sinon.
 * @param bool $clean ?
 * @param int $profondeur ?
 * @return array|bool
 *     - array : l'arbre XML,
 *     - false si l'arbre xml ne peut être créé ou est vide
 **/
function spip_xml_parse(&$texte, $strict = true, $clean = true, $profondeur = -1)
{
    $out = array();
    // enlever les commentaires
    $charset = 'AUTO';
    if ($clean === true) {
        if (preg_match(",<\\?xml\\s(.*?)encoding=['\"]?(.*?)['\"]?(\\s(.*))?\\?>,im", $texte, $regs)) {
            $charset = $regs[2];
        }
        $texte = preg_replace(',<!--(.*?)-->,is', '', $texte);
        $texte = preg_replace(',<\\?(.*?)\\?>,is', '', $texte);
        include_spip('inc/charsets');
        $clean = $charset;
        //$texte = importer_charset($texte,$charset);
    }
    if (is_string($clean)) {
        $charset = $clean;
    }
    $txt = $texte;
    // tant qu'il y a des tags
    $chars = preg_split(_SPIP_XML_TAG_SPLIT, $txt, 2, PREG_SPLIT_DELIM_CAPTURE);
    while (count($chars) >= 2) {
        // tag ouvrant
        //$chars = preg_split("{<([^>]*?)>}s",$txt,2,PREG_SPLIT_DELIM_CAPTURE);
        // $before doit etre vide ou des espaces uniquements!
        $before = trim($chars[0]);
        if (strlen($before) > 0) {
            return importer_charset($texte, $charset);
        }
        //$texte; // before non vide, donc on est dans du texte
        $tag = rtrim($chars[1]);
        $txt = $chars[2];
        if (strncmp($tag, '![CDATA[', 8) == 0) {
            return importer_charset($texte, $charset);
        }
        //$texte;
        if (substr($tag, -1) == '/') {
            // self closing tag
            $tag = rtrim(substr($tag, 0, strlen($tag) - 1));
            $out[$tag][] = "";
        } else {
            $closing_tag = preg_split(",\\s|\t|\n|\r,", trim($tag));
            $closing_tag = reset($closing_tag);
            // tag fermant
            $ncclos = strlen("</{$closing_tag}>");
            $p = strpos($txt, "</{$closing_tag}>");
            if ($p !== false and strpos($txt, "<") < $p) {
                $nclose = 0;
                $nopen = 0;
                $d = 0;
                while ($p !== false and $morceau = substr($txt, $d, $p - $d) and ($nopen += preg_match_all("{<" . preg_quote($closing_tag) . "(\\s*>|\\s[^>]*[^/>]>)}is", $morceau, $matches, PREG_SET_ORDER)) > $nclose) {
                    $nclose++;
                    $d = $p + $ncclos;
                    $p = strpos($txt, "</{$closing_tag}>", $d);
                }
            }
            if ($p === false) {
                if ($strict) {
                    $out[$tag][] = "erreur : tag fermant {$tag} manquant::{$txt}";
                    return $out;
                } else {
                    return importer_charset($texte, $charset);
                }
                //$texte // un tag qui constitue du texte a reporter dans $before
            }
            $content = substr($txt, 0, $p);
            $txt = substr($txt, $p + $ncclos);
            if ($profondeur == 0 or strpos($content, "<") === false) {
                $out[$tag][] = importer_charset($content, $charset);
            } else {
                $out[$tag][] = spip_xml_parse($content, $strict, $clean, $profondeur - 1);
            }
        }
        $chars = preg_split(_SPIP_XML_TAG_SPLIT, $txt, 2, PREG_SPLIT_DELIM_CAPTURE);
    }
    if (count($out) && strlen(trim($txt)) == 0) {
        return $out;
    } else {
        return importer_charset($texte, $charset);
    }
    //$texte;
}

function transcoder_page($texte, $headers='') {

	// Si tout est < 128 pas la peine d'aller plus loin
	if (is_ascii($texte)) {
		#spip_log('charset: ascii');
		return $texte;
	}

	// Reconnaitre le BOM utf-8 (0xEFBBBF)
	if (bom_utf8($texte)) {
		$charset = 'utf-8';
		$texte = substr($texte,3);
	}

	// charset precise par le contenu (xml)
	else if (preg_match(
	',<[?]xml[^>]*encoding[^>]*=[^>]*([-_a-z0-9]+?),UimsS', $texte, $regs))
		$charset = trim(strtolower($regs[1]));
	// charset precise par le contenu (html)
	else if (preg_match(
	',<(meta|html|body)[^>]*charset[^>]*=[^>]*([-_a-z0-9]+?),UimsS',
	$texte, $regs)
	# eviter #CHARSET des squelettes
	AND (($tmp = trim(strtolower($regs[2]))) != 'charset'))
		$charset = $tmp;
	// charset de la reponse http
	else if (preg_match(',charset=([-_a-z0-9]+),i', $headers, $regs))
		$charset = trim(strtolower($regs[1]));
	else $charset = '';
	// normaliser les noms du shif-jis japonais
	if (preg_match(',^(x|shift)[_-]s?jis$,i', $charset))
		$charset = 'shift-jis';

	if ($charset) {
		spip_log("charset: $charset");
	} else {
		// valeur par defaut
		if (is_utf8($texte))
			$charset = 'utf-8';
		else
			$charset = 'iso-8859-1';
		spip_log("charset probable: $charset");
	}

	return importer_charset($texte, $charset);
}

function lignes_longues($texte, $l = 70, $espace='­') {
	if ($l<1) return $texte;
	if (!preg_match("/[\w,\/.]{".$l."}/UmsS", $texte))
		return $texte;
	// Passer en utf-8 pour ne pas avoir de coupes trop courtes avec les &#xxxx;
	// qui prennent 7 caracteres
	#include_spip('inc/charsets');
	$texte = str_replace("&nbsp;","<&nbsp>",$texte);
	$texte = html2unicode($texte, true);
	$texte = str_replace("<&nbsp>","&nbsp;",$texte);
	$texte = unicode_to_utf_8(charset2unicode(
		$texte, $GLOBALS['meta']['charset'], true));

	// echapper les tags (on ne veut pas casser les a href=...)
	$tags = array();
	if (preg_match_all('/<.+>|&(?:amp;)?#x?[0-9]+;|&(?:amp;)?[a-zA-Z1-4]{2,6};/UumsS', $texte, $t, PREG_SET_ORDER)) {
		foreach ($t as $n => $tag) {
			$tags[$n] = $tag[0];
			$texte = str_replace($tag[0], "<---$n--->", $texte);
		}
	}
	// casser les mots longs qui restent
	// note : on pourrait preferer couper sur les / , etc.
	if (preg_match_all("/[\w,\/.]{".$l."}/UmsS", $texte, $longs, PREG_SET_ORDER)) {
		foreach ($longs as $long) {
			$texte = str_replace($long[0], $long[0].$espace, $texte);
		}
	}

	// retablir les tags
	if (preg_match_all('/<---[\s0-9]+--->/UumsS', $texte, $t, PREG_SET_ORDER)) {
		foreach ($t as $tag) {
			$n = intval(preg_replace(',[^0-9]+,U','',$tag[0]));
			$texte = str_replace($tag[0], $tags[$n], $texte);
		}
	}

	return importer_charset($texte, 'utf-8');
}

/**
 * Normaliser le charset de la reponse Paypal si besoin
 * @param $response
 * @return mixed
 */
function paypal_charset_reponse($response)
{
    if (isset($response['charset']) and $response['charset'] !== $GLOBALS['meta']['charset']) {
        include_spip('inc/charsets');
        foreach ($response as $k => $v) {
            $response[$k] = importer_charset($v, $response['charset']);
        }
    }
    return $response;
}

function import_lire_champs($f, $fields, $gz, $phpmyadmin, $table, $atts)
{
	$values = array();
	$dir_img = 0;


	if (($atts['version_base'] < '1.934')
	AND $table == '/spip_documents') {

	  $dir_img = '@^'. preg_quote (isset($atts['dir_img']) ? $atts['dir_img']:'IMG/') . '@';
	}

	if (!isset($GLOBALS['meta']['charset_insertion']))
		$charset = '';
	else {
		$charset = $GLOBALS['meta']['charset_insertion'];
		if ($charset == $GLOBALS['meta']['charset'])
			$charset = '';
	}
	for (;;) {
		$b = false;
		if (!($col = xml_fetch_tag($f, $b, $gz))) return false;
		if ($col[0] == '/') { 
			if ($col != $table) {
				spip_log("table $table, tag fermant inattendu:$col");
		  }
			break;
		}
		$value = $b = (($col != 'maj') AND (isset($fields[$col])));
		if (!xml_fetch_tag($f, $value, $gz)) return false;

		if ($b) {
			if ($phpmyadmin)
				$value = str_replace($phpmyadmin[0],$phpmyadmin[1],$value);
			elseif ($dir_img) {
			  $value = preg_replace($dir_img, '', $value);
			}
			if ($charset) 
				$value = importer_charset($value, $charset);
			$values[$col]= $value;
		}
	}

	return $values;
}