3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2014 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
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 \***************************************************************************/
13 if (!defined('_ECRIRE_INC_VERSION')) return;
15 // librairie pour parametrage plugin
17 define('_FILE_PLUGIN_CONFIG', "plugin.xml");
18 # l'adresse du repertoire de telechargement et de decompactage des plugins
19 define('_DIR_PLUGINS_AUTO', _DIR_PLUGINS
.'auto/');
22 include_spip('inc/texte');
24 function spip_version_compare($v1,$v2,$op){
25 $v1 = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1.\\2',$v1));
26 $v2 = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1.\\2',$v2));
27 $v1 = str_replace('rc','RC',$v1); // certaines versions de PHP ne comprennent RC qu'en majuscule
28 $v2 = str_replace('rc','RC',$v2); // certaines versions de PHP ne comprennent RC qu'en majuscule
29 $v1 = explode('.',$v1);
30 $v2 = explode('.',$v2);
31 while (count($v1)<count($v2))
33 while (count($v2)<count($v1))
35 $v1 = implode('.',$v1);
36 $v2 = implode('.',$v2);
38 return version_compare($v1, $v2,$op);
41 // lecture des sous repertoire plugin existants
42 // $dir_plugins pour forcer un repertoire (ex: _DIR_EXTENSIONS)
43 // _DIR_PLUGINS_SUPPL pour aller en chercher ailleurs (separes par des ":")
44 // http://doc.spip.org/@liste_plugin_files
45 function liste_plugin_files($dir_plugins = null){
46 static $plugin_files=array();
48 if (is_null($dir_plugins)) {
49 $dir_plugins = _DIR_PLUGINS
;
50 if (defined('_DIR_PLUGINS_SUPPL'))
51 $dir_plugins_suppl = array_filter(explode(':',_DIR_PLUGINS_SUPPL
));
54 if (!isset($plugin_files[$dir_plugins])
55 OR count($plugin_files[$dir_plugins]) == 0){
56 $plugin_files[$dir_plugins] = array();
57 foreach (preg_files($dir_plugins, '/plugin[.]xml$') as $plugin) {
58 $plugin_files[$dir_plugins][] = substr(dirname($plugin),strlen($dir_plugins));
60 sort($plugin_files[$dir_plugins]);
62 // hack affreux pour avoir le bon chemin pour les repertoires
63 // supplementaires ; chemin calcule par rapport a _DIR_PLUGINS.
64 if (isset($dir_plugins_suppl)) {
65 foreach($dir_plugins_suppl as $suppl) {
66 foreach (preg_files(_DIR_RACINE
.$suppl, 'plugin[.]xml$') as $plugin) {
67 $plugin_files[$dir_plugins][] = (_DIR_RACINE?
'':'../').dirname($plugin);
73 return $plugin_files[$dir_plugins];
76 // http://doc.spip.org/@plugin_version_compatible
77 function plugin_version_compatible($intervalle,$version){
78 if (!strlen($intervalle)) return true;
79 if (!preg_match(',^[\[\(]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-]*)[\]\)]$,',$intervalle,$regs)) return false;
80 #var_dump("$version::$intervalle");
83 $minimum_inc = $intervalle{0}=="[";
84 $maximum_inc = substr($intervalle,-1)=="]";
85 #var_dump("$version::$minimum_inc::$minimum::$maximum::$maximum_inc");
86 #var_dump(spip_version_compare($version,$minimum,'<'));
87 if (strlen($minimum)){
88 if ($minimum_inc AND spip_version_compare($version,$minimum,'<')) return false;
89 if (!$minimum_inc AND spip_version_compare($version,$minimum,'<=')) return false;
91 if (strlen($maximum)){
92 if ($maximum_inc AND spip_version_compare($version,$maximum,'>')) return false;
93 if (!$maximum_inc AND spip_version_compare($version,$maximum,'>=')) return false;
101 * Faire la liste des librairies disponibles
102 * retourne un array ( nom de la lib => repertoire , ... )
106 // http://doc.spip.org/@liste_librairies
107 function plugins_liste_librairies() {
109 foreach (array_reverse(creer_chemin()) as $d) {
110 if (is_dir($dir = $d.'lib/')
111 AND $t = @opendir
($dir)) {
112 while (($f = readdir($t)) !== false) {
114 AND is_dir("$dir/$f"))
122 // Prend comme argument le tableau des <necessite> et retourne un tableau vide
123 // si tout est bon, et un tableau avec une entree par erreur sinon
124 // http://doc.spip.org/@erreur_necessite
125 function erreur_necessite($n, $liste) {
126 if (!is_array($n) OR !count($n)) {
131 foreach($n as $need){
132 $id = strtoupper($need['id']);
134 // Necessite SPIP version x ?
136 if (!plugin_version_compatible($need['version'],
137 $GLOBALS['spip_version_branche'])) {
138 $msg[] = _T('plugin_necessite_spip', array(
139 'version' => $need['version']
144 // Necessite une librairie ?
145 else if (preg_match(',^(lib):(.*),i', $need['id'], $r)) {
147 if (!find_in_path('lib/'.$lib)) {
149 if (isset($need['src'])) {
151 include_spip('inc/charger_plugin');
152 $lien_download = '<br />'
153 .bouton_telechargement_plugin($url, strtolower($r[1]));
155 $msg[] = _T('plugin_necessite_lib', array('lib'=>$lib)) . $lien_download;
159 // Necessite un autre plugin version x ?
160 else if (!isset($liste[$id])
161 OR !plugin_version_compatible($need['version'],$liste[$id]['version'])
163 $msg[] = _T('plugin_necessite_plugin', array(
165 'version' => $need['version']));
173 // http://doc.spip.org/@liste_plugin_valides
174 function liste_plugin_valides($liste_plug, $force = false){
179 // lister les extensions qui sont automatiquement actives
180 $liste_extensions = liste_plugin_files(_DIR_EXTENSIONS
);
182 '_DIR_EXTENSIONS'=>$liste_extensions,
183 '_DIR_PLUGINS'=>$liste_plug
185 // creer une premiere liste non ordonnee mais qui ne retient
186 // que les plugins valides, et dans leur derniere version en cas de doublon
187 $liste_non_classee = array();
189 $get_infos = charger_fonction('get_infos','plugins');
191 foreach($listes as $dir_type=>$l){
192 foreach($l as $k=>$plug) {
193 // renseigner ce plugin
194 $infos[$dir_type][$plug] = $get_infos($plug,$force,constant($dir_type));
195 // si il n'y a pas d'erreur
196 if ($infos[$dir_type][$plug] AND !isset($infos[$dir_type][$plug]['erreur'])) {
197 // regarder si on a pas deja selectionne le meme plugin dans une autre version
198 $version = isset($infos[$dir_type][$plug]['version'])?
$infos[$dir_type][$plug]['version']:NULL;
199 if (isset($liste_non_classee[$p=strtoupper($infos[$dir_type][$plug]['prefix'])])){
200 // prendre le plus recent
201 if (spip_version_compare($version,$liste_non_classee[$p]['version'],'>'))
202 unset($liste_non_classee[$p]);
208 $liste_non_classee[$p] = array(
209 'nom' => $infos[$dir_type][$plug]['nom'],
210 'etat' => $infos[$dir_type][$plug]['etat'],
211 'dir_type' => $dir_type, // extensions ou plugins
213 'version'=>isset($infos[$dir_type][$plug]['version'])?
$infos[$dir_type][$plug]['version']:NULL
219 // il y a des plugins a trier
220 if (is_array($liste_non_classee)){
221 // pour tester utilise, il faut connaitre tous les plugins
222 // qui seront forcement pas la a la fin,
223 // car absent de la liste des plugins actifs
224 $toute_la_liste = $liste_non_classee;
226 // construire une liste ordonnee des plugins
228 while ($c=count($liste_non_classee) AND $c!=$count){ // tant qu'il reste des plugins a classer, et qu'on ne stagne pas
229 #echo "tour::";var_dump($liste_non_classee);
231 foreach($liste_non_classee as $p=>$resume) {
232 $plug = $resume['dir'];
233 $dir_type = $resume['dir_type'];
234 // si des plugins sont necessaire, on ne peut inserer qu'apres eux
235 $necessite_ok = !erreur_necessite($infos[$dir_type][$plug]['necessite'], $liste);
236 // si des plugins sont utiles, on ne peut inserer qu'apres eux,
237 // sauf si ils sont de toute facon absents de la liste
239 // tous les plugins "utilise" absents
240 $nb_utilise_absents_toleres = count(erreur_necessite($infos[$dir_type][$plug]['utilise'], $toute_la_liste));
241 // tous les plugins "utilise" absents de la liste deja trie
242 $nb_utilise_absents_tries = count(erreur_necessite($infos[$dir_type][$plug]['utilise'], $liste));
243 if (abs($nb_utilise_absents_tries - $nb_utilise_absents_toleres) > 0) {
247 if ($necessite_ok AND $utilise_ok){
248 $liste[$p] = $liste_non_classee[$p];
250 unset($liste_non_classee[$p]);
254 if (count($liste_non_classee)) {
255 include_spip('inc/lang');
256 utiliser_langue_visiteur();
258 foreach($liste_non_classee as $p=>$resume){
259 $plug = $resume['dir'];
260 $dir_type = $resume['dir_type'];
261 if ($n = erreur_necessite($infos[$dir_type][$plug]['necessite'], $liste)){
262 $erreurs .= "<li>" . _T('plugin_impossible_activer',
263 array('plugin' => constant($dir_type). $plug)
264 ) . "<ul><li>" . implode("</li><li>", $n) . "</li></ul></li>";
267 // dependance circulaire, ou utilise qu'on peut ignorer ?
268 // dans le doute on fait une erreur quand meme
269 // plutot que d'inserer silencieusement et de risquer un bug sournois latent
270 $necessite = erreur_necessite($infos[$dir_type][$plug]['utilise'], $liste);
271 $erreurs .= "<li>" . _T('plugin_impossible_activer',
272 array('plugin' => constant($dir_type). $plug)
273 ) . "<ul><li>" . implode("</li><li>", $necessite) . "</li></ul></li>";
276 ecrire_meta('plugin_erreur_activation',
277 "<ul>$erreurs</ul>");
281 return array($liste,$ordre,$infos);
284 // A utiliser pour initialiser ma variable globale $plugin
285 // http://doc.spip.org/@liste_plugin_actifs
286 function liste_plugin_actifs(){
287 $meta_plugin = isset($GLOBALS['meta']['plugin'])?
$GLOBALS['meta']['plugin']:'';
288 if (strlen($meta_plugin)>0){
289 if (is_array($t=unserialize($meta_plugin)))
291 else{ // compatibilite pre 1.9.2, mettre a jour la meta
292 spip_log("MAJ meta plugin vieille version : $meta_plugin","plugin");
293 $t = explode(",",$meta_plugin);
294 list($liste,,) = liste_plugin_valides($t);
295 include_spip('inc/meta');
296 ecrire_meta('plugin',serialize($liste));
305 * Lister les chemins vers les plugins actifs d'un dossier plugins/
309 // http://doc.spip.org/@liste_chemin_plugin_actifs
310 function liste_chemin_plugin_actifs($dir_plugins=_DIR_PLUGINS
){
311 $liste = liste_plugin_actifs();
312 foreach ($liste as $prefix=>$infos) {
313 // compat au moment d'une migration depuis version anterieure
314 // si pas de dir_type, alors c'est _DIR_PLUGINS
315 if (!isset($infos['dir_type']))
316 $infos['dir_type'] = "_DIR_PLUGINS";
317 if (defined($infos['dir_type'])
318 AND constant($infos['dir_type'])==$dir_plugins)
319 $liste[$prefix] = $infos['dir'];
321 unset($liste[$prefix]);
326 // http://doc.spip.org/@ecrire_plugin_actifs
327 function ecrire_plugin_actifs($plugin,$pipe_recherche=false,$operation='raz') {
328 static $liste_pipe_manquants=array();
330 // creer le repertoire cache/ si necessaire ! (installation notamment)
331 sous_repertoire(_DIR_CACHE
, '', false,true);
333 $liste_fichier_verif = array();
334 if (($pipe_recherche)&&(!in_array($pipe_recherche,$liste_pipe_manquants)))
335 $liste_pipe_manquants[]=$pipe_recherche;
337 if ($operation!='raz'){
338 $plugin_actifs = liste_chemin_plugin_actifs();
339 $plugin_liste = liste_plugin_files();
340 $plugin_valides = array_intersect($plugin_actifs,$plugin_liste);
341 if ($operation=='ajoute')
342 $plugin = array_merge($plugin_valides,$plugin);
343 if ($operation=='enleve')
344 $plugin = array_diff($plugin_valides,$plugin);
347 // recharger le xml des plugins a activer
348 list($plugin_valides,$ordre,$infos) = liste_plugin_valides($plugin,true);
350 ecrire_meta('plugin',serialize($plugin_valides));
351 effacer_meta('message_crash_plugins'); // baisser ce flag !
352 $plugin_header_info = array();
353 foreach($plugin_valides as $p=>$resume){
354 $plugin_header_info[]= $p.($resume['version']?
"(".$resume['version'].")":"");
356 ecrire_meta('plugin_header',substr(strtolower(implode(",",$plugin_header_info)),0,900));
358 $start_file = "<"."?php\nif (defined('_ECRIRE_INC_VERSION')) {\n";
359 $end_file = "}\n?".">";
361 if (is_array($infos)){
362 // construire tableaux de boutons et onglets
363 $liste_boutons = array();
364 $liste_onglets = array();
365 foreach($ordre as $p){
366 $dir_type = $plugin_valides[$p]['dir_type'];
367 $plug = $plugin_valides[$p]['dir'];
368 $info = $infos[$dir_type][$plug];
369 if (isset($info['bouton'])){
370 $liste_boutons = array_merge($liste_boutons,$info['bouton']);
372 if (isset($info['onglet'])){
373 $liste_onglets = array_merge($liste_onglets,$info['onglet']);
378 // generer les fichier
379 // charger_plugins_options.php
380 // charger_plugins_fonctions.php
381 if (defined('_DIR_PLUGINS_SUPPL'))
382 $dir_plugins_suppl = implode(array_filter(explode(':',_DIR_PLUGINS_SUPPL
)),'|');
384 foreach(array('chemins'=>_CACHE_PLUGINS_PATH
,'options'=>_CACHE_PLUGINS_OPT
,'fonctions'=>_CACHE_PLUGINS_FCT
) as $charge=>$fileconf){
388 if (is_array($infos)){
389 foreach($ordre as $p){
390 $dir_type = $plugin_valides[$p]['dir_type'];
391 $plug = $plugin_valides[$p]['dir'];
392 $info = $infos[$dir_type][$plug];
393 if($dir_plugins_suppl && preg_match(',('.$dir_plugins_suppl.'),',$plugin_valides[$p]['dir'])){
394 //$plugin_valides[$p]['dir_type'] = '_DIR_RACINE';
395 $dir_type = '_DIR_RACINE';
396 //if(!test_espace_prive())
397 $plug = str_replace('../','',$plug);
399 $root_dir_type = str_replace('_DIR_','_ROOT_',$dir_type);
400 $dir = $dir_type.".'" . $plug ."/'";
401 // definir le plugin, donc le path avant l'include du fichier options
402 // permet de faire des include_spip pour attraper un inc_ du plugin
403 if ($charge=='chemins'){
404 $prefix = strtoupper(preg_replace(',\W,','_',$info['prefix']));
405 $splugs .= "define('_DIR_PLUGIN_$prefix',$dir);\n";
406 foreach($info['path'] as $chemin){
407 if (!isset($chemin['version']) OR plugin_version_compatible($chemin['version'],$GLOBALS['spip_version_branche'])){
408 $dir = $chemin['dir'];
409 if (strlen($dir) AND $dir{0}=="/") $dir = substr($dir,1);
410 if (!isset($chemin['type']) OR $chemin['type']=='public')
411 $chemins['public'][]="_DIR_PLUGIN_$prefix".(strlen($dir)?
".'$dir'":"");
412 if (!isset($chemin['type']) OR $chemin['type']=='prive')
413 $chemins['prive'][]="_DIR_PLUGIN_$prefix".(strlen($dir)?
".'$dir'":"");
414 #$splugs .= "if (".(($chemin['type']=='public')?"":"!")."_DIR_RESTREINT) ";
415 #$splugs .= "_chemin(_DIR_PLUGIN_$prefix".(strlen($dir)?".'$dir'":"").");\n";
419 // concerne uniquement options et fonctions
420 if (isset($info[$charge])){
421 foreach($info[$charge] as $file){
422 // on genere un if file_exists devant chaque include pour pouvoir garder le meme niveau d'erreur general
425 if (strlen(constant($dir_type)) && (strpos($plug, constant($dir_type)) === 0)) {
426 $dir = str_replace("'".constant($dir_type), $root_dir_type.".'", "'$plug/'");
428 if($root_dir_type == '_ROOT_RACINE'){
429 $plug = str_replace('../','',$plug);
432 $dir = $root_dir_type.".'$plug/'";
433 $s .= "if (file_exists(\$f=$dir.'".trim($file)."')){ include_once \$f;}\n";
434 $liste_fichier_verif[] = "$root_dir_type:$plug/".trim($file);
439 if ($charge=='chemins'){
440 if (count($chemins)){
441 $splugs .= "if (_DIR_RESTREINT) _chemin(implode(':',array(".implode(',',array_reverse($chemins['public'])).")));\n";
442 $splugs .= "else _chemin(implode(':',array(".implode(',',array_reverse($chemins['prive'])).")));\n";
445 if ($charge=='options'){
446 $s .= "if (!function_exists('boutons_plugins')){function boutons_plugins(){return unserialize('".str_replace("'","\'",serialize($liste_boutons))."');}}\n";
447 $s .= "if (!function_exists('onglets_plugins')){function onglets_plugins(){return unserialize('".str_replace("'","\'",serialize($liste_onglets))."');}}\n";
449 ecrire_fichier($fileconf, $start_file . $splugs . $s . $end_file);
452 if (is_array($infos)){
453 // construire tableaux de pipelines et matrices et boutons
454 // $GLOBALS['spip_pipeline']
455 // $GLOBALS['spip_matrice']
456 $liste_boutons = array();
457 foreach($ordre as $p){
458 $dir_type = $plugin_valides[$p]['dir_type'];
459 $root_dir_type = str_replace('_DIR_','_ROOT_',$dir_type);
460 $plug = $plugin_valides[$p]['dir'];
461 $info = $infos[$dir_type][$plug];
463 $prefix = $info['prefix']."_";
464 if (isset($info['pipeline']) AND is_array($info['pipeline'])){
465 foreach($info['pipeline'] as $pipe){
467 if (isset($pipe['action']))
468 $action = $pipe['action'];
471 $nomlower = strtolower($nom);
473 AND isset($GLOBALS['spip_pipeline'][$nom])
474 AND !isset($GLOBALS['spip_pipeline'][$nomlower])){
475 $GLOBALS['spip_pipeline'][$nomlower] = $GLOBALS['spip_pipeline'][$nom];
476 unset($GLOBALS['spip_pipeline'][$nom]);
479 if (!isset($GLOBALS['spip_pipeline'][$nom])) // creer le pipeline eventuel
480 $GLOBALS['spip_pipeline'][$nom]="";
481 if (strpos($GLOBALS['spip_pipeline'][$nom],"|$prefix$action")===FALSE)
482 $GLOBALS['spip_pipeline'][$nom] = preg_replace(",(\|\||$),","|$prefix$action\\1",$GLOBALS['spip_pipeline'][$nom],1);
483 if (isset($pipe['inclure'])){
484 $GLOBALS['spip_matrice']["$prefix$action"] =
485 "$root_dir_type:$plug/".$pipe['inclure'];
492 // on charge les fichiers d'options qui peuvent completer
493 // la globale spip_pipeline egalement
494 if (@is_readable
(_CACHE_PLUGINS_PATH
))
495 include_once(_CACHE_PLUGINS_PATH
); // securite : a priori n'a pu etre fait plus tot
496 if (@is_readable
(_CACHE_PLUGINS_OPT
)) {
497 include_once(_CACHE_PLUGINS_OPT
);
499 spip_log("pipelines desactives: impossible de produire " . _CACHE_PLUGINS_OPT
);
502 // on ajoute les pipe qui ont ete recenses manquants
503 foreach($liste_pipe_manquants as $add_pipe)
504 if (!isset($GLOBALS['spip_pipeline'][$add_pipe]))
505 $GLOBALS['spip_pipeline'][$add_pipe]= '';
507 $liste_fichier_verif2 = pipeline_precompile();
508 $liste_fichier_verif = array_merge($liste_fichier_verif,$liste_fichier_verif2);
510 // on note dans tmp la liste des fichiers qui doivent etre presents,
511 // pour les verifier "souvent"
512 // ils ne sont verifies que depuis l'espace prive, mais peuvent etre reconstruit depuis l'espace public
513 // dans le cas d'un plugin non declare, spip etant mis devant le fait accompli
514 // hackons donc avec un "../" en dur dans ce cas, qui ne manquera pas de nous embeter un jour...
515 foreach ($liste_fichier_verif as $k => $f){
516 // si un _DIR_XXX: est dans la chaine, on extrait la constante
517 if (preg_match(",(_(DIR|ROOT)_[A-Z_]+):,Ums",$f,$regs))
518 $f = str_replace($regs[0],$regs[2]=="ROOT"?
constant($regs[1]):(_DIR_RACINE?
"":"../").constant($regs[1]),$f);
519 $liste_fichier_verif[$k] = $f;
521 ecrire_fichier(_CACHE_PLUGINS_VERIF
,
522 serialize($liste_fichier_verif));
526 // precompilation des pipelines
527 // http://doc.spip.org/@pipeline_precompile
528 function pipeline_precompile(){
529 global $spip_pipeline, $spip_matrice;
530 $liste_fichier_verif = array();
532 $start_file = "<"."?php\nif (defined('_ECRIRE_INC_VERSION')) {\n";
533 $end_file = "}\n?".">";
535 foreach($spip_pipeline as $action=>$pipeline){
538 $pipe = array_filter(explode('|',$pipeline));
539 // Eclater le pipeline en filtres et appliquer chaque filtre
540 foreach ($pipe as $fonc) {
542 $s_call .= '$val = minipipe(\''.$fonc.'\', $val);'."\n";
543 if (isset($spip_matrice[$fonc])){
544 $file = $spip_matrice[$fonc];
545 $liste_fichier_verif[] = $file;
546 $s_inc .= 'if (file_exists($f=';
548 // si un _DIR_XXX: est dans la chaine, on extrait la constante
549 if (preg_match(",(_(DIR|ROOT)_[A-Z_]+):,Ums",$file,$regs)){
551 $root_dir = str_replace('_DIR_','_ROOT_',$dir);
552 if (defined($root_dir))
554 $file = str_replace($regs[0],"'.".$dir.".'",$file);
555 $file = str_replace("''.","",$file);
556 $file = str_replace(constant($dir), '', $file);
558 $s_inc .= $file . ')){include_once($f);}'."\n";
561 $content .= "// Pipeline $action \n";
562 $content .= "function execute_pipeline_$action(&\$val){\n";
565 $content .= "return \$val;\n}\n\n";
567 ecrire_fichier(_CACHE_PIPELINES
, $start_file . $content . $end_file);
568 return $liste_fichier_verif;
571 // pas sur que ca serve...
572 // http://doc.spip.org/@liste_plugin_inactifs
573 function liste_plugin_inactifs(){
574 return array_diff (liste_plugin_files(),liste_chemin_plugin_actifs());
577 // mise a jour du meta en fonction de l'etat du repertoire
578 // Les ecrire_meta() doivent en principe aussi initialiser la valeur a vide
579 // si elle n'existe pas
580 // risque de pb en php5 a cause du typage ou de null (verifier dans la doc php)
581 function actualise_plugins_actifs($pipe_recherche = false){
582 if (!spip_connect()) return false;
583 $plugin_actifs = liste_chemin_plugin_actifs();
584 $plugin_liste = liste_plugin_files();
585 $plugin_new = array_intersect($plugin_actifs,$plugin_liste);
586 $actifs_avant = $GLOBALS['meta']['plugin'];
587 ecrire_plugin_actifs($plugin_new,$pipe_recherche);
588 // retourner -1 si la liste des plugins actifs a change
589 return (strcmp($GLOBALS['meta']['plugin'],$actifs_avant)==0) ?
1 : -1;
592 // http://doc.spip.org/@spip_plugin_install
593 function spip_plugin_install($action, $infos){
594 $prefix = $infos['prefix'];
595 $version_cible = $infos['version_base'];
596 if (isset($infos['meta']) AND (($table = $infos['meta']) !== 'meta'))
597 $nom_meta = "base_version";
599 $nom_meta = $prefix."_base_version";
604 return (isset($GLOBALS[$table])
605 AND isset($GLOBALS[$table][$nom_meta])
606 AND spip_version_compare($GLOBALS[$table][$nom_meta],$version_cible,'>='));
609 if (function_exists($upgrade = $prefix."_upgrade"))
610 $upgrade($nom_meta, $version_cible, $table);
613 if (function_exists($vider_tables = $prefix."_vider_tables"))
614 $vider_tables($nom_meta, $table);
619 // http://doc.spip.org/@desinstalle_un_plugin
620 function desinstalle_un_plugin($plug,$infos){
621 // faire les include qui vont bien
622 charge_instal_plugin($plug, $infos);
623 $version_cible = isset($infos['version_base'])?
$infos['version_base']:'';
624 $prefix_install = $infos['prefix']."_install";
625 if (function_exists($prefix_install)){
626 $prefix_install('uninstall',$infos['prefix'],$version_cible);
627 $ok = $prefix_install('test',$infos['prefix'],$version_cible);
630 if (isset($infos['version_base'])){
631 spip_plugin_install('uninstall',$infos);
632 $ok = spip_plugin_install('test',$infos);
639 function charge_instal_plugin($plug,$infos,$dir_plugins = '_DIR_PLUGINS'){
640 // passer en chemin absolu si possible
641 $dir = str_replace('_DIR_','_ROOT_',$dir_plugins);
645 // faire les include qui vont bien
646 foreach($infos['install'] as $file){
648 if (file_exists($f=constant($dir)."$plug/$file")){
654 function installe_un_plugin($plug,$infos,$dir_plugins = '_DIR_PLUGINS'){
656 charge_instal_plugin($plug, $infos, $dir_plugins);
658 $version_cible = isset($infos['version_base'])?
$infos['version_base']:'';
659 $prefix_install = $infos['prefix']."_install";
660 // cas de la fonction install fournie par le plugin
661 if (function_exists($prefix_install)){
662 // voir si on a besoin de faire l'install
663 $ok = $prefix_install('test',$infos['prefix'],$version_cible);
665 echo "<div class='install-plugins'>";
666 echo _T('plugin_titre_installation',array('plugin'=>typo($infos['nom'])))."<br />";
667 $prefix_install('install',$infos['prefix'],$version_cible);
668 $ok = $prefix_install('test',$infos['prefix'],$version_cible);
669 // vider le cache des definitions des tables
670 $trouver_table = charger_fonction('trouver_table','base');
671 $trouver_table(false);
672 echo "<span class='".($ok?
'ok':'erreur')."'>".($ok ?
_L("OK"):_L("Echec"))."</span>";
675 return $ok; // le plugin est deja installe et ok
677 // pas de fonction instal fournie, mais une version_base dans le plugin
678 // on utilise la fonction par defaut
679 if (isset($infos['version_base'])){
680 $ok = spip_plugin_install('test',$infos);
682 echo "<div class='install-plugins'>";
683 echo _T('plugin_titre_installation',array('plugin'=>typo($infos['nom'])))."<br />";
684 spip_plugin_install('install',$infos);
685 $ok = spip_plugin_install('test',$infos);
686 // vider le cache des definitions des tables
687 $trouver_table = charger_fonction('trouver_table','base');
688 $trouver_table(false);
689 echo "<span class='".($ok?
'ok':'erreur')."'>".($ok ?
_L("OK"):_L("Echec"))."</span>";
692 return $ok; // le plugin est deja installe et ok
697 // http://doc.spip.org/@installe_plugins
698 function installe_plugins($test = false){
699 $meta_plug_installes = array();
701 // vider le cache des descriptions de tables avant installation
702 $trouver_table = charger_fonction('trouver_table', 'base');
705 $liste = liste_plugin_actifs();
706 $get_infos = charger_fonction('get_infos','plugins');
708 foreach ($liste as $prefix=>$resume) {
709 $plug = $resume['dir'];
710 $dir_type = $resume['dir_type'];
711 $infos = $get_infos($plug,false,constant($dir_type));
712 if ($infos AND isset($infos['install'])){
713 if ($test) return true; // il y a des installations a faire
714 $ok = installe_un_plugin($plug,$infos,$dir_type);
715 // on peut enregistrer le chemin ici car il est mis a jour juste avant l'affichage
716 // du panneau -> cela suivra si le plugin demenage
718 $meta_plug_installes[] = $plug;
719 // vider le cache des descriptions de tables apres chaque installation
723 ecrire_meta('plugin_installes',serialize($meta_plug_installes),'non');
724 if ($test) return false; // il n'y a pas d'installations a faire
725 return true; // succes
728 // http://doc.spip.org/@plugin_est_installe
729 function plugin_est_installe($plug_path){
730 $plugin_installes = isset($GLOBALS['meta']['plugin_installes'])?
unserialize($GLOBALS['meta']['plugin_installes']):array();
731 if (!$plugin_installes) return false;
732 return in_array($plug_path,$plugin_installes);
735 // http://doc.spip.org/@verifie_include_plugins
736 function verifie_include_plugins() {
737 include_spip('inc/meta');
738 ecrire_meta('message_crash_plugins', 1);
740 /* if (_request('exec')!="admin_plugin"
741 AND $_SERVER['X-Requested-With'] != 'XMLHttpRequest'){
742 if (@is_readable(_DIR_PLUGINS)) {
743 include_spip('inc/headers');
744 redirige_url_ecrire("admin_plugin");
746 // plus de repertoire plugin existant, le menu n'existe plus
747 // on fait une mise a jour silencieuse
748 // generer les fichiers php precompiles
749 // de chargement des plugins et des pipelines
750 actualise_plugins_actifs();
751 spip_log("desactivation des plugins suite a suppression du repertoire");
757 // http://doc.spip.org/@message_crash_plugins
758 function message_crash_plugins() {
759 if (autoriser('configurer')
760 AND lire_fichier(_CACHE_PLUGINS_VERIF
,$l)
761 AND $l = @unserialize
($l)) {
763 foreach ($l as $fichier) {
764 if (!@is_readable
($fichier)) {
765 spip_log("Verification plugin: echec sur $fichier !");
771 $err = array_map('joli_repertoire', array_unique($err));
772 return "<a href='".generer_url_ecrire('admin_plugin')."'>"
773 ._T('plugins_erreur',
774 array('plugins' => join(', ', $err)))