www/ecrire/inc/plugin.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Gestion de l'activation des plugins
  15  *
  16  * @package SPIP\Core\Plugins
  17  **/
  18
  19 if (!defined('_ECRIRE_INC_VERSION')) {
  20         return;
  21 }
  22
  23 /** l'adresse du repertoire de telechargement et de decompactage des plugins */
  24 define('_DIR_PLUGINS_AUTO', _DIR_PLUGINS . 'auto/');
  25
  26 #include_spip('inc/texte'); // ????? Appelle public/parametrer trop tot avant la reconstruction du chemin des plugins.
  27 include_spip('plugins/installer');
  28
  29 /**
  30  * Retourne la description de chaque plugin présent dans un répertoire
  31  *
  32  * Lecture des sous repertoire plugin existants
  33  *
  34  * @example
  35  *     - `liste_plugin_files()`
  36  *     - `liste_plugin_files(_DIR_PLUGINS_DIST)`
  37  *     - `liste_plugin_files(_DIR_PLUGINS_SUPPL)`
  38  *
  39  * @uses fast_find_plugin_dirs()
  40  * @uses plugins_get_infos_dist()
  41  *
  42  * @param string|null $dir_plugins
  43  *     - string : Chemin (relatif à la racine du site) du répertoire à analyser.
  44  *     - null : utilise le chemin `_DIR_PLUGINS`.
  45  * @return array
  46 **/
  47 function liste_plugin_files($dir_plugins = null) {
  48         static $plugin_files = array();
  49         if (is_null($dir_plugins)) {
  50                 $dir_plugins = _DIR_PLUGINS;
  51         }
  52         if (!isset($plugin_files[$dir_plugins])
  53                 or count($plugin_files[$dir_plugins]) == 0
  54         ) {
  55                 $plugin_files[$dir_plugins] = array();
  56                 foreach (fast_find_plugin_dirs($dir_plugins) as $plugin) {
  57                         $plugin_files[$dir_plugins][] = substr($plugin, strlen($dir_plugins));
  58                 }
  59
  60                 sort($plugin_files[$dir_plugins]);
  61                 // et on lit le XML de tous les plugins pour le mettre en cache
  62                 // et en profiter pour nettoyer ceux qui n'existent plus du cache
  63                 $get_infos = charger_fonction('get_infos', 'plugins');
  64                 $get_infos($plugin_files[$dir_plugins], false, $dir_plugins, true);
  65         }
  66
  67         return $plugin_files[$dir_plugins];
  68 }
  69
  70 /**
  71  * Recherche rapide des répertoires de plugins contenus dans un répertoire
  72  *
  73  * @uses is_plugin_dir()
  74  *
  75  * @param string $dir
  76  *     Chemin du répertoire dont on souhaite retourner les sous répertoires
  77  * @param int $max_prof
  78  *     Profondeur maximale des sous répertoires
  79  * @return array
  80  *     Liste complète des répeertoires
  81 **/
  82 function fast_find_plugin_dirs($dir, $max_prof = 100) {
  83         $fichiers = array();
  84         // revenir au repertoire racine si on a recu dossier/truc
  85         // pour regarder dossier/truc/ ne pas oublier le / final
  86         $dir = preg_replace(',/[^/]*$,', '', $dir);
  87         if ($dir == '') {
  88                 $dir = '.';
  89         }
  90
  91         if (!is_dir($dir)) {
  92                 return $fichiers;
  93         }
  94         if (is_plugin_dir($dir, '')) {
  95                 $fichiers[] = $dir;
  96
  97                 return $fichiers;
  98         }
  99         if ($max_prof <= 0) {
 100                 return $fichiers;
 101         }
 102
 103         $subdirs = array();
 104         if (@is_dir($dir) and is_readable($dir) and $d = opendir($dir)) {
 105                 while (($f = readdir($d)) !== false) {
 106                         if ($f[0] != '.' # ignorer . .. .svn etc
 107                                 and $f != 'CVS'
 108                                 and is_dir($f = "$dir/$f")
 109                         ) {
 110                                 $subdirs[] = $f;
 111                         }
 112                 }
 113                 closedir($d);
 114         }
 115
 116         foreach ($subdirs as $d) {
 117                 $fichiers = array_merge($fichiers, fast_find_plugin_dirs("$d/", $max_prof - 1));
 118         }
 119
 120         return $fichiers;
 121 }
 122
 123 /**
 124  * Indique si un répertoire (ou plusieurs) est la racine d'un plugin SPIP
 125  *
 126  * Vérifie le ou les chemins relatifs transmis pour vérifier qu'ils contiennent
 127  * un `plugin.xml` ou un `paquet.xml`. Les chemins valides sont retournés.
 128  *
 129  * @param string|string[] $dir
 130  *     Chemin (relatif à `$dir_plugins`), ou liste de chemins à tester
 131  * @param string|null $dir_plugins
 132  *     - string : Chemin de répertoire (relatif à la `_DIR_RACINE`), départ des chemin(s) à tester
 133  *     - null (par défaut) : utilise le chemin `_DIR_PLUGINS`
 134  * @return string|string[]
 135  *     - string : Le chemin accepté (c'était un plugin)
 136  *     - '' : ce n'était pas un chemin valide
 137  *     - array : Ensemble des chemins acceptés (si `$dir` était array)
 138 **/
 139 function is_plugin_dir($dir, $dir_plugins = null) {
 140
 141         if (is_array($dir)) {
 142                 foreach ($dir as $k => $d) {
 143                         if (!is_plugin_dir($d, $dir_plugins)) {
 144                                 unset($dir[$k]);
 145                         }
 146                 }
 147
 148                 return $dir;
 149         }
 150         if (is_null($dir_plugins)) {
 151                 $dir_plugins = _DIR_PLUGINS;
 152         }
 153         $search = array("$dir_plugins$dir/plugin.xml", "$dir_plugins$dir/paquet.xml");
 154
 155         foreach ($search as $s) {
 156                 if (file_exists($s)) {
 157                         return $dir;
 158                 }
 159         }
 160
 161         return '';
 162 }
 163
 164 /** Regexp d'extraction des informations d'un intervalle de compatibilité */
 165 define('_EXTRAIRE_INTERVALLE', ',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,');
 166
 167 /**
 168  * Teste si le numéro de version d'un plugin est dans un intervalle donné.
 169  *
 170  * Cette fonction peut être volontairement trompée (phase de développement) :
 171  * voir commentaire infra sur l'utilisation de la constante _DEV_VERSION_SPIP_COMPAT
 172  *
 173  * @uses spip_version_compare()
 174  *
 175  * @param string $intervalle
 176  *    Un intervalle entre 2 versions. ex: [2.0.0-dev;2.1.*]
 177  * @param string $version
 178  *    Un numéro de version. ex: 3.1.99]
 179  * @param string $avec_quoi
 180  *    Ce avec quoi est testée la compatibilité. par défaut ('')
 181  *    avec un plugin (cas des 'necessite'), parfois ('spip')
 182  *    avec SPIP.
 183  * @return bool
 184  *    True si dans l'intervalle, false sinon.
 185  **/
 186 function plugin_version_compatible($intervalle, $version, $avec_quoi = '') {
 187
 188         if (!strlen($intervalle)) {
 189                 return true;
 190         }
 191         if (!preg_match(_EXTRAIRE_INTERVALLE, $intervalle, $regs)) {
 192                 return false;
 193         }
 194         // Extraction des bornes et traitement de * pour la borne sup :
 195         // -- on autorise uniquement les ecritures 3.0.*, 3.*
 196         $minimum = $regs[1];
 197         $maximum = $regs[2];
 198
 199         //  si une version SPIP de compatibilité a été définie (dans
 200         //  mes_options.php, sous la forme : define('_DEV_VERSION_SPIP_COMPAT', '3.1.0');
 201         //  on l'utilise (phase de dev, de test...) mais *que* en cas de comparaison
 202         //  avec la version de SPIP (ne nuit donc pas aux tests de necessite
 203         //  entre plugins)
 204         if (defined('_DEV_VERSION_SPIP_COMPAT') and $avec_quoi == 'spip' and $version !== _DEV_VERSION_SPIP_COMPAT) {
 205                 if (plugin_version_compatible($intervalle, _DEV_VERSION_SPIP_COMPAT, $avec_quoi)) {
 206                         return true;
 207                 }
 208                 // si pas de compatibilite avec _DEV_VERSION_SPIP_COMPAT, on essaye quand meme avec la vrai version
 209                 // cas du plugin qui n'est compatible qu'avec cette nouvelle version
 210         }
 211
 212         $minimum_inc = $intervalle{0} == "[";
 213         $maximum_inc = substr($intervalle, -1) == "]";
 214
 215         if (strlen($minimum)) {
 216                 if ($minimum_inc and spip_version_compare($version, $minimum, '<')) {
 217                         return false;
 218                 }
 219                 if (!$minimum_inc and spip_version_compare($version, $minimum, '<=')) {
 220                         return false;
 221                 }
 222         }
 223         if (strlen($maximum)) {
 224                 if ($maximum_inc and spip_version_compare($version, $maximum, '>')) {
 225                         return false;
 226                 }
 227                 if (!$maximum_inc and spip_version_compare($version, $maximum, '>=')) {
 228                         return false;
 229                 }
 230         }
 231
 232         return true;
 233 }
 234
 235 /**
 236  * Construire la liste des infos strictement necessaires aux plugins à activer
 237  * afin de les mémoriser dans une meta pas trop grosse
 238  *
 239  * @uses liste_plugin_files()
 240  * @uses plugins_get_infos_dist()
 241  * @uses plugin_valide_resume()
 242  * @uses plugin_fixer_procure()
 243  *
 244  * @param array $liste_plug
 245  * @param bool $force
 246  * @return array
 247  */
 248 function liste_plugin_valides($liste_plug, $force = false) {
 249         $liste_ext = liste_plugin_files(_DIR_PLUGINS_DIST);
 250         $get_infos = charger_fonction('get_infos', 'plugins');
 251         $infos = array(
 252                 // lister les extensions qui sont automatiquement actives
 253                 '_DIR_PLUGINS_DIST' => $get_infos($liste_ext, $force, _DIR_PLUGINS_DIST),
 254                 '_DIR_PLUGINS' => $get_infos($liste_plug, $force, _DIR_PLUGINS)
 255         );
 256
 257         // creer une premiere liste non ordonnee mais qui ne retient
 258         // que les plugins valides, et dans leur derniere version en cas de doublon
 259         $infos['_DIR_RESTREINT'][''] = $get_infos('./', $force, _DIR_RESTREINT);
 260         $infos['_DIR_RESTREINT']['SPIP']['version'] = $GLOBALS['spip_version_branche'];
 261         $infos['_DIR_RESTREINT']['SPIP']['chemin'] = array();
 262         $liste_non_classee = array(
 263                 'SPIP' => array(
 264                         'nom' => 'SPIP',
 265                         'etat' => 'stable',
 266                         'version' => $GLOBALS['spip_version_branche'],
 267                         'dir_type' => '_DIR_RESTREINT',
 268                         'dir' => '',
 269                 )
 270         );
 271
 272         $invalides = array();
 273         foreach ($liste_ext as $plug) {
 274                 if (isset($infos['_DIR_PLUGINS_DIST'][$plug])) {
 275                         plugin_valide_resume($liste_non_classee, $plug, $infos, '_DIR_PLUGINS_DIST');
 276                 }
 277         }
 278         foreach ($liste_plug as $plug) {
 279                 if (isset($infos['_DIR_PLUGINS'][$plug])) {
 280                         $r = plugin_valide_resume($liste_non_classee, $plug, $infos, '_DIR_PLUGINS');
 281                         if (is_array($r)) {
 282                                 $invalides = array_merge($invalides, $r);
 283                         }
 284                 }
 285         }
 286
 287         if (defined('_DIR_PLUGINS_SUPPL') and _DIR_PLUGINS_SUPPL) {
 288                 $infos['_DIR_PLUGINS_SUPPL'] = $get_infos($liste_plug, false, _DIR_PLUGINS_SUPPL);
 289                 foreach ($liste_plug as $plug) {
 290                         if (isset($infos['_DIR_PLUGINS_SUPPL'][$plug])) {
 291                                 $r = plugin_valide_resume($liste_non_classee, $plug, $infos, '_DIR_PLUGINS_SUPPL');
 292                                 if (is_array($r)) {
 293                                         $invalides = array_merge($invalides, $r);
 294                                 }
 295                         }
 296                 }
 297         }
 298
 299         plugin_fixer_procure($liste_non_classee, $infos);
 300
 301         // les plugins qui sont dans $liste_non_classee ne sont pas invalides (on a trouve un autre version valide)
 302         $invalides = array_diff_key($invalides, $liste_non_classee);
 303
 304         return array($infos, $liste_non_classee, $invalides);
 305 }
 306
 307 /**
 308  * Ne retenir un plugin que s'il est valide
 309  * et dans leur plus recente version compatible
 310  * avec la version presente de SPIP
 311  *
 312  * @uses plugin_version_compatible()
 313  * @uses spip_version_compare()
 314  *
 315  * @param array $liste
 316  * @param string $plug
 317  * @param array $infos
 318  * @param string $dir_type
 319  * @return string|array
 320  *   string prefixe dans $liste si on a accepte le plugin
 321  *   array description short si on ne le retient pas (pour memorisation dans une table des erreurs)
 322  */
 323 function plugin_valide_resume(&$liste, $plug, $infos, $dir_type) {
 324         $i = $infos[$dir_type][$plug];
 325         $p = strtoupper($i['prefix']);
 326         $short_desc = array(
 327                 'nom' => $i['nom'],
 328                 'etat' => $i['etat'],
 329                 'version' => $i['version'],
 330                 'dir' => $plug,
 331                 'dir_type' => $dir_type
 332         );
 333         if (isset($i['erreur']) and $i['erreur']) {
 334                 $short_desc['erreur'] = $i['erreur'];
 335                 return array($p=>$short_desc);
 336         }
 337         if (!plugin_version_compatible($i['compatibilite'], $GLOBALS['spip_version_branche'], 'spip')) {
 338                 return array($p=>$short_desc);
 339         }
 340         if (!isset($liste[$p])
 341                 or spip_version_compare($i['version'], $liste[$p]['version'], '>')
 342         ) {
 343                 $liste[$p] = $short_desc;
 344         }
 345         // ok le plugin etait deja dans la liste ou on a choisi une version plus recente
 346         return $p;
 347 }
 348
 349 /**
 350  * Compléter la liste des plugins avec les éventuels procure
 351  *
 352  * les balises `<procure>` sont considerées comme des plugins proposés,
 353  * mais surchargeables (on peut activer un plugin qui procure ça pour l'améliorer,
 354  * donc avec le même prefixe, qui sera pris en compte si il a une version plus grande)
 355  *
 356  * @uses spip_version_compare()
 357  *
 358  * @param array $liste
 359  * @param array $infos
 360  */
 361 function plugin_fixer_procure(&$liste, &$infos) {
 362         foreach ($liste as $p => $resume) {
 363                 $i = $infos[$resume['dir_type']][$resume['dir']];
 364                 if (isset($i['procure']) and $i['procure']) {
 365                         foreach ($i['procure'] as $procure) {
 366                                 $p = strtoupper($procure['nom']);
 367                                 $dir = $resume['dir'];
 368                                 if ($dir) {
 369                                         $dir .= "/";
 370                                 }
 371                                 $dir .= "procure:" . $procure['nom'];
 372
 373                                 $procure['etat'] = '?';
 374                                 $procure['dir_type'] = $resume['dir_type'];
 375                                 $procure['dir'] = $dir;
 376
 377                                 // si ce plugin n'est pas deja procure, ou dans une version plus ancienne
 378                                 // on ajoute cette version a la liste
 379                                 if (!isset($liste[$p])
 380                                         or spip_version_compare($procure['version'], $liste[$p]['version'], '>')
 381                                 ) {
 382                                         $liste[$p] = $procure;
 383
 384                                         // on fournit une information minimale pour ne pas perturber la compilation
 385                                         $infos[$resume['dir_type']][$dir] = array(
 386                                                 'prefix' => $procure['nom'],
 387                                                 'nom' => $procure['nom'],
 388                                                 'etat' => $procure['etat'],
 389                                                 'version' => $procure['version'],
 390                                                 'chemin' => array(),
 391                                                 'necessite' => array(),
 392                                                 'utilise' => array(),
 393                                                 'lib' => array(),
 394                                                 'menu' => array(),
 395                                                 'onglet' => array(),
 396                                                 'procure' => array(),
 397                                         );
 398                                 }
 399                         }
 400                 }
 401         }
 402 }
 403
 404 /**
 405  * Extrait les chemins d'une liste de plugin
 406  *
 407  * Sélectionne au passage ceux qui sont dans `$dir_plugins` uniquement
 408  * si valeur non vide
 409  *
 410  * @param array $liste
 411  * @param string $dir_plugins
 412  * @return array
 413  */
 414 function liste_chemin_plugin($liste, $dir_plugins = _DIR_PLUGINS) {
 415         foreach ($liste as $prefix => $infos) {
 416                 if (!$dir_plugins
 417                         or (
 418                                 defined($infos['dir_type'])
 419                                 and constant($infos['dir_type']) == $dir_plugins)
 420                 ) {
 421                         $liste[$prefix] = $infos['dir'];
 422                 } else {
 423                         unset($liste[$prefix]);
 424                 }
 425         }
 426
 427         return $liste;
 428 }
 429
 430 /**
 431  * Liste les chemins vers les plugins actifs du dossier fourni en argument
 432  * a partir d'une liste d'elelements construits par plugin_valide_resume
 433  *
 434  * @uses liste_plugin_actifs()
 435  * @uses liste_chemin_plugin()
 436  *
 437  * @param string $dir_plugins
 438  *     Chemin du répertoire de plugins
 439  * @return array
 440  */
 441 function liste_chemin_plugin_actifs($dir_plugins = _DIR_PLUGINS) {
 442         include_spip('plugins/installer');
 443
 444         return liste_chemin_plugin(liste_plugin_actifs(), $dir_plugins);
 445 }
 446
 447 /**
 448  * Trier les plugins en vériant leur dépendances (qui doivent être présentes)
 449  *
 450  * Pour tester "utilise", il faut connaître tous les plugins
 451  * qui seront forcément absents à la fin,
 452  * car absent de la liste des plugins actifs.
 453  *
 454  * Il faut donc construire une liste ordonnée.
 455  *
 456  * Cette fonction détecte des dépendances circulaires,
 457  * avec un doute sur un "utilise" qu'on peut ignorer.
 458  * Mais ne pas insérer silencieusement et risquer un bug sournois latent
 459  *
 460  * @uses plugin_version_compatible()
 461  *
 462  * @param array $infos
 463  *     Répertoire (plugins, plugins-dist, ...) => Couples (prefixes => infos completes) des plugins qu'ils contiennent
 464  * @param array $liste_non_classee
 465  *     Couples (prefixe => description) des plugins qu'on souhaite utiliser
 466  * @return array
 467  *     Tableau de 3 éléments :
 468  *     - $liste : couples (prefixes => description) des plugins valides
 469  *     - $ordre : couples (prefixes => infos completes) des plugins triés
 470  *                (les plugins nécessités avant les plugins qui les utilisent)
 471  *     - $liste_non_classee : couples (prefixes => description) des plugins
 472  *                qui n'ont pas satisfait leurs dépendances
 473 **/
 474 function plugin_trier($infos, $liste_non_classee) {
 475         $toute_la_liste = $liste_non_classee;
 476         $liste = $ordre = array();
 477         $count = 0;
 478
 479         while ($c = count($liste_non_classee) and $c != $count) { // tant qu'il reste des plugins a classer, et qu'on ne stagne pas
 480                 #echo "tour::";var_dump($liste_non_classee);
 481                 $count = $c;
 482                 foreach ($liste_non_classee as $p => $resume) {
 483                         $plug = $resume['dir'];
 484                         $dir_type = $resume['dir_type'];
 485                         $info1 = $infos[$dir_type][$plug];
 486                         // si des plugins sont necessaires,
 487                         // on ne peut inserer qu'apres eux
 488                         foreach ($info1['necessite'] as $need) {
 489                                 $nom = strtoupper($need['nom']);
 490                                 $compat = isset($need['compatibilite']) ? $need['compatibilite'] : '';
 491                                 if (!isset($liste[$nom]) or !plugin_version_compatible($compat, $liste[$nom]['version'])) {
 492                                         $info1 = false;
 493                                         break;
 494                                 }
 495                         }
 496                         if (!$info1) {
 497                                 continue;
 498                         }
 499                         // idem si des plugins sont utiles,
 500                         // sauf si ils sont de toute facon absents de la liste
 501                         foreach ($info1['utilise'] as $need) {
 502                                 $nom = strtoupper($need['nom']);
 503                                 $compat = isset($need['compatibilite']) ? $need['compatibilite'] : '';
 504                                 if (isset($toute_la_liste[$nom])) {
 505                                         if (!isset($liste[$nom]) or
 506                                                 !plugin_version_compatible($compat, $liste[$nom]['version'])
 507                                         ) {
 508                                                 $info1 = false;
 509                                                 break;
 510                                         }
 511                                 }
 512                         }
 513                         if ($info1) {
 514                                 $ordre[$p] = $info1;
 515                                 $liste[$p] = $liste_non_classee[$p];
 516                                 unset($liste_non_classee[$p]);
 517                         }
 518                 }
 519         }
 520
 521         return array($liste, $ordre, $liste_non_classee);
 522 }
 523
 524 /**
 525  * Collecte les erreurs de dépendances des plugins dans la meta `plugin_erreur_activation`
 526  *
 527  * @uses plugin_necessite()
 528  * @uses plugin_controler_lib()
 529  *
 530  * @param array $liste_non_classee
 531  *     Couples (prefixe => description) des plugins en erreur
 532  * @param array $liste
 533  *     Couples (prefixe => description) des plugins qu'on souhaite utiliser
 534  * @param array $infos
 535  *     Répertoire (plugins, plugins-dist, ...) => Couples (prefixes => infos completes) des plugins qu'ils contiennent
 536 **/
 537 function plugins_erreurs($liste_non_classee, $liste, $infos, $msg = array()) {
 538         static $erreurs = array();
 539
 540         if (!is_array($liste)) {
 541                 $liste = array();
 542         }
 543
 544         // les plugins en erreur ne sont pas actifs ; ils ne doivent pas être dans la liste
 545         $liste = array_diff_key($liste, $liste_non_classee);
 546
 547         foreach ($liste_non_classee as $p => $resume) {
 548                 $dir_type = $resume['dir_type'];
 549                 $plug = $resume['dir'];
 550                 $k = $infos[$dir_type][$plug];
 551
 552                 $plug = constant($dir_type) . $plug;
 553                 if (!isset($msg[$p])) {
 554                         if (isset($resume['erreur']) and $resume['erreur']) {
 555                                 $msg[$p] = array($resume['erreur']);
 556                         }
 557                         elseif (!plugin_version_compatible($k['compatibilite'], $GLOBALS['spip_version_branche'], 'spip')) {
 558                                 $msg[$p] = array(plugin_message_incompatibilite($k['compatibilite'], $GLOBALS['spip_version_branche'], 'SPIP', 'necessite'));
 559                         }
 560                         elseif (!$msg[$p] = plugin_necessite($k['necessite'], $liste, 'necessite')) {
 561                                 $msg[$p] = plugin_necessite($k['utilise'], $liste, 'utilise');
 562                         }
 563                 } else {
 564                         foreach ($msg[$p] as $c => $l) {
 565                                 $msg[$p][$c] = plugin_controler_lib($l['nom'], $l['lien']);
 566                         }
 567                 }
 568                 $erreurs[$plug] = $msg[$p];
 569         }
 570
 571         ecrire_meta('plugin_erreur_activation', serialize($erreurs));
 572 }
 573
 574 /**
 575  * Retourne les erreurs d'activation des plugins, au format html ou brut
 576  *
 577  * @param bool $raw
 578  *     - true : pour obtenir le tableau brut des erreurs
 579  *     - false : Code HTML
 580  * @param bool $raz
 581  *     - true pour effacer la meta qui stocke les erreurs.
 582  * @return string|array
 583  *     - Liste des erreurs ou code HTML des erreurs
 584 **/
 585 function plugin_donne_erreurs($raw = false, $raz = true) {
 586         if (!isset($GLOBALS['meta']['plugin_erreur_activation'])) {
 587                 return $raw ? array() : '';
 588         }
 589         $list = @unserialize($GLOBALS['meta']['plugin_erreur_activation']);
 590         // Compat ancienne version
 591         if (!$list) {
 592                 $list = $raw ? array() : $GLOBALS['meta']['plugin_erreur_activation'];
 593         } elseif (!$raw) {
 594                 foreach ($list as $plug => $msg) {
 595                         $list[$plug] = "<li>" . _T('plugin_impossible_activer', array('plugin' => $plug))
 596                                 . "<ul><li>" . implode("</li><li>", $msg) . "</li></ul></li>";
 597                 }
 598                 $list = "<ul>" . join("\n", $list) . "</ul>";
 599         }
 600         if ($raz) {
 601                 effacer_meta('plugin_erreur_activation');
 602         }
 603
 604         return $list;
 605 }
 606
 607 /**
 608  * Teste des dépendances
 609  *
 610  * Et vérifie que chaque dépendance est présente
 611  * dans la liste de plugins donnée
 612  *
 613  * @uses plugin_controler_necessite()
 614  *
 615  * @param array $n
 616  *    Tableau de dépendances dont on souhaite vérifier leur présence
 617  * @param array $liste
 618  *    Tableau des plugins présents
 619  * @return array
 620  *    Tableau des messages d'erreurs reçus. Il sera vide si tout va bien.
 621  *
 622  **/
 623 function plugin_necessite($n, $liste, $balise = 'necessite') {
 624         $msg = array();
 625         foreach ($n as $need) {
 626                 $id = strtoupper($need['nom']);
 627                 $r = plugin_controler_necessite(
 628                         $liste,
 629                         $id,
 630                         isset($need['compatibilite']) ? $need['compatibilite'] : '',
 631                         $balise
 632                 );
 633                 if ($r) {
 634                         $msg[] = $r;
 635                 }
 636         }
 637
 638         return $msg;
 639 }
 640
 641 /**
 642  * Vérifie qu'une dépendance (plugin) est bien présente.
 643  *
 644  * @uses plugin_version_compatible()
 645  * @uses plugin_message_incompatibilite()
 646  *
 647  * @param $liste
 648  *    Liste de description des plugins
 649  * @param $nom
 650  *    Le plugin donc on cherche la presence
 651  * @param $intervalle
 652  *    L'éventuelle intervalle de compatibilité de la dépendance. ex: [1.1.0;]
 653  * @param $balise
 654  *    Permet de définir si on teste un utilise ou un nécessite
 655  * @return string.
 656  *    Vide si ok,
 657  *    Message d'erreur lorsque la dépendance est absente.
 658  **/
 659 function plugin_controler_necessite($liste, $nom, $intervalle, $balise) {
 660         if (isset($liste[$nom]) and plugin_version_compatible($intervalle, $liste[$nom]['version'])) {
 661                 return '';
 662         }
 663
 664         return plugin_message_incompatibilite(
 665                 $intervalle,
 666                 (isset($liste[$nom]) ? $liste[$nom]['version'] : ""),
 667                 $nom,
 668                 $balise
 669         );
 670 }
 671
 672 /**
 673  * @param string $intervalle
 674  *     L'éventuelle intervalle de compatibilité de la dépendance. ex: [1.1.0;]
 675  * @param string $version
 676  *     La version en cours active pour le plugin demandé (ou php ou extension php demandée)
 677  * @param string $nom
 678  *     Le plugin (ou php ou extension php) qui est absent
 679  * @param string $balise
 680  *     Le type de balise utilisé (necessite ou utilise)
 681  * @return string
 682  *     Le message d'erreur.
 683  */
 684 function plugin_message_incompatibilite($intervalle, $version, $nom, $balise) {
 685
 686         // prendre en compte les erreurs de dépendances à PHP
 687         // ou à une extension PHP avec des messages d'erreurs dédiés.
 688         $type = 'plugin';
 689         if ($nom === 'SPIP') {
 690                 $type = 'spip';
 691         } elseif ($nom === 'PHP') {
 692                 $type = 'php';
 693         } elseif (strncmp($nom, 'PHP:', 4) === 0) {
 694                 $type = 'extension_php';
 695                 list(,$nom) = explode(':', $nom, 2);
 696         }
 697
 698         if (preg_match(_EXTRAIRE_INTERVALLE, $intervalle, $regs)) {
 699                 $minimum = $regs[1];
 700                 $maximum = $regs[2];
 701
 702                 $minimum_inclus = $intervalle{0} == "[";
 703                 $maximum_inclus = substr($intervalle, -1) == "]";
 704
 705                 if (strlen($minimum)) {
 706                         if ($minimum_inclus and spip_version_compare($version, $minimum, '<')) {
 707                                 return _T("plugin_${balise}_${type}", array(
 708                                         'plugin' => $nom,
 709                                         'version' => ' &ge; ' . $minimum
 710                                 ));
 711                         }
 712                         if (!$minimum_inclus and spip_version_compare($version, $minimum, '<=')) {
 713                                 return _T("plugin_${balise}_${type}", array(
 714                                         'plugin' => $nom,
 715                                         'version' => ' &gt; ' . $minimum
 716                                 ));
 717                         }
 718                 }
 719
 720                 if (strlen($maximum)) {
 721                         if ($maximum_inclus and spip_version_compare($version, $maximum, '>')) {
 722                                 return _T("plugin_${balise}_${type}", array(
 723                                         'plugin' => $nom,
 724                                         'version' => ' &le; ' . $maximum
 725                                 ));
 726                         }
 727                         if (!$maximum_inclus and spip_version_compare($version, $maximum, '>=')) {
 728                                 return _T("plugin_${balise}_plugin", array(
 729                                         'plugin' => $nom,
 730                                         'version' => ' &lt; ' . $maximum
 731                                 ));
 732                         }
 733                 }
 734         }
 735
 736         // note : il ne peut pas y avoir d'erreur sur
 737         // - un 'utilise' sans version.
 738         // - un 'php' sans version.
 739         return _T("plugin_necessite_${type}_sans_version", array('plugin' => $nom));
 740 }
 741
 742
 743 function plugin_controler_lib($lib, $url) {
 744         /* Feature sortie du core, voir STP
 745          * if ($url) {
 746                 include_spip('inc/charger_plugin');
 747                 $url = '<br />' . bouton_telechargement_plugin($url, 'lib');
 748         }*/
 749         return _T('plugin_necessite_lib', array('lib' => $lib)) . " <a href='$url'>$url</a>";
 750 }
 751
 752
 753 /**
 754  * Calcule la liste des plugins actifs et recompile les fichiers caches
 755  * qui leurs sont relatifs
 756  *
 757  * @uses ecrire_plugin_actifs()
 758  *
 759  * @param bool $pipe_recherche ?
 760  * @return bool
 761  *     true si il y a eu des modifications sur la liste des plugins actifs, false sinon
 762  **/
 763 function actualise_plugins_actifs($pipe_recherche = false) {
 764         return ecrire_plugin_actifs('', $pipe_recherche, 'force');
 765 }
 766
 767
 768 /**
 769  * Calcule ou modifie la liste des plugins actifs et recompile les fichiers caches
 770  * qui leurs sont relatifs
 771  *
 772  * @note
 773  *   Les  ecrire_meta() doivent en principe aussi initialiser la valeur a vide
 774  *   si elle n'existe pas risque de pb en php5 a cause du typage ou de null
 775  *   (verifier dans la doc php)
 776  *
 777  * @param string|string[] $plugin
 778  *     Plugin ou plugins concernés (leur chemin depuis le répertoire plugins)
 779  * @param bool $pipe_recherche
 780  *     ?
 781  * @param string $operation
 782  *     - raz : recalcule tout
 783  *     - ajoute : ajoute le plugin indiqué à la liste des plugins actifs
 784  *     - enleve : enleve le plugin indiqué de la liste des plugins actifs
 785  *     - force  : ?
 786  * @return bool
 787  *     true si il y a eu des modifications sur la liste des plugins actifs, false sinon
 788  **/
 789 function ecrire_plugin_actifs($plugin, $pipe_recherche = false, $operation = 'raz') {
 790
 791         // creer le repertoire cache/ si necessaire ! (installation notamment)
 792         $cache = sous_repertoire(_DIR_CACHE, '', false, true);
 793
 794         // Si on n'a ni cache accessible, ni connexion SQL, on ne peut pas faire grand chose encore.
 795         if (!$cache and !spip_connect()) {
 796                 return false;
 797         }
 798
 799         if ($operation != 'raz') {
 800                 $plugin_valides = liste_chemin_plugin_actifs();
 801                 $plugin_valides = is_plugin_dir($plugin_valides);
 802                 if (defined('_DIR_PLUGINS_SUPPL') && _DIR_PLUGINS_SUPPL) {
 803                         $plugin_valides_supp = liste_chemin_plugin_actifs(_DIR_PLUGINS_SUPPL);
 804                         $plugin_valides_supp = is_plugin_dir($plugin_valides_supp, _DIR_PLUGINS_SUPPL);
 805                         $plugin_valides = array_merge($plugin_valides, $plugin_valides_supp);
 806                 }
 807                 // si des plugins sont en attentes (coches mais impossible a activer)
 808                 // on les reinjecte ici
 809                 if (isset($GLOBALS['meta']['plugin_attente'])
 810                         and $a = unserialize($GLOBALS['meta']['plugin_attente'])
 811                 ) {
 812                         $plugin_valides = $plugin_valides + liste_chemin_plugin($a);
 813                 }
 814
 815                 if ($operation == 'ajoute') {
 816                         $plugin = array_merge($plugin_valides, $plugin);
 817                 } elseif ($operation == 'enleve') {
 818                         $plugin = array_diff($plugin_valides, $plugin);
 819                 } else {
 820                         $plugin = $plugin_valides;
 821                 }
 822         }
 823         $actifs_avant = isset($GLOBALS['meta']['plugin']) ? $GLOBALS['meta']['plugin'] : '';
 824
 825         // si une fonction de gestion de dependances existe, l'appeler ici
 826         if ($ajouter_dependances = charger_fonction("ajouter_dependances", "plugins", true)) {
 827                 $plugin = $ajouter_dependances($plugin);
 828         }
 829
 830         // recharger le xml des plugins a activer
 831         // on force le reload ici, meme si le fichier xml n'a pas change
 832         // pour ne pas rater l'ajout ou la suppression d'un fichier fonctions/options/administrations
 833         // pourra etre evite quand on ne supportera plus les plugin.xml
 834         // en deplacant la detection de ces fichiers dans la compilation ci dessous
 835         list($infos, $liste, $invalides) = liste_plugin_valides($plugin, true);
 836         // trouver l'ordre d'activation
 837         list($plugin_valides, $ordre, $reste) = plugin_trier($infos, $liste);
 838         if ($invalides or $reste) {
 839                 plugins_erreurs(array_merge($invalides, $reste), $liste, $infos);
 840         }
 841
 842         // Ignorer les plugins necessitant une lib absente
 843         // et preparer la meta d'entete Http
 844         $err = $msg = $header = array();
 845         foreach ($plugin_valides as $p => $resume) {
 846                 // Les headers ne doivent pas indiquer les versions des extensions PHP, ni la version PHP
 847                 if (0 !== strpos($p, 'PHP:') and $p !== 'PHP') {
 848                         $header[] = $p . ($resume['version'] ? "(" . $resume['version'] . ")" : "");
 849                 }
 850                 if ($resume['dir']) {
 851                         foreach ($infos[$resume['dir_type']][$resume['dir']]['lib'] as $l) {
 852                                 if (!find_in_path($l['nom'], 'lib/')) {
 853                                         $err[$p] = $resume;
 854                                         $msg[$p][] = $l;
 855                                         unset($plugin_valides[$p]);
 856                                 }
 857                         }
 858                 }
 859         }
 860         if ($err) {
 861                 plugins_erreurs($err, '', $infos, $msg);
 862         }
 863
 864         if (isset($GLOBALS['meta']['message_crash_plugins'])) {
 865                 effacer_meta('message_crash_plugins');
 866         }
 867         ecrire_meta('plugin', serialize($plugin_valides));
 868         $liste = array_diff_key($liste, $plugin_valides);
 869         ecrire_meta('plugin_attente', serialize($liste));
 870         $header = strtolower(implode(",", $header));
 871         if (!isset($GLOBALS['spip_header_silencieux']) or !$GLOBALS['spip_header_silencieux']) {
 872                 ecrire_fichier(_DIR_VAR . "config.txt",
 873                         (defined('_HEADER_COMPOSED_BY') ? _HEADER_COMPOSED_BY : "Composed-By: SPIP") . ' ' . $GLOBALS['spip_version_affichee'] . " @ www.spip.net + " . $header);
 874         } else {
 875                 @unlink(_DIR_VAR . "config.txt");
 876         }
 877         // generer charger_plugins_chemin.php
 878         plugins_precompile_chemin($plugin_valides, $ordre);
 879         // generer les fichiers
 880         // - charger_plugins_options.php
 881         // - charger_plugins_fonctions.php
 882         plugins_precompile_xxxtions($plugin_valides, $ordre);
 883         // charger les chemins des plugins et les fichiers d'options
 884         // (qui peuvent déclarer / utiliser des pipelines, ajouter d'autres chemins)
 885         plugins_amorcer_plugins_actifs();
 886         // mise a jour de la matrice des pipelines
 887         $prepend_code = pipeline_matrice_precompile($plugin_valides, $ordre, $pipe_recherche);
 888         // generer le fichier _CACHE_PIPELINE
 889         pipeline_precompile($prepend_code);
 890
 891         if (spip_connect()) {
 892                 // lancer et initialiser les nouveaux crons !
 893                 include_spip('inc/genie');
 894                 genie_queue_watch_dist();
 895         }
 896
 897         return ($GLOBALS['meta']['plugin'] != $actifs_avant);
 898 }
 899
 900 /**
 901  * Écrit le fichier de déclaration des chemins (path) des plugins actifs
 902  *
 903  * Le fichier créé, une fois exécuté permet à SPIP de rechercher
 904  * des fichiers dans les répertoires des plugins concernés.
 905  *
 906  * @see _chemin() Utilisé pour déclarer les chemins.
 907  * @uses plugin_version_compatible()
 908  * @uses ecrire_fichier_php()
 909  *
 910  * @param array $plugin_valides
 911  *     Couples (prefixe => description) des plugins qui seront actifs
 912  * @param array $ordre
 913  *     Couples (prefixe => infos complètes) des plugins qui seront actifs, dans l'ordre de leurs dépendances
 914 **/
 915 function plugins_precompile_chemin($plugin_valides, $ordre) {
 916         $chemins = array();
 917         $contenu = "";
 918         foreach ($ordre as $p => $info) {
 919                 // $ordre peur contenir des plugins en attente et non valides pour ce hit
 920                 if (isset($plugin_valides[$p])) {
 921                         $dir_type = $plugin_valides[$p]['dir_type'];
 922                         $plug = $plugin_valides[$p]['dir'];
 923                         // definir le plugin, donc le path avant l'include du fichier options
 924                         // permet de faire des include_spip pour attraper un inc_ du plugin
 925
 926                         $dir = $dir_type . ".'" . $plug . "/'";
 927
 928                         $prefix = strtoupper(preg_replace(',\W,', '_', $info['prefix']));
 929                         if ($prefix !== "SPIP") {
 930                                 $contenu .= "define('_DIR_PLUGIN_$prefix',$dir);\n";
 931                                 foreach ($info['chemin'] as $chemin) {
 932                                         if (!isset($chemin['version']) or plugin_version_compatible($chemin['version'],
 933                                                         $GLOBALS['spip_version_branche'], 'spip')
 934                                         ) {
 935                                                 $dir = $chemin['path'];
 936                                                 if (strlen($dir) and $dir{0} == "/") {
 937                                                         $dir = substr($dir, 1);
 938                                                 }
 939                                                 if (strlen($dir) and $dir == "./") {
 940                                                         $dir = '';
 941                                                 }
 942                                                 if (strlen($dir)) {
 943                                                         $dir = rtrim($dir, '/') . '/';
 944                                                 }
 945                                                 if (!isset($chemin['type']) or $chemin['type'] == 'public') {
 946                                                         $chemins['public'][] = "_DIR_PLUGIN_$prefix" . (strlen($dir) ? ".'$dir'" : "");
 947                                                 }
 948                                                 if (!isset($chemin['type']) or $chemin['type'] == 'prive') {
 949                                                         $chemins['prive'][] = "_DIR_PLUGIN_$prefix" . (strlen($dir) ? ".'$dir'" : "");
 950                                                 }
 951                                         }
 952                                 }
 953                         }
 954                 }
 955         }
 956         if (count($chemins)) {
 957                 $contenu .= "if (_DIR_RESTREINT) _chemin(implode(':',array(" . implode(',',
 958                                 array_reverse($chemins['public'])) . ")));\n"
 959                         . "else _chemin(implode(':',array(" . implode(',', array_reverse($chemins['prive'])) . ")));\n";
 960         }
 961
 962         ecrire_fichier_php(_CACHE_PLUGINS_PATH, $contenu);
 963 }
 964
 965 /**
 966  * Écrit les fichiers de chargement des fichiers d'options et de fonctions des plugins
 967  *
 968  * Les onglets et menus déclarés dans le fichier paquet.xml des plugins sont également
 969  * ajoutés au fichier de fonctions créé.
 970  *
 971  * @uses plugin_ongletbouton()
 972  * @uses ecrire_fichier_php()
 973  *
 974  * @param array $plugin_valides
 975  *     Couples (prefixe => description) des plugins qui seront actifs
 976  * @param array $ordre
 977  *     Couples (prefixe => infos complètes) des plugins qui seront actifs, dans l'ordre de leurs dépendances
 978 **/
 979 function plugins_precompile_xxxtions($plugin_valides, $ordre) {
 980         $contenu = array('options' => '', 'fonctions' => '');
 981         $boutons = array();
 982         $onglets = array();
 983         $sign = "";
 984
 985         foreach ($ordre as $p => $info) {
 986                 // $ordre peur contenir des plugins en attente et non valides pour ce hit
 987                 if (isset($plugin_valides[$p])) {
 988                         $dir_type = $plugin_valides[$p]['dir_type'];
 989                         $plug = $plugin_valides[$p]['dir'];
 990                         $dir = constant($dir_type);
 991                         $root_dir_type = str_replace('_DIR_', '_ROOT_', $dir_type);
 992                         if ($info['menu']) {
 993                                 $boutons = array_merge($boutons, $info['menu']);
 994                         }
 995                         if ($info['onglet']) {
 996                                 $onglets = array_merge($onglets, $info['onglet']);
 997                         }
 998                         foreach ($contenu as $charge => $v) {
 999                                 // si pas declare/detecte a la lecture du paquet.xml,
1000                                 // detecer a nouveau ici puisque son ajout ne provoque pas une modif du paquet.xml
1001                                 // donc ni sa relecture, ni sa detection
1002                                 if (!isset($info[$charge])
1003                                         and $dir // exclure le cas du plugin "SPIP"
1004                                         and strpos($dir, ":") === false // exclure le cas des procure:
1005                                         and file_exists("$dir$plug/paquet.xml") // uniquement pour les paquet.xml
1006                                 ) {
1007                                         if (is_readable("$dir$plug/" . ($file = $info['prefix'] . "_" . $charge . ".php"))) {
1008                                                 $info[$charge] = array($file);
1009                                         }
1010                                 }
1011                                 if (isset($info[$charge])) {
1012                                         $files = $info[$charge];
1013                                         foreach ($files as $k => $file) {
1014                                                 // on genere un if file_exists devant chaque include
1015                                                 // pour pouvoir garder le meme niveau d'erreur general
1016                                                 $file = trim($file);
1017                                                 if (!is_readable("$dir$plug/$file")
1018                                                         // uniquement pour les paquet.xml
1019                                                         and file_exists("$dir$plug/paquet.xml")
1020                                                 ) {
1021                                                         unset($info[$charge][$k]);
1022                                                 } else {
1023                                                         $_file = $root_dir_type . ".'$plug/$file'";
1024                                                         $contenu[$charge] .= "include_once_check($_file);\n";
1025                                                 }
1026                                         }
1027                                 }
1028                         }
1029                         $sign .= md5(serialize($info));
1030                 }
1031         }
1032
1033         $contenu['options'] = "define('_PLUGINS_HASH','" . md5($sign) . "');\n" . $contenu['options'];
1034         $contenu['fonctions'] .= plugin_ongletbouton("boutons_plugins", $boutons)
1035                 . plugin_ongletbouton("onglets_plugins", $onglets);
1036
1037         ecrire_fichier_php(_CACHE_PLUGINS_OPT, $contenu['options']);
1038         ecrire_fichier_php(_CACHE_PLUGINS_FCT, $contenu['fonctions']);
1039 }
1040
1041 /**
1042  * Compile les entrées d'un menu et retourne le code php d'exécution
1043  *
1044  * Génère et retourne un code php (pour enregistrement dans un fichier de cache)
1045  * permettant d'obtenir la liste des entrées de menus, ou des onglets
1046  * de l'espace privé.
1047  *
1048  * Définit également une constante (_UPDATED_$nom et _UPDATED_md5_$nom),
1049  * signalant une modification de ces menus
1050  *
1051  * @param string $nom Nom du type de menu
1052  *     Exemple: boutons_plugins, onglets_plugins
1053  * @param array $val Liste des entrées de ce menu
1054  * @return string Code php
1055  */
1056 function plugin_ongletbouton($nom, $val) {
1057         if (!$val) {
1058                 $val = array();
1059         }
1060
1061         $val = serialize($val);
1062         $md5 = md5($val);
1063
1064         if (!defined("_UPDATED_$nom")) {
1065                 define("_UPDATED_$nom", $val);
1066                 define("_UPDATED_md5_$nom", $md5);
1067         }
1068         $val = "unserialize('" . str_replace("'", "\'", $val) . "')";
1069
1070         return
1071                 "if (!function_exists('$nom')) {\n"
1072                 . "function $nom(){return defined('_UPDATED_$nom')?unserialize(_UPDATED_$nom):$val;}\n"
1073                 . "function md5_$nom(){return defined('_UPDATED_md5_$nom')?_UPDATED_md5_$nom:'" . $md5 . "';}\n"
1074                 . "}\n";
1075 }
1076
1077 /**
1078  * Chargement des plugins actifs dans le path de SPIP
1079  * et exécution de fichiers d'options des plugins
1080  *
1081  * Les fichiers d'options peuvent déclarer des pipelines ou de
1082  * nouveaux chemins.
1083  *
1084  * La connaissance chemins peut être nécessaire pour la construction
1085  * du fichier d'exécution des pipelines.
1086 **/
1087 function plugins_amorcer_plugins_actifs() {
1088
1089         if (@is_readable(_CACHE_PLUGINS_PATH)) {
1090                 include_once(_CACHE_PLUGINS_PATH);
1091         }
1092
1093         if (@is_readable(_CACHE_PLUGINS_OPT)) {
1094                 include_once(_CACHE_PLUGINS_OPT);
1095         } else {
1096                 spip_log("pipelines desactives: impossible de produire " . _CACHE_PLUGINS_OPT);
1097         }
1098 }
1099
1100 /**
1101  * Crée la liste des filtres à traverser pour chaque pipeline
1102  *
1103  * Complète la globale `spip_pipeline` des fonctions que doit traverser un pipeline,
1104  * et la globale `spip_matrice` des fichiers à charger qui contiennent ces fonctions.
1105  *
1106  * Retourne aussi pour certaines balises présentes dans les paquet.xml (script, style, genie),
1107  * un code PHP à insérer au début de la chaîne du ou des pipelines associés à cette balise
1108  * (insert_head, insert_head_css, taches_generales_cron, ...). Ce sont des écritures
1109  * raccourcies pour des usages fréquents de ces pipelines.
1110  *
1111  * @param array $plugin_valides
1112  *     Couples (prefixe => description) des plugins qui seront actifs
1113  * @param array $ordre
1114  *     Couples (prefixe => infos complètes) des plugins qui seront actifs, dans l'ordre de leurs dépendances
1115  * @param string $pipe_recherche
1116  * @return array
1117  *     Couples (nom du pipeline => Code PHP à insérer au début du pipeline)
1118 **/
1119 function pipeline_matrice_precompile($plugin_valides, $ordre, $pipe_recherche) {
1120         static $liste_pipe_manquants = array();
1121         if (($pipe_recherche) && (!in_array($pipe_recherche, $liste_pipe_manquants))) {
1122                 $liste_pipe_manquants[] = $pipe_recherche;
1123         }
1124
1125         $prepend_code = array();
1126
1127         foreach ($ordre as $p => $info) {
1128                 // $ordre peur contenir des plugins en attente et non valides pour ce hit
1129                 if (isset($plugin_valides[$p])) {
1130                         $dir_type = $plugin_valides[$p]['dir_type'];
1131                         $root_dir_type = str_replace('_DIR_', '_ROOT_', $dir_type);
1132                         $plug = $plugin_valides[$p]['dir'];
1133                         $prefix = (($info['prefix'] == "spip") ? "" : $info['prefix'] . "_");
1134                         if (isset($info['pipeline']) and is_array($info['pipeline'])) {
1135                                 foreach ($info['pipeline'] as $pipe) {
1136                                         $nom = $pipe['nom'];
1137                                         if (isset($pipe['action'])) {
1138                                                 $action = $pipe['action'];
1139                                         } else {
1140                                                 $action = $nom;
1141                                         }
1142                                         $nomlower = strtolower($nom);
1143                                         if ($nomlower != $nom
1144                                                 and isset($GLOBALS['spip_pipeline'][$nom])
1145                                                 and !isset($GLOBALS['spip_pipeline'][$nomlower])
1146                                         ) {
1147                                                 $GLOBALS['spip_pipeline'][$nomlower] = $GLOBALS['spip_pipeline'][$nom];
1148                                                 unset($GLOBALS['spip_pipeline'][$nom]);
1149                                         }
1150                                         $nom = $nomlower;
1151                                         // une action vide est une declaration qui ne doit pas etre compilee !
1152                                         if (!isset($GLOBALS['spip_pipeline'][$nom])) // creer le pipeline eventuel
1153                                         {
1154                                                 $GLOBALS['spip_pipeline'][$nom] = "";
1155                                         }
1156                                         if ($action) {
1157                                                 if (strpos($GLOBALS['spip_pipeline'][$nom], "|$prefix$action") === false) {
1158                                                         $GLOBALS['spip_pipeline'][$nom] = preg_replace(",(\|\||$),", "|$prefix$action\\1",
1159                                                                 $GLOBALS['spip_pipeline'][$nom], 1);
1160                                                 }
1161                                                 if (isset($pipe['inclure'])) {
1162                                                         $GLOBALS['spip_matrice']["$prefix$action"] =
1163                                                                 "$root_dir_type:$plug/" . $pipe['inclure'];
1164                                                 }
1165                                         }
1166                                 }
1167                         }
1168                         if (isset($info['genie']) and count($info['genie'])) {
1169                                 if (!isset($prepend_code['taches_generales_cron'])) {
1170                                         $prepend_code['taches_generales_cron'] = "";
1171                                 }
1172                                 foreach ($info['genie'] as $genie) {
1173                                         $nom = $prefix . $genie['nom'];
1174                                         $periode = max(60, intval($genie['periode']));
1175                                         if (charger_fonction($nom, "genie", true)) {
1176                                                 $prepend_code['taches_generales_cron'] .= "\$val['$nom'] = $periode;\n";
1177                                         } else {
1178                                                 spip_log("Fonction genie_$nom introuvable", _LOG_ERREUR);
1179                                         }
1180                                 }
1181                         }
1182                         if (isset($info['style']) and count($info['style'])) {
1183                                 if (!isset($prepend_code['insert_head_css'])) {
1184                                         $prepend_code['insert_head_css'] = "";
1185                                 }
1186                                 if (!isset($prepend_code['header_prive_css'])) {
1187                                         $prepend_code['header_prive_css'] = "";
1188                                 }
1189                                 foreach ($info['style'] as $style) {
1190                                         if (isset($style['path']) and $style['path']) {
1191                                                 $code = "if (\$f=timestamp(direction_css(find_in_path('" . addslashes($style['path']) . "')))) ";
1192                                         } else {
1193                                                 $code = "if (\$f='" . addslashes($style['url']) . "') ";
1194                                         }
1195                                         $code .= "\$val .= '<link rel=\"stylesheet\" href=\"'.\$f.'\" type=\"text/css\"";
1196                                         if (isset($style['media']) and strlen($style['media'])) {
1197                                                 $code .= " media=\"" . addslashes($style['media']) . "\"";
1198                                         }
1199                                         $code .= "/>';\n";
1200                                         if ($style['type'] != 'prive') {
1201                                                 $prepend_code['insert_head_css'] .= $code;
1202                                         }
1203                                         if ($style['type'] != 'public') {
1204                                                 $prepend_code['header_prive_css'] .= $code;
1205                                         }
1206                                 }
1207                         }
1208                         if (!isset($prepend_code['insert_head'])) {
1209                                 $prepend_code['insert_head'] = "";
1210                         }
1211                         if (!isset($prepend_code['header_prive'])) {
1212                                 $prepend_code['header_prive'] = "";
1213                         }
1214                         if (isset($info['script']) and count($info['script'])) {
1215                                 foreach ($info['script'] as $script) {
1216                                         if (isset($script['path']) and $script['path']) {
1217                                                 $code = "if (\$f=timestamp(find_in_path('" . addslashes($script['path']) . "'))) ";
1218                                         } else {
1219                                                 $code = "if (\$f='" . addslashes($script['url']) . "') ";
1220                                         }
1221                                         $code .= "\$val .= '<script src=\"'.\$f.'\" type=\"text/javascript\"></script>';\n";
1222                                         if ($script['type'] != 'prive') {
1223                                                 $prepend_code['insert_head'] .= $code;
1224                                         }
1225                                         if ($script['type'] != 'public') {
1226                                                 $prepend_code['header_prive'] .= $code;
1227                                         }
1228                                 }
1229                         }
1230                 }
1231         }
1232
1233         $prepend_code['insert_head'] =
1234                 "include_once_check(_DIR_RESTREINT . 'inc/pipelines.php');\n"
1235                 . "\$val = minipipe('f_jQuery', \$val);\n"
1236                 . $prepend_code['insert_head'];
1237         $prepend_code['header_prive'] =
1238                 "include_once_check(_DIR_RESTREINT . 'inc/pipelines_ecrire.php');\n"
1239                 . "\$val = minipipe('f_jQuery_prive', \$val);\n"
1240                 . $prepend_code['header_prive'];
1241
1242         // on ajoute les pipe qui ont ete recenses manquants
1243         foreach ($liste_pipe_manquants as $add_pipe) {
1244                 if (!isset($GLOBALS['spip_pipeline'][$add_pipe])) {
1245                         $GLOBALS['spip_pipeline'][$add_pipe] = '';
1246                 }
1247         }
1248
1249         return $prepend_code;
1250 }
1251
1252 /**
1253  * Précompilation des pipelines
1254  *
1255  * Crée le fichier d'exécution des pipelines
1256  * dont le chemin est défini par `_CACHE_PIPELINES`
1257  *
1258  * La liste des pipelines est définie par la globale `spip_pipeline`
1259  * qui a été remplie soit avec les fichiers d'options, soit avec
1260  * des descriptions de plugins (plugin.xml ou paquet.xml) dont celui de SPIP lui-même.
1261  *
1262  * Les fichiers à charger pour accéder aux fonctions qui doivent traverser
1263  * un pipeline se trouve dans la globale `spip_matrice`.
1264  *
1265  * @see pipeline_matrice_precompile()
1266  *
1267  * @uses ecrire_fichier_php()
1268  * @uses clear_path_cache()
1269  *
1270  * @param array $prepend_code
1271  *     Code PHP à insérer avant le passage dans la chaîne des fonctions d'un pipeline
1272  *     Couples 'Nom du pipeline' => Code PHP à insérer
1273 **/
1274 function pipeline_precompile($prepend_code = array()) {
1275
1276         $content = "";
1277         foreach ($GLOBALS['spip_pipeline'] as $action => $pipeline) {
1278                 $s_inc = "";
1279                 $s_call = "";
1280                 $pipe = array_filter(explode('|', $pipeline));
1281                 // Eclater le pipeline en filtres et appliquer chaque filtre
1282                 foreach ($pipe as $fonc) {
1283                         $fonc = trim($fonc);
1284                         $s_call .= '$val = minipipe(\'' . $fonc . '\', $val);' . "\n";
1285                         if (isset($GLOBALS['spip_matrice'][$fonc])) {
1286                                 $file = $GLOBALS['spip_matrice'][$fonc];
1287                                 $file = "'$file'";
1288                                 // si un _DIR_XXX: est dans la chaine, on extrait la constante
1289                                 if (preg_match(",(_(DIR|ROOT)_[A-Z_]+):,Ums", $file, $regs)) {
1290                                         $dir = $regs[1];
1291                                         $root_dir = str_replace('_DIR_', '_ROOT_', $dir);
1292                                         if (defined($root_dir)) {
1293                                                 $dir = $root_dir;
1294                                         }
1295                                         $file = str_replace($regs[0], "'." . $dir . ".'", $file);
1296                                         $file = str_replace("''.", "", $file);
1297                                         $file = str_replace(constant($dir), '', $file);
1298                                 }
1299                                 $s_inc .= "include_once_check($file);\n";
1300                         }
1301                 }
1302                 if (strlen($s_inc)) {
1303                         $s_inc = "static \$inc=null;\nif (!\$inc){\n$s_inc\$inc=true;\n}\n";
1304                 }
1305                 $content .= "// Pipeline $action \n"
1306                         . "function execute_pipeline_$action(&\$val){\n"
1307                         . $s_inc
1308                         . ((isset($prepend_code[$action]) and strlen($prepend_code[$action])) ? trim($prepend_code[$action]) . "\n" : '')
1309                         . $s_call
1310                         . "return \$val;\n}\n";
1311         }
1312         ecrire_fichier_php(_CACHE_PIPELINES, $content);
1313         clear_path_cache();
1314 }
1315
1316
1317 /**
1318  * Indique si un chemin de plugin fait parti des plugins activés sur le site
1319  *
1320  * @param string $plug_path
1321  *     Chemin du plugin
1322  * @return bool
1323  *     true si le plugin est actif, false sinon
1324 **/
1325 function plugin_est_installe($plug_path) {
1326         $plugin_installes = isset($GLOBALS['meta']['plugin_installes']) ? unserialize($GLOBALS['meta']['plugin_installes']) : array();
1327         if (!$plugin_installes) {
1328                 return false;
1329         }
1330
1331         return in_array($plug_path, $plugin_installes);
1332 }
1333
1334
1335 /**
1336  * Parcours les plugins activés et appelle leurs fonctions d'installation si elles existent.
1337  *
1338  * Elle ajoute ensuite les plugins qui ont été installés dans la valeur "plugin_installes"
1339  * de la table meta. Cette meta ne contient que les noms des plugins qui ont une version_base.
1340  *
1341  * @uses plugins_installer_dist()
1342  **/
1343 function plugin_installes_meta() {
1344         if (isset($GLOBALS['fichier_php_compile_recent'])) {
1345                 // attendre eventuellement l'invalidation du cache opcode
1346                 spip_attend_invalidation_opcode_cache($GLOBALS['fichier_php_compile_recent']);
1347         }
1348
1349         $installer_plugins = charger_fonction('installer', 'plugins');
1350         $meta_plug_installes = array();
1351         foreach (unserialize($GLOBALS['meta']['plugin']) as $prefix => $resume) {
1352                 if ($plug = $resume['dir']) {
1353                         $infos = $installer_plugins($plug, 'install', $resume['dir_type']);
1354                         if ($infos) {
1355                                 if (!is_array($infos) or $infos['install_test'][0]) {
1356                                         $meta_plug_installes[] = $plug;
1357                                 }
1358                                 if (is_array($infos)) {
1359                                         list($ok, $trace) = $infos['install_test'];
1360                                         include_spip('inc/filtres_boites');
1361                                         echo "<div class='install-plugins svp_retour'>"
1362                                                 . boite_ouvrir(_T('plugin_titre_installation', array('plugin' => typo($infos['nom']))),
1363                                                         ($ok ? 'success' : 'error'))
1364                                                 . $trace
1365                                                 . "<div class='result'>"
1366                                                 . ($ok ? ((isset($infos['upgrade']) && $infos['upgrade']) ? _T("plugin_info_upgrade_ok") : _T("plugin_info_install_ok")) : _T("avis_operation_echec"))
1367                                                 . "</div>"
1368                                                 . boite_fermer()
1369                                                 . "</div>";
1370                                 }
1371                         }
1372                 }
1373         }
1374         ecrire_meta('plugin_installes', serialize($meta_plug_installes), 'non');
1375 }
1376
1377 /**
1378  * Écrit un fichier PHP
1379  *
1380  * @param string $nom
1381  *     Chemin du fichier
1382  * @param string $contenu
1383  *     Contenu du fichier (sans les balises ouvrantes et fermantes de PHP)
1384  * @param string $comment
1385  *     Commentaire : code écrit en tout début de fichier, après la balise PHP ouvrante
1386 **/
1387 function ecrire_fichier_php($nom, $contenu, $comment = '') {
1388         if (!isset($GLOBALS['fichier_php_compile_recent'])) {
1389                 $GLOBALS['fichier_php_compile_recent'] = 0;
1390         }
1391
1392         $contenu = '<' . '?php' . "\n" . $comment . "\nif (defined('_ECRIRE_INC_VERSION')) {\n" . $contenu . "}\n?" . '>';
1393         // si un fichier existe deja on verifie que son contenu change avant de l'ecraser
1394         // si pas de modif on ne touche pas au fichier initial
1395         if (file_exists($nom)) {
1396                 if (substr($nom, -4) == '.php') {
1397                         $fichier_tmp = substr($nom, 0, -4) . '.tmp.php';
1398                 }
1399                 else {
1400                         $fichier_tmp = $nom . '.tmp';
1401                 }
1402                 file_put_contents($fichier_tmp, $contenu);
1403                 if(md5_file($nom) == md5_file($fichier_tmp)) {
1404                         $GLOBALS['fichier_php_compile_recent'] = max($GLOBALS['fichier_php_compile_recent'], filemtime($nom));
1405                         @unlink($fichier_tmp);
1406                         return;
1407                 }
1408                 @unlink($fichier_tmp);
1409         }
1410         ecrire_fichier($nom, $contenu);
1411         $GLOBALS['fichier_php_compile_recent'] = max($GLOBALS['fichier_php_compile_recent'], filemtime($nom));
1412         spip_clear_opcode_cache(realpath($nom));
1413 }