function accesrestreint_pre_boucle(&$boucle)
{
if (!isset($boucle->modificateur['tout_voir'])) {
$securise = false;
switch ($boucle->type_requete) {
case 'hierarchie':
case 'articles':
case 'breves':
case 'syndication':
$t = $boucle->id_table . '.id_rubrique';
$boucle->select = array_merge($boucle->select, array($t));
// pour postgres
$boucle->where[] = accesrestreint_rubriques_accessibles_where($t);
$securise = true;
break;
case 'evenements':
case 'petitions':
$t = $boucle->id_table . '.id_article';
$boucle->select = array_merge($boucle->select, array($t));
$boucle->where[] = accesrestreint_articles_accessibles_where($t);
$securise = true;
break;
case 'signatures':
// ajouter une jointure sur petitions si besoin
$t = array_search("spip_petitions", $boucle->from);
if (!$t) {
$t = trouver_jointure_champ("id_petition", $boucle);
}
$t = $t . '.id_article';
$boucle->select = array_merge($boucle->select, array($t));
$boucle->where[] = accesrestreint_articles_accessibles_where($t);
$securise = true;
break;
default:
if (function_exists($accessible_where = "accesrestreint_" . $boucle->type_requete . "_accessibles_where")) {
$t = $boucle->id_table . '.' . $boucle->primary;
$boucle->select = array_merge($boucle->select, array($t));
$boucle->where[] = $accessible_where($t);
$securise = true;
}
break;
}
if ($securise) {
$boucle->hash .= "if (!defined('_DIR_PLUGIN_ACCESRESTREINT')){\n\t\t\t\$link_empty = generer_url_ecrire('admin_vider'); \$link_plugin = generer_url_ecrire('admin_plugin');\n\t\t\t\$message_fr = 'La restriction d\\'accès a ete desactivée. <a href=\"'.\$link_plugin.'\">Corriger le problème</a> ou <a href=\"'.\$link_empty.'\">vider le cache</a> pour supprimer les restrictions.';\n\t\t\t\$message_en = 'Acces Restriction is now unusable. <a href=\"'.\$link_plugin.'\">Correct this trouble</a> or <a href=\"'.generer_url_ecrire('admin_vider').'\">empty the cache</a> to finish restriction removal.';\n\t\t\tdie(\$message_fr.'<br />'.\$message_en);\n\t\t\t}";
}
}
return $boucle;
}
/**
* Décrit un critère non déclaré explicitement
*
* Décrit un critère non déclaré comme {id_article} {id_article>3} en
* retournant un tableau de l'analyse si la colonne (ou l'alias) existe vraiment.
*
* Ajoute au passage pour chaque colonne utilisée (alias et colonne véritable)
* un modificateur['criteres'][colonne].
*
* S'occupe de rechercher des exceptions, tel que
* - les id_parent, id_enfant, id_secteur,
* - des colonnes avec des exceptions déclarées,
* - des critères de date (jour_relatif, ...),
* - des critères sur tables jointes explicites (mots.titre),
* - des critères sur tables de jointure non explicite (id_mot sur une boucle articles...)
*
*
* @param string $idb Identifiant de la boucle
* @param array $boucles AST du squelette
* @param Critere $crit Paramètres du critère dans cette boucle
* @return array|string
* Liste si on trouve le champ :
* - string $arg
* Opérande avant l'opérateur : souvent la colonne d'application du critère, parfois un calcul
* plus complexe dans le cas des dates.
* - string $op
* L'opérateur utilisé, tel que '='
* - string[] $val
* Liste de codes PHP obtenant les valeurs des comparaisons (ex: id_article sur la boucle parente)
* Souvent (toujours ?) un tableau d'un seul élément.
* - $col_alias
* - $where_complement
*
* Chaîne vide si on ne trouve pas le champ...
**/
function calculer_critere_infixe($idb, &$boucles, $crit)
{
global $table_criteres_infixes;
global $exceptions_des_jointures, $exceptions_des_tables;
$boucle =& $boucles[$idb];
$type = $boucle->type_requete;
$table = $boucle->id_table;
$desc = $boucle->show;
$col_vraie = null;
list($fct, $col, $op, $val, $args_sql) = calculer_critere_infixe_ops($idb, $boucles, $crit);
$col_alias = $col;
$where_complement = false;
// Cas particulier : id_enfant => utiliser la colonne id_objet
if ($col == 'id_enfant') {
$col = $boucle->primary;
}
// Cas particulier : id_parent => verifier les exceptions de tables
if (in_array($col, array('id_parent', 'id_secteur')) and isset($exceptions_des_tables[$table][$col]) or isset($exceptions_des_tables[$table][$col]) and is_string($exceptions_des_tables[$table][$col])) {
$col = $exceptions_des_tables[$table][$col];
} else {
if ($col == 'id_secteur' and $critere_secteur = charger_fonction("critere_secteur_{$type}", "public", true)) {
$table = $critere_secteur($idb, $boucles, $val, $crit);
} else {
if (!isset($exceptions_des_jointures[table_objet_sql($table)][$col]) and !isset($exceptions_des_jointures[$col]) and count(trouver_champs_decomposes($col, $desc)) > 1) {
$e = decompose_champ_id_objet($col);
$col = array_shift($e);
$where_complement = primary_doublee($e, $table);
} else {
if ($c = calculer_critere_infixe_date($idb, $boucles, $col)) {
list($col, $col_vraie) = $c;
$table = '';
} else {
if (preg_match('/^(.*)\\.(.*)$/', $col, $r)) {
list(, $table, $col) = $r;
$col_alias = $col;
$trouver_table = charger_fonction('trouver_table', 'base');
if ($desc = $trouver_table($table, $boucle->sql_serveur) and isset($desc['field'][$col]) and $cle = array_search($desc['table'], $boucle->from)) {
$table = $cle;
} else {
$table = trouver_jointure_champ($col, $boucle, array($table), $crit->cond or $op != '=');
}
#$table = calculer_critere_externe_init($boucle, array($table), $col, $desc, ($crit->cond OR $op!='='), true);
if (!$table) {
return '';
}
} elseif (@(!array_key_exists($col, $desc['field'])) and @(!array_key_exists('*', $desc['field']))) {
$r = calculer_critere_infixe_externe($boucle, $crit, $op, $desc, $col, $col_alias, $table);
if (!$r) {
return '';
}
list($col, $col_alias, $table, $where_complement, $desc) = $r;
}
}
}
}
}
$col_vraie = $col_vraie ? $col_vraie : $col;
// Dans tous les cas,
// virer les guillemets eventuels autour d'un int (qui sont refuses par certains SQL)
// et passer dans sql_quote avec le type si connu
// et int sinon si la valeur est numerique
// sinon introduire le vrai type du champ si connu dans le sql_quote (ou int NOT NULL sinon)
// Ne pas utiliser intval, PHP tronquant les Bigint de SQL
if ($op == '=' or in_array($op, $table_criteres_infixes)) {
// defaire le quote des int et les passer dans sql_quote avec le bon type de champ si on le connait, int sinon
// prendre en compte le debug ou la valeur arrive avec un commentaire PHP en debut
if (preg_match(",^\\A(\\s*//.*?\$\\s*)?\"'(-?\\d+)'\"\\z,ms", $val[0], $r)) {
$val[0] = $r[1] . '"' . sql_quote($r[2], $boucle->sql_serveur, isset($desc['field'][$col_vraie]) ? $desc['field'][$col_vraie] : 'int NOT NULL') . '"';
} elseif (preg_match('/\\Asql_quote[(](.*?)(,[^)]*?)?(,[^)]*(?:\\(\\d+\\)[^)]*)?)?[)]\\s*\\z/ms', $val[0], $r) and (!isset($r[3]) or !$r[3])) {
$r = $r[1] . ((isset($r[2]) and $r[2]) ? $r[2] : ",''") . ",'" . (isset($desc['field'][$col_vraie]) ? addslashes($desc['field'][$col_vraie]) : 'int NOT NULL') . "'";
$val[0] = "sql_quote({$r})";
}
}
// Indicateur pour permettre aux fonctionx boucle_X de modifier
// leurs requetes par defaut, notamment le champ statut
// Ne pas confondre champs de la table principale et des jointures
if ($table === $boucle->id_table) {
$boucles[$idb]->modificateur['criteres'][$col_vraie] = true;
if ($col_alias != $col_vraie) {
$boucles[$idb]->modificateur['criteres'][$col_alias] = true;
}
}
// ajout pour le cas special d'une condition sur le champ statut:
// il faut alors interdire a la fonction de boucle
// de mettre ses propres criteres de statut
// http://www.spip.net/@statut (a documenter)
// garde pour compatibilite avec code des plugins anterieurs, mais redondant avec la ligne precedente
if ($col == 'statut') {
$boucles[$idb]->statut = true;
}
// inserer le nom de la table SQL devant le nom du champ
if ($table) {
if ($col[0] == "`") {
$arg = "{$table}." . substr($col, 1, -1);
} else {
$arg = "{$table}.{$col}";
}
} else {
$arg = $col;
}
// inserer la fonction SQL
if ($fct) {
$arg = "{$fct}({$arg}{$args_sql})";
}
return array($arg, $op, $val, $col_alias, $where_complement);
}
function critere_par_joint($table, $champ, &$boucle, $idb)
{
$t = array_search($table, $boucle->from);
if (!$t) $t = trouver_jointure_champ($champ, $boucle);
return !$t ? '' : ("'" . $t . '.' . $champ . "'");
}
/**
* Cherche un champ dans une boucle
*
* Le champ peut être :
*
* - un alias d'un autre : il faut alors le calculer, éventuellement en
* construisant une jointure.
* - présent dans la table : on l'utilise
* - absent, mais le type de boucle l'autorise (joker des itérateurs DATA) :
* on l'utilise et lève le drapeau joker
* - absent, on cherche une jointure et on l'utilise si on en trouve.
*
* @todo
* Ici la recherche de jointure sur l'absence d'un champ ne cherche
* une jointure que si des jointures explicites sont demandées,
* et non comme à d'autres endroits sur toutes les jointures possibles.
* Il faut homogénéiser cela.
*
*
* @param string $idb Identifiant de la boucle
* @param string $nom_champ Nom du champ SQL cherché
* @param Boucle $boucles AST du squelette
* @param bool $joker
* Le champ peut-il être inconnu à la compilation ?
* Ce drapeau sera levé si c'est le cas.
* @return array
* Liste (Nom du champ véritable, nom du champ demandé).
* Le nom du champ véritable est une expression pour le SELECT de
* la boucle tel que "rubriques.titre" ou "mots.titre AS titre_mot".
* Les éléments de la liste sont vides si on ne trouve rien.
**/
function index_tables_en_pile($idb, $nom_champ, &$boucles, &$joker)
{
global $exceptions_des_tables;
$r = $boucles[$idb]->type_requete;
// boucle recursive, c'est foutu...
if ($r == TYPE_RECURSIF) {
return array();
}
if (!$r) {
$joker = false;
// indiquer a l'appelant
# continuer pour chercher l'erreur suivante
return array("'#" . $r . ':' . $nom_champ . "'", '');
}
$desc = $boucles[$idb]->show;
// le nom du champ est il une exception de la table ? un alias ?
$excep = isset($exceptions_des_tables[$r]) ? $exceptions_des_tables[$r] : '';
if ($excep) {
$excep = isset($excep[$nom_champ]) ? $excep[$nom_champ] : '';
}
if ($excep) {
$joker = false;
// indiquer a l'appelant
return index_exception($boucles[$idb], $desc, $nom_champ, $excep);
} else {
// le champ est réellement présent, on le prend.
if (isset($desc['field'][$nom_champ])) {
$t = $boucles[$idb]->id_table;
$joker = false;
// indiquer a l'appelant
return array("{$t}.{$nom_champ}", $nom_champ);
} elseif (isset($desc['field']['*'])) {
$joker = true;
// indiquer a l'appelant
return array($nom_champ, $nom_champ);
} else {
$joker = false;
// indiquer a l'appelant
// regarder si le champ est deja dans une jointure existante
// sinon, si il y a des joitures explicites, la construire
if (!($t = trouver_champ_exterieur($nom_champ, $boucles[$idb]->from, $boucles[$idb]))) {
if ($boucles[$idb]->jointures_explicites) {
// [todo] Ne pas lancer que lorsque il y a des jointures explicites !!!!
// fonctionnel, il suffit d'utiliser $boucles[$idb]->jointures au lieu de jointures_explicites
// mais est-ce ce qu'on veut ?
$jointures = preg_split("/\\s+/", $boucles[$idb]->jointures_explicites);
if ($cle = trouver_jointure_champ($nom_champ, $boucles[$idb], $jointures)) {
$t = trouver_champ_exterieur($nom_champ, $boucles[$idb]->from, $boucles[$idb]);
}
}
}
if ($t) {
// si on a trouvé une jointure possible, on fait comme
// si c'était une exception pour le champ demandé
return index_exception($boucles[$idb], $desc, $nom_champ, array($t[1]['id_table'], reset($t[2])));
}
return array('', '');
}
}
}
