Skip to content
Extraits de code Groupes Projets

Comparer les révisions

Les modifications sont affichées comme si la révision source était fusionnée avec la révision cible. En savoir plus sur la comparaison des révisions.

Source

Sélectionner le projet cible
No results found

Cible

Sélectionner le projet cible
  • spip/spip
  • Roman/spip
  • g0uZ/spip_puce_changement_statut_rapide_sans_JS_inline
  • erational/issue_4450
  • cy.altern/spip_core
  • fa_b/spip
  • glopglop/spip
  • MathieuAlphamosa/spip
  • taffit/spip
  • claffont/spip
  • RealET/spip
  • alexis.pellicier/spip
  • syl20/spip
  • cpol/spip_cpol0
  • franck_r/spip
  • JLuc/spip
  • JLuc/jluc-spip
  • bricebou/spip
  • Jack31/spip-issue-5919
  • Plumf/spip
  • jo/spip
  • pierretux/spip
  • placido/spip
  • touti/spip
  • florent.tri/spip
25 résultats
Afficher les modifications
Masquer les modifications d'espaces
En ligne Côte à côte
Affichage de
avec 0 ajout et 2571 suppressions
ecrire/balise/configurer_metas.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// Une balise qui prend en argument un squelette suppose contenir un FORM
// et gere ses saises automatiquement dans une table SQL a 2 colonnes
// nom / valeur
// Comme l'emplacement du squelette est calcule (par l'argument de la balise)
// on ne peut rien dire sur l'existence du squelette lors de la compil
// On pourrait toutefois traiter le cas de l'argument qui est une constante.
function balise_CONFIGURER_METAS_dist($p) {
return calculer_balise_dynamique($p, $p->nom_champ, array());
}
// A l'execution on dispose du nom du squelette, on verifie qu'il existe.
// Pour le calcul du contexte, c'est comme la balise #FORMULAIRE_.
// y compris le controle au retour pour faire apparaitre le message d'erreur.
function balise_CONFIGURER_METAS_dyn($form) {
include_spip('balise/formulaire_');
if (!existe_formulaire($form)) return '';
$args = func_get_args();
$contexte = balise_FORMULAIRE__contexte('configurer_metas', $args);
if (!is_array($contexte)) return $contexte;
return array('formulaires/' . $form, 3600, $contexte);
}
?>
ecrire/balise/formulaire_.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
include_spip('inc/filtres');
function protege_champ($texte){
if (is_array($texte))
$texte = array_map('protege_champ',$texte);
else {
// ne pas corrompre une valeur serialize
if (preg_match(",^[abis]:\d+[:;],", $texte) AND unserialize($texte)!=false)
return $texte;
$texte = entites_html($texte);
$texte = str_replace("'","&#39;",$texte);
}
return $texte;
}
function existe_formulaire($form)
{
if (substr($form,0,11)=="FORMULAIRE_")
$form = strtolower(substr($form,11));
else
$form = strtolower($form);
if (!$form) return ''; // on ne sait pas, le nom du formulaire n'est pas fourni ici
return trouver_fond($form, 'formulaires/') ? $form : false;
}
/* prendre en charge par defaut les balises formulaires simples */
// http://doc.spip.org/@balise_FORMULAIRE__dist
function balise_FORMULAIRE__dist($p) {
// Cas d'un #FORMULAIRE_TOTO inexistant : renvoyer la chaine vide.
// mais si #FORMULAIRE_{toto} on ne peut pas savoir a la compilation, continuer
if (existe_formulaire($p->nom_champ)===FALSE) {
$p->code = "''";
$p->interdire_scripts = false;
return $p;
}
// sinon renvoyer un code php dnamique
return calculer_balise_dynamique($p, $p->nom_champ, array());
}
/* prendre en charge par defaut les balises dynamiques formulaires simples */
// http://doc.spip.org/@balise_FORMULAIRE__dyn
function balise_FORMULAIRE__dyn($form)
{
$form = existe_formulaire($form);
if (!$form) return '';
// deux moyen d'arriver ici :
// soit #FORMULAIRE_XX reroute avec 'FORMULAIRE_XX' ajoute en premier arg
// soit #FORMULAIRE_{xx}
// recuperer les arguments passes a la balise
// on enleve le premier qui est le nom de la balise
// deja recupere ci-dessus
$args = func_get_args();
array_shift($args);
$contexte = balise_FORMULAIRE__contexte($form, $args);
if (!is_array($contexte)) return $contexte;
return array("formulaires/$form", 3600, $contexte);
}
function balise_FORMULAIRE__contexte($form, $args)
{
// tester si ce formulaire vient d'etre poste (memes arguments)
// pour ne pas confondre 2 #FORMULAIRES_XX identiques sur une meme page
// si poste, on recupere les erreurs
$je_suis_poste = false;
if ($post_form = _request('formulaire_action')
AND $post_form==$form
AND $p = _request('formulaire_action_args')
AND is_array($p = decoder_contexte_ajax($p, $post_form))) {
// enlever le faux attribut de langue masque
array_shift($p);
if (formulaire__identifier($form, $args, $p))
$je_suis_poste = true;
}
$editable = true;
$erreurs = $post = array();
if ($je_suis_poste) {
$post = traiter_formulaires_dynamiques(true);
$e = "erreurs_$form";
$erreurs = isset($post[$e]) ? $post[$e] : array();
$editable = "editable_$form";
$editable = (!isset($post[$e]))
|| count($erreurs)
|| (isset($post[$editable]) && $post[$editable]);
}
$valeurs = formulaire__charger($form, $args, $je_suis_poste);
// si $valeurs n'est pas un tableau, le formulaire n'est pas applicable
// C'est plus fort qu'editable qui est gere par le squelette
// Idealement $valeur doit etre alors un message explicatif.
if (!is_array($valeurs)) return is_string($valeurs) ? $valeurs : '';
// charger peut passer une action si le formulaire ne tourne pas sur self()
// ou une action vide si elle ne sert pas
$action = (isset($valeurs['action'])) ? $valeurs['action'] : self('&amp;', true);
// bug IEx : si action finit par /
// IE croit que le <form ... action=../ > est autoferme
if (substr($action,-1)=='/') {
// on ajoute une ancre pour feinter IE, au pire ca tue l'ancre qui finit par un /
$action .= '#';
}
// recuperer la saisie en cours si erreurs
// seulement si c'est ce formulaire qui est poste
// ou si on le demande explicitement par le parametre _forcer_request = true
$dispo = ($je_suis_poste || (isset($valeurs['_forcer_request']) && $valeurs['_forcer_request']));
foreach(array_keys($valeurs) as $champ){
if ($champ[0]!=='_' AND !in_array($champ, array('message_ok','message_erreur','editable'))) {
if ($dispo AND (($v = _request($champ))!==NULL))
$valeurs[$champ] = $v;
if ($action)
$action = parametre_url($action,$champ,'');
// nettoyer l'url des champs qui vont etre saisis
// proteger les ' et les " dans les champs que l'on va injecter
$valeurs[$champ] = protege_champ($valeurs[$champ]);
}
}
if ($action) {
// nettoyer l'url
$action = parametre_url($action,'formulaire_action','');
$action = parametre_url($action,'formulaire_action_args','');
}
if (isset($valeurs['_action'])){
$securiser_action = charger_fonction('securiser_action','inc');
$secu = $securiser_action(reset($valeurs['_action']),end($valeurs['_action']),'',-1);
$valeurs['_hidden'] = (isset($valeurs['_hidden'])?$valeurs['_hidden']:'') .
"<input type='hidden' name='arg' value='".$secu['arg']."' />"
. "<input type='hidden' name='hash' value='".$secu['hash']."' />";
}
// empiler la lang en tant que premier argument implicite du CVT
// pour permettre de la restaurer au moment du Verifier et du Traiter
array_unshift($args, $GLOBALS['spip_lang']);
$valeurs['formulaire_args'] = encoder_contexte_ajax($args, $form);
$valeurs['erreurs'] = $erreurs;
$valeurs['action'] = $action;
$valeurs['form'] = $form;
if (!isset($valeurs['id'])) $valeurs['id'] = 'new';
// editable peut venir de charger() ou de traiter() sinon
if (!isset($valeurs['editable'])) $valeurs['editable'] = $editable;
// dans tous les cas, renvoyer un espace ou vide (et pas un booleen)
$valeurs['editable'] = ($valeurs['editable']?' ':'');
if ($je_suis_poste) {
$valeurs['message_erreur'] = "";
if (isset($erreurs['message_erreur']))
$valeurs['message_erreur'] = $erreurs['message_erreur'];
$valeurs['message_ok'] = "";
if (isset($post["message_ok_$form"]))
$valeurs['message_ok'] = $post["message_ok_$form"];
elseif (isset($erreurs['message_ok']))
$valeurs['message_ok'] = $erreurs["message_ok"];
}
return $valeurs;
}
/**
* Charger les valeurs de saisie du formulaire
*
* @param string $form
* @param array $args
* @param bool $poste
* @return array
*/
function formulaire__charger($form, $args, $poste)
{
if ($charger_valeurs = charger_fonction("charger","formulaires/$form",true))
$valeurs = call_user_func_array($charger_valeurs,$args);
else $valeurs = array();
$valeurs = pipeline(
'formulaire_charger',
array(
'args'=>array('form'=>$form,'args'=>$args,'je_suis_poste'=>$poste),
'data'=>$valeurs)
);
return $valeurs;
}
/**
* Verifier que le formulaire en cours est celui qui est poste
* on se base sur la fonction identifier (si elle existe) qui fournit
* une signature identifiant le formulaire a partir de ses arguments
* significatifs
*
* En l'absence de fonction identifier, on se base sur l'egalite des
* arguments, ce qui fonctionne dans les cas simples
*
* @param string $form
* @param array $args
* @param array $p
* @return bool
*/
function formulaire__identifier($form, $args, $p) {
if ($identifier_args = charger_fonction("identifier","formulaires/$form",true)) {
return call_user_func_array($identifier_args,$args)===call_user_func_array($identifier_args,$p);
}
return $args===$p;
}
?>
ecrire/balise/formulaire_admin.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
include_spip('inc/autoriser');
include_spip('base/abstract_sql');
// http://doc.spip.org/@balise_FORMULAIRE_ADMIN
function balise_FORMULAIRE_ADMIN ($p) {
return calculer_balise_dynamique($p,'FORMULAIRE_ADMIN', array());
}
# on ne peut rien dire au moment de l'execution du squelette
// http://doc.spip.org/@balise_FORMULAIRE_ADMIN_stat
function balise_FORMULAIRE_ADMIN_stat($args, $filtres) {
return $args;
}
# les boutons admin sont mis d'autorite si absents
# donc une variable statique controle si FORMULAIRE_ADMIN a ete vu.
# Toutefois, si c'est le debuger qui appelle,
# il peut avoir recopie le code dans ses donnees et il faut le lui refounir.
# Pas question de recompiler: ca fait boucler !
# Le debuger transmet donc ses donnees, et cette balise y retrouve son petit.
// http://doc.spip.org/@balise_FORMULAIRE_ADMIN_dyn
function balise_FORMULAIRE_ADMIN_dyn($float='', $debug='') {
global $var_preview, $use_cache;
static $dejafait = false;
if (!@$_COOKIE['spip_admin'])
return '';
if (!is_array($debug)) {
if ($dejafait)
return '';
} else {
if ($dejafait) {
if (empty($debug['sourcefile'])) return '';
foreach($debug['sourcefile'] as $k => $v) {
if (strpos($v,'administration.') !== false)
return $debug['resultat'][$k . 'tout'];
}
return '';
}
}
$dejafait = true;
// Preparer le #ENV des boutons
$env = admin_objet();
// Pas de "modifier ce..." ? -> donner "acces a l'espace prive"
if (!$env)
$env['ecrire'] = _DIR_RESTREINT_ABS;
$env['divclass'] = $float;
$env['lang'] = admin_lang();
$env['calcul'] = (_request('var_mode') ? 'recalcul' : 'calcul');
$env['debug'] = $var_preview ? "" : admin_debug();
$env['analyser'] = (!$env['debug'] AND !$GLOBALS['xhtml']) ? '' : admin_valider();
$env['inclure'] = ($GLOBALS['var_inclure']?'inclure':'');
if (!$use_cache)
$env['use_cache'] = ' *';
if (isset($debug['validation'])) {
$env['xhtml_error'] = $debug['validation'];
}
$env['_pipeline'] = 'formulaire_admin';
return array('formulaires/administration', 0, $env);
}
// Afficher le bouton 'Modifier ce...'
// s'il y a un $id_XXX defini globalement par spip_register_globals
// Attention a l'ordre dans la boucle:
// on ne veut pas la rubrique si un autre bouton est possible
// http://doc.spip.org/@admin_objet
function admin_objet()
{
include_spip('inc/urls');
$env = array();
$trouver_table = charger_fonction('trouver_table','base');
$objets = urls_liste_objets(false);
$objets = array_diff($objets, array('rubrique'));
array_unshift($objets, 'rubrique');
foreach ($objets as $obj) {
$type = $obj;
$_id_type = id_table_objet($type);
if (isset($GLOBALS['contexte'][$_id_type]) AND $id = $GLOBALS['contexte'][$_id_type]) {
$id = sql_getfetsel($_id_type, table_objet_sql($type), "$_id_type=".intval($id));
if ($id) {
$env[$_id_type] = $id;
$env['objet'] = $type;
$env['id_objet'] = $id;
if (!function_exists($g = 'generer_url_ecrire_'.$obj))
$g = charger_fonction($g, 'urls');
$env['voir_'.$obj] =
str_replace('&amp;', '&', $g($id, '','', 'prop'));
if ($desc = $trouver_table(table_objet_sql($type))
AND isset($desc['field']['id_rubrique'])) {
unset($env['id_rubrique']);
unset($env['voir_rubrique']);
if (admin_preview($type, $id, $desc))
$env['preview']=parametre_url(self(),'var_mode','preview','&');
}
}
}
}
return $env;
}
// http://doc.spip.org/@admin_preview
function admin_preview($type, $id, $desc=null)
{
if ($GLOBALS['var_preview']) return '';
if (!$desc) {
$trouver_table = charger_fonction('trouver_table','base');
$desc = $trouver_table(table_objet_sql($type));
}
if (!$desc OR !isset($desc['field']['statut']))
return '';
include_spip('inc/autoriser');
if (!autoriser('previsualiser')) return '';
$notpub = sql_in("statut", array('prop', 'prive'));
if ($type == 'article' AND $GLOBALS['meta']['post_dates'] != 'oui')
$notpub .= " OR (statut='publie' AND date>".sql_quote(date('Y-m-d H:i:s')).")";
return sql_fetsel('1', table_objet_sql($type), id_table_objet($type)."=".$id." AND ($notpub)");
}
//
// Regler les boutons dans la langue de l'admin (sinon tant pis)
//
// http://doc.spip.org/@admin_lang
function admin_lang()
{
$alang = sql_getfetsel('lang', 'spip_auteurs', "login=" . sql_quote(preg_replace(',^@,','',@$_COOKIE['spip_admin'])));
if (!$alang) return '';
$l = lang_select($alang);
$alang = $GLOBALS['spip_lang'];
if ($l) lang_select();
return $alang;
}
// http://doc.spip.org/@admin_valider
function admin_valider()
{
global $xhtml;
return ((@$xhtml !== 'true') ?
(parametre_url(self(), 'var_mode', 'debug', '&')
.'&var_mode_affiche=validation') :
('http://validator.w3.org/check?uri='
. rawurlencode("http://" . $_SERVER['HTTP_HOST'] . nettoyer_uri())));
}
// http://doc.spip.org/@admin_debug
function admin_debug()
{
return ((
(isset($GLOBALS['forcer_debug']) AND $GLOBALS['forcer_debug'])
OR (isset($GLOBALS['bouton_admin_debug']) AND $GLOBALS['bouton_admin_debug'])
OR (
isset($GLOBALS['var_mode'])
AND $GLOBALS['var_mode'] == 'debug'
AND $_COOKIE['spip_debug']
)
) AND autoriser('debug')
)
? parametre_url(self(),'var_mode', 'debug', '&'): '';
}
?>
ecrire/balise/formulaire_ecrire_auteur.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
include_spip('base/abstract_sql');
// On prend l'email dans le contexte de maniere a ne pas avoir a le
// verifier dans la base ni a le devoiler au visiteur
// http://doc.spip.org/@balise_FORMULAIRE_ECRIRE_AUTEUR
function balise_FORMULAIRE_ECRIRE_AUTEUR ($p) {
return calculer_balise_dynamique($p,'FORMULAIRE_ECRIRE_AUTEUR', array('id_auteur', 'id_article', 'email'));
}
// http://doc.spip.org/@balise_FORMULAIRE_ECRIRE_AUTEUR_stat
function balise_FORMULAIRE_ECRIRE_AUTEUR_stat($args, $context_compil) {
include_spip('inc/filtres');
// Pas d'id_auteur ni d'id_article ? Erreur de contexte
$id = intval($args[1]);
if (!$args[0] AND !$id) {
$msg = array('zbug_champ_hors_motif',
array ('champ' => 'FORMULAIRE_ECRIRE_AUTEUR',
'motif' => 'AUTEURS/ARTICLES'));
erreur_squelette($msg, $context_compil);
return '';
}
// Si on est dans un contexte article,
// sortir tous les mails des auteurs de l'article
if (!$args[0] AND $id) {
$r = '';
$s = sql_allfetsel('email',
'spip_auteurs AS A LEFT JOIN spip_auteurs_liens AS L ON (A.id_auteur=L.id_auteur AND L.objet=\'article\')',
"A.email != '' AND L.id_article=$id");
foreach($s as $row) {
if (email_valide($row['email']))
$r .= ','.$row['email'];
}
$args[2] = substr($r, 1);
}
// On ne peut pas ecrire a un auteur dont le mail n'est pas valide
if (!$args[2] OR !email_valide($args[2]))
return '';
// OK
return $args;
}
?>
ecrire/balise/formulaire_inscription.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
include_spip('base/abstract_sql');
include_spip('inc/filtres');
// Balise independante du contexte
// http://doc.spip.org/@balise_FORMULAIRE_INSCRIPTION
function balise_FORMULAIRE_INSCRIPTION ($p) {
return calculer_balise_dynamique($p, 'FORMULAIRE_INSCRIPTION', array());
}
// args[0] un statut d'auteur (redacteur par defaut)
// args[1] indique le focus eventuel
// args[2] indique la rubrique eventuelle de proposition
// [(#FORMULAIRE_INSCRIPTION{nom_inscription, #ID_RUBRIQUE})]
// http://doc.spip.org/@balise_FORMULAIRE_INSCRIPTION_stat
function balise_FORMULAIRE_INSCRIPTION_stat($args, $context_compil) {
list($mode, $focus, $id) = $args;
$mode = tester_config($id, $mode);
return $mode ? array($mode, $focus, $id) : '';
}
?>
ecrire/balise/formulaire_recherche.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// Pas d'arg a compiler ==> pas besoin d'appeler calculer_balise_dynamique
// http://doc.spip.org/@balise_FORMULAIRE_RECHERCHE_stat
function balise_FORMULAIRE_RECHERCHE_stat($args, $context_compil) {
// le premier element du tableau etait auparavant un script.
// Voir si on ne pourrait pas simplifier maintenant
return array('', $args ? $args[0] : '');
}
?>
ecrire/balise/index.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
X
ecrire/balise/info_.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
/**
* Generer n'importe quel info pour un objet : #INFO_TITRE{article, #ENV{id_article}}
* Utilise la fonction generer_info_entite() de inc/filtres
* se reporter a sa documentation
*
*/
function balise_INFO__dist($p){
$info = $p->nom_champ;
$type_objet = interprete_argument_balise(1,$p);
$id_objet = interprete_argument_balise(2,$p);
if ($info === 'INFO_' or !$type_objet or !$id_objet) {
$msg = _T('zbug_balise_sans_argument', array('balise' => ' INFO_'));
erreur_squelette($msg, $p);
$p->interdire_scripts = false;
return $p;
} elseif ($f = charger_fonction($nom, 'balise', true)) {
return $f($p);
}else {
$p->code = champ_sql($info, $p);
if (strpos($p->code, '@$Pile[0]') !== false) {
$info = strtolower(substr($info,5));
$p->code = "generer_info_entite($id_objet, $type_objet, '$info')";
}
$p->interdire_scripts = false;
return $p;
}
}
?>
ecrire/balise/login_prive.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// http://doc.spip.org/@balise_LOGIN_PRIVE
function balise_LOGIN_PRIVE ($p) {
return calculer_balise_dynamique($p, 'LOGIN_PRIVE', array('url'));
}
# retourner:
# 1. l'url collectee ci-dessus (args0) ou donnee en premier parametre (args1)
# #LOGIN_PRIVE{#URL_ECRIRE}
# 2. un eventuel parametre (args2) indiquant le login et permettant une ecriture
# <boucle(AUTEURS)>[(#LOGIN_PRIVE{#URL_ECRIRE, #LOGIN})]
// http://doc.spip.org/@balise_LOGIN_PRIVE_stat
function balise_LOGIN_PRIVE_stat ($args, $filtres) {
return array(isset($args[1]) ? $args[1] : $args[0], (isset($args[2]) ? $args[2] : ''));
}
// http://doc.spip.org/@balise_LOGIN_PRIVE_dyn
function balise_LOGIN_PRIVE_dyn($url, $login) {
include_spip('balise/formulaire_');
if (!$url # pas d'url passee en filtre ou dans le contexte
AND !$url = _request('url') # ni d'url passee par l'utilisateur
)
$url = generer_url_ecrire('accueil','',true);
return balise_FORMULAIRE__dyn('login',$url,$login,true);
}
?>
ecrire/balise/login_public.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// http://doc.spip.org/@balise_LOGIN_PUBLIC
function balise_LOGIN_PUBLIC ($p, $nom='LOGIN_PUBLIC') {
return calculer_balise_dynamique($p, $nom, array('url'));
}
# retourner:
# 1. l'url collectee ci-dessus (args0) ou donnee en premier parametre (args1)
# #LOGIN_PUBLIC{#SELF}
# 2. un eventuel parametre (args2) indiquant le login et permettant une ecriture
# <boucle(AUTEURS)>[(#LOGIN_PUBLIC{#SELF, #LOGIN})]
// http://doc.spip.org/@balise_LOGIN_PUBLIC_stat
function balise_LOGIN_PUBLIC_stat ($args, $filtres) {
return array(isset($args[1]) ? $args[1] : $args[0], (isset($args[2]) ? $args[2] : ''));
}
// http://doc.spip.org/@balise_LOGIN_PUBLIC_dyn
function balise_LOGIN_PUBLIC_dyn($url, $login) {
include_spip('balise/formulaire_');
if (!$url # pas d'url passee en filtre ou dans le contexte
AND !$url = _request('url') # ni d'url passee par l'utilisateur
)
$url = parametre_url(self(), '', '', '&');
return balise_FORMULAIRE__dyn('login',$url,$login,false);
}
?>
ecrire/balise/logo_.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
//
// Fonction des balises #LOGO_XXXX
// (les balises portant ce type de nom sont traitees en bloc ici)
//
// http://doc.spip.org/@balise_LOGO__dist
function balise_LOGO__dist ($p) {
preg_match(",^LOGO_([A-Z_]+?)(|_NORMAL|_SURVOL|_RUBRIQUE)$,i", $p->nom_champ, $regs);
$type = strtolower($regs[1]);
$suite_logo = $regs[2];
// cas de #LOGO_SITE_SPIP
if ($type == 'site_spip') {
$type = 'site';
$_id_objet = "\"'0'\"";
}
$id_objet = id_table_objet($type);
if (!$_id_objet)
$_id_objet = champ_sql($id_objet, $p);
$fichier = ($p->etoile === '**') ? -1 : 0;
$coord = array();
$align = $lien = '';
$mode_logo = '';
if ($p->param AND !$p->param[0][0]) {
$params = $p->param[0];
array_shift($params);
foreach($params as $a) {
if ($a[0]->type === 'texte') {
$n = $a[0]->texte;
if (is_numeric($n))
$coord[]= $n;
elseif (in_array($n,array('top','left','right','center','bottom')))
$align = $n;
elseif (in_array($n,array('auto','icone','apercu','vignette')))
$mode_logo = $n;
}
else $lien = calculer_liste($a, $p->descr, $p->boucles, $p->id_boucle);
}
}
$coord_x = !$coord ? 0 : intval(array_shift($coord));
$coord_y = !$coord ? 0 : intval(array_shift($coord));
if ($p->etoile === '*') {
include_spip('balise/url_');
$lien = generer_generer_url_arg($type, $p, $_id_objet);
}
$connect = $p->id_boucle ?$p->boucles[$p->id_boucle]->sql_serveur :'';
if ($type == 'document') {
$qconnect = _q($connect);
$doc = "quete_document($_id_objet, $qconnect)";
if ($fichier)
$code = "quete_logo_file($doc, $qconnect)";
else $code = "quete_logo_document($doc, " . ($lien ? $lien : "''") . ", '$align', '$mode_logo', $coord_x, $coord_y, $qconnect)";
// (x=non-faux ? y : '') pour affecter x en retournant y
if ($p->descr['documents'])
$code = '(($doublons["documents"] .= ",". '
. $_id_objet
. ") ? $code : '')";
}
elseif ($connect) {
$code = "''";
spip_log("Les logos distants ne sont pas prevus");
} else {
$code = logo_survol($id_objet, $_id_objet, $type, $align, $fichier, $lien, $p, $suite_logo);
}
// demande de reduction sur logo avec ecriture spip 2.1 : #LOGO_xxx{200, 0}
if ($coord_x OR $coord_y) {
$code = "filtrer('image_graver',filtrer('image_reduire',".$code.", '$coord_x', '$coord_y'))";
}
$p->code = $code;
$p->interdire_scripts = false;
return $p;
}
function logo_survol($id_objet, $_id_objet, $type, $align, $fichier, $lien, $p, $suite)
{
$code = "quete_logo('$id_objet', '" .
(($suite == '_SURVOL') ? 'off' :
(($suite == '_NORMAL') ? 'on' : 'ON')) .
"', $_id_objet," .
(($suite == '_RUBRIQUE') ?
champ_sql("id_rubrique", $p) :
(($type == 'rubrique') ? "quete_parent($_id_objet)" : "''")) .
", " . intval($fichier) . ")";
if ($fichier) return $code;
$code = "\n((!is_array(\$l = $code)) ? '':\n (" .
'"<img class=\"spip_logos\" alt=\"\"' .
($align ? " align=\\\"$align\\\"" : '')
. ' src=\"$l[0]\"" . $l[2] . ($l[1] ? " onmouseover=\"this.src=\'$l[1]\'\" onmouseout=\"this.src=\'$l[0]\'\"" : "") . \' />\'))';
if (!$lien) return $code;
return ('(strlen($logo='.$code.')?\'<a href="\' .' . $lien . ' . \'">\' . $logo . \'</a>\':\'\')');
}
?>
ecrire/balise/menu_lang.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// #MENU_LANG affiche le menu des langues de l'espace public
// et preselectionne celle la globale $lang
// ou de l'argument fourni: #MENU_LANG{#ENV{malangue}}
// http://doc.spip.org/@balise_MENU_LANG
function balise_MENU_LANG ($p) {
return calculer_balise_dynamique($p,'MENU_LANG', array('lang'));
}
// s'il n'y a qu'une langue eviter definitivement la balise ?php
// http://doc.spip.org/@balise_MENU_LANG_stat
function balise_MENU_LANG_stat ($args, $filtres) {
if (strpos($GLOBALS['meta']['langues_multilingue'],',') === false) return '';
return $filtres ? $filtres : $args;
}
// normalement $opt sera toujours non vide suite au test ci-dessus
// http://doc.spip.org/@balise_MENU_LANG_dyn
function balise_MENU_LANG_dyn($opt) {
include_spip('balise/menu_lang_ecrire');
return menu_lang_pour_tous('var_lang', $opt);
}
?>
ecrire/balise/menu_lang_ecrire.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// #MENU_LANG_ECRIRE affiche le menu des langues de l'espace privé
// et preselectionne celle la globale $lang
// ou de l'arguemnt fourni: #MENU_LANG_ECRIRE{#ENV{malangue}}
// http://doc.spip.org/@balise_MENU_LANG_ECRIRE
function balise_MENU_LANG_ECRIRE ($p) {
return calculer_balise_dynamique($p,'MENU_LANG_ECRIRE', array('lang'));
}
// s'il n'y a qu'une langue proposee eviter definitivement la balise ?php
// http://doc.spip.org/@balise_MENU_LANG_ECRIRE_stat
function balise_MENU_LANG_ECRIRE_stat ($args, $filtres) {
include_spip('inc/lang');
if (strpos($GLOBALS['meta']['langues_proposees'],',') === false) return '';
return $filtres ? $filtres : $args;
}
// normalement $opt sera toujours non vide suite au test ci-dessus
// http://doc.spip.org/@balise_MENU_LANG_ECRIRE_dyn
function balise_MENU_LANG_ECRIRE_dyn($opt) {
return menu_lang_pour_tous('var_lang_ecrire', $opt);
}
// http://doc.spip.org/@menu_lang_pour_tous
function menu_lang_pour_tous($nom, $default) {
include_spip('inc/lang');
if ($GLOBALS['spip_lang'] <> $default) {
$opt = lang_select($default); # et remplace
if ($GLOBALS['spip_lang'] <> $default) {
$default = ''; # annule tout choix par defaut
if ($opt) lang_select();
}
}
$opt = liste_options_langues($nom, $default);
if (!$opt)
return '';
# lien a partir de /
$cible = parametre_url(self(), 'lang' , '', '&');
$post = generer_url_action('converser', 'redirect='. rawurlencode($cible), '&');
return array('formulaires/menu_lang',
3600,
array('nom' => $nom,
'url' => $post,
'langues' => $opt
)
);
}
?>
ecrire/balise/url_.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// Les balises URL_$type sont generiques, sauf qq cas particuliers.
// Si ces balises sont utilisees pour la base locale,
// production des appels a generer_url_entite(id-courant, entite)
// Si la base est externe et non geree par SPIP
// on retourne NULL pour provoquer leur interpretation comme champ SQL normal.
// Si la base est externe et sous SPIP,
// on produit l'URL de l'objet si c'est une piece jointe
// ou sinon l'URL du site local applique sur l'objet externe
// ce qui permet de le voir a travers les squelettes du site local
// On communique le type-url distant a generer_url_entite mais il ne sert pas
// car rien ne garantit que le .htaccess soit identique. A approfondir
// http://doc.spip.org/@generer_generer_url
function generer_generer_url($type, $p)
{
$_id = interprete_argument_balise(1,$p);
if (!$_id) $_id = champ_sql('id_' . $type, $p);
return generer_generer_url_arg($type, $p, $_id);
}
function generer_generer_url_arg($type, $p, $_id)
{
if ($s = trouver_nom_serveur_distant($p)) {
// si une fonction de generation des url a ete definie pour ce connect l'utiliser
if (function_exists($f = 'generer_generer_url_'.$s)){
return $f($type, $_id, $s);
}
if (!$GLOBALS['connexions'][strtolower($s)]['spip_connect_version']) {
return NULL;
}
$s = _q($s);
if ($type == 'document') {
return
"quete_meta('adresse_site', $s) . '/' .\n\t" .
"quete_meta('dir_img', $s) . \n\t" .
"quete_fichier($_id,$s)";
}
$s = ", '', '', $s, quete_meta('type_urls', $s)";
}
else
$s = ", '', '', true";
return "urlencode_1738(generer_url_entite($_id, '$type'$s))";
}
// http://doc.spip.org/@balise_URL__dist
function balise_URL__dist($p) {
$nom = $p->nom_champ;
if ($nom === 'URL_') {
$msg = array('zbug_balise_sans_argument', array('balise' => ' URL_'));
erreur_squelette($msg, $p);
$p->interdire_scripts = false;
return $p;
} elseif ($f = charger_fonction($nom, 'balise', true)) {
return $f($p);
}else {
$code = champ_sql($nom, $p);
if (strpos($code, '@$Pile[0]') !== false) {
$nom = strtolower(substr($nom,4));
$code = generer_generer_url($nom, $p);
if ($code === NULL) return NULL;
}
if (!$p->etoile)
$p->code = "vider_url($code)";
$p->interdire_scripts = false;
return $p;
}
}
// http://doc.spip.org/@balise_URL_ARTICLE_dist
function balise_URL_ARTICLE_dist($p) {
// Cas particulier des boucles (SYNDIC_ARTICLES)
if ($p->type_requete == 'syndic_articles') {
$code = champ_sql('url', $p);
} else $code = generer_generer_url('article', $p);
$p->code = "vider_url($code)";
$p->interdire_scripts = false;
return $p;
}
// http://doc.spip.org/@balise_URL_SITE_dist
function balise_URL_SITE_dist($p)
{
$code = champ_sql('url_site', $p);
if (strpos($code, '@$Pile[0]') !== false) {
$code = generer_generer_url('site', $p);
if ($code === NULL) return NULL;
} else {
if (!$p->etoile)
$code = "calculer_url($code,'','url', \$connect)";
}
$p->code = $code;
$p->interdire_scripts = false;
return $p;
}
// Autres balises URL_*, qui ne concernent pas une table
// (historique)
// http://doc.spip.org/@balise_URL_SITE_SPIP_dist
function balise_URL_SITE_SPIP_dist($p) {
$p->code = "sinon(\$GLOBALS['meta']['adresse_site'],'.')";
$p->code = "htmlspecialchars(".$p->code.")";
$p->interdire_scripts = false;
return $p;
}
//
// #URL_PAGE{backend} -> backend.php3 ou ?page=backend selon les cas
// Pour les pages qui commencent par "spip_", il faut eventuellement
// aller chercher spip_action.php?action=xxxx
//
// http://doc.spip.org/@balise_URL_PAGE_dist
function balise_URL_PAGE_dist($p) {
$p->code = interprete_argument_balise(1,$p);
$args = interprete_argument_balise(2,$p);
if ($args == NULL)
$args = "''";
if ($s = trouver_nom_serveur_distant($p)) {
if (!$GLOBALS['connexions'][strtolower($s)]['spip_connect_version']) {
$p->code = "404";
} else {
// si une fonction de generation des url a ete definie pour ce connect l'utiliser
// elle devra aussi traiter le cas derogatoire type=page
if (function_exists($f = 'generer_generer_url_'.$s)){
if ($args AND $args!=="''") $p->code .= ", $args";
$p->code = $f('page', $p->code, $s);
return $p;
}
$s = 'connect=' . addslashes($s);
$args = (($args AND $args!=="''") ? "$args . '&$s'" : "'$s'");
}
}
spip_log("connect vaut $s ca donne " . $p->code . " args $args");
if (!$args) $args = "''";
$p->code = 'generer_url_public(' . $p->code . ", $args)";
#$p->interdire_scripts = true;
return $p;
}
//
// #URL_ECRIRE{naviguer} -> ecrire/?exec=naviguer
//
// http://doc.spip.org/@balise_URL_ECRIRE_dist
function balise_URL_ECRIRE_dist($p) {
$code = interprete_argument_balise(1,$p);
if (!$code)
$fonc = "''";
else{
if (preg_match("/^'[^']*'$/", $code))
$fonc = $code;
else {$code = "(\$f = $code)"; $fonc = '$f';}
$args = interprete_argument_balise(2,$p);
if ($args != "''" && $args!==NULL)
$fonc .= ',' . $args;
}
$p->code = 'generer_url_ecrire(' . $fonc .')';
if ($code)
$p->code = "(tester_url_ecrire($code) ?" . $p->code .' : "")';
#$p->interdire_scripts = true;
return $p;
}
//
// #URL_ACTION_AUTEUR{converser,arg,redirect} -> ecrire/?action=converser&arg=arg&hash=xxx&redirect=redirect
//
// http://doc.spip.org/@balise_URL_ACTION_AUTEUR_dist
function balise_URL_ACTION_AUTEUR_dist($p) {
$p->descr['session'] = true;
if ($p->boucles[$p->id_boucle]->sql_serveur) {
$p->code = 'generer_url_public("404")';
return $p;
}
$p->code = interprete_argument_balise(1,$p);
$args = interprete_argument_balise(2,$p);
if ($args != "''" && $args!==NULL)
$p->code .= ",".$args;
$redirect = interprete_argument_balise(3,$p);
if ($redirect != "''" && $redirect!==NULL)
$p->code .= ",".$redirect;
$p->code = "generer_action_auteur(" . $p->code . ")";
$p->interdire_scripts = false;
return $p;
}
?>
ecrire/balise/url_logout.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return; #securite
// http://doc.spip.org/@balise_URL_LOGOUT
function balise_URL_LOGOUT ($p) {return calculer_balise_dynamique($p,'URL_LOGOUT', array());
}
// $args[0] = url destination apres logout [(#URL_LOGOUT{url})]
// http://doc.spip.org/@balise_URL_LOGOUT_stat
function balise_URL_LOGOUT_stat ($args, $filtres) {
return array($args[0]);
}
// http://doc.spip.org/@balise_URL_LOGOUT_dyn
function balise_URL_LOGOUT_dyn($cible) {
if (!$GLOBALS['visiteur_session']['login']) return '';
return generer_url_action('logout',"logout=public&url=" . rawurlencode($cible ? $cible : self('&')));
}
?>
ecrire/base/abstract_sql.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
define('sql_ABSTRACT_VERSION', 1);
include_spip('base/connect_sql');
// Ce fichier definit la couche d'abstraction entre SPIP et ses serveurs SQL.
// Cette version 1 est un ensemble de fonctions ecrites rapidement
// pour generaliser le code strictement MySQL de SPIP <= 1.9.2
// Des retouches sont a prevoir apres l'experience des premiers portages.
// Les symboles sql_* (constantes et nom de fonctions) sont reserves
// a cette interface, sans quoi le gestionnaire de version dysfonctionnera.
// Fonction principale. Elle charge l'interface au serveur de base de donnees
// via la fonction spip_connect_version qui etablira la connexion au besoin.
// Elle retourne la fonction produisant la requete SQL demandee
// Erreur fatale si la fonctionnalite est absente sauf si le 3e arg <> false
// http://doc.spip.org/@sql_serveur
function sql_serveur($ins_sql='', $serveur='', $continue=false) {
return spip_connect_sql(sql_ABSTRACT_VERSION, $ins_sql, $serveur, $continue);
}
// Demande si un charset est disponible.
// http://doc.spip.org/@sql_get_charset
function sql_get_charset($charset, $serveur='', $option=true){
// le nom http du charset differe parfois du nom SQL utf-8 ==> utf8 etc.
$desc = sql_serveur('', $serveur, true,true);
$desc = $desc[sql_ABSTRACT_VERSION];
$c = $desc['charsets'][$charset];
if ($c) {
if (function_exists($f=@$desc['get_charset']))
if ($f($c, $serveur, $option!==false)) return $c;
}
spip_log("SPIP ne connait pas les Charsets disponibles sur le serveur $serveur. Le serveur choisira seul.");
return false;
}
// Regler le codage de connexion
// http://doc.spip.org/@sql_set_charset
function sql_set_charset($charset,$serveur='', $option=true){
$f = sql_serveur('set_charset', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($charset, $serveur, $option!==false);
}
// Fonction pour SELECT, retournant la ressource interrogeable par sql_fetch.
// Recoit en argument:
// - le tableau (ou cha�ne) des champs a` ramener (Select)
// - le tableau (ou cha�ne) des tables a` consulter (From)
// - le tableau (ou cha�ne) des conditions a` remplir (Where)
// - le crite`re de regroupement (Group by)
// - le tableau de classement (Order By)
// - le crite`re de limite (Limit)
// - le tableau des des post-conditions a remplir (Having)
// - le serveur sollicite (pour retrouver la connexion)
// - option peut avoir 3 valeurs :
// false -> ne pas l'executer mais la retourner,
// continue -> ne pas echouer en cas de serveur sql indisponible,
// autre -> executer la requete.
// Le cas "autre" est, pour une requete produite par le compilateur,
// un tableau donnnant le contexte afin d'indiquer le lieu de l'erreur au besoin
// Retourne false en cas d'erreur, apres l'avoir denoncee.
// Les portages doivent retourner la requete elle-meme en cas d'erreur,
// afin de disposer du texte brut.
// http://doc.spip.org/@sql_select
function sql_select ($select = array(), $from = array(), $where = array(),
$groupby = array(), $orderby = array(), $limit = '', $having = array(),
$serveur='', $option=true) {
$f = sql_serveur('select', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$debug = (isset($GLOBALS['var_mode']) AND $GLOBALS['var_mode'] == 'debug' );
if (($option !== false) AND !$debug) {
$res = $f($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, is_array($option) ? true : $option);
} else {
$query = $f($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, false);
if (!$option) return $query;
// le debug, c'est pour ce qui a ete produit par le compilateur
if (isset($GLOBALS['debug']['aucasou'])) {
list($table, $id,) = $GLOBALS['debug']['aucasou'];
$nom = $GLOBALS['debug_objets']['courant'] . $id;
$GLOBALS['debug_objets']['requete'][$nom] = $query;
}
$res = $f($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, true);
}
if (!is_string($res)) return $res;
// denoncer l'erreur SQL dans sa version brute
spip_sql_erreur($serveur);
// idem dans sa version squelette (prefixe des tables non substitue)
erreur_squelette(array(sql_errno($serveur), sql_error($serveur), $res), $option);
return false;
}
// Recupere la syntaxe de la requete select sans l'executer
// simplement $option = false au lieu de true
// http://doc.spip.org/@sql_get_select
function sql_get_select($select = array(), $from = array(), $where = array(),
$groupby = array(), $orderby = array(), $limit = '', $having = array(),
$serveur='') {
return sql_select ($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, false);
}
// Comme ci-dessus, mais ramene seulement et tout de suite le nombre de lignes
// Pas de colonne ni de tri a donner donc, et l'argument LIMIT est trompeur
// http://doc.spip.org/@sql_countsel
function sql_countsel($from = array(), $where = array(),
$groupby = array(), $having = array(),
$serveur='', $option=true) {
$f = sql_serveur('countsel', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($from, $where, $groupby, $having, $serveur, $option!==false);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_alter
function sql_alter($q, $serveur='', $option=true) {
$f = sql_serveur('alter', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($q, $serveur, $option!==false);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_fetch
function sql_fetch($res, $serveur='', $option=true) {
$f = sql_serveur('fetch', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($res, NULL, $serveur, $option!==false);
}
function sql_fetch_all($res, $serveur='', $option=true){
$rows = array();
if (!$res) return $rows;
$f = sql_serveur('fetch', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return array();
while ($r = $f($res, NULL, $serveur, $option!==false))
$rows[] = $r;
sql_free($res, $serveur);
return $rows;
}
function sql_seek($res, $row_number, $serveur='', $option=true) {
$f = sql_serveur('seek', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($res, $row_number, $serveur, $option!==false);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_listdbs
function sql_listdbs($serveur='', $option=true) {
$f = sql_serveur('listdbs', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($serveur);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_selectdb
function sql_selectdb($nom, $serveur='', $option=true)
{
$f = sql_serveur('selectdb', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($nom, $serveur, $option!==false);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_count
function sql_count($res, $serveur='', $option=true)
{
$f = sql_serveur('count', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($res, $serveur, $option!==false);
if ($r===false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_free
function sql_free($res, $serveur='', $option=true)
{
$f = sql_serveur('free', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($res);
}
// Cette fonction ne garantit pas une portabilite totale
// ===> lui preferer la suivante.
// Elle est fournie pour permettre l'actualisation de vieux codes
// par un Sed brutal qui peut donner des resultats provisoirement acceptables
// http://doc.spip.org/@sql_insert
function sql_insert($table, $noms, $valeurs, $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('insert', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $noms, $valeurs, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_insertq
function sql_insertq($table, $couples=array(), $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('insertq', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $couples, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_insertq_multi
function sql_insertq_multi($table, $couples=array(), $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('insertq_multi', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $couples, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_update
function sql_update($table, $exp, $where='', $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('update', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $exp, $where, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// Update est presque toujours appelee sur des constantes ou des dates
// Cette fonction est donc plus utile que la precedente,d'autant qu'elle
// permet de gerer les differences de representation des constantes.
// http://doc.spip.org/@sql_updateq
function sql_updateq($table, $exp, $where='', $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('updateq', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $exp, $where, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_delete
function sql_delete($table, $where='', $serveur='', $option=true)
{
$f = sql_serveur('delete', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $where, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_replace
function sql_replace($table, $couples, $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('replace', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $couples, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_replace_multi
function sql_replace_multi($table, $tab_couples, $desc=array(), $serveur='', $option=true)
{
$f = sql_serveur('replace_multi', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $tab_couples, $desc, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_drop_table
function sql_drop_table($table, $exist='', $serveur='', $option=true)
{
$f = sql_serveur('drop_table', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $exist, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// supprimer une vue sql
// http://doc.spip.org/@sql_drop_view
function sql_drop_view($table, $exist='', $serveur='', $option=true)
{
$f = sql_serveur('drop_view', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $exist, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_showbase
function sql_showbase($spip=NULL, $serveur='', $option=true)
{
if ($spip == NULL){
$connexion = $GLOBALS['connexions'][$serveur ? $serveur : 0];
$spip = $connexion['prefixe'] . '\_%';
}
$f = sql_serveur('showbase', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($spip, $serveur, $option!==false);
}
function sql_alltable($spip=NULL, $serveur='', $option=true)
{
$q = sql_showbase($spip, $serveur, $option);
$r = array();
if ($q) while ($t = sql_fetch($q, $serveur)) { $r[] = array_shift($t);}
return $r;
}
// http://doc.spip.org/@sql_showtable
function sql_showtable($table, $table_spip = false, $serveur='', $option=true)
{
if ($table_spip){
$connexion = $GLOBALS['connexions'][$serveur ? $serveur : 0];
$prefixe = $connexion['prefixe'];
$vraie_table = preg_replace('/^spip/', $prefixe, $table);
} else $vraie_table = $table;
$f = sql_serveur('showtable', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$f = $f($vraie_table, $serveur, $option!==false);
if (!$f) return array();
if (isset($GLOBALS['tables_principales'][$table]['join']))
$f['join'] = $GLOBALS['tables_principales'][$table]['join'];
elseif (isset($GLOBALS['tables_auxiliaires'][$table]['join']))
$f['join'] = $GLOBALS['tables_auxiliaires'][$table]['join'];
return $f;
}
// http://doc.spip.org/@sql_create
function sql_create($nom, $champs, $cles=array(), $autoinc=false, $temporary=false, $serveur='', $option=true) {
$f = sql_serveur('create', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($nom, $champs, $cles, $autoinc, $temporary, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
function sql_create_base($nom, $serveur='', $option=true)
{
$f = sql_serveur('create_base', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($nom, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// Fonction pour creer une vue
// nom : nom de la vue,
// select_query : une requete select, idealement cree avec $req = sql_select()
// (en mettant $option du sql_select a false pour recuperer la requete)
// http://doc.spip.org/@sql_create_view
function sql_create_view($nom, $select_query, $serveur='', $option=true) {
$f = sql_serveur('create_view', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($nom, $select_query, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_multi
function sql_multi($sel, $lang, $serveur='', $option=true)
{
$f = sql_serveur('multi', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($sel, $lang);
}
// http://doc.spip.org/@sql_error
function sql_error($serveur='') {
$f = sql_serveur('error', $serveur, 'continue');
if (!is_string($f) OR !$f) return false;
return $f('query inconnue', $serveur, $option!==false);
}
// http://doc.spip.org/@sql_errno
function sql_errno($serveur='') {
$f = sql_serveur('errno', $serveur, 'continue');
if (!is_string($f) OR !$f) return false;
return $f($serveur);
}
// http://doc.spip.org/@sql_explain
function sql_explain($q, $serveur='', $option=true) {
$f = sql_serveur('explain', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($q, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_optimize
function sql_optimize($table, $serveur='', $option=true) {
$f = sql_serveur('optimize', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// http://doc.spip.org/@sql_repair
function sql_repair($table, $serveur='', $option=true) {
$f = sql_serveur('repair', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($table, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
// Fonction la plus generale ... et la moins portable
// A n'utiliser qu'en derniere extremite
// http://doc.spip.org/@sql_query
function sql_query($ins, $serveur='', $option=true) {
$f = sql_serveur('query', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
$r = $f($ins, $serveur, $option!==false);
if ($r === false) spip_sql_erreur($serveur);
return $r;
}
# une composition tellement frequente...
// http://doc.spip.org/@sql_fetsel
function sql_fetsel($select = array(), $from = array(), $where = array(),
$groupby = array(), $orderby = array(), $limit = '',
$having = array(), $serveur='', $option=true) {
$q = sql_select($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, $option);
if ($option===false) return $q;
if (!$q) return array();
$r = sql_fetch($q, $serveur, $option);
sql_free($q, $serveur, $option);
return $r;
}
// Retourne le tableau de toutes les lignes d'une requete Select
// http://doc.spip.org/@sql_allfetsel
function sql_allfetsel($select = array(), $from = array(), $where = array(),
$groupby = array(), $orderby = array(), $limit = '',
$having = array(), $serveur='', $option=true) {
$q = sql_select($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, $option);
if ($option===false) return $q;
return sql_fetch_all($q, $serveur, $option);
}
# Retourne l'unique champ demande dans une requete Select a resultat unique
// http://doc.spip.org/@sql_getfetsel
function sql_getfetsel($select, $from = array(), $where = array(), $groupby = array(),
$orderby = array(), $limit = '', $having = array(), $serveur='', $option=true) {
if (preg_match('/\s+as\s+(\w+)$/i', $select, $c)) $id = $c[1];
elseif (!preg_match('/\W/', $select)) $id = $select;
else {$id = 'n'; $select .= ' AS n';}
$r = sql_fetsel($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur, $option);
if ($option===false) return $r;
if (!$r) return NULL;
return $r[$id];
}
// http://doc.spip.org/@sql_version
function sql_version($serveur='', $option=true) {
$row = sql_fetsel("version() AS n", '','','','','','',$serveur);
return ($row['n']);
}
// prend une chaine sur l'aphabet hexa
// et retourne sa representation numerique:
// FF ==> 0xFF en MySQL mais x'FF' en PG
// http://doc.spip.org/@sql_hex
function sql_hex($val, $serveur='', $option=true)
{
$f = sql_serveur('hex', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($val);
}
function sql_quote($val, $serveur='', $type='')
{
$f = sql_serveur('quote', $serveur, true);
if (!is_string($f) OR !$f) $f = '_q';
return $f($val, $type);
}
function sql_date_proche($champ, $interval, $unite, $serveur='', $option=true)
{
$f = sql_serveur('date_proche', $serveur, true);
if (!is_string($f) OR !$f) return false;
return $f($champ, $interval, $unite);
}
function sql_in($val, $valeurs, $not='', $serveur='', $option=true) {
if (is_array($valeurs)) {
$f = sql_serveur('quote', $serveur, true);
if (!is_string($f) OR !$f) return false;
$valeurs = join(',', array_map($f, array_unique($valeurs)));
} elseif ($valeurs[0]===',') $valeurs = substr($valeurs,1);
if (!strlen(trim($valeurs))) return ($not ? "0=0" : '0=1');
$f = sql_serveur('in', $serveur, $option==='continue' OR $option===false);
if (!is_string($f) OR !$f) return false;
return $f($val, $valeurs, $not, $serveur, $option!==false);
}
// Penser a dire dans la description du serveur
// s'il accepte les requetes imbriquees afin d'optimiser ca
// http://doc.spip.org/@sql_in_select
function sql_in_select($in, $select, $from = array(), $where = array(),
$groupby = array(), $orderby = array(), $limit = '', $having = array(), $serveur='')
{
$liste = array();
$res = sql_select($select, $from, $where, $groupby, $orderby, $limit, $having, $serveur);
while ($r = sql_fetch($res)) {$liste[] = array_shift($r);}
sql_free($res);
return sql_in($in, $liste);
}
/**
* Implementation securisee du saut en avant,
* qui ne depend pas de la disponibilite de la fonction sql_seek
* ne fait rien pour une valeur negative ou nulle de $saut
* retourne la position apres le saut
*
* @param resource $res
* @param int $pos
* position courante
* @param int $saut
* saut demande
* @param int $count
* position maximale
* (nombre de resultat de la requete OU position qu'on ne veut pas depasser)
* @param <type> $serveur
* @param <type> $option
* @return int
*/
function sql_skip($res, $pos, $saut, $count, $serveur='', $option=true){
// pas de saut en arriere qu'on ne sait pas faire sans sql_seek
if (($saut=intval($saut))<=0) return $pos;
$seek = $pos + $saut;
// si le saut fait depasser le maxi, on libere la resource
// et on sort
if ($seek>=$count) {sql_free($res, $serveur, $option); return $count;}
if (sql_seek($res, $seek))
$pos = $seek;
else
while ($pos<$seek AND sql_fetch($res, $serveur, $option))
$pos++;
return $pos;
}
// http://doc.spip.org/@sql_test_int
function sql_test_int($type, $serveur='', $option=true)
{
return preg_match('/^(TINYINT|SMALLINT|MEDIUMINT|INT|INTEGER|BIGINT)/i',trim($type));
}
// http://doc.spip.org/@sql_test_date
function sql_test_date($type, $serveur='', $option=true)
{
return preg_match('/^(DATE|DATETIME|TIMESTAMP|TIME)/i',trim($type));
}
// Cette fonction devrait disparaitre
// http://doc.spip.org/@description_table
function description_table($nom){
global $tables_principales, $tables_auxiliaires;
static $f;
include_spip('base/serial');
if (isset($tables_principales[$nom]))
return $tables_principales[$nom];
include_spip('base/auxiliaires');
if (isset($tables_auxiliaires[$nom]))
return $tables_auxiliaires[$nom];
if (!$trouver_table) $trouver_table = charger_fonction('trouver_table', 'base');
return $trouver_table($nom);
}
if(!function_exists("ctype_xdigit")){
function ctype_xdigit($string = ""){
return !strlen( trim( $string, "1234567890abcdefABCDEF" ) );
}/* endfunction ctype_xdigit */
}/* endif not function_exists ctype_xdigit */
?>
ecrire/base/auxiliaires.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@base_auxiliaires
function base_auxiliaires(&$tables_auxiliaires){
$spip_resultats = array(
"recherche" => "char(16) DEFAULT '' NOT NULL",
"id" => "INT UNSIGNED NOT NULL",
"points" => "INT UNSIGNED DEFAULT '0' NOT NULL",
"maj" => "TIMESTAMP" );
$spip_resultats_key = array(
// pas de cle ni index, ca fait des insertions plus rapides et les requetes jointes utilisees en recheche ne sont pas plus lentes ...
);
$spip_auteurs_liens = array(
"id_auteur" => "bigint(21) DEFAULT '0' NOT NULL",
"id_objet" => "bigint(21) DEFAULT '0' NOT NULL",
"objet" => "VARCHAR (25) DEFAULT '' NOT NULL",
"vu" => "ENUM('non', 'oui') DEFAULT 'non' NOT NULL");
$spip_auteurs_liens_key = array(
"PRIMARY KEY" => "id_auteur,id_objet,objet",
"KEY id_auteur" => "id_auteur");
/*
$spip_auteurs_articles = array(
"id_auteur" => "bigint(21) DEFAULT '0' NOT NULL",
"id_article" => "bigint(21) DEFAULT '0' NOT NULL");
$spip_auteurs_articles_key = array(
"PRIMARY KEY" => "id_auteur, id_article",
"KEY id_article" => "id_article");
$spip_auteurs_rubriques = array(
"id_auteur" => "bigint(21) DEFAULT '0' NOT NULL",
"id_rubrique" => "bigint(21) DEFAULT '0' NOT NULL");
$spip_auteurs_rubriques_key = array(
"PRIMARY KEY" => "id_auteur, id_rubrique",
"KEY id_rubrique" => "id_rubrique");
$spip_auteurs_messages = array(
"id_auteur" => "bigint(21) DEFAULT '0' NOT NULL",
"id_message" => "bigint(21) DEFAULT '0' NOT NULL",
"vu" => "CHAR (3)");
$spip_auteurs_messages_key = array(
"PRIMARY KEY" => "id_auteur, id_message",
"KEY id_message" => "id_message");
*/
$spip_documents_liens = array(
"id_document" => "bigint(21) DEFAULT '0' NOT NULL",
"id_objet" => "bigint(21) DEFAULT '0' NOT NULL",
"objet" => "VARCHAR (25) DEFAULT '' NOT NULL",
"vu" => "ENUM('non', 'oui') DEFAULT 'non' NOT NULL");
$spip_documents_liens_key = array(
"PRIMARY KEY" => "id_document,id_objet,objet",
"KEY id_document" => "id_document");
$spip_meta = array(
"nom" => "VARCHAR (255) NOT NULL",
"valeur" => "text DEFAULT ''",
"impt" => "ENUM('non', 'oui') DEFAULT 'oui' NOT NULL",
"maj" => "TIMESTAMP");
$spip_meta_key = array(
"PRIMARY KEY" => "nom");
/*
$tables_auxiliaires['spip_auteurs_articles'] = array(
'field' => &$spip_auteurs_articles,
'key' => &$spip_auteurs_articles_key);
$tables_auxiliaires['spip_auteurs_rubriques'] = array(
'field' => &$spip_auteurs_rubriques,
'key' => &$spip_auteurs_rubriques_key);
$tables_auxiliaires['spip_auteurs_messages'] = array(
'field' => &$spip_auteurs_messages,
'key' => &$spip_auteurs_messages_key);
*/
$tables_auxiliaires['spip_auteurs_liens'] = array(
'field' => &$spip_auteurs_liens,
'key' => &$spip_auteurs_liens_key);
$tables_auxiliaires['spip_documents_liens'] = array(
'field' => &$spip_documents_liens,
'key' => &$spip_documents_liens_key);
$tables_auxiliaires['spip_meta'] = array(
'field' => &$spip_meta,
'key' => &$spip_meta_key);
$tables_auxiliaires['spip_resultats'] = array(
'field' => &$spip_resultats,
'key' => &$spip_resultats_key);
$tables_auxiliaires = pipeline('declarer_tables_auxiliaires',$tables_auxiliaires);
}
global $tables_auxiliaires;
base_auxiliaires($tables_auxiliaires);
?>
ecrire/base/connect_sql.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
//
// Utilitaires indispensables autour des serveurs SQL
//
// API d'appel aux bases de donnees:
// on charge le fichier config/$serveur ($serveur='connect' pour le principal)
// qui est cense initaliser la connexion en appelant spip_connect_db
// laquelle met dans la globale db_ok la description de la connexion
// On la memorise dans un tableau pour permettre plusieurs serveurs.
// A l'installation, il faut simuler l'existence de ce fichier
// http://doc.spip.org/@spip_connect
function spip_connect($serveur='', $version='') {
global $connexions, $spip_sql_version;
$serveur = !is_string($serveur) ? '' : strtolower($serveur);
$index = $serveur ? $serveur : 0;
if (!$version) $version = $spip_sql_version;
if (isset($connexions[$index][$version])) return $connexions[$index];
include_spip('base/abstract_sql');
$install = (_request('exec') == 'install');
// Premiere connexion ?
if (!($old = isset($connexions[$index]))) {
$f = (!preg_match('/^[\w\.]*$/', $serveur))
? '' // nom de serveur mal ecrit
: ($serveur ?
( _DIR_CONNECT. $serveur . '.php') // serveur externe
: (_FILE_CONNECT ? _FILE_CONNECT // serveur principal ok
: ($install ? _FILE_CONNECT_TMP // init du serveur principal
: ''))); // installation pas faite
unset($GLOBALS['db_ok']);
unset($GLOBALS['spip_connect_version']);
if ($f) {
if (is_readable($f)) {
include($f);
} elseif ($serveur AND !$install) {
// chercher une declaration de serveur dans le path
// qui pourra un jour servir a declarer des bases sqlite
// par des plugins. Et sert aussi aux boucles POUR.
find_in_path("$serveur.php",'connect/',true);
}
}
if (!isset($GLOBALS['db_ok'])) {
// fera mieux la prochaine fois
if ($install) return false;
spip_log("spip_connect: serveur $index mal defini dans '$f'.");
// ne plus reessayer si ce n'est pas l'install
return $connexions[$index]=false;
}
$connexions[$index] = $GLOBALS['db_ok'];
}
// si la connexion a deja ete tentee mais a echoue, le dire!
if (!$connexions[$index]) return false;
// la connexion a reussi ou etait deja faite.
// chargement de la version du jeu de fonctions
// si pas dans le fichier par defaut
$type = $GLOBALS['db_ok']['type'];
$jeu = 'spip_' . $type .'_functions_' . $version;
if (!isset($GLOBALS[$jeu])) {
if (!find_in_path($type . '_' . $version . '.php', 'req/', true)){
spip_log("spip_connect: serveur $index version '$version' non defini pour '$type'");
// ne plus reessayer
return $connexions[$index][$version] = array();
}
}
$connexions[$index][$version] = $GLOBALS[$jeu];
if ($old) return $connexions[$index];
$connexions[$index]['spip_connect_version'] = isset($GLOBALS['spip_connect_version']) ? $GLOBALS['spip_connect_version'] : 0;
// initialisation de l'alphabet utilise dans les connexions SQL
// si l'installation l'a determine.
// Celui du serveur principal l'impose aux serveurs secondaires
// s'ils le connaissent
if (!$serveur) {
$charset = spip_connect_main($GLOBALS[$jeu]);
if (!$charset) {
unset($connexions[$index]);
spip_log("spip_connect: absence de charset");
return false;
}
} else {
if ($connexions[$index]['spip_connect_version']
AND $r = sql_getfetsel('valeur', 'spip_meta', "nom='charset_sql_connexion'",'','','','',$serveur))
$charset = $r;
else $charset = -1;
}
if ($charset != -1) {
$f = $GLOBALS[$jeu]['set_charset'];
if (function_exists($f))
$f($charset, $serveur);
}
return $connexions[$index];
}
function spip_sql_erreur($serveur='')
{
$connexion = spip_connect($serveur);
$e = sql_errno($serveur);
$t = (isset($connexion['type']) ? $connexion['type'] : 'sql');
$m = "Erreur $e de $t: " . sql_error($serveur) . "\n" . $connexion['last'];
$f = $t . $serveur;
spip_log($m, $f);
}
// Cette fonction ne doit etre appelee qu'a travers la fonction sql_serveur
// definie dans base/abstract_sql
// Elle existe en tant que gestionnaire de versions,
// connue seulement des convertisseurs automatiques
// http://doc.spip.org/@spip_connect_sql
function spip_connect_sql($version, $ins='', $serveur='', $cont=false) {
$desc = spip_connect($serveur, $version);
if (function_exists($f = @$desc[$version][$ins])) return $f;
if ($cont) return $desc;
if ($ins)
spip_log("Le serveur '$serveur' version $version n'a pas '$ins'");
include_spip('inc/minipres');
echo minipres(_T('info_travaux_titre'), _T('titre_probleme_technique'));
exit;
}
// Fonction appelee par le fichier cree dans config/ a l'instal'.
// Il contient un appel direct a cette fonction avec comme arguments
// les identifants de connexion.
// Si la connexion reussit, la globale db_ok memorise sa description.
// C'est un tableau egalement retourne en valeur, pour les appels a l'install'
// http://doc.spip.org/@spip_connect_db
function spip_connect_db($host, $port, $login, $pass, $db='', $type='mysql', $prefixe='', $auth='') {
global $db_ok;
## TODO : mieux differencier les serveurs
$f = _DIR_TMP . $type . 'out';
if (@file_exists($f)
AND (time() - @filemtime($f) < 30)
AND !defined('_ECRIRE_INSTALL')) {
return;
}
if (!$prefixe)
$prefixe = isset($GLOBALS['table_prefix'])
? $GLOBALS['table_prefix'] : $db;
$h = charger_fonction($type, 'req', true);
if (!$h) {
spip_log("les requetes $type ne sont pas fournies");
return;
}
if ($g = $h($host, $port, $login, $pass, $db, $prefixe)) {
if (!is_array($auth)) {
// compatibilite version 0.7 initiale
$g['ldap'] = $auth;
$auth = array('ldap' => $auth);
}
$g['authentification'] = $auth;
$g['type'] = $type;
return $db_ok = $g;
}
// En cas d'indisponibilite du serveur, eviter de le bombarder
if (!defined('_ECRIRE_INSTALL')) {
@touch($f);
$err = "Echec connexion $host $port $login $db";
spip_log($err);
spip_log($err, $type);
}
}
// Premiere connexion au serveur principal:
// retourner le charset donnee par la table principale
// mais verifier que le fichier de connexion n'est pas trop vieux
// Version courante = 0.7
// La version 0.7 indique un serveur d'authentification comme 8e arg
// La version 0.6 indique le prefixe comme 7e arg
// La version 0.5 indique le serveur comme 6e arg
//
// La version 0.0 (non numerotee) doit etre refaite par un admin
// les autres fonctionnent toujours, meme si :
// - la version 0.1 est moins performante que la 0.2
// - la 0.2 fait un include_ecrire('inc_db_mysql.php3').
// http://doc.spip.org/@spip_connect_main
function spip_connect_main($connexion)
{
if ($GLOBALS['spip_connect_version']< 0.1 AND _DIR_RESTREINT){
include_spip('inc/headers');
redirige_url_ecrire('upgrade', 'reinstall=oui');
}
if (!($f = $connexion['select'])) return false;
if (!$r = $f('valeur','spip_meta', "nom='charset_sql_connexion'"))
return false;
if (!($f = $connexion['fetch'])) return false;
$r = $f($r);
return ($r['valeur'] ? $r['valeur'] : -1);
}
// compatibilite
function spip_connect_ldap($serveur='') {
include_spip('auth/ldap');
return auth_ldap_connect($serveur);
}
// Echappement d'une valeur (num, string, array) sous forme de chaine PHP
// pour un array(1,'a',"a'") renvoie la chaine "'1','a','a\''"
// Usage sql un peu deprecie, a remplacer par sql_quote()
// http://doc.spip.org/@_q
function _q ($a) {
return (is_numeric($a)) ? strval($a) :
(!is_array($a) ? ("'" . addslashes($a) . "'")
: join(",", array_map('_q', $a)));
}
// Nommage bizarre des tables d'objets
// http://doc.spip.org/@table_objet
function table_objet($type,$serveur='') {
static $surnoms = null;
$type = preg_replace(',^spip_|^id_|s$,', '', $type);
if (!$type) return;
if (!$surnoms){
// passer dans un pipeline qui permet aux plugins de declarer leurs exceptions
$surnoms = pipeline('declarer_tables_objets_surnoms',
array(
'doc' => 'documents', # pour les modeles
'img' => 'documents',
'emb' => 'documents',
'type_document' => 'types_documents', # hum
'extension' => 'types_documents' # hum
));
}
if (isset($surnoms[$type]))
return $surnoms[$type];
$trouver_table = charger_fonction('trouver_table', 'base');
if ($desc = $trouver_table(rtrim($type,'s')."s",$serveur))
return $desc['id_table'];
elseif ($desc = $trouver_table($type,$serveur))
return $desc['id_table'];
spip_log('table_objet('.$type.') calculee sans verification');
return rtrim($type,'s')."s"; # cas historique ne devant plus servir
}
// http://doc.spip.org/@table_objet_sql
function table_objet_sql($type,$serveur='') {
global $table_des_tables;
$nom = table_objet($type, $serveur);
include_spip('public/interfaces');
if (isset($table_des_tables[$nom])) {
$t = $table_des_tables[$nom];
$nom = 'spip_' . $t;
}
return $nom ;
}
// http://doc.spip.org/@id_table_objet
function id_table_objet($type,$serveur='') {
$type = objet_type($type,$serveur);
if ($type == 'type')
return 'extension';
else {
if (!$type) return;
$t = table_objet($type);
$trouver_table = charger_fonction('trouver_table', 'base');
$desc = $trouver_table($t,$serveur);
return @$desc['key']["PRIMARY KEY"];
}
}
// http://doc.spip.org/@objet_type
function objet_type($table_objet){
static $surnoms = null;
if (!$table_objet) return;
if (!$surnoms)
// passer dans un pipeline qui permet aux plugins de declarer leurs exceptions
$surnoms = pipeline('declarer_type_surnoms', array('racine-site'=>'site'));
// scenario de base
// le type est decline a partir du nom de la table en enlevant le prefixe eventuel
// et la marque du pluriel
// on accepte id_xx en entree aussi
$type = preg_replace(',^spip_|^id_|s$,', '', $table_objet);
if (isset($surnoms[$type]))
return $surnoms[$type];
// securite : eliminer les caracteres non \w
$type = preg_replace(',[^\w-],','',$type);
// si le type redonne bien la table c'est bon
// oui si table_objet ressemblait deja a un type
if ( $type==$table_objet
OR (table_objet($type)==$table_objet)
OR (table_objet_sql($type)==$table_objet))
return $type;
// sinon on passe par la cle primaire id_xx pour trouver le type
// car le s a la fin est incertain
// notamment en cas de pluriel derogatoire
// id_jeu/spip_jeux id_journal/spip_journaux qui necessitent tout deux
// une declaration jeu => jeux, journal => journaux
// dans le pipeline declarer_tables_objets_surnoms
$trouver_table = charger_fonction('trouver_table', 'base');
if (
($desc = $trouver_table($table_objet)
OR $desc = $trouver_table(table_objet($type)))
AND isset($desc['key']["PRIMARY KEY"])){
$primary = $desc['key']["PRIMARY KEY"];
$primary = explode(',',$primary);
$primary = reset($primary);
$type = preg_replace(',^id_,', '', $primary);
$type = preg_replace(',^spip_|^id_|s$,', '', table_objet($type));
}
if (isset($surnoms[$type]))
$type = $surnoms[$type];
// on a fait ce qu'on a pu
return $type;
}
// Recuperer le nom de la table de jointure xxxx sur l'objet yyyy
// http://doc.spip.org/@table_jointure
function table_jointure($x, $y) {
$trouver_table = charger_fonction('trouver_table', 'base');
$xdesc = $trouver_table(table_objet($x));
$ydesc = $trouver_table(table_objet($y));
$tx = $xdesc['table'];
$ty = $ydesc['table'];
$ix = @$xdesc['key']["PRIMARY KEY"];
$iy = @$ydesc['key']["PRIMARY KEY"];
if ($table = $GLOBALS['tables_jointures'][$ty][$ix]) return $table;
if ($table = $GLOBALS['tables_jointures'][$tx][$iy]) return $table;
return '';
}
// Pour compatibilite. Ne plus utiliser.
// http://doc.spip.org/@spip_query
function spip_query($query, $serveur='') {
global $spip_sql_version;
$f = spip_connect_sql($spip_sql_version, 'query', $serveur, true);
return function_exists($f) ? $f($query, $serveur) : false;
}
?>
ecrire/base/convert_sql_utf8.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@base_convert_sql_utf8_dist
function base_convert_sql_utf8_dist($titre='', $reprise=false)
{
if (!$titre) return; // anti-testeur automatique
ecrire_meta('convert_sql_utf8','oui','non');
echo install_debut_html($titre);
echo "<p>", _T('utf8_convert_timeout'), "</p><hr />\n";
convert_sql_utf8($titre);
echo "<p><b>"._T('utf8_convert_termine')."</b></p>";
effacer_meta('convert_sql_utf8');
// bouton "retour au site" + redirige_par_entete
echo "<p style='text-align: right'>",
"<a href='", generer_url_ecrire("config_lang"), "'> &gt;&gt; ",
_T('icone_retour'),"</a></p>",
install_fin_html();
}
// http://doc.spip.org/@convert_sql_utf8
function convert_sql_utf8($titre){
define(_DEBUG_CONVERT, false);
$charset_spip = $GLOBALS['meta']['charset'];
$charset_supporte = false;
$utf8_supporte = false;
// verifier que mysql gere le charset courant pour effectuer les conversions
if ($c = sql_get_charset($charset_spip)){
$sql_charset = $c['charset'];
$sql_collation = $c['collation'];
$charset_supporte = true;
}
if (!$charset_supporte){
$res = spip_query("SHOW CHARACTER SET");
while ($row = sql_fetch($res)){
if ($row['Charset']=='utf8') $utf8_supporte = true;
}
echo install_debut_html($titre);
echo _L("Le charset SPIP actuel $charset_spip n'est pas supporte par votre serveur MySQL<br/>"); # non traduit car complexe & obsolete
if ($utf8_supporte)
echo _L("Votre serveur supporte utf-8, vous devriez convertir votre site en utf-8 avant de recommencer cette operation");
echo install_fin_html();
} else {
echo _L("Charset Actuel du site SPIP : $charset_spip<br/>");
echo _L("Conversion des champs des tables spip de type latin1 vers <b>$sql_charset</b> (collation $sql_collation) <br/>");
// lister les collations et leur charset correspondant
$res = spip_query("SHOW COLLATION");
$charset2collations = array();
while ($row = sql_fetch($res)){
$charset2collations[$row['Collation']] = $row['Charset'];
}
$count = 0;
// lister les tables spip
include_spip('base/serial');
include_spip('base/auxiliaires');
$res = spip_query("SHOW TABLES");
while (($row = sql_fetch($res)) /*&& ($count<1)*/){
$nom = array_shift($row);
if (preg_match(',^'.$GLOBALS['table_prefix'].'_(.*)$,',$nom,$regs)){
$count++;
$nom = $regs[1];
echo "<hr /><h2>$nom</h2>";
// lister les champs de la table
$res2 = spip_query("SHOW FULL COLUMNS FROM spip_$nom");
while ($row2 = sql_fetch($res2)){
$collation = $row2['Collation'];
$champ = $row2['Field'];
if ($collation!="NULL"
&& isset($charset2collations[$collation])
&& $charset2collations[$collation]=='latin1'){
echo "Conversion de '$champ' depuis $collation (".$charset2collations[$collation]."):";
// conversion de latin1 vers le charset reel du contenu
$type_texte= $row2['Type'];
$type_blob = "blob";
if (strpos($type_texte,"text")!==FALSE)
$type_blob = str_replace("text","blob",$type_texte);
// sauf si blob expressement demande dans la description !
if ((
$a = $GLOBALS['tables_principales']['spip_'.$nom]['field'][$champ]
OR $a = $GLOBALS['tables_auxiliaires']['spip_'.$nom]['field'][$champ]
) AND preg_match(',blob,i', $a)) {
echo "On ignore le champ blob $nom.$champ <hr />\n";
} else {
$default = $row2['Default']?(" DEFAULT ".sql_quote($row2['Default'])):"";
$notnull = ($row2['Null']=='YES')?"":" NOT NULL";
$q = "ALTER TABLE spip_$nom CHANGE $champ $champ $type_blob $default $notnull";
if (!_DEBUG_CONVERT)
$b = spip_query($q);
echo "<pre>$q</pre>$b\n";
$q = "ALTER TABLE spip_$nom CHANGE $champ $champ $type_texte CHARACTER SET $sql_charset COLLATE $sql_collation $default $notnull";
if (!_DEBUG_CONVERT)
$b = spip_query($q);
echo "<pre>$q</pre>\n";
}
}
}
// on ne change le charset par defaut de la table que quand tous ses champs sont convertis
$q = "ALTER TABLE spip_$nom DEFAULT CHARACTER SET $sql_charset COLLATE $sql_collation";
if (!_DEBUG_CONVERT)
$b = spip_query($q);
echo "<pre>$q</pre>$b\n";
}
}
ecrire_meta('charset_sql_base',$sql_charset,'non');
ecrire_meta('charset_sql_connexion',$sql_charset,'non');
}
}
?>
ecrire/base/convert_utf8.php supprimé 100644 → 0
Voir le fichier @ 2cd2abaf
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@convert_utf8_init
function convert_utf8_init($tables_a_convertir)
{
// noter dans les meta qu'on veut convertir, et quoi
$charset_source = $GLOBALS['meta']['charset'];
ecrire_meta('charset', 'utf-8');
foreach ($tables_a_convertir as $table => $champ) {
spip_log("demande update charset table $table ($champ)");
spip_query("UPDATE $table SET $champ = CONCAT('<CONVERT ".$charset_source.">', $champ) WHERE $champ NOT LIKE '<CONVERT %'");
}
spip_unlink(_DIR_TMP.'convert_utf8_backup.sql');
// convertir spip_meta
foreach ($GLOBALS['meta'] as $c => $v) {
$v2 = unicode_to_utf_8(charset2unicode($v, $charset_source));
if ($v2 != $v) ecrire_meta($c, $v2);
}
}
// http://doc.spip.org/@base_convert_utf8_dist
function base_convert_utf8_dist($titre='', $reprise=false)
{
if (!$titre) return; // anti-testeur automatique
// une liste des tables a convertir, avec le champ dans lequel on
// indique '<CONVERT charset>' ; on commence par les rubriques sinon
// ca fait desordre dans l'interface privee
$tables_a_convertir = array(
'spip_rubriques' => 'titre',
'spip_auteurs' => 'nom',
'spip_articles' => 'titre',
'spip_breves' => 'titre',
'spip_documents' => 'titre',
'spip_forum' => 'titre',
'spip_mots' => 'titre',
'spip_groupes_mots' => 'titre',
'spip_petitions' => 'texte',
'spip_signatures' => 'nom_email',
'spip_syndic' => 'nom_site',
'spip_syndic_articles' => 'titre',
'spip_messages' => 'titre'
);
if (!$reprise) convert_utf8_init($tables_a_convertir);
echo install_debut_html($titre);
echo "<p>", _T('utf8_convert_timeout'), "</p><hr />\n";
// preparer un fichier de sauvegarde au cas ou
// on met 'a' car ca peut demander plusieurs rechargements
$f = @fopen(_DIR_TMP.'convert_utf8_backup.sql', 'a');
foreach ($tables_a_convertir as $table => $champ) {
convert_table_utf8($f, $table, $champ);
}
if ($f) fclose($f);
echo "<p><b>"._T('utf8_convert_termine')."</b></p>";
echo "<p>,"._T('utf8_convert_verifier', array('rep' => joli_repertoire(_DIR_TMP))), '</p>';
// bouton "retour au site" + redirige_par_entete
echo "<p style='text-align: right'>",
"<a href='", generer_url_ecrire("config_lang"), "'> &gt;&gt; ",
_T('icone_retour'),"</a></p>",
install_fin_html();
}
// http://doc.spip.org/@convert_table_utf8
function convert_table_utf8($f, $table, $champ)
{
echo "<br /><b>$table</b> &nbsp; ";
$s = spip_query("SELECT * FROM $table WHERE $champ LIKE '<CONVERT %'");
// recuperer 'id_article' (encore un truc a faire dans table_objet)
preg_match(',^spip_(.*?)s?$,', $table, $r);
$id_champ = 'id_'.$r[1];
if ($table == 'spip_petitions') $id_champ = 'id_article';
if ($table == 'spip_groupes_mots') $id_champ = 'id_groupe';
// lire les donnees dans un array
while ($t = sql_fetch($s)) {
$query = array();
$query_no_convert = '';
$query_extra = '';
$charset_source='AUTO';
foreach ($t as $c => $v) {
if ($c == $champ) {
preg_match(',^<CONVERT (.*?)>,', $v, $reg);
$v = substr($v, strlen($reg[0]));
$charset_source = $reg[1];
$query[] = "$c=" . sql_quote($v);
} else {
if (!is_numeric($v)
AND !is_ascii($v)) {
// traitement special car donnees serializees
if ($c == 'extra') {
$query_no_convert .= ", $c=".sql_quote($v);
$query_extra = convert_extra($v, $charset_source);
} else
$query[] = "$c=" . sql_quote($v);
} else
# pour le backup
$query_no_convert .= ", $c=".sql_quote($v);
}
}
$set = join(', ', $query);
$where = "$id_champ = ".$t[$id_champ];
// On l'enregistre telle quelle sur le fichier de sauvegarde
if ($f) fwrite($f,
"UPDATE $table SET $set$query_no_convert"
." WHERE $where;\n"
);
// Mais on la transcode
// en evitant une double conversion
if ($charset_source != 'utf-8') {
$query = "UPDATE $table SET "
. unicode_to_utf_8(charset2unicode($set, $charset_source))
. $query_extra
. " WHERE $where AND $champ LIKE '<CONVERT %'";
#echo $query;
spip_query($query);
echo '. '; flush();
}
}
sql_free($s);
}
// stocker le nouvel extra
// http://doc.spip.org/@convert_extra
function convert_extra($v, $charset_source) {
if ($extra = @unserialize($v)) {
foreach ($extra as $key=>$val)
$extra[$key] = unicode_to_utf_8(
charset2unicode($val, $charset_source));
return ", extra=".sql_quote(serialize($extra));
}
}
?>

Forge communautaire SPIP | Charte d'utilisation | Signaler un problème sur ce site