.-.-.-.-.-

effacer_messagerecu.php000064400000002502152525112720011234 0ustar00<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2020                                                *
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
\***************************************************************************/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * @param int $id_auteur
 * @param int $id_message
 * @return void
 */
function action_effacer_messagerecu_dist($id_auteur = null, $id_message = null) {
	if (is_null($id_auteur) or is_null($id_message)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
		list($id_auteur, $id_message) = explode('-', $arg);
	}

include_spip('inc/autoriser');
	if (autoriser('effacer', 'messagerecu', $id_message, null, array('id_auteur' => $id_auteur))) {
		include_spip('inc/messages');
		messagerie_effacer_message_recu($id_auteur, $id_message);
	}
}
quete_calendrier_prive.php000064400000012407152525112720012003 0ustar00<?php

/**
 * Gestion de l'action de quête des événements du calendrier
 *
 * @package SPIP\Organiseur\Action
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Fournir une liste d'"evenements" entre deux dates start et end
 * au format json
 *
 * Utilisé pour l'affichage du calendrier privé et public
 *
 * @pipeline_appel quete_calendrier_prive
 * @uses quete_calendrier_interval_rv()
 * @uses quete_calendrier_interval()
 * @uses convert_fullcalendar_quete_calendrier_interval_rv()
 * @uses convert_fullcalendar_quete_calendrier_interval()
 *
 * @return void
 */
function action_quete_calendrier_prive_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$securiser_action();

$start = strtotime(_request('start'));
	$end = strtotime(_request('end'));
	$quoi = _request('quoi');

include_spip('inc/quete_calendrier');

$evt = array();

// recuperer la liste des evenements au format ics
	$start = date('Y-m-d H:i:s', $start);
	$end = date('Y-m-d H:i:s', $end);
	$limites = array(sql_quote($start), sql_quote($end));

// on fonction de quoi on récupère : tout (rv + publication) ou l'un ou l'autre.
	$entier = $duree = array();

if (!$quoi or $quoi == 'rv') {
		$duree = quete_calendrier_interval_rv(reset($limites), end($limites));
		$evt = convert_fullcalendar_quete_calendrier_interval_rv($duree, $evt);
	}

if (!$quoi or $quoi == 'publication') {
		list($entier, ) = quete_calendrier_interval($limites);
		$evt = convert_fullcalendar_quete_calendrier_interval($entier, $evt);
	}

// permettre aux plugins d'afficher leurs evenements dans ce calendrier
	$evt = pipeline(
		'quete_calendrier_prive',
		array(
			'args' => array('start' => $start, 'end' => $end, 'quoi' => $quoi),
			'data' => $evt,
		)
	);

// format json
	include_spip('inc/json');
	echo json_encode($evt);
}

/**
 * Convertir une date au format ical renvoyée par quete_calendrier_interval
 * dans le format attendu par fullcalendar : yyyy-mm-dd H:i:s
 *
 * @param $dateical
 * @return string
 */
function convert_dateical($dateical) {
	$d = explode('T', $dateical);
	$amj = reset($d);
	$s = substr($amj, 0, 4) . '-' . substr($amj, 4, 2) . '-' . substr($amj, 6, 2);
	if (count($d) > 1) {
		$his = end($d);
		$s .= ' ' . substr($his, 0, 2) . ':' . substr($his, 2, 2) . ':' . substr($his, 4, 2);
	}

return $s;
}

/**
 * Convertir une sortie événement de quète calendrier_interval
 * dans le format attendu par fullcalendar
 *
 * @param array $messages
 *     Les événements / messages au format de la quete calendrier_interval
 * @param array $evt
 *     Les événements au format fullcalendar déjà présents
 * @return array
 *     Les événements au format fullcalendar
 **/
function convert_fullcalendar_quete_calendrier_interval($messages, $evt = array()) {
	if (!$messages) {
		return $evt;
	}

// la retransformer au format attendu par fullcalendar
	// facile : chaque evt n'est mentionne qu'une fois, a une date
	foreach ($messages as $amj => $l) {
		$date = substr($amj, 0, 4) . '-' . substr($amj, 4, 2) . '-' . substr($amj, 6, 2);
		foreach ($l as $e) {
			$evt[] = array(
				'id' => 0,
				'title' => $e['SUMMARY'],
				'allDay' => true,
				'start' => $date,
				'end' => $date,
				'url' => str_replace('&amp;', '&', $e['URL']),
				'className' => 'calendrier-event ' . $e['CATEGORIES'],
				'description' => $e['DESCRIPTION'],
			);
		}
	}

return $evt;
}

/**
 * Convertir une sortie événement de quete calendrier_interval_rv
 * dans le format attendu par fullcalendar
 *
 * @use convert_dateical()
 *
 * @param array $messages
 *     Les événements / messages au format issu de la quete calendrier_interval_rv
 * @param array $evt
 *     Les événements au format fullcalendar déjà présents
 * @return array
 *     Les événements au format fullcalendar
 **/
function convert_fullcalendar_quete_calendrier_interval_rv($messages, $evt = array()) {
	if (!$messages) {
		return $evt;
	}

// ici il faut faire attention : un evt apparait N fois
	// mais on a son id
	$seen = array();

// toutes les messages déjà inscrits qu'on ne remet pas
	foreach ($evt as $e) {
		$seen[$e['url']] = true;
	}

foreach ($messages as $l) {
		foreach ($l as $id => $e) {
			$url = str_replace('&amp;', '&', $e['URL']);
			if (!isset($seen[$url])) {
				$evt[] = array(
					'id' => $id,
					'title' => $e['SUMMARY'],
					'allDay' => false,
					'start' => convert_dateical($e['DTSTART']), //Ymd\THis
					'end' => convert_dateical($e['DTEND']), // Ymd\THis
					'url' => $url,
					'className' => 'calendrier-event ' . $e['CATEGORIES'],
					'description' => $e['DESCRIPTION'],
				);
				$seen[$url] = true;
			}
		}
	}

return $evt;
}
envoyer_message.php000064400000002453152525112720010456 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * @param int $id_message
 * @return void
 */
function action_envoyer_message_dist($id_message = null) {

if (is_null($id_message)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$id_message = $securiser_action();
	}

include_spip('inc/autoriser');
	if (intval($id_message)
		and $type = sql_getfetsel('type', 'spip_messages', 'id_message=' . intval($id_message))
		and autoriser('envoyermessage', $type, $id_message)
	) {
		include_spip('action/editer_objet');
		objet_modifier('message', $id_message, array('statut' => 'publie'));
	}
}
quete_autocomplete.php000064400000002244152525112720011165 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

function action_quete_autocomplete_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();
	if ($arg
		and $arg == $GLOBALS['visiteur_session']['id_auteur']
	) {
		include_spip('inc/actions');
		include_spip('inc/json');
		echo ajax_retour(
			recuperer_fond('prive/squelettes/inclure/organiseur-autocomplete-auteur', array('term' => _request('term'))),
			'application/json'
		);
	}
}
supprimer_message.php000064400000002264152525112720011015 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * @param int $id_message
 * @return void
 */
function action_supprimer_message_dist($id_message = null) {
	if (is_null($id_message)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$id_message = $securiser_action();
	}

include_spip('inc/autoriser');
	if (autoriser('supprimer', 'message', $id_message)) {
		include_spip('action/editer_objet');
		objet_modifier('message', $id_message, array('statut' => 'poub'));
	}
}
seo_save_meta.php000064400000001711152525221350010071 0ustar00<?php
/**
* BouncingOrange SPIP SEO plugin
*
* @category   SEO
* @package    SPIP_SEO
* @author     Pierre ROUSSET (p.rousset@gmail.com)
* @copyright  Copyright (c) 2009 BouncingOrange (http://www.bouncingorange.com)
* @license    http://opensource.org/licenses/gpl-2.0.php  General Public License (GPL 2.0)
*/

if (!defined("_ECRIRE_INC_VERSION")) return;

function action_seo_save_meta_dist() {
	include_spip('inc/abstract_sql');

$id_object   = _request('id_object');
	$type_object = _request('type_object');
	$meta_tag 	 = is_array(_request('meta_tag')) ? _request('meta_tag') : array();
	
	if(!autoriser('modifier', $type_object, $id_object)) {
		echo "Error :(";
		return;
	}
	
	sql_delete("spip_seo", "id_object = $id_object AND type_object = '$type_object'");
	
	foreach ($meta_tag as $name => $content) {
		sql_insertq('spip_seo', array('id_object' => $id_object, 'type_object' => $type_object, 'meta_name' => $name, 'meta_content' => $content));
	} 
	
}

?>
teleporter.php000064400000006534152525277620007467 0ustar00<?php
/**
 * Gestion de l'action teleporter
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Actions
 */

/**
 * Téléporter et déballer un composant
 *
 * @param string $methode
 *   http|git|svn|...
 * @param string $source
 *   URL source du composant
 * @param string $dest
 *   Chemin du répertoire où déballer le composant. Inclus le dernier segment
 * @param array $options
 *   revision => ''
 *   --ignore-externals
 * @return bool|string
 *   String : texte d'une erreur
 *   true si l'opération est correctement réalisée
 */
function action_teleporter_composant_dist($methode, $source, $dest, $options = array()) {

# Si definie a '', le chargeur est interdit ; mais on n'aurait de toutes
	# facons jamais pu venir ici avec toutes les securisations faites :^)
	# sauf si on doit télécharger une lib dans _DIR_LIB
	if (!preg_match(',' . substr(_DIR_LIB, 0, -1) . ',', $dest) && !_DIR_PLUGINS_AUTO) {
		die('Vous ne pouvez pas télécharger, absence de _DIR_PLUGINS_AUTO');
	}
	if (!autoriser('ajouter', '_plugins')){
		return _T('svp:erreur_teleporter_chargement_source_impossible', ['source' => $source]);
	}

// verifier que la methode est connue
	if (!$teleporter = charger_fonction($methode, "teleporter", true)) {
		spip_log("Methode $methode inconnue pour teleporter $source vers $dest", "teleport" . _LOG_ERREUR);

return _T('svp:erreur_teleporter_methode_inconue', array('methode' => $methode));
	}

if (!$dest = teleporter_verifier_destination($d = $dest)) {
		spip_log("Rerpertoire $d non accessible pour teleporter $source vers $d", "teleport" . _LOG_ERREUR);

return _T('svp:erreur_teleporter_destination_erreur', array('dir' => $d));
		#$texte = "<p>"._T('plugin_erreur_droit1',array('dest'=>$dest))."</p>"
		#  . "<p>"._T('plugin_erreur_droit2').aider('install0')."</p>";
	}

# destination temporaire des fichiers si besoin
	$options['dir_tmp'] = sous_repertoire(_DIR_CACHE, 'chargeur');

return $teleporter($methode, $source, $dest, $options);
}

/**
 * Vérifier et préparer l'arborescence jusqu'au répertoire parent
 *
 * @param string $dest
 * @return bool|string
 *     false en cas d'échec
 *     Chemin du répertoire sinon
 */
function teleporter_verifier_destination($dest) {
	$dest = rtrim($dest, "/");
	$final = basename($dest);
	$base = dirname($dest);
	$create = array();
	// on cree tout le chemin jusqu'a dest non inclus
	while (!is_dir($base)) {
		$create[] = basename($base);
		$base = dirname($base);
	}
	while (count($create)) {
		if (!is_writable($base)) {
			return false;
		}
		$base = sous_repertoire($base, array_pop($create));
		if (!$base) {
			return false;
		}
	}

if (!is_writable($base)) {
		return false;
	}

return $base . "/$final";
}

/**
 * Déplace un répertoire pour libérer l'emplacement.
 *
 * Si le répertoire donné existe, le déplace dans un répertoire de backup.
 * Si ce backup existe déjà, il est supprimé auparavant.
 * Retourne le nouveau chemin du répertoire.
 *
 * @param string $dest
 *     Chemin du répertoire à déplacer
 * @return string
 *     Nouveau chemin du répertoire s'il existait,
 *     Chaîne vide sinon
 **/
function teleporter_nettoyer_vieille_version($dest) {
	$old = "";
	if (is_dir($dest)) {
		$dir = dirname($dest);
		$base = basename($dest);
		$old = "$dir/.$base.bck";
		if (is_dir($old)) {
			supprimer_repertoire($old);
		}
		rename($dest, $old);
	}

return $old;
}
actionner.php000064400000010013152525277620007247 0ustar00<?php

/**
 * Gestion de l'action actionner
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Actions
 */

if (!defined("_ECRIRE_INC_VERSION")) {
	return;
}

/**
 * Action effectuant 1 action dans la liste des actions à réaliser
 * sur les plugins.
 *
 * Cette action sera relancée tant qu'il reste des actions à faire
 */
function action_actionner_dist() {
	// droits
	include_spip('inc/autoriser');
	if (!autoriser('configurer', '_plugins')) {
		include_spip('inc/minipres');
		echo minipres();
		exit;
	}

include_spip('inc/svp_actionner');
	include_spip('inc/headers');
	$actionneur = new Actionneur();
	$actionneur->get_actions();

if ($actionneur->one_action()) {
		// si SVP a été enlevé des actifs, on redirige sur la fin...
		// sinon cette page d'action/actionner devient introuvable.
		// dans ce cas précis, les autres actions prévues venant après la desactivation de SVP
		// ne pourront être traitees... SVP n'étant plus là !
		if ($actionneur->tester_si_svp_desactive()) {
			$url = _request('redirect');
		} else {
			$url = generer_action_auteur('actionner', '', _request('redirect'));
		}

// en mode pas à pas, on affiche un bilan entre chaque action
		// et on demande a l'utilistateur de cliquer pour realiser
		// l'action suivante.
		include_spip('inc/config');
		if (lire_config('svp/mode_pas_a_pas') == 'oui') {
			include_spip('inc/minipres');
			include_spip('inc/filtres');
			$pres = $actionneur->presenter_actions();
			$btn = "<a href='".attribut_html($url)."'>[ Action Suivante ]</a>";
			$styles = "
				<style type='text/css'>
				#minipres #actionner .fail {color:#c30000;}
				#minipres #actionner ul {margin-left: 0.5em;}
				#minipres #actionner li {list-style-type:square; margin-left: 0.5em;}
				</style>";
			echo minipres(_T('svp:installation_en_cours'), $pres . '<br /><br />' . $btn . $styles);
			die();
		}

// s'il n'y avait en tout est pour tout qu'une seule action, rediriger directement
		if ($actionneur->progression() === 1 and count($actionneur->done) === 1) {
			redirige_par_entete(str_replace('&amp;', '&', $url));
		}
		// sinon bel affichage de la progression
		svp_redirige_boucle(
			str_replace('&amp;', '&', $url),
			$actionneur->presenter_derniere_action(),
			$actionneur->progression()
		);
	}

foreach ($actionneur->done as $done) {
		if ($done['todo'] == 'on') {
			if ($voir = session_get('svp_admin_plugin_voir')
				and $voir == 'inactif'
			) {
				session_set('svp_admin_plugin_voir', 'actif');
			}
			break;
		}
	}

include_spip('inc/svp_depoter_local');
	svp_actualiser_paquets_locaux();

if (!_request('redirect')) {
		$GLOBALS['redirect'] = generer_url_ecrire('admin_plugin');
	} else {
		$GLOBALS['redirect'] = str_replace('&amp;', '&', _request('redirect'));
	}
}

/**
 * Redirections par refresh d'une URL afin d'éviter des blocages de redirections par les navigateurs
 * lorsqu'elles sont trop nombreuses
 *
 * @param string $url
 * @param string $texte Texte de l'action réalisée
 * @param string $progres
 */
function svp_redirige_boucle($url, $texte, $progres){
	include_spip('inc/minipres');

//@apache_setenv('no-gzip', 1); // provoque page blanche chez certains hebergeurs donc ne pas utiliser
	@ini_set('zlib.output_compression', '0'); // pour permettre l'affichage au fur et a mesure
	@ini_set('output_buffering', 'off');
	@ini_set('implicit_flush', 1);
	@ob_implicit_flush(1);

$pres = '<meta http-equiv="refresh" content="0;'.$url.'">';
	$pres .="
			<div class='derniere_action'>$texte</div>
			<div class='progression'>" . round($progres*100) . "%</div>
			<div class='bar'><div style='width:".round($progres*100)."%'></div></div>
			";

$styles = "
		<style type='text/css'>
		#minipres .derniere_action { font-weight:bold; }
		#minipres div {
			line-height:140%;
		}
		#minipres div.progression {
			margin-top:2em;
			font-weight:bold;
			font-size:1.4em;
			text-align:center;
		}
		#minipres .bar {border:1px solid #aaa;}
		#minipres .bar div {background:#aaa;height:1em;}
		</style>";

echo minipres(_T('svp:installation_en_cours'), $pres . $styles);
	exit;
}
editer_depot.php000064400000005602152525277620007744 0ustar00<?php

/**
 * Gestion de l'action editer_depot
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Actions
 */
if (!defined("_ECRIRE_INC_VERSION")) {
	return;
}

/**
 * Action de mise à jour des descriptions d'un dépot
 *
 * @return array
 *     Liste identifiant du dépot, texte d'erreur éventuel
 **/
function action_editer_depot_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

// Verification des autorisations
	if (!autoriser('webmestre')) {
		include_spip('inc/minipres');
		echo minipres();
		exit();
	}

// Le depot n'est jamais cree par une edition mais via le formulaire ajouter_depot
	// On est toujours en presence d'une mise a jour pour cette action, l'id_depot
	// doit donc etre renseigne sinon c'est une erreur
	if ($id_depot = intval($arg)) {
		// On teste si l'auteur est connecte. Si non on renvoie sur le formulaire login
		$id_auteur = $GLOBALS['visiteur_session']['id_auteur'];
		if (!($id_auteur)) {
			include_spip('inc/headers');
			redirige_url_ecrire();
		}

// On met a jour le depot avec les saisies
		if (sql_updateq('spip_depots',
			array(
				'titre' => _request('titre'),
				'descriptif' => _request('descriptif'),
				'type' => _request('type')
			),
			'id_depot=' . sql_quote($id_depot))) {
			;
		}
		// Enregistre l'envoi dans la BD
		// Dans le cas du depot rien n'est fait actuellement, on garde cette fonction
		// par souci de coherence avec les autres editions d'objet et pour usage futur
		$err = depots_set($id_depot);
		if (!$err) {
			spip_log("ACTION MODIFIER DEPOT (manuel) : id_depot = " . $id_depot, 'svp_actions.' . _LOG_INFO);
		}
	}

return array($id_depot, $err);
}

/**
 * Appelle toutes les fonctions de modification d'un dépot
 * $err est de la forme '&trad_err=1'
 *
 * @note
 *     Cette fonction ne fait rien actuellement !!
 *
 * @param int $id_depot
 *     Identifiant du dépot
 * @return string
 *     Texte d'une eventuelle erreur
 **/
function depots_set($id_depot) {
	$err = '';

// unifier $texte en cas de texte trop long
	// - non utilisabe sur le descriptif aujourd'huiez

// Enregistrer les revisions
	// - revisions_depot()

// Modifier le statut ?
	// - instituer_depot()

return $err;
}
supprimer_depot.php000064400000001477152525277620010524 0ustar00<?php
/**
 * Gestion de l'action supprimer_depot
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Actions
 */

/**
 * Action de suppression en base de données d'un dépot et de ses plugins
 *
 * @uses  svp_supprimer_depot()
 * @return void
 */
function action_supprimer_depot_dist() {

// Securisation: aucun argument attendu
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

// Verification des autorisations
	if (!autoriser('webmestre')) {
		include_spip('inc/minipres');
		echo minipres();
		exit();
	}

// Suppression du depot et de ses plugins
	if ($id_depot = intval($arg)) {
		include_spip('inc/svp_depoter_distant');
		svp_supprimer_depot($id_depot);
		spip_log("ACTION SUPPRIMER DEPOT (manuel) : id_depot = " . $id_depot, 'svp_actions.' . _LOG_INFO);
	}
}
actualiser_depot.php000064400000002710152525277620010621 0ustar00<?php
/**
 * Gestion de l'action actualiser_depot
 *
 * @plugin SVP pour SPIP
 * @license GPL
 * @package SPIP\SVP\Actions
 */

/**
 * Action de mise à jour en base de données de la liste des plugins
 * d'un ou de tous les dépots
 */
function action_actualiser_depot_dist() {

// Securisation: aucun argument attendu
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

// Verification des autorisations
	if (!autoriser('webmestre')) {
		include_spip('inc/minipres');
		echo minipres();
		exit();
	}

// Actualisation des plugins du depot ou de tous les plugins suivant l'argument de l'action
	// Le depot lui-meme n'est mis a jour que partiellement via le fichier XML une fois que
	// la premiere insertion a ete effectuee. En effet, seules les infos non editables dans le prive
	// peuvent etre actualisees lors de cette action
	include_spip('inc/svp_depoter_distant');
	if ($arg === 'tout') {
		if ($ids_depots = sql_allfetsel('id_depot', 'spip_depots')) {
			$ids_depots = array_map('reset', $ids_depots);
			foreach ($ids_depots as $_id_depot) {
				svp_actualiser_depot($_id_depot);
			}
			// On consigne l'action
			spip_log("ACTION ACTUALISER TOUS LES DEPOTS (manuel)", 'svp_actions.' . _LOG_INFO);
		}
	} else {
		if ($id_depot = intval($arg)) {
			svp_actualiser_depot($id_depot);
			// On consigne l'action
			spip_log("ACTION ACTUALISER DEPOT (manuel) : id_depot = " . $id_depot, 'svp_actions.' . _LOG_INFO);
		}
	}
}
etre_webmestre.php000064400000003615152525343600010303 0ustar00<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2019                                                *
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
\***************************************************************************/

/**
 * Gestion de l'action pour s'autoriser webmestre
 *
 * @package SPIP\Core\Autorisations
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/actions');

/**
 * Prouver qu'on a les droits de webmestre via un ftp, et
 * devenir webmestre sans refaire l'install
 *
 * @return void
 */
function action_etre_webmestre_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$time = $securiser_action();

if (time() - $time < 15 * 60
		and $GLOBALS['visiteur_session']['statut'] == '0minirezo'
		and $GLOBALS['visiteur_session']['webmestre'] !== 'oui'
	) {
		$action = _T('info_admin_etre_webmestre');
		$admin = charger_fonction('admin', 'inc');
		// lance la verif par ftp et l'appel
		// a base_etre_webmestre_dist quand c'est OK
		if ($r = $admin('etre_webmestre', $action)) {
			echo $r;
			exit;
		}
	}

}

/**
 * Passe l'administrateur connecté en webmestre.
 *
 * @return void
 */
function base_etre_webmestre_dist() {
	if ($GLOBALS['visiteur_session']['statut'] == '0minirezo' and $GLOBALS['visiteur_session']['webmestre'] !== 'oui') {
		include_spip('action/editer_auteur');
		instituer_auteur($GLOBALS['visiteur_session']['id_auteur'], array('webmestre' => 'oui'), true);
	}
}
logout.php000064400000011044152525343600006573 0ustar00<?php

/**
 * Action pour déconnecter une personne authentifiée
 *
 * @package SPIP\Core\Authentification
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/cookie');

/**
 * Se déloger
 *
 * Pour éviter les CSRF on passe par une étape de confirmation si pas de jeton fourni
 * avec un autosubmit js pour ne pas compliquer l'expérience utilisateur
 *
 * Déconnecte l'utilisateur en cours et le redirige sur l'URL indiquée par
 * l'argument de l'action sécurisée, et sinon sur la page d'accueil
 * de l'espace public.
 *
 */
function action_logout_dist() {
	$logout = _request('logout');
	$url = securiser_redirect_action(_request('url'));
	// cas particulier, logout dans l'espace public
	if ($logout == 'public' and !$url) {
		$url = url_de_base();
	}

// seul le loge peut se deloger (mais id_auteur peut valoir 0 apres une restauration avortee)
	if (isset($GLOBALS['visiteur_session']['id_auteur'])
		and is_numeric($GLOBALS['visiteur_session']['id_auteur'])
		// des sessions anonymes avec id_auteur=0 existent, mais elle n'ont pas de statut : double check
		and isset($GLOBALS['visiteur_session']['statut'])
	) {

// il faut un jeton pour fermer la session (eviter les CSRF)
		if (!$jeton = _request('jeton')
			or !verifier_jeton_logout($jeton, $GLOBALS['visiteur_session'])
		) {
			$jeton = generer_jeton_logout($GLOBALS['visiteur_session']);
			$action = generer_url_action("logout", "jeton=$jeton");
			$action = parametre_url($action, 'logout', _request('logout'));
			$action = parametre_url($action, 'url', _request('url'));
			include_spip("inc/minipres");
			include_spip("inc/filtres");
			$texte = bouton_action(_T('spip:icone_deconnecter'), $action);
			$texte = "<div class='boutons'>$texte</div>";
			$texte .= '<script type="text/javascript">document.write("<style>body{visibility:hidden;}</style>");window.document.forms[0].submit();</script>';
			$res = minipres(_T('spip:icone_deconnecter'), $texte, '', true);
			echo $res;

return;
		}

include_spip('inc/auth');
		auth_trace($GLOBALS['visiteur_session'], '0000-00-00 00:00:00');
		// le logout explicite vaut destruction de toutes les sessions
		if (isset($_COOKIE['spip_session'])) {
			$session = charger_fonction('session', 'inc');
			$session($GLOBALS['visiteur_session']['id_auteur']);
			spip_setcookie('spip_session', $_COOKIE['spip_session'], time() - 3600);
		}
		// si authentification http, et que la personne est loge,
		// pour se deconnecter, il faut proposer un nouveau formulaire de connexion http
		if (isset($_SERVER['PHP_AUTH_USER'])
			and !$GLOBALS['ignore_auth_http']
			and $GLOBALS['auth_can_disconnect']
		) {
			ask_php_auth(_T('login_deconnexion_ok'),
				_T('login_verifiez_navigateur'),
				_T('login_retour_public'),
				"redirect=" . _DIR_RESTREINT_ABS,
				_T('login_test_navigateur'),
				true);

}
	}

// Rediriger en contrant le cache navigateur (Safari3)
	include_spip('inc/headers');
	redirige_par_entete($url
		? parametre_url($url, 'var_hasard', uniqid(rand()), '&')
		: generer_url_public('login'));
}

/**
 * Generer un jeton de logout personnel et ephemere
 *
 * @param array $session
 * @param null|string $alea
 * @return string
 */
function generer_jeton_logout($session, $alea = null) {
	if (is_null($alea)) {
		include_spip('inc/acces');
		$alea = charger_aleas();
	}

$jeton = md5($session['date_session']
		. $session['id_auteur']
		. $session['statut']
		. $alea
	);

return $jeton;
}

/**
 * Verifier que le jeton de logout est bon
 *
 * Il faut verifier avec alea_ephemere_ancien si pas bon avec alea_ephemere
 * pour gerer le cas de la rotation d'alea
 *
 * @param string $jeton
 * @param array $session
 * @return bool
 */
function verifier_jeton_logout($jeton, $session) {
	if (generer_jeton_logout($session) === $jeton) {
		return true;
	}

if (generer_jeton_logout($session, $GLOBALS['meta']['alea_ephemere_ancien']) === $jeton) {
		return true;
	}

return false;
}
confirmer_email.php000064400000003223152525343600010415 0ustar00<?php

/**
 * Gestion de l'action confirmer_email
 *
 * @package SPIP\Core\Inscription
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Confirmer un changement d'email
 *
 * @global array $GLOBALS ['visiteur_session']
 * @global string $GLOBALS ['redirect']
 * @return void
 */
function action_confirmer_email_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

include_spip('inc/filtres');
	if ($GLOBALS['visiteur_session']['id_auteur'] and email_valide($arg)) {
		include_spip('action/editer_auteur');
		auteur_modifier($GLOBALS['visiteur_session']['id_auteur'], array('email' => $arg));
	}
	// verifier avant de rediriger pour invalider le message de confirmation
	// si ca n'a pas marche
	if ($redirect = _request('redirect') and !$arg == sql_getfetsel('email', 'spip_auteurs',
			'id_auteur=' . intval($GLOBALS['visiteur_session']))
	) {
		$GLOBALS['redirect'] = parametre_url($redirect, 'email_modif', '');
	}

}
calculer_taille_cache.php000064400000005737152525343600011545 0ustar00<?php

/**
 * Gestion de l'action calculer_taille_cache
 *
 * @package SPIP\Core\Cache
 **/
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Calculer la taille du cache ou du cache image pour l'afficher en ajax sur la page d'admin de SPIP
 *
 * Si l'argument reçu est 'images', c'est la taille du cache _DIR_VAR qui est calculé,
 * sinon celle du cache des squelettes (approximation)
 *
 * @param string|null $arg
 *     Argument attendu. En absence utilise l'argument
 *     de l'action sécurisée.
 */
function action_calculer_taille_cache_dist($arg = null) {
	if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}
	include_spip('inc/filtres');

if ($arg == 'images') {
		$taille = calculer_taille_dossier(_DIR_VAR);
		$res = _T('ecrire:taille_cache_image',
			array(
				'dir' => joli_repertoire(_DIR_VAR),
				'taille' => "<b>" . (taille_en_octets($taille) > 0 ? taille_en_octets($taille) : "0 octet") . "</b>"
			)
		);
	} else {
		include_spip('inc/invalideur');
		$taille =
			calculer_taille_dossier(_DIR_CACHE_XML)
			+ calculer_taille_dossier(_DIR_CACHE . 'skel/')
			+ calculer_taille_dossier(_DIR_CACHE . 'wheels/')
			+ calculer_taille_dossier(_DIR_CACHE . 'contextes/');
		$taille += intval(taille_du_cache());
		if ($taille <= 150000) {
			$res = _T('taille_cache_vide');
		} elseif ($taille <= 1024 * 1024) {
			$res = _T('taille_cache_moins_de', array('octets' => taille_en_octets(1024 * 1024)));
		} else {
			$res = _T('taille_cache_octets', array('octets' => taille_en_octets($taille)));
		}
		$res = "<b>$res</b>";
	}

$res = "<p>$res</p>";
	ajax_retour($res);
}

/**
 * Calculer la taille d'un dossier, sous dossiers inclus
 *
 * @param string $dir Répertoire dont on souhaite évaluer la taille
 * @return int Taille en octets
 */
function calculer_taille_dossier($dir) {
	if (!is_dir($dir) or !is_readable($dir)) {
		return 0;
	}
	$handle = opendir($dir);
	if (!$handle) {
		return 0;
	}
	$taille = 0;
	while (($fichier = @readdir($handle)) !== false) {
		// Eviter ".", "..", ".htaccess", etc.
		if ($fichier[0] == '.') {
			continue;
		}
		if (is_file($d = "$dir/$fichier")) {
			$taille += filesize($d);
		} else {
			if (is_dir($d)) {
				$taille += calculer_taille_dossier($d);
			}
		}
	}
	closedir($handle);

return $taille;
}
session.php000064400000003134152525343600006746 0ustar00<?php

/**
 * Gestion d'une action ajoutant une variable dans une session SPIP
 *
 * @package SPIP\Core\Sessions
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action pour poser une variable de session SPIP
 *
 * Poster sur cette action en indiquant les clés `var` et `val`
 *
 * Utilisé par exemple par le script javascript 'autosave' pour sauvegarder
 * les formulaires en cours d'édition
 *
 * @todo
 *   Envoyer en réponse : json contenant toutes les variables publiques de la session
 **/
function action_session_dist() {
	if ($var = _request('var')
		and preg_match(',^[a-z_0-9-]+$,i', $var)
	) {
		if ($_SERVER['REQUEST_METHOD'] == 'POST') {
			include_spip('inc/session');
			session_set('session_' . $var, $val = _request('val'));
			#spip_log("autosave:$var:$val",'autosave');
		}
	}

# TODO: mode lecture de session ; n'afficher que ce qu'il faut
	#echo json_encode($GLOBALS['visiteur_session']);
}
editer_objet.php000064400000034442152525343600007730 0ustar00<?php

/**
 * Gestion générique de modification des objets éditoriaux
 *
 * @package SPIP\Core\Edition
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Point d'entrée d'édition d'un objet
 *
 * On ne peut entrer que par un appel en fournissant $id et $objet
 * ou avec un argument d'action sécurisée de type "objet/id"
 *
 * @param int $id
 * @param string $objet
 * @param array $set
 * @return array
 */
function action_editer_objet_dist($id = null, $objet = null, $set = null) {

// appel direct depuis une url avec arg = "objet/id"
	if (is_null($id) or is_null($objet)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
		list($objet, $id) = array_pad(explode("/", $arg, 2), 2, null);
	}

// appel incorrect ou depuis une url erronnée interdit
	if (is_null($id) or is_null($objet)) {
		include_spip('inc/minipres');
		echo minipres(_T('info_acces_interdit'));
		die();
	}

// si id n'est pas un nombre, c'est une creation
	// mais on verifie qu'on a toutes les donnees qu'il faut.
	if (!$id = intval($id)) {
		// on ne sait pas si un parent existe mais on essaye
		$id_parent = _request('id_parent');
		$id = objet_inserer($objet, $id_parent);
	}

if (!($id = intval($id)) > 0) {
		return array($id, _L('echec enregistrement en base'));
	}

// Enregistre l'envoi dans la BD
	$err = objet_modifier($objet, $id, $set);

return array($id, $err);
}

/**
 * Appelle toutes les fonctions de modification d'un objet
 * $err est un message d'erreur eventuelle
 *
 * @param string $objet
 * @param int $id
 * @param array|null $set
 * @return mixed|string
 */
function objet_modifier($objet, $id, $set = null) {
	if (include_spip('action/editer_' . $objet)
		and function_exists($modifier = $objet . "_modifier")
	) {
		return $modifier($id, $set);
	}

$table_sql = table_objet_sql($objet);
	$trouver_table = charger_fonction('trouver_table', 'base');
	$desc = $trouver_table($table_sql);
	if (!$desc or !isset($desc['field'])) {
		spip_log("Objet $objet inconnu dans objet_modifier", _LOG_ERREUR);

return _L("Erreur objet $objet inconnu");
	}
	include_spip('inc/modifier');

$champ_date = '';
	if (isset($desc['date']) and $desc['date']) {
		$champ_date = $desc['date'];
	} elseif (isset($desc['field']['date'])) {
		$champ_date = 'date';
	}

$white = array_keys($desc['field']);
	// on ne traite pas la cle primaire par defaut, notamment car
	// sur une creation, id_x vaut 'oui', et serait enregistre en id_x=0 dans la base
	$white = array_diff($white, array($desc['key']['PRIMARY KEY']));

if (isset($desc['champs_editables']) and is_array($desc['champs_editables'])) {
		$white = $desc['champs_editables'];
	}
	$c = collecter_requests(
	// white list
		$white,
		// black list
		array($champ_date, 'statut', 'id_parent', 'id_secteur'),
		// donnees eventuellement fournies
		$set
	);

// Si l'objet est publie, invalider les caches et demander sa reindexation
	if (objet_test_si_publie($objet, $id)) {
		$invalideur = "id='$objet/$id'";
		$indexation = true;
	} else {
		$invalideur = "";
		$indexation = false;
	}

if ($err = objet_modifier_champs($objet, $id,
		array(
			'data' => $set,
			'nonvide' => '',
			'invalideur' => $invalideur,
			'indexation' => $indexation,
			// champ a mettre a date('Y-m-d H:i:s') s'il y a modif
			'date_modif' => (isset($desc['field']['date_modif']) ? 'date_modif' : '')
		),
		$c)
	) {
		return $err;
	}

// Modification de statut, changement de rubrique ?
	// FIXME: Ici lorsqu'un $set est passé, la fonction collecter_requests() retourne tout
	//         le tableau $set hors black liste, mais du coup on a possiblement des champs en trop. 
	$c = collecter_requests(array($champ_date, 'statut', 'id_parent'), array(), $set);
	$err = objet_instituer($objet, $id, $c);

return $err;
}

/**
 * Insere en base un objet generique
 *
 * @param string $objet
 * @param int $id_parent
 * @param array|null $set
 * @global array $GLOBALS ['visiteur_session']
 * @global array $GLOBALS ['meta']
 * @global string $GLOBALS ['spip_lang']
 * @return bool|int
 */
function objet_inserer($objet, $id_parent = null, $set = null) {
	if (include_spip('action/editer_' . $objet)
		and function_exists($inserer = $objet . "_inserer")
	) {
		return $inserer($id_parent, $set);
	}

$table_sql = table_objet_sql($objet);
	$trouver_table = charger_fonction('trouver_table', 'base');
	$desc = $trouver_table($table_sql);
	if (!$desc or !isset($desc['field'])) {
		return 0;
	}

$lang_rub = "";
	$champs = array();
	if (isset($desc['field']['id_rubrique'])) {
		// Si id_rubrique vaut 0 ou n'est pas definie, creer l'objet
		// dans la premiere rubrique racine
		if (!$id_rubrique = intval($id_parent)) {
			$row = sql_fetsel("id_rubrique, id_secteur, lang", "spip_rubriques", "id_parent=0", '', '0+titre,titre', "1");
			$id_rubrique = $row['id_rubrique'];
		} else {
			$row = sql_fetsel("lang, id_secteur", "spip_rubriques", "id_rubrique=" . intval($id_rubrique));
		}

$champs['id_rubrique'] = $id_rubrique;
		if (isset($desc['field']['id_secteur'])) {
			$champs['id_secteur'] = $row['id_secteur'];
		}
		$lang_rub = $row['lang'];
	}

// La langue a la creation : si les liens de traduction sont autorises
	// dans les rubriques, on essaie avec la langue de l'auteur,
	// ou a defaut celle de la rubrique
	// Sinon c'est la langue de la rubrique qui est choisie + heritee
	if (isset($desc['field']['lang']) and !empty($GLOBALS['meta']['multi_objets']) and in_array($table_sql,
			explode(',', $GLOBALS['meta']['multi_objets']))
	) {
		lang_select($GLOBALS['visiteur_session']['lang']);
		if (in_array($GLOBALS['spip_lang'],
			explode(',', $GLOBALS['meta']['langues_multilingue']))) {
			$champs['lang'] = $GLOBALS['spip_lang'];
			if (isset($desc['field']['langue_choisie'])) {
				$champs['langue_choisie'] = 'oui';
			}
		}
	} elseif (isset($desc['field']['lang']) and isset($desc['field']['langue_choisie'])) {
		$champs['lang'] = ($lang_rub ? $lang_rub : $GLOBALS['meta']['langue_site']);
		$champs['langue_choisie'] = 'non';
	}

if (isset($desc['field']['statut'])) {
		if (isset($desc['statut_textes_instituer'])) {
			$cles_statut = array_keys($desc['statut_textes_instituer']);
			$champs['statut'] = reset($cles_statut);
		} else {
			$champs['statut'] = 'prepa';
		}
	}

if ((isset($desc['date']) and $d = $desc['date']) or isset($desc['field'][$d = 'date'])) {
		$champs[$d] = date('Y-m-d H:i:s');
	}

if ($set) {
		$champs = array_merge($champs, $set);
	}

// Envoyer aux plugins
	$champs = pipeline('pre_insertion',
		array(
			'args' => array(
				'table' => $table_sql,
				'id_parent' => $id_parent,
			),
			'data' => $champs
		)
	);

$id = sql_insertq($table_sql, $champs);

if ($id) {
		// controler si le serveur n'a pas renvoye une erreur
		// et associer l'auteur sinon
		// si la table n'a pas deja un champ id_auteur
		// et si le form n'a pas poste un id_auteur (meme vide, ce qui sert a annuler cette auto association)
		if ($id > 0
			and !isset($desc['field']['id_auteur'])
		) {
			$id_auteur = ((is_null(_request('id_auteur')) and isset($GLOBALS['visiteur_session']['id_auteur'])) ?
				$GLOBALS['visiteur_session']['id_auteur']
				: _request('id_auteur'));
			if ($id_auteur) {
				include_spip('action/editer_auteur');
				auteur_associer($id_auteur, array($objet => $id));
			}
		}

pipeline('post_insertion',
			array(
				'args' => array(
					'table' => $table_sql,
					'id_parent' => $id_parent,
					'id_objet' => $id,
				),
				'data' => $champs
			)
		);

}

return $id;
}

/**
 * Modifie le statut et/ou la date d'un objet
 *
 * @param string $objet
 * @param int $id
 * @param array $c
 *   $c est un array ('statut', 'id_parent' = changement de rubrique)
 *   statut et rubrique sont lies, car un admin restreint peut deplacer
 *   un objet publie vers une rubrique qu'il n'administre pas
 * @param bool $calcul_rub
 * @return string
 */
function objet_instituer($objet, $id, $c, $calcul_rub = true) {
	if (include_spip('action/editer_' . $objet)
		and function_exists($instituer = $objet . "_instituer")
	) {
		return $instituer($id, $c, $calcul_rub);
	}

$table_sql = table_objet_sql($objet);
	$trouver_table = charger_fonction('trouver_table', 'base');
	$desc = $trouver_table($table_sql);
	if (!$desc or !isset($desc['field'])) {
		return _L("Impossible d'instituer $objet : non connu en base");
	}

include_spip('inc/autoriser');
	include_spip('inc/rubriques');
	include_spip('inc/modifier');

$sel = array();
	$sel[] = (isset($desc['field']['statut']) ? "statut" : "'' as statut");

$champ_date = '';
	if (isset($desc['date']) and $desc['date']) {
		$champ_date = $desc['date'];
	} elseif (isset($desc['field']['date'])) {
		$champ_date = 'date';
	}

$sel[] = ($champ_date ? "$champ_date as date" : "'' as date");
	$sel[] = (isset($desc['field']['id_rubrique']) ? 'id_rubrique' : "0 as id_rubrique");

$row = sql_fetsel($sel, $table_sql, id_table_objet($objet) . '=' . intval($id));

$id_rubrique = $row['id_rubrique'];
	$statut_ancien = $statut = $row['statut'];
	$date_ancienne = $date = $row['date'];
	$champs = array();

$d = ($date and isset($c[$champ_date])) ? $c[$champ_date] : null;
	$s = (isset($desc['field']['statut']) and isset($c['statut'])) ? $c['statut'] : $statut;

// cf autorisations dans inc/instituer_objet
	if ($s != $statut or ($d and $d != $date)) {
		if ($id_rubrique ?
			autoriser('publierdans', 'rubrique', $id_rubrique)
			:
			autoriser('instituer', $objet, $id, null, array('statut' => $s))
		) {
			$statut = $champs['statut'] = $s;
		} else {
			if ($s != 'publie' and autoriser('modifier', $objet, $id)) {
				$statut = $champs['statut'] = $s;
			} else {
				spip_log("editer_objet $id refus " . join(' ', $c));
			}
		}

// En cas de publication, fixer la date a "maintenant"
		// sauf si $c commande autre chose
		// ou si l'objet est deja date dans le futur
		// En cas de proposition d'un objet (mais pas depublication), idem
		if ($champ_date) {
			if ($champs['statut'] == 'publie'
				or ($champs['statut'] == 'prop' and !in_array($statut_ancien, array('publie', 'prop')))
				or $d
			) {
				if ($d or strtotime($d = $date) > time()) {
					$champs[$champ_date] = $date = $d;
				} else {
					$champs[$champ_date] = $date = date('Y-m-d H:i:s');
				}
			}
		}
	}

// Verifier que la rubrique demandee existe et est differente
	// de la rubrique actuelle
	if ($id_rubrique
		and isset($c['id_parent'])
		and $id_parent = $c['id_parent']
		and $id_parent != $id_rubrique
		and (sql_fetsel('1', "spip_rubriques", "id_rubrique=" . intval($id_parent)))
	) {
		$champs['id_rubrique'] = $id_parent;

// si l'objet etait publie
		// et que le demandeur n'est pas admin de la rubrique
		// repasser l'objet en statut 'propose'.
		if ($statut == 'publie'
			and !autoriser('publierdans', 'rubrique', $id_rubrique)
		) {
			$champs['statut'] = 'prop';
		}
	}

// Envoyer aux plugins
	$champs = pipeline('pre_edition',
		array(
			'args' => array(
				'table' => $table_sql,
				'id_objet' => $id,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
				'date_ancienne' => $date_ancienne,
				'id_parent_ancien' => $id_rubrique,
			),
			'data' => $champs
		)
	);

if (!count($champs)) {
		return '';
	}

// Envoyer les modifs.
	objet_editer_heritage($objet, $id, $id_rubrique, $statut_ancien, $champs, $calcul_rub);

// Invalider les caches
	include_spip('inc/invalideur');
	suivre_invalideur("id='$objet/$id'");

/*
	if ($date) {
		$t = strtotime($date);
		$p = @$GLOBALS['meta']['date_prochain_postdate'];
		if ($t > time() AND (!$p OR ($t < $p))) {
			ecrire_meta('date_prochain_postdate', $t);
		}
	}*/

// Pipeline
	pipeline('post_edition',
		array(
			'args' => array(
				'table' => $table_sql,
				'id_objet' => $id,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
				'date_ancienne' => $date_ancienne,
				'id_parent_ancien' => $id_rubrique,
			),
			'data' => $champs
		)
	);

// Notifications
	if ($notifications = charger_fonction('notifications', 'inc')) {
		$notifications("instituer$objet", $id,
			array('statut' => $statut, 'statut_ancien' => $statut_ancien, 'date' => $date, 'date_ancienne' => $date_ancienne)
		);
	}

return ''; // pas d'erreur
}

/**
 * Fabrique la requete d'institution de l'objet, avec champs herites
 *
 * @param string $objet
 * @param int $id
 * @param int $id_rubrique
 * @param string $statut
 * @param array $champs
 * @param bool $cond
 * @return void
 */
function objet_editer_heritage($objet, $id, $id_rubrique, $statut, $champs, $cond = true) {
	$table_sql = table_objet_sql($objet);
	$trouver_table = charger_fonction('trouver_table', 'base');
	$desc = $trouver_table($table_sql);

// Si on deplace l'objet
	// changer aussi son secteur et sa langue (si heritee)
	if (isset($champs['id_rubrique'])) {

$row_rub = sql_fetsel("id_secteur, lang", "spip_rubriques", "id_rubrique=" . sql_quote($champs['id_rubrique']));
		$langue = $row_rub['lang'];

if (isset($desc['field']['id_secteur'])) {
			$champs['id_secteur'] = $row_rub['id_secteur'];
		}

if (isset($desc['field']['lang']) and isset($desc['field']['langue_choisie'])) {
			if (sql_fetsel('1', $table_sql,
				id_table_objet($objet) . "=" . intval($id) . " AND langue_choisie<>'oui' AND lang<>" . sql_quote($langue))) {
				$champs['lang'] = $langue;
			}
		}
	}

if (!$champs) {
		return;
	}
	sql_updateq($table_sql, $champs, id_table_objet($objet) . '=' . intval($id));

// Changer le statut des rubriques concernees
	if ($cond) {
		include_spip('inc/rubriques');
		//$postdate = ($GLOBALS['meta']["post_dates"] == "non" AND isset($champs['date']) AND (strtotime($champs['date']) < time()))?$champs['date']:false;
		$postdate = false;
		// On rajoute les infos de l'objet
		$infos = array(
			'objet' => $objet,
			'id_objet' => $id,
			'statut_ancien' => $statut,
		);
		calculer_rubriques_if($id_rubrique, $champs, $infos, $postdate);
	}
}
index.php000064400000000002152525343600006361 0ustar00X
menu_rubriques.php000064400000014762152525343600010341 0ustar00<?php

/**
 * Gestion de l'action d'affichage du navigateur de rubrique du bandeau
 *
 * @package SPIP\Core\Rubriques
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/autoriser');
include_spip('inc/texte');
include_spip('inc/filtres');

/**
 * Action d'affichage en ajax du navigateur de rubrique du bandeau
 *
 * @uses gen_liste_rubriques()
 * @uses menu_rubriques()
 *
 * @return string
 *     Code HTML présentant la liste des rubriques
 **/
function action_menu_rubriques_dist() {

// si pas acces a ecrire, pas acces au menu
	// on renvoi un 401 qui fait echouer la requete ajax silencieusement
	if (!autoriser('ecrire')) {
		$retour = "<ul class='cols_1'><li class='toutsite'><a href='" . generer_url_ecrire('accueil') . "'>" . _T('public:lien_connecter') . "</a></li></ul>";
		include_spip('inc/actions');
		ajax_retour($retour);
		exit;
	}

if ($date = intval(_request('date'))) {
		header("Last-Modified: " . gmdate("D, d M Y H:i:s", $date) . " GMT");
	}

$r = gen_liste_rubriques();
	if (!$r
		and isset($_SERVER['HTTP_IF_MODIFIED_SINCE'])
		and !strstr($_SERVER['SERVER_SOFTWARE'], 'IIS/')
	) {
		include_spip('inc/headers');
		header('Content-Type: text/html; charset=' . $GLOBALS['meta']['charset']);
		http_status(304);
		exit;
	} else {
		include_spip('inc/actions');
		$ret = menu_rubriques();
		ajax_retour($ret);
	}
}

/**
 * Retourne une liste HTML des rubriques et rubriques enfants
 *
 * @param bool $complet
 *     - false pour n'avoir que le bouton racine «plan du site»
 *     - true pour avoir l'ensemble des rubriques en plus
 *
 * @return string
 *     Code HTML présentant la liste des rubriques
 **/
function menu_rubriques($complet = true) {
	$ret = "<li class='toutsite'><a href='" . generer_url_ecrire('plan') . "'>" . _T('info_tout_site') . "</a></li>";

if (!$complet) {
		return "<ul class='cols_1'>$ret\n</ul>\n";
	}

if (!isset($GLOBALS['db_art_cache'])) {
		gen_liste_rubriques();
	}
	$arr_low = extraire_article(0, $GLOBALS['db_art_cache']);

$total_lignes = $i = sizeof($arr_low);

if ($i > 0) {
		$nb_col = min(8, ceil($total_lignes / 30));
		if ($nb_col <= 1) {
			$nb_col = ceil($total_lignes / 10);
		}
		foreach ($arr_low as $id_rubrique => $titre_rubrique) {
			if (autoriser('voir', 'rubrique', $id_rubrique)) {
				$ret .= bandeau_rubrique($id_rubrique, $titre_rubrique, $i);
				$i++;
			}
		}

$ret = "<ul class='cols_$nb_col'>"
			. $ret
			. "\n</ul>\n";
	} else {
		$ret = "<ul class='cols_1'>$ret\n</ul>\n";
	}

return $ret;
}

/**
 * Retourne une liste HTML des rubriques enfants d'une rubrique
 *
 * @uses extraire_article()
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique parente
 * @param string $titre_rubrique
 *     Titre de cette rubrique
 * @param int $zdecal
 *     Décalage vertical, en nombre d'élément
 *
 * @return string
 *     Code HTML présentant la liste des rubriques
 **/
function bandeau_rubrique($id_rubrique, $titre_rubrique, $zdecal) {
	static $zmax = 6;

$nav = "<a href='"
		. generer_url_entite($id_rubrique, 'rubrique', '', '', false)
		. "'>"
		. supprimer_tags(preg_replace(',[\x00-\x1f]+,', ' ', $titre_rubrique))
		. "</a>\n";

// Limiter volontairement le nombre de sous-menus
	if (!(--$zmax)) {
		$zmax++;

return "\n<li>$nav</li>";
	}

$arr_rub = extraire_article($id_rubrique, $GLOBALS['db_art_cache']);
	$i = sizeof($arr_rub);
	if (!$i) {
		$zmax++;

return "\n<li>$nav</li>";
	}

$nb_col = 1;
	if ($nb_rub = count($arr_rub)) {
		$nb_col = min(10, max(1, ceil($nb_rub / 10)));
	}
	$ret = "<li class='haschild'>$nav<ul class='cols_$nb_col'>";
	foreach ($arr_rub as $id_rub => $titre_rub) {
		if (autoriser('voir', 'rubrique', $id_rub)) {
			$titre = supprimer_numero(typo($titre_rub));
			$ret .= bandeau_rubrique($id_rub, $titre, $zdecal + $i);
			$i++;
		}
	}
	$ret .= "</ul></li>\n";
	$zmax++;

return $ret;
}

/**
 * Obtient la liste des rubriques enfants d'une rubrique, prise dans le cache
 * du navigateur de rubrique
 *
 * @see gen_liste_rubriques() pour le calcul du cache
 *
 * @param int $id_p
 *     Identifiant de la rubrique parente des articles
 * @param array $t
 *     Cache des rubriques
 * @return array
 *     Liste des rubriques enfants de la rubrique (et leur titre)
 **/
function extraire_article($id_p, $t) {
	return array_key_exists($id_p, $t) ? $t[$id_p] : array();
}

/**
 * Génère le cache de la liste des rubriques pour la navigation du bandeau
 *
 * Le cache, qui comprend pour chaque rubrique ses rubriques enfants et leur titre, est :
 *
 * - réactualisé en fonction de la meta `date_calcul_rubriques`
 * - mis en cache dans le fichier défini par la constante `_CACHE_RUBRIQUES`
 * - stocké également dans la globale `db_art_cache`
 *
 * @return bool true.
 **/
function gen_liste_rubriques() {

include_spip('inc/config');
	// ici, un petit fichier cache ne fait pas de mal
	$last = lire_config('date_calcul_rubriques', 0);
	if (lire_fichier(_CACHE_RUBRIQUES, $cache)) {
		list($date, $GLOBALS['db_art_cache']) = @unserialize($cache);
		if ($date == $last) {
			return false;
		} // c'etait en cache :-)
	}
	// se restreindre aux rubriques utilisees recemment +secteurs

$where = sql_in_select("id_rubrique", "id_rubrique", "spip_rubriques", "", "", "id_parent=0 DESC, date DESC",
		_CACHE_RUBRIQUES_MAX);

// puis refaire la requete pour avoir l'ordre alphabetique

$res = sql_select("id_rubrique, titre, id_parent", "spip_rubriques", $where, '', 'id_parent, 0+titre, titre');

// il ne faut pas filtrer le autoriser voir ici
	// car on met le resultat en cache, commun a tout le monde
	$GLOBALS['db_art_cache'] = array();
	while ($r = sql_fetch($res)) {
		$t = sinon($r['titre'], _T('ecrire:info_sans_titre'));
		$GLOBALS['db_art_cache'][$r['id_parent']][$r['id_rubrique']] = supprimer_numero(typo($t));
	}

$t = array($last ? $last : time(), $GLOBALS['db_art_cache']);
	ecrire_fichier(_CACHE_RUBRIQUES, serialize($t));

return true;
}
tester.php000064400000012741152525343600006575 0ustar00<?php

/**
 * Gestion de l'action testant une librairie graphique
 *
 * @package SPIP\Core\Configurer
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Tester les capacités du serveur à utiliser une librairie graphique
 *
 * L'argument transmis dans la clé `arg` est le type de librairie parmi
 * gd2, gd1, netpbm, imagick ou convert
 *
 * L'action crée une vignette en utilisant la librairie indiquée puis
 * redirige sur l'image ainsi créée (sinon sur une image d'echec).
 **/
function action_tester_dist() {
	$arg = _request('arg');

$gd_formats = array();
	$gd_formats_read_gif = "";
	// verifier les formats acceptes par GD
	if ($arg == "gd1") {
		// Si GD est installe et php >= 4.0.2
		if (function_exists('imagetypes')) {

if (imagetypes() & IMG_GIF) {
				$gd_formats[] = "gif";
			} else {
				# Attention GD sait lire le gif mais pas forcement l'ecrire
				if (function_exists('ImageCreateFromGIF')) {
					$srcImage = @ImageCreateFromGIF(_ROOT_IMG_PACK . "test.gif");
					if ($srcImage) {
						$gd_formats_read_gif = ",gif";
						ImageDestroy($srcImage);
					}
				}
			}

if (imagetypes() & IMG_JPG) {
				$gd_formats[] = "jpg";
			}
			if (imagetypes() & IMG_PNG) {
				$gd_formats[] = "png";
			}
		} else {
			# ancienne methode de detection des formats, qui en plus
			# est bugguee car elle teste les formats en lecture
			# alors que la valeur deduite sert a identifier
			# les formats disponibles en ecriture... (cf. inc_logos)

if (function_exists('ImageCreateFromJPEG')) {
				$srcImage = @ImageCreateFromJPEG(_ROOT_IMG_PACK . "test.jpg");
				if ($srcImage) {
					$gd_formats[] = "jpg";
					ImageDestroy($srcImage);
				}
			}
			if (function_exists('ImageCreateFromGIF')) {
				$srcImage = @ImageCreateFromGIF(_ROOT_IMG_PACK . "test.gif");
				if ($srcImage) {
					$gd_formats[] = "gif";
					ImageDestroy($srcImage);
				}
			}
			if (function_exists('ImageCreateFromPNG')) {
				$srcImage = @ImageCreateFromPNG(_ROOT_IMG_PACK . "test.png");
				if ($srcImage) {
					$gd_formats[] = "png";
					ImageDestroy($srcImage);
				}
			}
		}

if (! empty($gd_formats)) {
			$gd_formats = join(",", $gd_formats);
		}
		ecrire_meta("gd_formats_read", $gd_formats . $gd_formats_read_gif);
		ecrire_meta("gd_formats", $gd_formats);
	} // verifier les formats netpbm
	else {
		if ($arg == "netpbm") {
			if (!defined('_PNMSCALE_COMMAND')) {
				define('_PNMSCALE_COMMAND', 'pnmscale');
			} // Securite : mes_options.php peut preciser le chemin absolu
			if (_PNMSCALE_COMMAND == '') {
				return;
			}
			$netpbm_formats = array();

$jpegtopnm_command = str_replace("pnmscale",
				"jpegtopnm", _PNMSCALE_COMMAND);
			$pnmtojpeg_command = str_replace("pnmscale",
				"pnmtojpeg", _PNMSCALE_COMMAND);

$vignette = _ROOT_IMG_PACK . "test.jpg";
			$dest = _DIR_VAR . "test-jpg.jpg";
			$commande = "$jpegtopnm_command $vignette | " . _PNMSCALE_COMMAND . " -width 10 | $pnmtojpeg_command > $dest";
			spip_log($commande);
			exec($commande);
			if ($taille = @getimagesize($dest)) {
				if ($taille[1] == 10) {
					$netpbm_formats[] = "jpg";
				}
			}
			$giftopnm_command = str_replace("pnmscale", "giftopnm", _PNMSCALE_COMMAND);
			$pnmtojpeg_command = str_replace("pnmscale", "pnmtojpeg", _PNMSCALE_COMMAND);
			$vignette = _ROOT_IMG_PACK . "test.gif";
			$dest = _DIR_VAR . "test-gif.jpg";
			$commande = "$giftopnm_command $vignette | " . _PNMSCALE_COMMAND . " -width 10 | $pnmtojpeg_command > $dest";
			spip_log($commande);
			exec($commande);
			if ($taille = @getimagesize($dest)) {
				if ($taille[1] == 10) {
					$netpbm_formats[] = "gif";
				}
			}

$pngtopnm_command = str_replace("pnmscale", "pngtopnm", _PNMSCALE_COMMAND);
			$vignette = _ROOT_IMG_PACK . "test.png";
			$dest = _DIR_VAR . "test-gif.jpg";
			$commande = "$pngtopnm_command $vignette | " . _PNMSCALE_COMMAND . " -width 10 | $pnmtojpeg_command > $dest";
			spip_log($commande);
			exec($commande);
			if ($taille = @getimagesize($dest)) {
				if ($taille[1] == 10) {
					$netpbm_formats[] = "png";
				}
			}

if ($netpbm_formats) {
				$netpbm_formats = join(",", $netpbm_formats);
			} else {
				$netpbm_formats = '';
			}
			ecrire_meta("netpbm_formats", $netpbm_formats);
		}
	}

// et maintenant envoyer la vignette de tests
	if (in_array($arg, array("gd1", "gd2", "imagick", "convert", "netpbm"))) {
		include_spip('inc/filtres');
		include_spip('inc/filtres_images_mini');
		$taille_preview = 150;
		$image = _image_valeurs_trans(_DIR_IMG_PACK . 'test_image.jpg', "reduire-$taille_preview-$taille_preview", 'jpg');

$image['fichier_dest'] = _DIR_VAR . "test_$arg";

if ($preview = _image_creer_vignette($image, $taille_preview, $taille_preview, $arg, true)
			and ($preview['width'] * $preview['height'] > 0)
		) {
			redirige_par_entete($preview['fichier']);
		}
	}

# image echec
	redirige_par_entete(chemin_image('puce-rouge-anim.gif'));
}
editer_liens.php000064400000065226152525343600007743 0ustar00<?php

/**
 * API d'édition de liens
 *
 * Cette API gère la création, modification et suppressions de liens
 * entre deux objets éditoriaux par l'intermédiaire de tables de liaison
 * tel que spip_xx_liens.
 *
 * L'unicité est assurée dans les fonctions sur le trio (id_x, objet, id_objet)
 * par défaut, ce qui correspond à la déclaration de clé primaire.
 *
 * Des rôles peuvent être déclarés pour des liaisons. À ce moment là,
 * une colonne spécifique doit être présente dans la table de liens
 * et l'unicité est alors assurée sur le quatuor (id_x, objet, id_objet, role)
 * et la clé primaire adaptée en conséquence.
 *
 * @package SPIP\Core\Liens\API
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

// charger la gestion les rôles sur les objets
include_spip('inc/roles');

/**
 * Teste l'existence de la table de liaison xxx_liens d'un objet
 *
 * @api
 * @param string $objet
 *     Objet à tester
 * @return array|bool
 *     - false si l'objet n'est pas associable.
 *     - array(clé primaire, nom de la table de lien) si associable
 */
function objet_associable($objet) {
	$trouver_table = charger_fonction('trouver_table', 'base');
	$table_sql = table_objet_sql($objet);

$l = "";
	if ($primary = id_table_objet($objet)
		and $trouver_table($l = $table_sql . "_liens")
		and !preg_match(',[^\w],', $primary)
		and !preg_match(',[^\w],', $l)
	) {
		return array($primary, $l);
	}

spip_log("Objet $objet non associable : ne dispose pas d'une cle primaire $primary OU d'une table liens $l");

return false;
}

/**
 * Associer un ou des objets à des objets listés
 *
 * `$objets_source` et `$objets_lies` sont de la forme
 * `array($objet=>$id_objets,...)`
 * `$id_objets` peut lui même être un scalaire ou un tableau pour une liste d'objets du même type
 * ou de la forme `array("NOT", $id_objets)` pour une sélection par exclusion
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * On peut passer optionnellement une qualification du (des) lien(s) qui sera
 * alors appliquée dans la foulée.
 * En cas de lot de liens, c'est la même qualification qui est appliquée a tous
 *
 * @api
 * @param array $objets_source
 * @param array|string $objets_lies
 * @param array $qualif
 * @return bool|int
 */
function objet_associer($objets_source, $objets_lies, $qualif = null) {
	$modifs = objet_traiter_liaisons('lien_insert', $objets_source, $objets_lies, $qualif);

if ($qualif) {
		objet_qualifier_liens($objets_source, $objets_lies, $qualif);
	}

return $modifs; // pas d'erreur
}

/**
 * Dissocier un (ou des) objet(s)  des objets listés
 *
 * `$objets_source` et `$objets_lies` sont de la forme
 * `array($objet=>$id_objets,...)`
 * `$id_objets` peut lui-même être un scalaire ou un tableau pour une liste d'objets du même type
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * un * pour $objet, $id_objet permet de traiter par lot
 * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 *
 * S'il y a des rôles possibles entre les 2 objets, et qu'aucune condition
 * sur la colonne du rôle n'est transmise, on ne supprime que les liens
 * avec le rôle par défaut. Si on veut supprimer tous les rôles,
 * il faut spécifier $cond => array('role' => '*')
 *
 * @api
 * @param array $objets_source
 * @param array|string $objets_lies
 * @param array|null $cond
 *     Condition du where supplémentaires
 *
 *     À l'exception de l'index 'role' qui permet de sélectionner un rôle
 *     ou tous les rôles (*), en s'affranchissant du vrai nom de la colonne.
 * @return bool|int
 */
function objet_dissocier($objets_source, $objets_lies, $cond = null) {
	return objet_traiter_liaisons('lien_delete', $objets_source, $objets_lies, $cond);
}

/**
 * Qualifier le lien entre un (ou des) objet(s) et des objets listés
 *
 * $objets_source et $objets sont de la forme
 * array($objet=>$id_objets,...)
 * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * un * pour $objet,$id_objet permet de traiter par lot
 * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 *
 * @api
 * @param array $objets_source
 * @param array|string $objets_lies
 * @param array $qualif
 * @return bool|int
 */
function objet_qualifier_liens($objets_source, $objets_lies, $qualif) {
	return objet_traiter_liaisons('lien_set', $objets_source, $objets_lies, $qualif);
}

/**
 * Trouver les liens entre objets
 *
 * $objets_source et $objets sont de la forme
 * array($objet=>$id_objets,...)
 * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * un * pour $objet,$id_objet permet de traiter par lot
 * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 *
 * renvoie une liste de tableaux decrivant chaque lien
 * dans lequel objet_source et objet_lie sont aussi affectes avec l'id de chaque
 * par facilite
 * ex :
 * array(
 *   array('id_document'=>23,'objet'=>'article','id_objet'=>12,'vu'=>'oui',
 *         'document'=>23,'article'=>12)
 * )
 *
 * @api
 * @param array $objets_source Couples (objets_source => identifiants) (objet qui a la table de lien)
 * @param array|string $objets_lies Couples (objets_lies => identifiants)
 * @param array|null $cond Condition du where supplémentaires
 * @return array
 *     Liste des trouvailles
 */
function objet_trouver_liens($objets_source, $objets_lies, $cond = null) {
	return objet_traiter_liaisons('lien_find', $objets_source, $objets_lies, $cond);
}

/**
 * Nettoyer les liens morts vers des objets qui n'existent plus
 *
 * $objets_source et $objets sont de la forme
 * array($objet=>$id_objets,...)
 * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * un * pour $objet,$id_objet permet de traiter par lot
 * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 *
 * @api
 * @param array $objets_source
 * @param array|string $objets_lies
 * @return int
 */
function objet_optimiser_liens($objets_source, $objets_lies) {
	spip_log("objet_optimiser_liens : ".json_encode($objets_source) . ', ' . json_encode($objets_lies), 'genie'._LOG_DEBUG);
	return objet_traiter_liaisons('lien_optimise', $objets_source, $objets_lies);
}

/**
 * Dupliquer tous les liens entrant ou sortants d'un objet
 * vers un autre (meme type d'objet, mais id different)
 * si $types est fourni, seuls les liens depuis/vers les types listes seront copies
 * si $exclure_types est fourni, les liens depuis/vers les types listes seront ignores
 *
 * @api
 * @param string $objet
 * @param int $id_source
 * @param int $id_cible
 * @param array $types
 * @param array $exclure_types
 * @return int
 *     Nombre de liens copiés
 */
function objet_dupliquer_liens($objet, $id_source, $id_cible, $types = null, $exclure_types = null) {
	include_spip('base/objets');
	$tables = lister_tables_objets_sql();
	$n = 0;
	foreach ($tables as $table_sql => $infos) {
		if (
			(is_null($types) or in_array($infos['type'], $types))
			and (is_null($exclure_types) or !in_array($infos['type'], $exclure_types))
		) {
			if (objet_associable($infos['type'])) {
				$liens = (($infos['type'] == $objet) ?
					objet_trouver_liens(array($objet => $id_source), '*')
					:
					objet_trouver_liens(array($infos['type'] => '*'), array($objet => $id_source)));
				foreach ($liens as $lien) {
					$n++;
					if ($infos['type'] == $objet) {
						if (
							(is_null($types) or in_array($lien['objet'], $types))
							and (is_null($exclure_types) or !in_array($lien['objet'], $exclure_types))
						) {
							objet_associer(array($objet => $id_cible), array($lien['objet'] => $lien[$lien['objet']]), $lien);
						}
					} else {
						objet_associer(array($infos['type'] => $lien[$infos['type']]), array($objet => $id_cible), $lien);
					}
				}
			}
		}
	}

return $n;
}

/**
 * Fonctions techniques
 * ne pas les appeler directement
 */

/**
 * Fonction générique qui
 * applique une operation de liaison entre un ou des objets et des objets listés
 *
 * $objets_source et $objets_lies sont de la forme
 * array($objet=>$id_objets,...)
 * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 *
 * Les objets sources sont les pivots qui portent les liens
 * et pour lesquels une table spip_xxx_liens existe
 * (auteurs, documents, mots)
 *
 * on peut passer optionnellement une qualification du (des) lien(s) qui sera
 * alors appliquee dans la foulee.
 * En cas de lot de liens, c'est la meme qualification qui est appliquee a tous
 *
 * @internal
 * @param string $operation
 *     Nom de la fonction PHP qui traitera l'opération
 * @param array $objets_source
 *     Liste de ou des objets source
 *     De la forme array($objet=>$id_objets,...), où $id_objets peut lui
 *     même être un scalaire ou un tableau pour une liste d'objets du même type
 * @param array $objets_lies
 *     Liste de ou des objets liés
 *     De la forme array($objet=>$id_objets,...), où $id_objets peut lui
 *     même être un scalaire ou un tableau pour une liste d'objets du même type
 * @param null|array $set
 *     Liste de coupels champs valeur, soit array(champs => valeur)
 *     En fonction des opérations il peut servir à différentes utilisations
 * @return bool|int|array
 */
function objet_traiter_liaisons($operation, $objets_source, $objets_lies, $set = null) {
	// accepter une syntaxe minimale pour supprimer tous les liens
	if ($objets_lies == '*') {
		$objets_lies = array('*' => '*');
	}
	$modifs = 0; // compter le nombre de modifications
	$echec = null;
	foreach ($objets_source as $objet => $ids) {
		if ($a = objet_associable($objet)) {
			list($primary, $l) = $a;
			if (!is_array($ids)) {
				$ids = array($ids);
			} elseif (reset($ids) == "NOT") {
				// si on demande un array('NOT',...) => recuperer la liste d'ids correspondants
				$where = lien_where($primary, $ids, '*', '*');
				$ids = sql_allfetsel($primary, $l, $where);
				$ids = array_map('reset', $ids);
			}
			foreach ($ids as $id) {
				$res = $operation($objet, $primary, $l, $id, $objets_lies, $set);
				if ($res === false) {
					spip_log("objet_traiter_liaisons [Echec] : $operation sur $objet/$primary/$l/$id", _LOG_ERREUR);
					$echec = true;
				} else {
					$modifs = ($modifs ? (is_array($res) ? array_merge($modifs, $res) : $modifs + $res) : $res);
				}
			}
		} else {
			$echec = true;
		}
	}

return ($echec ? false : $modifs); // pas d'erreur
}

/**
 * Sous fonction insertion
 * qui traite les liens pour un objet source dont la clé primaire
 * et la table de lien sont fournies
 *
 * $objets et de la forme
 * array($objet=>$id_objets,...)
 *
 * Retourne le nombre d'insertions réalisées
 *
 * @internal
 * @param string $objet_source Objet source de l'insertion (celui qui a la table de liaison)
 * @param string $primary Nom de la clé primaire de cet objet
 * @param string $table_lien Nom de la table de lien de cet objet
 * @param int $id Identifiant de l'objet sur lesquels on va insérer des liaisons
 * @param array $objets Liste des liaisons à faire, de la forme array($objet=>$id_objets)
 * @param array $qualif
 *     Liste des qualifications à appliquer (qui seront faites par lien_set()),
 *     dont on cherche un rôle à insérer également.
 *     Si l'objet dispose d'un champ rôle, on extrait des qualifications
 *     le rôle s'il est présent, sinon on applique le rôle par défaut.
 * @return bool|int
 *     Nombre d'insertions faites, false si échec.
 */
function lien_insert($objet_source, $primary, $table_lien, $id, $objets, $qualif) {
	$ins = 0;
	$echec = null;
	if (is_null($qualif)) {
		$qualif = array();
	}

foreach ($objets as $objet => $id_objets) {
		if (!is_array($id_objets)) {
			$id_objets = array($id_objets);
		}

// role, colonne, where par défaut
		list($role, $colonne_role, $cond) =
			roles_trouver_dans_qualif($objet_source, $objet, $qualif);

foreach ($id_objets as $id_objet) {
			$objet = ($objet == '*') ? $objet : objet_type($objet); # securite

$insertions = array(
				'id_objet' => $id_objet,
				'objet' => $objet,
				$primary => $id
			);
			// rôle en plus s'il est défini
			if ($role) {
				$insertions += array(
					$colonne_role => $role
				);
			}
			$args = array(
				'table_lien' => $table_lien,
				'objet_source' => $objet_source,
				'id_objet_source' => $id,
				'objet' => $objet,
				'id_objet' => $id_objet,
				'role' => $role,
				'colonne_role' => $colonne_role,
				'action' => 'insert',
			);

// Envoyer aux plugins
			$insertions = pipeline('pre_edition_lien',
				array(
					'args' => $args,
					'data' => $insertions
				)
			);
			$args['id_objet'] = $insertions['id_objet'];

$where = lien_where($primary, $id, $objet, $id_objet, $cond);

if ($id_objet = intval($insertions['id_objet'])
				and !sql_getfetsel($primary, $table_lien, $where)
			) {

$e = sql_insertq($table_lien, $insertions);
				if ($e !== false) {
					$ins++;
					lien_propage_date_modif($objet, $id_objet);
					lien_propage_date_modif($objet_source, $id);
					// Envoyer aux plugins
					pipeline('post_edition_lien',
						array(
							'args' => $args,
							'data' => $insertions
						)
					);
				} else {
					$echec = true;
				}
			}
		}
	}

return ($echec ? false : $ins);
}

/**
 * Fabriquer la condition where en tenant compte des jokers *
 *
 * @internal
 * @param string $primary Nom de la clé primaire
 * @param int|string|array $id_source Identifiant de la clé primaire
 * @param string $objet Nom de l'objet lié
 * @param int|string|array $id_objet Identifiant de l'objet lié
 * @param array $cond Conditions par défaut
 * @return array                        Liste des conditions
 */
function lien_where($primary, $id_source, $objet, $id_objet, $cond = array()) {
	if ((!is_array($id_source) and !strlen($id_source))
		or !strlen($objet)
		or (!is_array($id_objet) and !strlen($id_objet))
	) {
		return array("0=1");
	} // securite

$not = "";
	if (is_array($id_source) and reset($id_source) == "NOT") {
		$not = array_shift($id_source);
		$id_source = reset($id_source);
	}

$where = $cond;

if ($id_source !== '*') {
		$where[] = (is_array($id_source) ? sql_in(addslashes($primary), array_map('intval', $id_source),
			$not) : addslashes($primary) . ($not ? "<>" : "=") . intval($id_source));
	} elseif ($not) {
		$where[] = "0=1";
	} // idiot mais quand meme

$not = "";
	if (is_array($id_objet) and reset($id_objet) == "NOT") {
		$not = array_shift($id_objet);
		$id_objet = reset($id_objet);
	}

if ($objet !== '*') {
		$where[] = "objet=" . sql_quote($objet);
	}
	if ($id_objet !== '*') {
		$where[] = (is_array($id_objet) ? sql_in('id_objet', array_map('intval', $id_objet),
			$not) : "id_objet" . ($not ? "<>" : "=") . intval($id_objet));
	} elseif ($not) {
		$where[] = "0=1";
	} // idiot mais quand meme

return $where;
}

/**
 * Sous fonction suppression
 * qui traite les liens pour un objet source dont la clé primaire
 * et la table de lien sont fournies
 *
 * $objets et de la forme
 * array($objet=>$id_objets,...)
 * un * pour $id,$objet,$id_objets permet de traiter par lot
 *
 * On supprime tous les liens entre les objets indiqués par défaut,
 * sauf s'il y a des rôles déclarés entre ces 2 objets, auquel cas on ne
 * supprime que les liaisons avec le role déclaré par défaut si rien n'est
 * précisé dans $cond. Il faut alors passer $cond=array('role'=>'*') pour
 * supprimer tous les roles, ou array('role'=>'un_role') pour un role précis.
 *
 * @internal
 * @param string $objet_source
 * @param string $primary
 * @param string $table_lien
 * @param int $id
 * @param array $objets
 * @param array|null $cond
 *     Conditions where par défaut.
 *     Un cas particulier est géré lorsque l'index 'role' est présent (ou absent)
 * @return bool|int
 */
function lien_delete($objet_source, $primary, $table_lien, $id, $objets, $cond = null) {

$retire = array();
	$dels = 0;
	$echec = false;
	if (is_null($cond)) {
		$cond = array();
	}

foreach ($objets as $objet => $id_objets) {
		$objet = ($objet == '*') ? $objet : objet_type($objet); # securite
		if (!is_array($id_objets) or reset($id_objets) == "NOT") {
			$id_objets = array($id_objets);
		}
		foreach ($id_objets as $id_objet) {
			list($cond, $colonne_role, $role) = roles_creer_condition_role($objet_source, $objet, $cond);
			// id_objet peut valoir '*'
			$where = lien_where($primary, $id, $objet, $id_objet, $cond);

// lire les liens existants pour propager la date de modif
			$select = "$primary,id_objet,objet";
			if ($colonne_role) {
				$select .= ",$colonne_role";
			}
			$liens = sql_allfetsel($select, $table_lien, $where);

// iterer sur les liens pour permettre aux plugins de gerer
			foreach ($liens as $l) {

$args = array(
					'table_lien' => $table_lien,
					'objet_source' => $objet_source,
					'id_objet_source' => $l[$primary],
					'objet' => $l['objet'],
					'id_objet' => $l['id_objet'],
					'colonne_role' => $colonne_role,
					'role' => ($colonne_role ? $l[$colonne_role] : ''),
					'action' => 'delete',
				);

// Envoyer aux plugins
				$l = pipeline('pre_edition_lien',
					array(
						'args' => $args,
						'data' => $l
					)
				);
				$args['id_objet'] = $id_o = $l['id_objet'];

if ($id_o = intval($l['id_objet'])) {
					$where = lien_where($primary, $l[$primary], $l['objet'], $id_o, $cond);
					$e = sql_delete($table_lien, $where);
					if ($e !== false) {
						$dels += $e;
						lien_propage_date_modif($l['objet'], $id_o);
						lien_propage_date_modif($objet_source, $l[$primary]);
					} else {
						$echec = true;
					}
					$retire[] = array(
						'source' => array($objet_source => $l[$primary]),
						'lien' => array($l['objet'] => $id_o),
						'type' => $l['objet'],
						'role' => ($colonne_role ? $l[$colonne_role] : ''),
						'id' => $id_o
					);
					// Envoyer aux plugins
					pipeline('post_edition_lien',
						array(
							'args' => $args,
							'data' => $l
						)
					);
				}
			}
		}
	}

pipeline('trig_supprimer_objets_lies', $retire);

return ($echec ? false : $dels);
}

/**
 * Sous fonction optimisation
 * qui nettoie les liens morts (vers un objet inexistant)
 * pour un objet source dont la clé primaire
 * et la table de lien sont fournies
 *
 * $objets et de la forme
 * array($objet=>$id_objets,...)
 * un * pour $id,$objet,$id_objets permet de traiter par lot
 *
 * @internal
 * @param string $objet_source
 * @param string $primary
 * @param string $table_lien
 * @param int $id
 * @param array $objets
 * @return bool|int
 */
function lien_optimise($objet_source, $primary, $table_lien, $id, $objets) {
	include_spip('genie/optimiser');
	$echec = false;
	$dels = 0;
	foreach ($objets as $objet => $id_objets) {
		$objet = ($objet == '*') ? $objet : objet_type($objet); # securite
		if (!is_array($id_objets) or reset($id_objets) == "NOT") {
			$id_objets = array($id_objets);
		}
		foreach ($id_objets as $id_objet) {
			$where = lien_where($primary, $id, $objet, $id_objet);
			# les liens vers un objet inexistant
			$r = sql_select("DISTINCT objet", $table_lien, $where);
			while ($t = sql_fetch($r)) {
				$type = $t['objet'];
				$spip_table_objet = table_objet_sql($type);
				$id_table_objet = id_table_objet($type);
				$res = sql_select("L.$primary AS id,L.id_objet",
					// la condition de jointure inclue L.objet='xxx' pour ne joindre que les bonnes lignes
					// du coups toutes les lignes avec un autre objet ont un id_xxx=NULL puisque LEFT JOIN
					// il faut les eliminier en repetant la condition dans le where L.objet='xxx'
					"$table_lien AS L
									LEFT JOIN $spip_table_objet AS O
										ON (O.$id_table_objet=L.id_objet AND L.objet=" . sql_quote($type) . ")",
					"L.objet=" . sql_quote($type) . " AND O.$id_table_objet IS NULL");
				// sur une cle primaire composee, pas d'autres solutions que de virer un a un
				while ($row = sql_fetch($res)) {
					$e = sql_delete($table_lien,
						array("$primary=" . $row['id'], "id_objet=" . $row['id_objet'], "objet=" . sql_quote($type)));
					if ($e != false) {
						$dels += $e;
						spip_log(
							"lien_optimise: Entree " . $row['id'] . "/" . $row['id_objet'] . "/$type supprimee dans la table $table_lien",
							'genie'._LOG_INFO_IMPORTANTE
						);
					}
				}
			}

# les liens depuis un objet inexistant
			$table_source = table_objet_sql($objet_source);
			// filtrer selon $id, $objet, $id_objet eventuellement fournis
			// (en general '*' pour chaque)
			$where = lien_where("L.$primary", $id, $objet, $id_objet);
			$where[] = "O.$primary IS NULL";
			$res = sql_select("L.$primary AS id",
				"$table_lien AS L LEFT JOIN $table_source AS O ON L.$primary=O.$primary",
				$where);
			$dels += optimiser_sansref($table_lien, $primary, $res);
		}
	}

return ($echec ? false : $dels);
}

/**
 * Sous fonction qualification
 * qui traite les liens pour un objet source dont la clé primaire
 * et la table de lien sont fournies
 *
 * $objets et de la forme
 * array($objet=>$id_objets,...)
 * un * pour $id,$objet,$id_objets permet de traiter par lot
 *
 * exemple :
 * $qualif = array('vu'=>'oui');
 *
 * @internal
 * @param string $objet_source Objet source de l'insertion (celui qui a la table de liaison)
 * @param string $primary Nom de la clé primaire de cet objet
 * @param string $table_lien Nom de la table de lien de cet objet
 * @param int $id Identifiant de l'objet sur lesquels on va insérer des liaisons
 * @param array $objets Liste des liaisons à faire, de la forme array($objet=>$id_objets)
 * @param array $qualif
 *     Liste des qualifications à appliquer.
 *
 *     Si l'objet dispose d'un champ rôle, on extrait des qualifications
 *     le rôle s'il est présent, sinon on applique les qualifications
 *     sur le rôle par défaut.
 * @return bool|int
 *     Nombre de modifications faites, false si échec.
 */
function lien_set($objet_source, $primary, $table_lien, $id, $objets, $qualif) {
	$echec = null;
	$ok = 0;
	if (!$qualif) {
		return false;
	}
	// nettoyer qualif qui peut venir directement d'un objet_trouver_lien :
	unset($qualif[$primary]);
	unset($qualif[$objet_source]);
	if (isset($qualif['objet'])) {
		unset($qualif[$qualif['objet']]);
	}
	unset($qualif['objet']);
	unset($qualif['id_objet']);
	foreach ($objets as $objet => $id_objets) {

// role, colonne, where par défaut
		list($role, $colonne_role, $cond) =
			roles_trouver_dans_qualif($objet_source, $objet, $qualif);

$objet = ($objet == '*') ? $objet : objet_type($objet); # securite
		if (!is_array($id_objets) or reset($id_objets) == "NOT") {
			$id_objets = array($id_objets);
		}
		foreach ($id_objets as $id_objet) {

$args = array(
				'table_lien' => $table_lien,
				'objet_source' => $objet_source,
				'id_objet_source' => $id,
				'objet' => $objet,
				'id_objet' => $id_objet,
				'role' => $role,
				'colonne_role' => $colonne_role,
				'action' => 'modifier',
			);

// Envoyer aux plugins
			$qualif = pipeline('pre_edition_lien',
				array(
					'args' => $args,
					'data' => $qualif,
				)
			);
			$args['id_objet'] = $id_objet;

$where = lien_where($primary, $id, $objet, $id_objet, $cond);
			$e = sql_updateq($table_lien, $qualif, $where);

if ($e === false) {
				$echec = true;
			} else {
				// Envoyer aux plugins
				pipeline('post_edition_lien',
					array(
						'args' => $args,
						'data' => $qualif
					)
				);
				$ok++;
			}
		}
	}

return ($echec ? false : $ok);
}

/**
 * Sous fonction trouver
 * qui cherche les liens pour un objet source dont la clé primaire
 * et la table de lien sont fournies
 *
 * $objets et de la forme
 * array($objet=>$id_objets,...)
 * un * pour $id,$objet,$id_objets permet de traiter par lot
 *
 * Le tableau de condition peut avoir un index 'role' indiquant de
 * chercher un rôle précis, ou * pour tous les roles (alors équivalent
 * à l'absence de l'index)
 *
 * @internal
 * @param string $objet_source
 * @param string $primary
 * @param string $table_lien
 * @param int $id
 * @param array $objets
 * @param array|null $cond
 *     Condition du where par défaut
 *
 *     On peut passer un index 'role' pour sélectionner uniquement
 *     le role défini dedans (et '*' pour tous les rôles).
 * @return array
 */
function lien_find($objet_source, $primary, $table_lien, $id, $objets, $cond = null) {
	$trouve = array();
	foreach ($objets as $objet => $id_objets) {
		$objet = ($objet == '*') ? $objet : objet_type($objet); # securite
		// gerer les roles s'il y en a dans $cond
		list($cond) = roles_creer_condition_role($objet_source, $objet, $cond, true);
		// lien_where prend en charge les $id_objets sous forme int ou array
		$where = lien_where($primary, $id, $objet, $id_objets, $cond);
		$liens = sql_allfetsel('*', $table_lien, $where);
		// ajouter les entrees objet_source et objet cible par convenance
		foreach ($liens as $l) {
			$l[$objet_source] = $l[$primary];
			$l[$l['objet']] = $l['id_objet'];
			$trouve[] = $l;
		}
	}

return $trouve;
}

/**
 * Propager la date_modif sur les objets dont un lien a été modifié
 *
 * @internal
 * @param string $objet
 * @param array|int $ids
 */
function lien_propage_date_modif($objet, $ids) {
	static $done = array();
	$hash = md5($objet . serialize($ids));

// sql_updateq, peut être un rien lent.
	// On évite de l'appeler 2 fois sur les mêmes choses
	if (isset($done[$hash])) {
		return;
	}

$trouver_table = charger_fonction('trouver_table', 'base');

$table = table_objet_sql($objet);
	if ($desc = $trouver_table($table)
		and isset($desc['field']['date_modif'])
	) {
		$primary = id_table_objet($objet);
		$where = (is_array($ids) ? sql_in($primary, array_map('intval', $ids)) : "$primary=" . intval($ids));
		sql_updateq($table, array('date_modif' => date('Y-m-d H:i:s')), $where);
	}

$done[$hash] = true;
}
annuler_job.php000064400000002146152525343600007563 0ustar00<?php

/**
 * Gestion de l'action annuler_job
 *
 * @package SPIP\Core\Job
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Annuler un travail
 *
 * @return void
 */
function action_annuler_job_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$id_job = $securiser_action();

if ($id_job = intval($id_job)
		and autoriser('annuler', 'job', $id_job)
	) {
		job_queue_remove($id_job);
	}
}
desinstaller_plugin.php000064400000003663152525343600011341 0ustar00<?php

/**
 * Gestion de l'action desinstaller_plugin
 *
 * @package SPIP\Core\Plugins
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action de désinstallation d'un plugin
 *
 * L'argument attendu est le préfixe du plugin à désinstaller.
 *
 * @uses plugins_installer_dist()
 *
 * @global array visiteur_session
 * @return void
 */
function action_desinstaller_plugin_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();
	list($dir_plugins, $plugin) = explode("::", $arg);
	$dir_type = "_DIR_PLUGINS";
	if (defined('_DIR_PLUGINS_SUPPL') and $dir_plugins == _DIR_PLUGINS_SUPPL) {
		$dir_type = "_DIR_PLUGINS_SUPPL";
	}
	$installer_plugins = charger_fonction('installer', 'plugins');
	$infos = $installer_plugins($plugin, 'uninstall', $dir_type);
	if ($infos and !$infos['install_test'][0]) {
		include_spip('inc/plugin');
		ecrire_plugin_actifs(array($plugin), false, 'enleve');
		$erreur = '';
	} else {
		$erreur = 'erreur_plugin_desinstalation_echouee';
	}
	if ($redirect = _request('redirect')) {
		include_spip('inc/headers');
		if ($erreur) {
			$redirect = parametre_url($redirect, 'erreur', $erreur);
		}
		$redirect = str_replace('&amp;', '&', $redirect);
		redirige_par_entete($redirect);
	}
}
converser.php000064400000005603152525343600007274 0ustar00<?php

/**
 * Gestion de l'action converser qui permet changer de langue
 *
 * @package SPIP\Core\Langue
 **/
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/cookie');

/**
 * Point d'entrée pour changer de langue
 *
 * Pas de secu si espace public ou login ou installation
 * mais alors on n'accède pas à la base, on pose seulement le cookie.
 *
 * @return void
 */
function action_converser_dist() {
	$update_session = false;
	if (_request('arg') and spip_connect()) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$securiser_action();
		$update_session = true;
	}

$lang = action_converser_changer_langue($update_session);
	$redirect = rawurldecode(_request('redirect'));

if (!$redirect) {
		$redirect = _DIR_RESTREINT_ABS;
	}
	$redirect = parametre_url($redirect, 'lang', $lang, '&');
	redirige_par_entete($redirect, true);
}

/**
 * Cette fonction prépare le travail de changement de langue
 * en récupérant la bonne variable de langue
 *
 * @global array $GLOBALS ['visiteur_session']
 * @param bool $update_session
 * @return string
 */
function action_converser_changer_langue($update_session) {
	if ($lang = _request('var_lang')) {
		action_converser_post($lang);
	} elseif ($lang = _request('var_lang_ecrire')) {
		if ($update_session) {
			sql_updateq("spip_auteurs", array("lang" => $lang), "id_auteur = " . $GLOBALS['visiteur_session']['id_auteur']);
			$GLOBALS['visiteur_session']['lang'] = $lang;
			$session = charger_fonction('session', 'inc');
			if ($spip_session = $session($GLOBALS['visiteur_session'])) {
				spip_setcookie(
					'spip_session',
					$spip_session,
					time() + 3600 * 24 * 14
				);
			}
		}
		action_converser_post($lang, 'spip_lang_ecrire');
	}

return $lang;
}

/**
 * Cette fonction effectue le travail de changement de langue
 *
 * @param string $lang
 * @param bool $ecrire
 * @return void
 */
function action_converser_post($lang, $ecrire = false) {
	if ($lang) {
		include_spip('inc/lang');
		if (changer_langue($lang)) {
			spip_setcookie('spip_lang', $_COOKIE['spip_lang'] = $lang, time() + 365 * 24 * 3600);
			if ($ecrire) {
				spip_setcookie('spip_lang_ecrire', $_COOKIE['spip_lang_ecrire'] = $lang, time() + 365 * 24 * 3600);
			}
		}
	}
}
referencer_traduction.php000064400000006732152525343600011646 0ustar00<?php

/**
 * Gestion de l'action referencer_traduction gérant les liens de traductions
 *
 * @package SPIP\Core\Action
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Définir le lien de traduction vers un objet de réference
 *
 * Plusieurs cas :
 * - id_trad=0 : déréference le lien de traduction de id_objet
 * - id_trad=NN : référence le lien de traduction de id_objet vers NN
 * - id_objet=id_trad actuel et id_trad=new_id_trad : modifie la référence
 *   de tout le groupe de traduction
 *
 * @param string $objet
 *     Type d'objet
 * @param int $id_objet
 *     Identifiant de l'objet
 * @param int $id_trad
 *     Identifiant de la référence de traduction
 * @return bool
 *     - False si on ne trouve pas l'objet de référence
 *     - True sinon
 */
function action_referencer_traduction_dist($objet, $id_objet, $id_trad) {

// ne rien faire si id_trad est ambigu
	if (!is_numeric($id_trad)) {
		return false;
	}

$table_objet_sql = table_objet_sql($objet);
	$id_table_objet = id_table_objet($objet);

// on a fourni un id_trad : affectation ou modification du groupe de trad
	if ($id_trad) {
		// selectionner l'objet cible, qui doit etre different de nous-meme,
		// et quitter s'il n'existe pas
		$id_lier = sql_getfetsel('id_trad', $table_objet_sql,
			"$id_table_objet=" . intval($id_trad) . " AND NOT($id_table_objet=" . intval($id_objet) . ")");
		if ($id_lier === null) {
			spip_log("echec lien de trad vers objet $objet/$id_objet incorrect ($id_trad)");

return false;
		}

// $id_lier est le numero du groupe de traduction
		// Si l'objet vise n'est pas deja traduit, son identifiant devient
		// le nouvel id_trad de ce nouveau groupe et on l'affecte aux deux
		// objets
		if ($id_lier == 0) {
			sql_updateq($table_objet_sql, array("id_trad" => $id_trad), "$id_table_objet IN ($id_trad, $id_objet)");
		} // si id_lier = id_objet alors on veut changer la reference de tout le groupe de trad
		elseif ($id_lier == $id_objet) {
			sql_updateq($table_objet_sql, array("id_trad" => $id_trad), "id_trad = $id_lier");
		} // sinon ajouter notre objet dans le groupe
		else {
			sql_updateq($table_objet_sql, array("id_trad" => $id_lier), "$id_table_objet=" . intval($id_objet));
		}
	} // on a fourni un id_trad nul : sortir id_objet du groupe de trad
	else {
		$old_id_trad = sql_getfetsel('id_trad', $table_objet_sql, "$id_table_objet=" . intval($id_objet));
		// supprimer le lien de traduction
		sql_updateq($table_objet_sql, array("id_trad" => 0), "$id_table_objet=" . intval($id_objet));

// Verifier si l'ancien groupe ne comporte plus qu'un seul objet. Alors mettre a zero.
		$cpt = sql_countsel($table_objet_sql, "id_trad=" . intval($old_id_trad));
		if ($cpt == 1) {
			sql_updateq($table_objet_sql, array("id_trad" => 0), "id_trad=" . intval($old_id_trad));
		}
	}

return true;
}
super_cron.php000064400000003733152525343600007447 0ustar00<?php

/**
 * Action pour exécuter le cron de manière asynchrone si le serveur le permet
 *
 * @package SPIP\Core\Genie
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Url pour lancer le cron de manière asynchrone si le serveur le permet
 *
 * Cette fonction est utile pour être appelée depuis un cron UNIX par exemple
 * car elle se termine tout de suite
 *
 * Exemple de tache cron Unix pour un appel toutes les minutes :
 * `* * * * * curl  http://www.mondomaine.tld/spip.php?action=super_cron`
 *
 * @see queue_affichage_cron() Dont une partie du code est repris ici.
 * @see action_cron() URL appelée en asynchrone pour excécuter le cron
 */
function action_super_cron_dist() {
	// Si fsockopen est possible, on lance le cron via un socket
	// en asynchrone
	if (function_exists('fsockopen')) {
		$url = generer_url_action('cron');
		$parts = parse_url($url);
		$fp = fsockopen($parts['host'],
			isset($parts['port']) ? $parts['port'] : 80,
			$errno, $errstr, 30);
		if ($fp) {
			$out = "GET " . $parts['path'] . "?" . $parts['query'] . " HTTP/1.1\r\n";
			$out .= "Host: " . $parts['host'] . "\r\n";
			$out .= "Connection: Close\r\n\r\n";
			fwrite($fp, $out);
			fclose($fp);

return;
		}
	}
	// ici lancer le cron par un CURL asynchrone si CURL est présent
	// TBD

return;
}
debloquer_edition.php000064400000002667152525343600010772 0ustar00<?php

/**
 * Gestion de l'action debloquer_edition
 *
 * @package SPIP\Core\Edition
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Lever les blocages d'édition pour l'utilisateur courant
 *
 * @uses debloquer_tous()
 * @uses debloquer_edition()
 *
 * @global array visiteur_session
 * @return void
 */
function action_debloquer_edition_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

if ($arg) {
		include_spip('inc/drapeau_edition');
		if ($arg == 'tous') {
			debloquer_tous($GLOBALS['visiteur_session']['id_auteur']);
		} else {
			$arg = explode("-", $arg);
			list($objet, $id_objet) = $arg;
			debloquer_edition($GLOBALS['visiteur_session']['id_auteur'], $id_objet, $objet);
		}
	}
}
editer_logo.php000064400000012726152525343600007566 0ustar00<?php

/**
 * Gestion de l'API de modification/suppression des logos
 *
 * @package SPIP\Core\Logo\Edition
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Supprimer le logo d'un objet
 *
 * @param string $objet
 * @param int $id_objet
 * @param string $etat
 *     `on` ou `off`
 */
function logo_supprimer($objet, $id_objet, $etat) {
	$chercher_logo = charger_fonction('chercher_logo', 'inc');
	$objet = objet_type($objet);
	$primary = id_table_objet($objet);
	include_spip('inc/chercher_logo');

// existe-t-il deja un logo ?
	$logo = $chercher_logo($id_objet, $primary, $etat);
	if ($logo) {
		spip_unlink($logo[0]);
	}
}

/**
 * Modifier le logo d'un objet
 *
 * @param string $objet
 * @param int $id_objet
 * @param string $etat
 *     `on` ou `off`
 * @param string|array $source
 *     - array : sous tableau de `$_FILE` issu de l'upload
 *     - string : fichier source (chemin complet ou chemin relatif a `tmp/upload`)
 * @return string
 *     Erreur, sinon ''
 */
function logo_modifier($objet, $id_objet, $etat, $source) {
	$chercher_logo = charger_fonction('chercher_logo', 'inc');
	$objet = objet_type($objet);
	$primary = id_table_objet($objet);
	include_spip('inc/chercher_logo');
	$type = type_du_logo($primary);

// nom du logo
	$nom = $type . $etat . $id_objet;

// supprimer le logo eventueel existant
	logo_supprimer($objet, $id_objet, $etat);

include_spip('inc/documents');
	$erreur = '';

if (!$source) {
		spip_log('spip_image_ajouter : source inconnue');
		$erreur = 'source inconnue';

return $erreur;
	}

$file_tmp = _DIR_LOGOS . $nom . '.tmp';

$ok = false;
	// fichier dans upload/
	if (is_string($source)) {
		if (file_exists($source)) {
			$ok = @copy($source, $file_tmp);
		} elseif (file_exists($f = determine_upload() . $source)) {
			$ok = @copy($f, $file_tmp);
		}
	} elseif (!$erreur = check_upload_error($source['error'], '', true)) {
		// Intercepter une erreur a l'envoi
		// analyse le type de l'image (on ne fait pas confiance au nom de
		// fichier envoye par le browser : pour les Macs c'est plus sur)
		$ok = deplacer_fichier_upload($source['tmp_name'], $file_tmp);
	}

if ($erreur) {
		return $erreur;
	}
	if (!$ok or !file_exists($file_tmp)) {
		spip_log($erreur = "probleme de copie pour $file_tmp ");

return $erreur;
	}

$size = @getimagesize($file_tmp);
	$extension = !$size ? '' : ($size[2] > 3 ? '' : $GLOBALS['formats_logos'][$size[2] - 1]);
	if ($extension) {
		@rename($file_tmp, $file_tmp . ".$extension");
		$file_tmp = $file_tmp . ".$extension";
		$poids = filesize($file_tmp);

if (defined('_LOGO_MAX_WIDTH') or defined('_LOGO_MAX_HEIGHT')) {
			if ((defined('_LOGO_MAX_WIDTH') and _LOGO_MAX_WIDTH and $size[0] > _LOGO_MAX_WIDTH)
				or (defined('_LOGO_MAX_HEIGHT') and _LOGO_MAX_HEIGHT and $size[1] > _LOGO_MAX_HEIGHT)
			) {
				$max_width = (defined('_LOGO_MAX_WIDTH') and _LOGO_MAX_WIDTH) ? _LOGO_MAX_WIDTH : '*';
				$max_height = (defined('_LOGO_MAX_HEIGHT') and _LOGO_MAX_HEIGHT) ? _LOGO_MAX_HEIGHT : '*';

// pas la peine d'embeter le redacteur avec ca si on a active le calcul des miniatures
				// on met directement a la taille maxi a la volee
				if (isset($GLOBALS['meta']['creer_preview']) and $GLOBALS['meta']['creer_preview'] == 'oui') {
					include_spip('inc/filtres');
					$img = filtrer('image_reduire', $file_tmp, $max_width, $max_height);
					$img = extraire_attribut($img, 'src');
					$img = supprimer_timestamp($img);
					if (@file_exists($img) and $img !== $file_tmp) {
						spip_unlink($file_tmp);
						@rename($img, $file_tmp);
						$size = @getimagesize($file_tmp);
					}
				}
				// verifier au cas ou image_reduire a echoue
				if ((defined('_LOGO_MAX_WIDTH') and _LOGO_MAX_WIDTH and $size[0] > _LOGO_MAX_WIDTH)
					or (defined('_LOGO_MAX_HEIGHT') and _LOGO_MAX_HEIGHT and $size[1] > _LOGO_MAX_HEIGHT)
				) {
					spip_unlink($file_tmp);
					$erreur = _T(
						'info_logo_max_poids',
						array(
							'maxi' =>
								_T(
									'info_largeur_vignette',
									array(
										'largeur_vignette' => $max_width,
										'hauteur_vignette' => $max_height
									)
								),
							'actuel' =>
								_T(
									'info_largeur_vignette',
									array(
										'largeur_vignette' => $size[0],
										'hauteur_vignette' => $size[1]
									)
								)
						)
					);
				}
			}
		}

if (!$erreur and defined('_LOGO_MAX_SIZE') and _LOGO_MAX_SIZE and $poids > _LOGO_MAX_SIZE * 1024) {
			spip_unlink($file_tmp);
			$erreur = _T(
				'info_logo_max_poids',
				array(
					'maxi' => taille_en_octets(_LOGO_MAX_SIZE * 1024),
					'actuel' => taille_en_octets($poids)
				)
			);
		}

if (!$erreur) {
			@rename($file_tmp, _DIR_LOGOS . $nom . ".$extension");
		}
	} else {
		spip_unlink($file_tmp);
		$erreur = _T(
			'info_logo_format_interdit',
			array('formats' => join(', ', $GLOBALS['formats_logos']))
		);
	}

return $erreur;
}
preferer.php000064400000005206152525343600007077 0ustar00<?php

/**
 * Gestion (obsolète) des préférences d'un auteur
 *
 * Utilisé uniquement par ecrire/oo/index.php
 * Pour le reste, cela se passe par formulaires/configurer_preferences.
 *
 * @see prive/formulaires/configurer_preferences.php
 *
 * @package SPIP\Core\Auteurs\Preferences
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action de sauvegarde des préférences d'un auteur
 *
 * Définit une préférence d'un auteur pour l'affichage dans l'espace privé.
 *
 * @deprecated
 * @see prive/formulaires/configurer_preferences.php
 **/
function action_preferer_dist() {
	//
	// Preferences de presentation de l'espace prive
	//
	if ($_GET['arg'] !== 'display:4') {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	} else {
		$arg = $_GET['arg'];
	}

if (!preg_match(",^(.+):(.*)$,", $arg, $r)) {
		spip_log("action_preferer_dist: $arg pas compris");
	} else {
		$prefs_mod = false;

list(, $op, $val) = $r;
		if ($op == 'couleur') {
			$GLOBALS['visiteur_session']['prefs']['couleur'] = $val;
			$prefs_mod = true;
		} elseif ($op == 'display') {
			$GLOBALS['visiteur_session']['prefs']['display'] = $val;
			$prefs_mod = true;
		} elseif ($op == 'display_outils') {
			$GLOBALS['visiteur_session']['prefs']['display_outils'] = $val;
			$prefs_mod = true;
		}

if ($prefs_mod and intval($GLOBALS['visiteur_session']['id_auteur'])) {
			sql_updateq('spip_auteurs', array('prefs' => serialize($GLOBALS['visiteur_session']['prefs'])),
				"id_auteur=" . intval($GLOBALS['visiteur_session']['id_auteur']));
		}

if ($op == 'spip_ecran') {
			// Poser un cookie,
			// car ce reglage depend plus du navigateur que de l'utilisateur
			$GLOBALS['spip_ecran'] = $val;
			include_spip('inc/cookie');
			spip_setcookie('spip_ecran', $val, time() + 365 * 24 * 3600);
		}

// Si modif des couleurs en ajax, redirect inutile on a change de CSS
		if ($_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest') {
			exit;
		}

}
}
instituer_langue_rubrique.php000064400000003726152525343600012571 0ustar00<?php

/**
 * Action des changements de langue des rubriques
 *
 * @package SPIP\Core\Edition
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Modifie la langue d'une rubrique
 **/
function action_instituer_langue_rubrique_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();
	$changer_lang = _request('changer_lang');

list($id_rubrique, $id_parent) = preg_split('/\W/', $arg);

if ($changer_lang
		and $id_rubrique > 0
		and $GLOBALS['meta']['multi_rubriques'] == 'oui'
		and ($GLOBALS['meta']['multi_secteurs'] == 'non' or $id_parent == 0)
	) {
		if ($changer_lang != "herit") {
			sql_updateq('spip_rubriques', array('lang' => $changer_lang, 'langue_choisie' => 'oui'),
				"id_rubrique=$id_rubrique");
		} else {
			if ($id_parent == 0) {
				$langue_parent = $GLOBALS['meta']['langue_site'];
			} else {
				$langue_parent = sql_getfetsel("lang", "spip_rubriques", "id_rubrique=$id_parent");
			}
			sql_updateq('spip_rubriques', array('lang' => $langue_parent, 'langue_choisie' => 'non'),
				"id_rubrique=$id_rubrique");
		}
		include_spip('inc/rubriques');
		calculer_langues_rubriques();

// invalider les caches marques de cette rubrique
		include_spip('inc/invalideur');
		suivre_invalideur("id='rubrique/$id_rubrique'");
	}
}
supprimer_lien.php000064400000003013152525343600010314 0ustar00<?php

/**
 * Action pour dissocier un lien entre 2 objets
 *
 * @package SPIP\Core\Liens\API
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action pour dissocier 2 objets entre eux
 *
 * L'argument attendu est `objet1-id1-objet2-id2` (type d'objet, identifiant)
 * tel que `mot-7-rubrique-3`.
 *
 * @uses objet_dissocier()
 *
 * @param null|string $arg
 *     Clé des arguments. En absence utilise l'argument
 *     de l'action sécurisée.
 * @return void
 */
function action_supprimer_lien_dist($arg = null) {
	if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

$arg = explode("-", $arg);
	list($objet_source, $ids, $objet_lie, $idl) = $arg;

include_spip('action/editer_liens');
	objet_dissocier(array($objet_source => $ids), array($objet_lie => $idl));
}
cookie.php000064400000007312152525343600006536 0ustar00<?php

/**
 * Gestion de l'action cookie
 *
 * @package SPIP\Core\Inscription
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/actions');
include_spip('inc/cookie');

/**
 * Cette fonction traite les cookies posés au moment de l'authentification standard
 * ou vérifie que l'authentification HTTP est correcte
 *
 * @global bool ignore_auth_http
 * @param string|null $set_cookie_admin
 * @param string|null $change_session
 * @return void
 */
function action_cookie_dist($set_cookie_admin = null, $change_session = null) {
	$redirect_echec = $redirect = null;
	$test_echec_cookie = null;
	$url = "";
	if (is_null($set_cookie_admin)) {
		$set_cookie_admin = _request('cookie_admin');
		$change_session = _request('change_session');
		$test_echec_cookie = _request('test_echec_cookie');

// La cible de notre operation de connexion
		$url = securiser_redirect_action(_request('url'));
		$redirect = $url ? $url : generer_url_ecrire('accueil');
		$redirect_echec = _request('url_echec');
		if (!isset($redirect_echec)) {
			if (strpos($redirect, _DIR_RESTREINT_ABS) !== false) {
				$redirect_echec = generer_url_public('login', '', true);
			} else {
				$redirect_echec = $redirect;
			}
		}
	}

// rejoue le cookie pour renouveler spip_session
	if ($change_session == 'oui') {
		$session = charger_fonction('session', 'inc');
		$session(true);
		spip_log("statut 204 pour " . $_SERVER['REQUEST_URI']);
		http_status(204); // No Content
		return;
	}

// tentative de connexion en auth_http
	if (_request('essai_auth_http') and !$GLOBALS['ignore_auth_http']) {
		include_spip('inc/auth');
		if (@$_SERVER['PHP_AUTH_USER']
			and @$_SERVER['PHP_AUTH_PW']
			and $auteur = lire_php_auth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW'])
		) {
			auth_loger($auteur);
			redirige_par_entete(parametre_url($redirect, 't', time(), '&'));
		} else {
			ask_php_auth(_T('info_connexion_refusee'),
				_T('login_login_pass_incorrect'),
				_T('login_retour_site'),
				"url=" . rawurlencode($redirect),
				_T('login_nouvelle_tentative'),
				(strpos($url, _DIR_RESTREINT_ABS) !== false));
		}
	} else {

// en cas de login sur bonjour=oui, on tente de poser un cookie
		// puis de passer au login qui diagnostiquera l'echec de cookie
		// le cas echeant.
		if ($test_echec_cookie == 'oui') {
			spip_setcookie('spip_session', 'test_echec_cookie');
			if ($redirect) {
				$redirect = parametre_url(parametre_url($redirect_echec, 'var_echec_cookie', 'oui', '&'), 'url',
					rawurlencode($redirect), '&');
			}
		} else {

$cook = isset($_COOKIE['spip_admin']) ? $_COOKIE['spip_admin'] : '';
			// Suppression cookie d'admin ?
			if ($set_cookie_admin == "non") {
				if ($cook) {
					spip_setcookie('spip_admin', $cook, time() - 3600 * 24);
				}
			} // Ajout de cookie d'admin
			else {
				if ($set_cookie_admin and _DUREE_COOKIE_ADMIN) {
					spip_setcookie('spip_admin', $set_cookie_admin, time() + max(_DUREE_COOKIE_ADMIN, 2 * _RENOUVELLE_ALEA));
				}
			}
		}
	}

// Redirection finale
	if ($redirect) {
		redirige_par_entete($redirect, true);
	}
}
auth.php000064400000003040152525343600006220 0ustar00<?php

/**
 * Gestion de l'action auth
 *
 * @package SPIP\Core\Authentification
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Retour d'authentification pour les SSO
 */
function action_auth_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$arg = $securiser_action();

if (!preg_match(",^(\w+)[/](.+)$,", $arg, $r)) {
		spip_log("action_auth_dist $arg pas compris");
	} else {
		$auth_methode = $r[1];
		$login = $r[2];
		include_spip('inc/auth');
		$res = auth_terminer_identifier_login($auth_methode, $login);

if (is_string($res)) { // Erreur
			$redirect = _request('redirect');
			$redirect = parametre_url($redirect, 'var_erreur', $res, '&');
			include_spip('inc/headers');
			redirige_par_entete($redirect);
		}

// sinon on loge l'auteur identifie, et on finit (redirection automatique)
		auth_loger($res);
	}
}
instituer_langue_objet.php000064400000004711152525343600012031 0ustar00<?php

/**
 * Action des changements de langue des objets éditoriaux
 *
 * @package SPIP\Core\Edition
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Modifier la langue d'un objet
 *
 * @param string $objet
 * @param int $id
 * @param int $id_rubrique
 * @param string $changer_lang
 * @param string $serveur
 * @return string
 */
function action_instituer_langue_objet_dist($objet, $id, $id_rubrique, $changer_lang, $serveur='') {
	if ($changer_lang) {
		$table_objet_sql = table_objet_sql($objet);
		$id_table_objet = id_table_objet($objet);
		$trouver_table = charger_fonction('trouver_table', 'base');
		$desc = $trouver_table($table_objet_sql, $serveur);
		
		$set = array();
		if (isset($desc['field']['langue_choisie'])){
			$set['langue_choisie'] = 'oui';
		}
		
		if ($changer_lang != "herit") {
			$set['lang'] = $changer_lang;
			sql_updateq($table_objet_sql, $set, "$id_table_objet=" . intval($id),'',$serveur);
			include_spip('inc/rubriques'); // pour calculer_langues_rubriques et calculer_langues_utilisees
			if ($table_objet_sql == 'spip_rubriques') {
				calculer_langues_rubriques();
			}
			$langues = calculer_langues_utilisees($serveur);
			ecrire_meta('langues_utilisees', $langues);
		} else {
			$langue_parent = sql_getfetsel("lang", "spip_rubriques", "id_rubrique=" . intval($id_rubrique));
			if (!$langue_parent) {
				$langue_parent = $GLOBALS['meta']['langue_site'];
			}
			$changer_lang = $langue_parent;
			$set['lang'] = $changer_lang;
			if (isset($set['langue_choisie'])){
				$set['langue_choisie'] = 'non';
			}
			sql_updateq($table_objet_sql, $set, "$id_table_objet=" . intval($id),'',$serveur);
			if ($table_objet_sql == 'spip_rubriques') {
				include_spip('inc/rubriques');
				calculer_langues_rubriques();
			}
		}
	}

return $changer_lang;
}
redirect.php000064400000007246152525343600007074 0ustar00<?php

/**
 * Gestion de redirection publique à la volée d'un objet éditorial en
 * recalculant au passage son URL
 *
 * @package SPIP\Core\Redirections
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Script utile pour recalculer une URL symbolique dès son changement
 *
 * Cette action est appelé par les boutons 'Voir en ligne' ou par
 * le fichier `.htaccess` activé lors d'une URL du genre : http://site/1234
 *
 * @example
 *   ```
 *   [(#VAL{redirect}
 *      |generer_url_action{type=article&id=#ID_ARTICLE}
 *      |parametre_url{var_mode,calcul}
 *      |icone_horizontale{<:icone_voir_en_ligne:>,racine})]
 *   ```
 **/
function action_redirect_dist() {
	$type = _request('type');
	$id = intval(_request('id'));
	$page = false;

// verifier le type ou page transmis
	if (!preg_match('/^\w+$/', $type)) {
		$page = _request('page');
		if (!preg_match('/^\w+$/', $page)) {
			return;
		}
	}

if ($var_mode = _request('var_mode')) {
		// forcer la mise a jour de l'url de cet objet !
		if (!defined('_VAR_URLS')) {
			define('_VAR_URLS', true);
		}
	}

if ($page) {
		$url = generer_url_public($page, '', true);
	} else {
		$url = calculer_url_redirect_entite($type, $id, $var_mode);
	}

$status = '302';
	if ($url) {
		if ($var_mode) {
			$url = parametre_url($url, 'var_mode', $var_mode, '&');
		}

if ($var_mode == 'preview'
			and defined('_PREVIEW_TOKEN')
			and _PREVIEW_TOKEN
			and autoriser('previsualiser')
		) {
			include_spip('inc/securiser_action');
			$token = calculer_token_previsu($url);
			$url = parametre_url($url, 'var_previewtoken', $token);
		}

if (_request('status') and _request('status') == '301') {
			$status = '301';
		}
	} else {
		$url = generer_url_public('404', '', true);
	}

redirige_par_entete(str_replace('&amp;', '&', $url), '', $status);
}

/**
 * Retourne l’URL de l’objet sur lequel on doit rediriger
 *
 * On met en cache les calculs (si memoization),
 * et on ne donne pas l’URL si la personne n’y a pas accès
 *
 * @param string $type
 * @param int $id
 * @param string $var_mode
 */
function calculer_url_redirect_entite($type, $id, $var_mode) {
	// invalider le cache à chaque modif en bdd
	$date = 0;
	if (isset($GLOBALS['meta']['derniere_modif'])) {
		$date = $GLOBALS['meta']['derniere_modif'];
	}
	$key = "url-$date-$type-$id";

// Obtenir l’url et si elle est publié du cache memoization
	if (function_exists('cache_get') and $desc = cache_get($key)) {
		list($url, $publie) = $desc;
	}
	// Si on ne l’a pas trouvé, ou si var mode, on calcule l’url et son état publie
	if (empty($desc) or $var_mode) {
		$publie = objet_test_si_publie($type, $id);
		$url = generer_url_entite_absolue($id, $type, '', '', true);
		if (function_exists('cache_set')) {
			cache_set($key, array($url, $publie), 3600);
		}
	}

// On valide l’url si elle est publiee ; sinon si preview on teste l’autorisation
	if ($publie) {
		return $url;
	} elseif (defined('_VAR_PREVIEW') and _VAR_PREVIEW and autoriser('voir', $type, $id)) {
		return $url;
	}

return;
}
forcer_job.php000064400000002313152525343600007373 0ustar00<?php

/**
 * Action pour exécuter un job en attente, tout de suite
 *
 * @package SPIP\Core\Job
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Executer un travaille immediatement
 *
 * @return void
 */
function action_forcer_job_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$id_job = $securiser_action();

if ($id_job = intval($id_job)
		and autoriser('forcer', 'job', $id_job)
	) {
		include_spip('inc/queue');
		include_spip('inc/genie');
		queue_schedule(array($id_job));
	}

}
editer_auteur.php000064400000031755152525343600010136 0ustar00<?php

/**
 * Gestion de l'action editer_auteur et de l'API d'édition d'un auteur
 *
 * @package SPIP\Core\Auteurs\Edition
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Éditer ou créer un auteur
 *
 * Si aucun identifiant d'auteur n'est donné, on crée alors un nouvel auteur.
 *
 * @global array visiteur_session
 * @uses auteur_inserer()
 * @uses auteur_modifier()
 *
 * @param array|null $arg
 *     Identifiant de l'auteur. En absence utilise l'argument
 *     de l'action sécurisée.
 * @return array
 *     Liste (identifiant de l'auteur, Texte d'erreur éventuel)
 */
function action_editer_auteur_dist($arg = null) {

if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

// si id_auteur n'est pas un nombre, c'est une creation
	if (!$id_auteur = intval($arg)) {

if (($id_auteur = auteur_inserer()) > 0) {

# cf. GROS HACK
			# recuperer l'eventuel logo charge avant la creation
			# ils ont un id = 0-id_auteur de la session
			$id_hack = 0 - $GLOBALS['visiteur_session']['id_auteur'];
			$chercher_logo = charger_fonction('chercher_logo', 'inc');
			foreach (array('on', 'off') as $type) {
				if ($logo = $chercher_logo($id_hack, 'id_auteur', $type)) {
					if ($logo = reset($logo)) {
						rename($logo, str_replace($id_hack, $id_auteur, $logo));
					}
				}
			}
		}
	}

// Enregistre l'envoi dans la BD
	$err = "";
	if ($id_auteur > 0) {
		$err = auteur_modifier($id_auteur);
	}

if ($err) {
		spip_log("echec editeur auteur: $err", _LOG_ERREUR);
	}

return array($id_auteur, $err);
}

/**
 * Insérer un auteur en base
 *
 * @pipeline_appel pre_insertion
 * @pipeline_appel post_insertion
 *
 * @param string|null $source
 *     D'où provient l'auteur créé ? par défaut 'spip', mais peut être 'ldap' ou autre.
 * @param array|null $set
 * @return int
 *     Identifiant de l'auteur créé
 */
function auteur_inserer($source = null, $set = null) {

// Ce qu'on va demander comme modifications
	$champs = array();
	$champs['source'] = $source ? $source : 'spip';

$champs['login'] = '';
	$champs['statut'] = '5poubelle';  // inutilisable tant qu'il n'a pas ete renseigne et institue
	$champs['webmestre'] = 'non';

if ($set) {
		$champs = array_merge($champs, $set);
	}

// Envoyer aux plugins
	$champs = pipeline('pre_insertion',
		array(
			'args' => array(
				'table' => 'spip_auteurs',
			),
			'data' => $champs
		)
	);
	$id_auteur = sql_insertq("spip_auteurs", $champs);
	pipeline('post_insertion',
		array(
			'args' => array(
				'table' => 'spip_auteurs',
				'id_objet' => $id_auteur
			),
			'data' => $champs
		)
	);

return $id_auteur;
}

/**
 * Modifier un auteur
 *
 * Appelle toutes les fonctions de modification d'un auteur
 *
 * @param int $id_auteur
 *     Identifiant de l'auteur
 * @param array|null $set
 *     Couples (colonne => valeur) de données à modifier.
 *     En leur absence, on cherche les données dans les champs éditables
 *     qui ont été postés (via collecter_requests())
 * @param bool $force_update
 *   Permet de forcer la maj en base des champs fournis, sans passer par instancier.
 *   Utilise par auth/spip
 * @return string|null
 *
 *     - Chaîne vide si aucune erreur,
 *     - Chaîne contenant un texte d'erreur sinon.
 */
function auteur_modifier($id_auteur, $set = null, $force_update = false) {

include_spip('inc/modifier');
	include_spip('inc/filtres');
	$c = collecter_requests(
	// white list
		objet_info('auteur', 'champs_editables'),
		// black list
		$force_update ? array() : array('webmestre', 'pass', 'login'),
		// donnees eventuellement fournies
		$set
	);

if ($err = objet_modifier_champs('auteur', $id_auteur,
		array(
			'data' => $set,
			'nonvide' => array('nom' => _T('ecrire:item_nouvel_auteur'))
		),
		$c)
	) {
		return $err;
	}
	$session = $c;

$err = '';
	if (!$force_update) {
		// Modification de statut, changement de rubrique ?
		$c = collecter_requests(
		// white list
			array(
				'statut',
				'new_login',
				'new_pass',
				'login',
				'pass',
				'webmestre',
				'restreintes',
				'id_parent'
			),
			// black list
			array(),
			// donnees eventuellement fournies
			$set
		);
		if (isset($c['new_login']) and !isset($c['login'])) {
			$c['login'] = $c['new_login'];
		}
		if (isset($c['new_pass']) and !isset($c['pass'])) {
			$c['pass'] = $c['new_pass'];
		}
		$err = auteur_instituer($id_auteur, $c);
		$session = array_merge($session, $c);
	}

// .. mettre a jour les sessions de cet auteur
	include_spip('inc/session');
	$session['id_auteur'] = $id_auteur;
	unset($session['new_login']);
	unset($session['new_pass']);
	actualiser_sessions($session);

return $err;
}

/**
 * Associer un auteur à des objets listés
 *
 * @uses objet_associer()
 *
 * @param int $id_auteur
 *     Identifiant de l'auteur
 * @param array $objets
 *     Liste sous la forme `array($objet=>$id_objets,...)`.
 *     `$id_objets` peut lui-même être un scalaire ou un tableau pour une liste
 *     d'objets du même type.
 * @param array|null $qualif
 *     Optionnellement indique une qualification du (des) lien(s) qui sera
 *     alors appliquée dans la foulée.
 *     En cas de lot de liens, c'est la même qualification qui est appliquée à tous
 * @return string
 */
function auteur_associer($id_auteur, $objets, $qualif = null) {
	include_spip('action/editer_liens');

return objet_associer(array('auteur' => $id_auteur), $objets, $qualif);
}

/**
 * Ancien nommage pour compatibilité
 *
 * @deprecated Utiliser auteur_associer()
 * @see auteur_associer()
 *
 * @param int $id_auteur
 * @param array $c
 * @return string
 */
function auteur_referent($id_auteur, $c) {
	return auteur_associer($id_auteur, $c);
}

/**
 * Dissocier un auteur des objets listés
 *
 * @uses objet_dissocier()
 *
 * @param int $id_auteur
 *     Identifiant de l'auteur
 * @param array $objets
 *     Liste sous la forme `array($objet=>$id_objets,...)`.
 *     `$id_objets` peut lui-même être un scalaire ou un tableau pour une liste
 *     d'objets du même type.
 *
 *     Un `*` pour $id_auteur,$objet,$id_objet permet de traiter par lot
 * @return string
 */
function auteur_dissocier($id_auteur, $objets) {
	include_spip('action/editer_liens');

return objet_dissocier(array('auteur' => $id_auteur), $objets);
}

/**
 * Qualifier le lien d'un auteur avec les objets listés
 *
 * @uses objet_qualifier_liens()
 *
 * @param int $id_auteur
 *     Identifiant de l'auteur
 * @param array $objets
 *     Liste sous la forme `array($objet=>$id_objets,...)`.
 *     `$id_objets` peut lui-même être un scalaire ou un tableau pour une liste
 *     d'objets du même type.
 *
 *     Un `*` pour $id_auteur,$objet,$id_objet permet de traiter par lot
 * @param array $qualif
 *     Couples (colonne, valeur) tel que `array('vu'=>'oui');`
 * @return bool|int
 */
function auteur_qualifier($id_auteur, $objets, $qualif) {
	include_spip('action/editer_liens');

return objet_qualifier_liens(array('auteur' => $id_auteur), $objets, $qualif);
}

/**
 * Modifier le statut d'un auteur, ou son login/pass
 *
 * @pipeline_appel pre_edition
 * @pipeline_appel post_edition
 *
 * @param int $id_auteur
 *     Identifiant de l'auteur
 * @param array $c
 *     Couples (colonne => valeur) des données à instituer
 * @param bool $force_webmestre
 *     Autoriser un auteur à passer webmestre (force l'autorisation)
 * @return bool|string
 */
function auteur_instituer($id_auteur, $c, $force_webmestre = false) {
	if (!$id_auteur = intval($id_auteur)) {
		return false;
	}
	$erreurs = array(); // contiendra les differentes erreurs a traduire par _T()
	$champs = array();

// les memoriser pour les faire passer dans le pipeline pre_edition
	if (isset($c['login']) and strlen($c['login'])) {
		$champs['login'] = $c['login'];
	}
	if (isset($c['pass']) and strlen($c['pass'])) {
		$champs['pass'] = $c['pass'];
	}

$statut = $statut_ancien = sql_getfetsel('statut', 'spip_auteurs', 'id_auteur=' . intval($id_auteur));

if (isset($c['statut'])
		and (autoriser('modifier', 'auteur', $id_auteur, null, array('statut' => $c['statut'])))
	) {
		$statut = $champs['statut'] = $c['statut'];
	}

// Restreindre avant de declarer l'auteur
	// (section critique sur les droits)
	if (isset($c['id_parent']) and $c['id_parent']) {
		if (is_array($c['restreintes'])) {
			$c['restreintes'][] = $c['id_parent'];
		} else {
			$c['restreintes'] = array($c['id_parent']);
		}
	}

if (isset($c['webmestre'])
		and ($force_webmestre or autoriser('modifier', 'auteur', $id_auteur, null, array('webmestre' => '?')))
	) {
		$champs['webmestre'] = $c['webmestre'] == 'oui' ? 'oui' : 'non';
	}

// si statut change et n'est pas 0minirezo, on force webmestre a non
	if (isset($c['statut']) and $c['statut'] !== '0minirezo') {
		$champs['webmestre'] = $c['webmestre'] = 'non';
	}

// Envoyer aux plugins
	$champs = pipeline('pre_edition',
		array(
			'args' => array(
				'table' => 'spip_auteurs',
				'id_objet' => $id_auteur,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
			),
			'data' => $champs
		)
	);

if (isset($c['restreintes']) and is_array($c['restreintes'])
		and autoriser('modifier', 'auteur', $id_auteur, null, array('restreint' => $c['restreintes']))
	) {
		$rubriques = array_map('intval', $c['restreintes']);
		$rubriques = array_unique($rubriques);
		$rubriques = array_diff($rubriques, array(0));
		auteur_dissocier($id_auteur, array('rubrique' => '*'));
		auteur_associer($id_auteur, array('rubrique' => $rubriques));
	}

$flag_ecrire_acces = false;
	// commencer par traiter les cas particuliers des logins et pass
	// avant les autres ecritures en base
	if (isset($champs['login']) or isset($champs['pass'])) {
		$auth_methode = sql_getfetsel('source', 'spip_auteurs', 'id_auteur=' . intval($id_auteur));
		include_spip('inc/auth');
		if (isset($champs['login']) and strlen($champs['login'])) {
			if (!auth_modifier_login($auth_methode, $champs['login'], $id_auteur)) {
				$erreurs[] = 'ecrire:impossible_modifier_login_auteur';
			}
		}
		if (isset($champs['pass']) and strlen($champs['pass'])) {
			$champs['login'] = sql_getfetsel('login', 'spip_auteurs', 'id_auteur=' . intval($id_auteur));
			if (!auth_modifier_pass($auth_methode, $champs['login'], $champs['pass'], $id_auteur)) {
				$erreurs[] = 'ecrire:impossible_modifier_pass_auteur';
			}
		}
		unset($champs['login']);
		unset($champs['pass']);
		$flag_ecrire_acces = true;
	}

if (!count($champs)) {
		return implode(' ', array_map('_T', $erreurs));
	}
	sql_updateq('spip_auteurs', $champs, 'id_auteur=' . $id_auteur);

// .. mettre a jour les fichiers .htpasswd et .htpasswd-admin
	if ($flag_ecrire_acces
		or isset($champs['statut'])
	) {
		include_spip('inc/acces');
		ecrire_acces();
	}

// Invalider les caches
	include_spip('inc/invalideur');
	suivre_invalideur("id='auteur/$id_auteur'");

// Pipeline
	pipeline('post_edition',
		array(
			'args' => array(
				'table' => 'spip_auteurs',
				'id_objet' => $id_auteur,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
			),
			'data' => $champs
		)
	);

// Notifications
	if ($notifications = charger_fonction('notifications', 'inc')) {
		$notifications('instituerauteur', $id_auteur,
			array('statut' => $statut, 'statut_ancien' => $statut_ancien)
		);
	}

return implode(' ', array_map('_T', $erreurs));

}

// Fonctions Dépréciées
// --------------------

/**
 * Insertion d'un auteur
 *
 * @deprecated Utiliser auteur_inserer()
 * @see auteur_inserer()
 *
 * @param string|null $source
 * @return int
 */
function insert_auteur($source = null) {
	return auteur_inserer($source);
}

/**
 * Modification d'un auteur
 *
 * @deprecated Utiliser auteur_modifier()
 * @see auteur_modifier()
 *
 * @param int $id_auteur
 * @param array|null $set
 * @return string|null
 */
function auteurs_set($id_auteur, $set = null) {
	return auteur_modifier($id_auteur, $set);
}

/**
 * Modifier le statut d'un auteur, ou son login/pass
 *
 * @deprecated Utiliser auteur_instituer()
 * @see auteur_instituer()
 *
 * @param int $id_auteur
 * @param array $c
 * @param bool $force_webmestre
 * @return bool|string
 */
function instituer_auteur($id_auteur, $c, $force_webmestre = false) {
	return auteur_instituer($id_auteur, $c, $force_webmestre);
}

/**
 * Créer une révision d'un auteur
 *
 * @deprecated Utiliser auteur_modifier()
 * @see auteur_modifier()
 *
 * @param int $id_auteur
 * @param array $c
 * @return string|null
 */
function revision_auteur($id_auteur, $c = false) {
	return auteur_modifier($id_auteur, $c);
}
purger_queue.php000064400000002157152525343600007777 0ustar00<?php

/**
 * Gestion de l'action de purge des travaux en attente
 *
 * @package SPIP\Core\Queue
 **/
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Purger la liste des travaux en attente
 *
 * @return void
 */
function action_purger_queue_dist() {
	$securiser_action = charger_fonction('securiser_action', 'inc');
	$securiser_action();

if (autoriser('purger', 'queue')) {
		include_spip('inc/queue');
		queue_purger();
	}

}
instituer_objet.php000064400000003146152525343600010477 0ustar00<?php

/**
 * Action pour instituer un objet avec les puces rapides
 *
 * @package SPIP\Core\PuceStatut
 */

if (!defined("_ECRIRE_INC_VERSION")) {
	return;
}

/**
 * Instituer un objet avec les puces rapides
 *
 * @param null|string $arg
 *     Chaîne "objet id statut". En absence utilise l'argument
 *     de l'action sécurisée.
 */
function action_instituer_objet_dist($arg = null) {

if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

list($objet, $id_objet, $statut) = preg_split('/\W/', $arg);
	if (!$statut) {
		$statut = _request('statut_nouv');
	} // cas POST
	if (!$statut) {
		return;
	} // impossible mais sait-on jamais

if ($id_objet = intval($id_objet)
		and autoriser('instituer', $objet, $id_objet, '', array('statut' => $statut))
	) {

include_spip('action/editer_objet');
		objet_modifier($objet, $id_objet, array('statut' => $statut));
	}

}
supprimer_rubrique.php000064400000004717152525343600011237 0ustar00<?php

/**
 * Action de suppression d'une rubrique
 *
 * @package SPIP\Core\Rubriques
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/charsets');  # pour le nom de fichier

/**
 * Effacer une rubrique
 *
 * @param null|int $id_rubrique
 * @return void
 */
function action_supprimer_rubrique_dist($id_rubrique = null) {

if (is_null($id_rubrique)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$id_rubrique = $securiser_action();
	}

if (intval($id_rubrique)) {

sql_delete("spip_rubriques", "id_rubrique=" . intval($id_rubrique));
		// Les admin restreints qui n'administraient que cette rubrique
		// deviennent redacteurs
		// (il y a sans doute moyen de faire ca avec un having)

$q = sql_select("id_auteur", "spip_auteurs_liens", "objet='rubrique' AND id_objet=" . intval($id_rubrique));
		while ($r = sql_fetch($q)) {
			$id_auteur = $r['id_auteur'];
			// degrader avant de supprimer la restriction d'admin
			// section critique sur les droits
			$n = sql_countsel("spip_auteurs_liens",
				"objet='rubrique' AND id_objet!=" . intval($id_rubrique) . " AND id_auteur=" . intval($id_auteur));
			if (!$n) {
				include_spip('action/editer_auteur');
				auteurs_set($id_auteur, array("statut" => '1comite'));
			}
			sql_delete("spip_auteurs_liens",
				"objet='rubrique' AND id_objet=" . intval($id_rubrique) . " AND id_auteur=" . intval($id_auteur));
		}
		// menu_rubriques devra recalculer
		effacer_meta("date_calcul_rubriques");

// Une rubrique supprimable n'avait pas le statut "publie"
		// donc rien de neuf pour la rubrique parente
		include_spip('inc/rubriques');
		calculer_langues_rubriques();

// invalider les caches marques de cette rubrique
		include_spip('inc/invalideur');
		suivre_invalideur("id='rubrique/$id_rubrique'");
	}
}
inscrire_auteur.php000064400000024716152525343600010477 0ustar00<?php

/**
 * Gestion de l'inscription d'un auteur
 *
 * @package SPIP\Core\Inscription
 **/
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Inscrire un nouvel auteur sur la base de son nom et son email
 *
 * L'email est utilisé pour repérer si il existe déjà ou non
 * => identifiant par défaut
 *
 * @param string $statut
 * @param string $mail_complet
 * @param string $nom
 * @param array $options
 *   - login : login precalcule
 *   - id : id_rubrique fournit en second arg de #FORMULAIRE_INSCRIPTION
 *   - from : email de l'envoyeur pour l'envoi du mail d'inscription
 *   - force_nouveau : forcer le statut nouveau sur l'auteur inscrit, meme si il existait deja en base
 *   - modele_mail : squelette de mail a utiliser
 * @return array|string
 */
function action_inscrire_auteur_dist($statut, $mail_complet, $nom, $options = array()) {
	if (!is_array($options)) {
		$options = array('id' => $options);
	}

if (function_exists('test_inscription')) {
		$f = 'test_inscription';
	} else {
		$f = 'test_inscription_dist';
	}
	$desc = $f($statut, $mail_complet, $nom, $options);

// erreur ?
	if (!is_array($desc)) {
		return _T($desc);
	}

include_spip('base/abstract_sql');
	$res = sql_select("statut, id_auteur, login, email", "spip_auteurs", "email=" . sql_quote($desc['email']));
	// erreur ?
	if (!$res) {
		return _T('titre_probleme_technique');
	}

$row = sql_fetch($res);
	sql_free($res);
	if ($row) {
		if (isset($options['force_nouveau']) and $options['force_nouveau'] == true) {
			$desc['id_auteur'] = $row['id_auteur'];
			$desc = inscription_nouveau($desc);
		} else {
			$desc = $row;
		}
	} else // s'il n'existe pas deja, creer les identifiants
	{
		$desc = inscription_nouveau($desc);
	}

// erreur ?
	if (!is_array($desc)) {
		return $desc;
	}

// generer le mot de passe (ou le refaire si compte inutilise)
	$desc['pass'] = creer_pass_pour_auteur($desc['id_auteur']);

// attribuer un jeton pour confirmation par clic sur un lien
	$desc['jeton'] = auteur_attribuer_jeton($desc['id_auteur']);

// charger de suite cette fonction, pour ses utilitaires
	$envoyer_inscription = charger_fonction("envoyer_inscription", "");
	list($sujet, $msg, $from, $head) = $envoyer_inscription($desc, $nom, $statut, $options);

$notifications = charger_fonction('notifications', 'inc');
	notifications_envoyer_mails($mail_complet, $msg, $sujet, $from, $head);

// Notifications
	$notifications('inscription', $desc['id_auteur'],
		array('nom' => $desc['nom'], 'email' => $desc['email'])
	);

return $desc;
}

/**
 * Contrôler que le nom (qui sert à calculer le login) est plausible
 * et que l'adresse courriel est valide.
 *
 * On les normalise au passage (trim etc).
 *
 * On peut redéfinir cette fonction pour filtrer les adresses mail et les noms,
 * et donner des infos supplémentaires
 *
 * @param string $statut
 * @param string $mail
 * @param string $nom
 * @param array $options
 * @return array|string
 *     - array : si ok, tableau avec au minimum email, nom, mode (redac / forum)
 *     - string : si ko, chaîne de langue servant d'argument au filtre `_T` expliquant le refus
 *
 */
function test_inscription_dist($statut, $mail, $nom, $options) {
	include_spip('inc/filtres');
	if (!$r = email_valide($mail)) {
		return 'info_email_invalide';
	}
	$nom = trim(corriger_caracteres($nom));
	$res = array('email' => $r, 'nom' => $nom, 'prefs' => $statut);
	if (isset($options['login'])) {
		$login = trim(corriger_caracteres($options['login']));
		if ((strlen($login) >= _LOGIN_TROP_COURT) and (strlen($nom) <= 64)) {
			$res['login'] = $login;
		}
	}
	if (!isset($res['login']) and ((strlen($nom) < _LOGIN_TROP_COURT) or (strlen($nom) > 64))) {
		return 'ecrire:info_login_trop_court';
	}

return $res;
}

/**
 * On enregistre le demandeur comme 'nouveau', en memorisant le statut final
 * provisoirement dans le champ prefs, afin de ne pas visualiser les inactifs
 * A sa premiere connexion il obtiendra son statut final.
 *
 * @param array $desc
 * @return mixed|string
 */
function inscription_nouveau($desc) {
	if (!isset($desc['login']) or !strlen($desc['login'])) {
		$desc['login'] = test_login($desc['nom'], $desc['email']);
	}

$desc['statut'] = 'nouveau';
	include_spip('action/editer_auteur');
	if (isset($desc['id_auteur'])) {
		$id_auteur = $desc['id_auteur'];
	} else {
		$id_auteur = auteur_inserer();
	}

if (!$id_auteur) {
		return _T('titre_probleme_technique');
	}

$desc['lang'] = $GLOBALS['spip_lang'];

include_spip('inc/autoriser');
	// lever l'autorisation pour pouvoir modifier le statut
	autoriser_exception('modifier', 'auteur', $id_auteur);
	auteur_modifier($id_auteur, $desc);
	autoriser_exception('modifier', 'auteur', $id_auteur, false);

$desc['id_auteur'] = $id_auteur;

return $desc;
}

/**
 * http://code.spip.net/@test_login
 *
 * @param string $nom
 * @param string $mail
 * @return string
 */
function test_login($nom, $mail) {
	include_spip('inc/charsets');
	$nom = strtolower(translitteration($nom));
	$login_base = preg_replace("/[^\w\d_]/", "_", $nom);

// il faut eviter que le login soit vraiment trop court
	if (strlen($login_base) < 3) {
		$mail = strtolower(translitteration(preg_replace('/@.*/', '', $mail)));
		$login_base = preg_replace("/[^\w\d]/", "_", $mail);
	}
	if (strlen($login_base) < 3) {
		$login_base = 'user';
	}

$login = $login_base;

for ($i = 1; ; $i++) {
		if (!sql_countsel('spip_auteurs', "login='$login'")) {
			return $login;
		}
		$login = $login_base . $i;
	}

return $login;
}

/**
 * Construction du mail envoyant les identifiants
 *
 * Fonction redefinissable qui doit retourner un tableau
 * dont les elements seront les arguments de inc_envoyer_mail
 *
 * @param array $desc
 * @param string $nom
 * @param string $mode
 * @param array $options
 * @return array
 */
function envoyer_inscription_dist($desc, $nom, $mode, $options = array()) {

$contexte = array_merge($desc, $options);
	$contexte['nom'] = $nom;
	$contexte['mode'] = $mode;
	$contexte['url_confirm'] = generer_url_action('confirmer_inscription', '', true, true);
	$contexte['url_confirm'] = parametre_url($contexte['url_confirm'], 'email', $desc['email']);
	$contexte['url_confirm'] = parametre_url($contexte['url_confirm'], 'jeton', $desc['jeton']);

$modele_mail = 'modeles/mail_inscription';
	if (isset($options['modele_mail']) and $options['modele_mail']){
		$modele_mail = $options['modele_mail'];
	}
	$message = recuperer_fond($modele_mail, $contexte);
	$from = (isset($options['from']) ? $options['from'] : null);
	$head = null;

return array("", $message, $from, $head);
}

/**
 * Creer un mot de passe initial aleatoire
 *
 * @param int $id_auteur
 * @return string
 */
function creer_pass_pour_auteur($id_auteur) {
	include_spip('inc/acces');
	$pass = creer_pass_aleatoire(8, $id_auteur);
	include_spip('action/editer_auteur');
	auteur_instituer($id_auteur, array('pass' => $pass));

return $pass;
}

/**
 * Determine le statut d'inscription :
 * si $statut_tmp fourni, verifie qu'il est autorise
 * sinon determine le meilleur statut possible et le renvoie
 *
 * @param string $statut_tmp
 * @param int $id
 * @return string
 */
function tester_statut_inscription($statut_tmp, $id) {
	include_spip('inc/autoriser');
	if ($statut_tmp) {
		return autoriser('inscrireauteur', $statut_tmp, $id) ? $statut_tmp : '';
	} elseif (
		autoriser('inscrireauteur', $statut_tmp = "1comite", $id)
		or autoriser('inscrireauteur', $statut_tmp = "6forum", $id)
	) {
		return $statut_tmp;
	}

return '';
}

/**
 * Un nouvel inscrit prend son statut definitif a la 1ere connexion.
 * Le statut a ete memorise dans prefs (cf test_inscription_dist).
 * On le verifie, car la config a peut-etre change depuis,
 * et pour compatibilite avec les anciennes versions qui n'utilisaient pas "prefs".
 *
 * @param array $auteur
 * @return array
 */
function confirmer_statut_inscription($auteur) {
	// securite
	if ($auteur['statut'] != 'nouveau') {
		return $auteur;
	}

$s = $auteur['prefs'];
	// securite, au cas ou prefs aurait ete corrompu (ou deja ecrase par un tableau serialize)
	if (!preg_match(',^\w+$,', $s)) {
		$s = '6forum';
	}
	include_spip('inc/autoriser');
	if (!autoriser('inscrireauteur', $s)) {
		return $auteur;
	}

include_spip('inc/autoriser');
	// accorder l'autorisation de modif du statut auteur
	autoriser_exception('modifier', 'auteur', $auteur['id_auteur']);
	include_spip('action/editer_auteur');
	// changer le statut
	auteur_modifier($auteur['id_auteur'], array('statut' => $s));
	unset($_COOKIE['spip_session']); // forcer la maj de la session
	// lever l'autorisation de modif du statut auteur
	autoriser_exception('modifier', 'auteur', $auteur['id_auteur'], false);

// mettre a jour le statut
	$auteur['statut'] = $s;

return $auteur;
}

/**
 * Attribuer un jeton temporaire pour un auteur
 * en assurant l'unicite du jeton
 *
 * @param int $id_auteur
 * @return string
 */
function auteur_attribuer_jeton($id_auteur) {
	include_spip('inc/acces');
	// s'assurer de l'unicite du jeton pour le couple (email,cookie)
	do {
		$jeton = creer_uniqid();
		sql_updateq("spip_auteurs", array("cookie_oubli" => $jeton), "id_auteur=" . intval($id_auteur));
	} while (sql_countsel("spip_auteurs", "cookie_oubli=" . sql_quote($jeton)) > 1);

return $jeton;
}

/**
 * Retrouver l'auteur par son jeton
 *
 * @param string $jeton
 * @return array|bool
 */
function auteur_verifier_jeton($jeton) {
	// refuser un jeton corrompu
	if (preg_match(',[^0-9a-f.],i', $jeton)) {
		return false;
	}

// on peut tomber sur un jeton compose uniquement de chiffres, il faut forcer le $type pour sql_quote pour eviter de planter
	$desc = sql_fetsel('*', 'spip_auteurs', "cookie_oubli=" . sql_quote($jeton, '', 'string'));

return $desc;
}

/**
 * Effacer le jeton d'un auteur apres utilisation
 *
 * @param int $id_auteur
 * @return bool
 */
function auteur_effacer_jeton($id_auteur) {
	return sql_updateq("spip_auteurs", array("cookie_oubli" => ''), "id_auteur=" . intval($id_auteur));
}
editer_article.php000064400000040712152525343600010245 0ustar00<?php

/**
 * Gestion de l'action editer_article et de l'API d'édition d'un article
 *
 * @package SPIP\Core\Articles\Edition
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action d'édition d'un article dans la base de données dont
 * l'identifiant est donné en paramètre de cette fonction ou
 * en argument de l'action sécurisée
 *
 * Si aucun identifiant n'est donné, on crée alors un nouvel article,
 * à condition que la rubrique parente (id_rubrique) puisse être obtenue
 * (avec _request())
 *
 * @link http://code.spip.net/@action_editer_article_dist
 * @uses article_inserer()
 * @uses article_modifier()
 *
 * @param null|int $arg
 *     Identifiant de l'article. En absence utilise l'argument
 *     de l'action sécurisée.
 * @return array
 *     Liste (identifiant de l'article, Texte d'erreur éventuel)
 */
function action_editer_article_dist($arg = null) {
	include_spip('inc/autoriser');
	$err = "";
	if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

// si id_article n'est pas un nombre, c'est une creation 
	// mais on verifie qu'on a toutes les donnees qu'il faut.
	if (!$id_article = intval($arg)) {
		$id_parent = _request('id_parent');
		if (!$id_parent) {
			$err = _L("creation interdite d'un article sans rubrique");
		} elseif (!autoriser('creerarticledans', 'rubrique', $id_parent)) {
			$err = _T("info_creerdansrubrique_non_autorise");
		} else {
			$id_article = article_inserer($id_parent);
		}
	}

// Enregistre l'envoi dans la BD
	if ($id_article > 0) {
		$err = article_modifier($id_article);
	}

if ($err) {
		spip_log("echec editeur article: $err", _LOG_ERREUR);
	}

return array($id_article, $err);
}

/**
 * Modifier un article
 *
 * Appelle toutes les fonctions de modification d'un article
 *
 * @param int $id_article
 *     Identifiant de l'article à modifier
 * @param array|null $set
 *     Couples (colonne => valeur) de données à modifier.
 *     En leur absence, on cherche les données dans les champs éditables
 *     qui ont été postés (via collecter_requests())
 * @return string|null
 *
 *     - Chaîne vide si aucune erreur,
 *     - Null si aucun champ à modifier,
 *     - Chaîne contenant un texte d'erreur sinon.
 */
function article_modifier($id_article, $set = null) {

// unifier $texte en cas de texte trop long
	trop_longs_articles();

include_spip('inc/modifier');
	include_spip('inc/filtres');
	$c = collecter_requests(
	// white list
		objet_info('article', 'champs_editables'),
		// black list
		array('date', 'statut', 'id_parent'),
		// donnees eventuellement fournies
		$set
	);

// Si l'article est publie, invalider les caches et demander sa reindexation
	$t = sql_getfetsel("statut", "spip_articles", "id_article=" . intval($id_article));
	$invalideur = $indexation = false;
	if ($t == 'publie') {
		$invalideur = "id='article/$id_article'";
		$indexation = true;
	}

if ($err = objet_modifier_champs('article', $id_article,
		array(
			'data' => $set,
			'nonvide' => array('titre' => _T('info_nouvel_article') . " " . _T('info_numero_abbreviation') . $id_article),
			'invalideur' => $invalideur,
			'indexation' => $indexation,
			'date_modif' => 'date_modif' // champ a mettre a date('Y-m-d H:i:s') s'il y a modif
		),
		$c)
	) {
		return $err;
	}

// Modification de statut, changement de rubrique ?
	$c = collecter_requests(array('date', 'statut', 'id_parent'), array(), $set);
	$err = article_instituer($id_article, $c);

return $err;
}

/**
 * Insérer un nouvel article en base de données
 *
 * En plus des données enregistrées par défaut, la fonction :
 *
 * - retrouve un identifiant de rubrique pour stocker l'article (la
 *   première rubrique racine) si l'identifiant de rubrique transmis est
 *   nul.
 * - calcule la langue de l'article, soit
 *   - d'après la langue de la rubrique si les articles ne sont pas
 *     configurés comme pouvant être traduits,
 *   - d'après la langue de l'auteur en cours si les articles peuvent être traduits et
 *     si la langue de l'auteur est acceptée en tant que langue de traduction
 * - crée une liaison automatiquement entre l'auteur connecté et l'article
 *   créé, de sorte que la personne devient par défaut auteur de l'article
 *   qu'elle crée.
 *
 * @pipeline_appel pre_insertion
 * @pipeline_appel post_insertion
 *
 * @global array meta
 * @global array visiteur_session
 * @global string spip_lang
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique parente
 * @param array|null $set
 * @return int
 *     Identifiant du nouvel article
 *
 */
function article_inserer($id_rubrique, $set = null) {

// Si id_rubrique vaut 0 ou n'est pas definie, creer l'article
	// dans la premiere rubrique racine
	if (!$id_rubrique = intval($id_rubrique)) {
		$row = sql_fetsel("id_rubrique, id_secteur, lang", "spip_rubriques", "id_parent=0", '', '0+titre,titre', "1");
		$id_rubrique = $row['id_rubrique'];
	} else {
		$row = sql_fetsel("lang, id_secteur", "spip_rubriques", "id_rubrique=$id_rubrique");
	}

// eviter $id_secteur = NULL (erreur sqlite) si la requete precedente echoue 
	// cas de id_rubrique = -1 par exemple avec plugin "pages"
	$id_secteur = isset($row['id_secteur']) ? $row['id_secteur'] : 0;

$lang_rub = $row['lang'];

$lang = "";
	$choisie = 'non';
	// La langue a la creation : si les liens de traduction sont autorises
	// dans les rubriques, on essaie avec la langue de l'auteur,
	// ou a defaut celle de la rubrique
	// Sinon c'est la langue de la rubrique qui est choisie + heritee
	if (!empty($GLOBALS['meta']['multi_objets']) and in_array('spip_articles',
			explode(',', $GLOBALS['meta']['multi_objets']))
	) {
		lang_select($GLOBALS['visiteur_session']['lang']);
		if (in_array($GLOBALS['spip_lang'],
			explode(',', $GLOBALS['meta']['langues_multilingue']))) {
			$lang = $GLOBALS['spip_lang'];
			$choisie = 'oui';
		}
	}

if (!$lang) {
		$choisie = 'non';
		$lang = $lang_rub ? $lang_rub : $GLOBALS['meta']['langue_site'];
	}

$champs = array(
		'id_rubrique' => $id_rubrique,
		'id_secteur' => $id_secteur,
		'statut' => 'prepa',
		'date' => date('Y-m-d H:i:s'),
		'lang' => $lang,
		'langue_choisie' => $choisie
	);

if ($set) {
		$champs = array_merge($champs, $set);
	}

// Envoyer aux plugins
	$champs = pipeline('pre_insertion',
		array(
			'args' => array(
				'table' => 'spip_articles',
			),
			'data' => $champs
		)
	);

$id_article = sql_insertq("spip_articles", $champs);

// controler si le serveur n'a pas renvoye une erreur
	if ($id_article > 0) {
		$id_auteur = ((is_null(_request('id_auteur')) and isset($GLOBALS['visiteur_session']['id_auteur'])) ?
			$GLOBALS['visiteur_session']['id_auteur']
			: _request('id_auteur'));
		if ($id_auteur) {
			include_spip('action/editer_auteur');
			auteur_associer($id_auteur, array('article' => $id_article));
		}
	}

pipeline('post_insertion',
		array(
			'args' => array(
				'table' => 'spip_articles',
				'id_objet' => $id_article
			),
			'data' => $champs
		)
	);

return $id_article;
}

/**
 * Modification des statuts d'un article
 *
 * Modifie la langue, la rubrique ou les statuts d'un article.
 *
 * @global array $GLOBALS ['meta']
 *
 * @pipeline_appel pre_edition
 * @pipeline_appel post_edition
 *
 * @param int $id_article
 *     Identifiant de l'article
 * @param array $c
 *     Couples (colonne => valeur) des données à instituer
 *     Les colonnes 'statut' et 'id_parent' sont liées, car un admin restreint
 *     peut deplacer un article publié vers une rubrique qu'il n'administre pas
 * @param bool $calcul_rub
 *     True pour changer le statut des rubriques concernées si un article
 *     change de statut ou est déplacé dans une autre rubrique
 * @return string
 *     Chaîne vide
 */
function article_instituer($id_article, $c, $calcul_rub = true) {

include_spip('inc/autoriser');
	include_spip('inc/rubriques');
	include_spip('inc/modifier');

$row = sql_fetsel("statut, date, id_rubrique", "spip_articles", "id_article=$id_article");
	$id_rubrique = $row['id_rubrique'];
	$statut_ancien = $statut = $row['statut'];
	$date_ancienne = $date = $row['date'];
	$champs = array();

$d = isset($c['date']) ? $c['date'] : null;
	$s = isset($c['statut']) ? $c['statut'] : $statut;

// cf autorisations dans inc/instituer_article
	if ($s != $statut or ($d and $d != $date)) {
		if (autoriser('publierdans', 'rubrique', $id_rubrique)) {
			$statut = $champs['statut'] = $s;
		} else {
			if (autoriser('modifier', 'article', $id_article) and $s != 'publie') {
				$statut = $champs['statut'] = $s;
			} else {
				spip_log("editer_article $id_article refus " . join(' ', $c));
			}
		}

// En cas de publication, fixer la date a "maintenant"
		// sauf si $c commande autre chose
		// ou si l'article est deja date dans le futur
		// En cas de proposition d'un article (mais pas depublication), idem
		if ($champs['statut'] == 'publie'
			or ($champs['statut'] == 'prop' and ($d or !in_array($statut_ancien, array('publie', 'prop'))))
		) {
			if ($d or strtotime($d = $date) > time()) {
				$champs['date'] = $date = $d;
			} else {
				$champs['date'] = $date = date('Y-m-d H:i:s');
			}
		}
	}

// Verifier que la rubrique demandee existe et est differente
	// de la rubrique actuelle
	if (isset($c['id_parent'])
		and $id_parent = $c['id_parent']
		and $id_parent != $id_rubrique
		and (sql_fetsel('1', "spip_rubriques", "id_rubrique=" . intval($id_parent)))
	) {
		$champs['id_rubrique'] = $id_parent;

// si l'article etait publie
		// et que le demandeur n'est pas admin de la rubrique de destination
		// repasser l'article en statut 'propose'.
		if ($statut == 'publie'
			and !autoriser('publierdans', 'rubrique', $id_parent)
		) {
			$champs['statut'] = 'prop';
		}
	}

// Envoyer aux plugins
	$champs = pipeline('pre_edition',
		array(
			'args' => array(
				'table' => 'spip_articles',
				'id_objet' => $id_article,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
				'date_ancienne' => $date_ancienne,
			),
			'data' => $champs
		)
	);

if (!count($champs)) {
		return '';
	}

// Envoyer les modifs.
	editer_article_heritage($id_article, $id_rubrique, $statut_ancien, $champs, $calcul_rub);

// Invalider les caches
	include_spip('inc/invalideur');
	suivre_invalideur("id='article/$id_article'");

if ($date) {
		$t = strtotime($date);
		$p = @$GLOBALS['meta']['date_prochain_postdate'];
		if ($t > time() and (!$p or ($t < $p))) {
			ecrire_meta('date_prochain_postdate', $t);
		}
	}

// Pipeline
	pipeline('post_edition',
		array(
			'args' => array(
				'table' => 'spip_articles',
				'id_objet' => $id_article,
				'action' => 'instituer',
				'statut_ancien' => $statut_ancien,
				'date_ancienne' => $date_ancienne,
			),
			'data' => $champs
		)
	);

// Notifications
	if ($notifications = charger_fonction('notifications', 'inc')) {
		$notifications('instituerarticle', $id_article,
			array('statut' => $statut, 'statut_ancien' => $statut_ancien, 'date' => $date, 'date_ancienne' => $date_ancienne)
		);
	}

return ''; // pas d'erreur
}

/**
 * Fabrique la requête de modification de l'article, avec champs hérités
 *
 * @global array $GLOBALS ['meta']
 *
 * @param int $id_article
 *     Identifiant de l'article
 * @param int $id_rubrique
 *     Identifiant de la rubrique parente
 * @param string $statut
 *     Statut de l'article (prop, publie, ...)
 * @param array $champs
 *     Couples (colonne => valeur) des champs qui ont été modifiés
 * @param bool $cond
 *     True pour actualiser le statut et date de publication de la rubrique
 *     parente si nécessaire
 * @return void|null
 *     null si aucune action à faire
 *     void sinon
 */
function editer_article_heritage($id_article, $id_rubrique, $statut, $champs, $cond = true) {

// Si on deplace l'article
	//  changer aussi son secteur et sa langue (si heritee)
	if (isset($champs['id_rubrique'])) {

$row_rub = sql_fetsel("id_secteur, lang", "spip_rubriques", "id_rubrique=" . sql_quote($champs['id_rubrique']));

$langue = $row_rub['lang'];
		$champs['id_secteur'] = $row_rub['id_secteur'];
		if (sql_fetsel('1', 'spip_articles',
			"id_article=" . intval($id_article) . " AND langue_choisie<>'oui' AND lang<>" . sql_quote($langue))) {
			$champs['lang'] = $langue;
		}
	}

if (!$champs) {
		return;
	}

sql_updateq('spip_articles', $champs, "id_article=" . intval($id_article));

// Changer le statut des rubriques concernees

if ($cond) {
		include_spip('inc/rubriques');
		$postdate = ($GLOBALS['meta']["post_dates"] == "non" and isset($champs['date']) and (strtotime($champs['date']) < time())) ? $champs['date'] : false;
		calculer_rubriques_if($id_rubrique, $champs, $statut, $postdate);
	}
}

/**
 * Réunit les textes decoupés parce que trop longs
 *
 * @return void
 */
function trop_longs_articles() {
	if (is_array($plus = _request('texte_plus'))) {
		foreach ($plus as $n => $t) {
			$plus[$n] = preg_replace(",[\n\r]*,", "", $t);
		}
		set_request('texte', join('', $plus) . _request('texte'));
	}
}

// Fonctions Dépréciées
// --------------------

/**
 * Créer une révision d'un article
 *
 * @deprecated Utiliser article_modifier()
 * @see article_modifier()
 *
 * @param int $id_article
 *     Identifiant de l'article à modifier
 * @param array|null $c
 *     Couples (colonne => valeur) de données à modifier.
 *     En leur absence, on cherche les données dans les champs éditables
 *     qui ont été postés (via _request())
 * @return string|null
 *     Chaîne vide si aucune erreur,
 *     Null si aucun champ à modifier,
 *     Chaîne contenant un texte d'erreur sinon.
 */
function revisions_articles($id_article, $c = false) {
	return article_modifier($id_article, $c);
}

/**
 * Créer une révision d'un article
 *
 * @deprecated Utiliser article_modifier()
 * @see article_modifier()
 *
 * @param int $id_article
 *     Identifiant de l'article à modifier
 * @param array|null $c
 *     Couples (colonne => valeur) de données à modifier.
 *     En leur absence, on cherche les données dans les champs éditables
 *     qui ont été postés (via _request())
 * @return string|null
 *     Chaîne vide si aucune erreur,
 *     Null si aucun champ à modifier,
 *     Chaîne contenant un texte d'erreur sinon.
 */
function revision_article($id_article, $c = false) {
	return article_modifier($id_article, $c);
}

/**
 * Modifier un article
 *
 * @deprecated Utiliser article_modifier()
 * @see article_modifier()
 *
 * @param int $id_article
 *     Identifiant de l'article à modifier
 * @param array|null $set
 *     Couples (colonne => valeur) de données à modifier.
 *     En leur absence, on cherche les données dans les champs éditables
 *     qui ont été postés (via _request())
 * @return string|null
 *     Chaîne vide si aucune erreur,
 *     Null si aucun champ à modifier,
 *     Chaîne contenant un texte d'erreur sinon.
 */
function articles_set($id_article, $set = null) {
	return article_modifier($id_article, $set);
}

/**
 * Insertion d'un article dans une rubrique
 *
 * @deprecated Utiliser article_inserer()
 * @see article_inserer()
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique
 * @return int
 *     Identifiant du nouvel article
 */
function insert_article($id_rubrique) {
	return article_inserer($id_rubrique);
}

/**
 * Instituer un article dans une rubrique
 *
 * @deprecated Utiliser article_instituer()
 * @see article_instituer()
 *
 * @param int $id_article
 *     Identifiant de l'article
 * @param array $c
 *     Couples (colonne => valeur) des données à instituer
 *     Les colonnes 'statut' et 'id_parent' sont liées, car un admin restreint
 *     peut deplacer un article publié vers une rubrique qu'il n'administre pas
 * @param bool $calcul_rub
 *     True pour changer le statut des rubriques concernées si un article
 *     change de statut ou est déplacé dans une autre rubrique
 * @return string
 *     Chaîne vide
 */
function instituer_article($id_article, $c, $calcul_rub = true) {
	return article_instituer($id_article, $c, $calcul_rub);
}
confirmer_inscription.php000064400000005327152525343600011676 0ustar00<?php

/**
 * Gestion de l'action confirmer_inscription
 *
 * @package SPIP\Core\Inscription
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action de confirmation d'une inscription
 *
 * @global array $GLOBALS ['visiteur_session']
 * @global string $GLOBALS ['redirect']
 * @return void
 */
function action_confirmer_inscription_dist() {
	$jeton = _request('jeton');
	$email = _request('email');

include_spip('action/inscrire_auteur');
	if ($auteur = auteur_verifier_jeton($jeton)
		and $auteur['email'] == $email
		and $auteur['statut'] == 'nouveau'
	) {
		
		// d'abord on confirme son statut
		$auteur = confirmer_statut_inscription($auteur);

// OK c'est un nouvel inscrit qui confirme :
		// on le loge => ca va confirmer son statut et c'est plus sympa
		include_spip('inc/auth');
		auth_loger($auteur);

// et on efface son jeton
		auteur_effacer_jeton($auteur['id_auteur']);

// si pas de redirection demandee, rediriger vers public ou prive selon le statut de l'auteur
		// TODO: ne semble pas marcher si inscrit non visiteur, a debug
		if (!_request('redirect')) {
			// on passe id_auteur explicite pour forcer une lecture en base de toutes les infos
			if (autoriser('ecrire', '', '', $auteur['id_auteur'])) {
				// poser un cookie admin aussi
				$cookie = charger_fonction('cookie', 'action');
				$cookie("@" . $GLOBALS['visiteur_session']['login']);
				$GLOBALS['redirect'] = _DIR_RESTREINT_ABS;
			} else {
				$GLOBALS['redirect'] = $GLOBALS['meta']['adresse_site'];
			}
		}
	} else {
		// lien perime :
		if ($GLOBALS['visiteur_session']['id_auteur']) {
			// on passe id_auteur explicite pour forcer une lecture en base de toutes les infos
			if (autoriser('ecrire', '', '', $GLOBALS['visiteur_session']['id_auteur'])) {
				$GLOBALS['redirect'] = _DIR_RESTREINT_ABS;
			} else {
				$GLOBALS['redirect'] = $GLOBALS['meta']['adresse_site'];
			}
		} else // rediriger vers la page de login si pas encore loge
		{
			$GLOBALS['redirect'] = parametre_url(generer_url_public('login', '', false), 'url', _request('redirect'));
		}
	}

}
purger.php000064400000005563152525343600006577 0ustar00<?php

/**
 * Gestion de l'action purger pour nettoyer le cache
 *
 * @package SPIP\Core\Cache
 **/
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action de purge du cache
 *
 * L'argument peut être :
 *
 * - inhibe_cache : inhibe le cache pendant 24h
 * - reactive_cache : enlève l'inhibition du cache
 * - cache : nettoie tous les caches (sauf celui des vignettes)
 * - squelettes : nettoie le cache de compilation des squelettes
 * - vignettes : nettoie le cache des vignettes (et compressions css/js)
 *
 * @pipeline_appel trig_purger
 * @uses supprime_invalideurs()
 * @uses purger_repertoire()
 *
 * @param string|null $arg
 *     Argument attendu. En absence utilise l'argument
 *     de l'action sécurisée.
 */
function action_purger_dist($arg = null) {
	if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

include_spip('inc/invalideur');

spip_log("purger $arg");

switch ($arg) {
		case 'inhibe_cache':
			// inhiber le cache pendant 24h
			ecrire_meta('cache_inhib', $_SERVER['REQUEST_TIME'] + 24 * 3600);
			break;
		case 'reactive_cache':
			effacer_meta('cache_inhib');
			break;

case 'cache':
			supprime_invalideurs();
			@spip_unlink(_CACHE_RUBRIQUES);
			@spip_unlink(_CACHE_CHEMIN);
			@spip_unlink(_DIR_TMP . "plugin_xml_cache.gz");
			// on ne supprime que _CACHE_PLUGINS_OPT qui declenche la reconstruction des 3
			// _CACHE_PIPELINES _CACHE_PLUGINS_PATH et _CACHE_PLUGINS_FCT
			// pour eviter des problemes de concurence
			// cf http://core.spip.net/issues/2989
			//@spip_unlink(_CACHE_PIPELINES);
			//@spip_unlink(_CACHE_PLUGINS_PATH);
			//@spip_unlink(_CACHE_PLUGINS_FCT);
			@spip_unlink(_CACHE_PLUGINS_OPT);
			purger_repertoire(_DIR_CACHE, array('subdir' => true));
			purger_repertoire(_DIR_AIDE);
			purger_repertoire(_DIR_VAR . 'cache-css');
			purger_repertoire(_DIR_VAR . 'cache-js');
			break;

case 'squelettes':
			purger_repertoire(_DIR_SKELS);
			break;

case 'vignettes':
			purger_repertoire(_DIR_VAR, array('subdir' => true));
			supprime_invalideurs();
			purger_repertoire(_DIR_CACHE, array('subdir' => true));
			break;
	}

// le faire savoir aux plugins
	pipeline('trig_purger', $arg);
}
editer_rubrique.php000064400000022203152525343600010453 0ustar00<?php

/**
 * Gestion de l'action editer_rubrique et de l'API d'édition des rubriques
 *
 * @package SPIP\Core\Rubriques\Edition
 */
if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

include_spip('inc/rubriques');

/**
 * Action d'édition d'une rubrique
 *
 * Crée la rubrique si elle n'existe pas encore
 * Redirige après l'action sur _request('redirect') si présent
 *
 * @param null|int $arg
 *     - null : vérifie la sécurité de l'action.
 *              Si ok, obtient l'identifiant de rubrique à éditer
 *              (oui 'oui' pour une nouvelle rubrique)
 *     - int  : identifiant de rubrique dont on demande l'édition
 * @return array
 *     Liste : identifiant de la rubrique, message d'erreur éventuel.
 *
 */
function action_editer_rubrique_dist($arg = null) {

if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

if (!$id_rubrique = intval($arg)) {
		if ($arg != 'oui') {
			include_spip('inc/headers');
			redirige_url_ecrire();
		}
		$id_rubrique = rubrique_inserer(_request('id_parent'));
	}

$err = rubrique_modifier($id_rubrique);

if (_request('redirect')) {
		$redirect = parametre_url(
			urldecode(_request('redirect')),
			'id_rubrique', $id_rubrique, '&');

include_spip('inc/headers');
		redirige_par_entete($redirect);
	}

return array($id_rubrique, $err);
}

/**
 * Insérer une rubrique en base
 *
 * @param int $id_parent
 *     Identifiant de la rubrique parente.
 *     0 pour la racine.
 * @param array|null $set
 * @return int
 *     Identifiant de la rubrique crée
 */
function rubrique_inserer($id_parent, $set = null) {
	$champs = array(
		'titre' => _T('item_nouvelle_rubrique'),
		'id_parent' => intval($id_parent),
		'statut' => 'prepa'
	);

if ($set) {
		$champs = array_merge($champs, $set);
	}

// Envoyer aux plugins
	$champs = pipeline('pre_insertion',
		array(
			'args' => array(
				'table' => 'spip_rubriques',
			),
			'data' => $champs
		)
	);

$id_rubrique = sql_insertq("spip_rubriques", $champs);
	pipeline('post_insertion',
		array(
			'args' => array(
				'table' => 'spip_rubriques',
				'id_objet' => $id_rubrique
			),
			'data' => $champs
		)
	);
	propager_les_secteurs();
	calculer_langues_rubriques();

return $id_rubrique;
}

/**
 * Modifier une rubrique en base
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique modifiée
 * @param array|null $set
 *     Tableau qu'on peut proposer en lieu et place de _request()
 * @return bool|string
 *     - false  : Aucune modification, aucun champ n'est à modifier
 *     - chaîne vide : Vide si tout s'est bien passé
 *     - chaîne : Texte d'un message d'erreur
 */
function rubrique_modifier($id_rubrique, $set = null) {
	include_spip('inc/autoriser');
	include_spip('inc/filtres');

include_spip('inc/modifier');
	$c = collecter_requests(
	// white list
		objet_info('rubrique', 'champs_editables'),
		// black list
		array('id_parent', 'confirme_deplace'),
		// donnees eventuellement fournies
		$set
	);

if ($err = objet_modifier_champs('rubrique', $id_rubrique,
		array(
			'data' => $set,
			'nonvide' => array('titre' => _T('titre_nouvelle_rubrique') . " " . _T('info_numero_abbreviation') . $id_rubrique)
		),
		$c)
	) {
		return $err;
	}

$c = collecter_requests(array('id_parent', 'confirme_deplace'), array(), $set);
	// Deplacer la rubrique
	if (isset($c['id_parent'])) {
		$err = rubrique_instituer($id_rubrique, $c);
	}

// invalider les caches marques de cette rubrique
	include_spip('inc/invalideur');
	suivre_invalideur("id='rubrique/$id_rubrique'");
	// et celui de menu_rubriques 
	effacer_meta("date_calcul_rubriques");

return $err;
}

/**
 * Déplace les brèves d'une rubrique dans le secteur d'un nouveau parent
 *
 * Si c'est une rubrique-secteur contenant des brèves, on ne deplace
 * que si $confirme_deplace == 'oui', et change alors l'id_rubrique des
 * brèves en question
 *
 * @todo À déporter dans le plugin brèves via un pipeline ?
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique déplacée
 * @param int $id_parent
 *     Identifiant du nouveau parent de la rubrique
 * @param array $c
 *     Informations pour l'institution (id_rubrique, confirme_deplace)
 * @return bool
 *     true si le déplacement est fait ou s'il n'y a rien à faire
 *     false si la confirmation du déplacement n'est pas présente
 */
function editer_rubrique_breves($id_rubrique, $id_parent, $c = array()) {
	if (!sql_countsel('spip_breves', "id_rubrique=$id_rubrique")) {
		return true;
	}

if (empty($c['confirme_deplace']) or $c['confirme_deplace'] != 'oui') {
		return false;
	}

if ($id_secteur = sql_getfetsel("id_secteur",
		"spip_rubriques", "id_rubrique=$id_parent")
	) {
		sql_updateq("spip_breves", array("id_rubrique" => $id_secteur), "id_rubrique=$id_rubrique");
	}

return true;
}

/**
 * Instituer une rubrique (changer son parent)
 *
 * Change le parent d'une rubrique, si les autorisations sont correctes,
 * mais n'accèpte pas de déplacer une rubrique dans une de ses filles, tout de même !
 *
 * Recalcule les secteurs, les langues et déplace les brèves au passage.
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique à instituer
 * @param array $c
 *     Informations pour l'institution (id_rubrique, confirme_deplace)
 * @global array $GLOBALS ['visiteur_session']
 * @return string
 *     Chaîne vide : aucune erreur
 *     Chaîne : Texte du message d'erreur
 */
function rubrique_instituer($id_rubrique, $c) {
	// traitement de la rubrique parente
	// interdiction de deplacer vers ou a partir d'une rubrique
	// qu'on n'administre pas.

if (null !== ($id_parent = $c['id_parent'])) {
		$id_parent = intval($id_parent);
		$filles = calcul_branche_in($id_rubrique);
		if (strpos(",$id_parent,", ",$filles,") !== false) {
			spip_log("La rubrique $id_rubrique ne peut etre fille de sa descendante $id_parent");
		} else {
			$s = sql_fetsel("id_parent, statut", "spip_rubriques", "id_rubrique=$id_rubrique");
			$old_parent = $s['id_parent'];

if (!($id_parent != $old_parent
				and autoriser('publierdans', 'rubrique', $id_parent)
				and autoriser('creerrubriquedans', 'rubrique', $id_parent)
				and autoriser('publierdans', 'rubrique', $old_parent)
			)
			) {
				if ($s['statut'] != 'new') {
					spip_log("deplacement de $id_rubrique vers $id_parent refuse a " . $GLOBALS['visiteur_session']['id_auteur'] . ' ' . $GLOBALS['visiteur_session']['statut']);
				}
			} elseif (editer_rubrique_breves($id_rubrique, $id_parent, $c)) {
				$statut_ancien = $s['statut'];
				sql_updateq('spip_rubriques', array('id_parent' => $id_parent), "id_rubrique=$id_rubrique");

propager_les_secteurs();

// Deplacement d'une rubrique publiee ==> chgt general de leur statut
				if ($statut_ancien == 'publie') {
					calculer_rubriques_if($old_parent, array('id_rubrique' => $id_parent), $statut_ancien);
				}
				// Creation ou deplacement d'une rubrique non publiee
				// invalider le cache de leur menu
				elseif (!$statut_ancien || $old_parent != $id_parent) {
					effacer_meta("date_calcul_rubriques");
				}

calculer_langues_rubriques();
			}
		}
	}

return ''; // pas d'erreur
}

/**
 * Crée une rubrique
 *
 * @deprecated
 *     Utiliser rubrique_inserer()
 * @see rubrique_inserer()
 *
 * @param int $id_parent
 *     Identifiant de la rubrique parente.
 *     0 pour la racine.
 * @return int
 *     Identifiant de la rubrique crée
 **/
function insert_rubrique($id_parent) {
	return rubrique_inserer($id_parent);
}

/**
 * Modifie les contenus d'une rubrique
 *
 * @deprecated
 *     Utiliser rubrique_modifier()
 * @see rubrique_modifier()
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique à instituer
 * @param array|null $set
 *     Tableau qu'on peut proposer en lieu et place de _request()
 * @return bool|string
 *     - false  : Aucune modification, aucun champ n'est à modifier
 *     - chaîne vide : Vide si tout s'est bien passé
 *     - chaîne : Texte d'un message d'erreur
 **/
function revisions_rubriques($id_rubrique, $set = null) {
	return rubrique_modifier($id_rubrique, $set);
}

/**
 * Institue une rubrique (change son parent)
 *
 * @deprecated
 *     Utiliser rubrique_instituer()
 * @see rubrique_instituer()
 *
 * @param int $id_rubrique
 *     Identifiant de la rubrique à instituer
 * @param array $c
 *     Informations pour l'institution (id_rubrique, confirme_deplace)
 * @return string
 *     Chaine vide : aucune erreur
 *     Chaîne : Texte du message d'erreur
 **/
function instituer_rubrique($id_rubrique, $c) {
	return rubrique_instituer($id_rubrique, $c);
}
ajouter_lien.php000064400000002762152525343600007751 0ustar00<?php

/**
 * Gestion de l'action ajouter_lien
 *
 * @package SPIP\Core\Liens
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Action pour lier 2 objets entre eux
 *
 * L'argument attendu est `objet1-id1-objet2-id2` (type d'objet, identifiant)
 * tel que `mot-7-rubrique-3`.
 *
 * @uses objet_associer()
 *
 * @param null|string $arg
 *     Clé des arguments. En absence utilise l'argument
 *     de l'action sécurisée.
 * @return void
 */
function action_ajouter_lien_dist($arg = null) {
	if (is_null($arg)) {
		$securiser_action = charger_fonction('securiser_action', 'inc');
		$arg = $securiser_action();
	}

$arg = explode("-", $arg);
	list($objet_source, $ids, $objet_lie, $idl) = $arg;

include_spip('action/editer_liens');
	objet_associer(array($objet_source => $ids), array($objet_lie => $idl));
}
activer_plugins.php000064400000005656152525343600010474 0ustar00<?php

/**
 * Gestion de l'action activer_plugins
 *
 * @package SPIP\Core\Plugins
 **/

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Mise à jour des données si envoi via formulaire
 *
 * @global array $GLOBALS ['visiteur_session']
 * @global array $GLOBALS ['meta']
 * @return void
 */
function enregistre_modif_plugin() {
	include_spip('inc/plugin');
	// recuperer les plugins dans l'ordre des $_POST
	$test = array();
	foreach (liste_plugin_files() as $file) {
		$test['s' . substr(md5(_DIR_PLUGINS . $file), 0, 16)] = $file;
	}
	if (defined('_DIR_PLUGINS_SUPPL')) {
		foreach (liste_plugin_files(_DIR_PLUGINS_SUPPL) as $file) {
			$test['s' . substr(md5(_DIR_PLUGINS_SUPPL . $file), 0, 16)] = $file;
		}
	}

$plugin = array();

foreach ($_POST as $choix => $val) {
		if (isset($test[$choix]) && $val == 'O') {
			$plugin[] = $test[$choix];
		}
	}

spip_log("Changement des plugins actifs par l'auteur " . $GLOBALS['visiteur_session']['id_auteur'] . ": " . join(',',
			$plugin));
	ecrire_plugin_actifs($plugin);

// Chaque fois que l'on valide des plugins, on memorise la liste de ces plugins comme etant "interessants", avec un score initial, qui sera decremente a chaque tour : ainsi un plugin active pourra reter visible a l'ecran, jusqu'a ce qu'il tombe dans l'oubli.
	$plugins_interessants = @unserialize($GLOBALS['meta']['plugins_interessants']);
	if (!is_array($plugins_interessants)) {
		$plugins_interessants = array();
	}

$plugins_interessants2 = array();

foreach ($plugins_interessants as $plug => $score) {
		if ($score > 1) {
			$plugins_interessants2[$plug] = $score - 1;
		}
	}
	foreach ($plugin as $plug) {
		$plugins_interessants2[$plug] = 10;
	} // score initial
	ecrire_meta('plugins_interessants', serialize($plugins_interessants2));
}

/**
 * Fonction d'initialisation avant l'activation des plugins
 *
 * Vérifie les droits et met à jour les méta avant de lancer l'activation des plugins
 *
 * @return void
 */
function action_activer_plugins_dist() {

$securiser_action = charger_fonction('securiser_action', 'inc');
	$securiser_action();

if (!autoriser('configurer', '_plugins')) {
		die('erreur');
	}
	// forcer la maj des meta pour les cas de modif de numero de version base via phpmyadmin
	lire_metas();
	enregistre_modif_plugin();
}
tester_taille.php000064400000010617152525343600010127 0ustar00<?php

/**
 * Gestion de l'action testant, pour la librairie graphique GD2, la taille
 * maximale des images qu'il est capable de traiter
 *
 * @package SPIP\Core\Configurer
 */

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}
include_spip('inc/headers');

/**
 * Interception très probable d'une impossibilité de créer l'image demandée
 * dans le buffer de ob_start()
 *
 * Si c'est le cas, on redirige sur la page prévue, testant un autre cas
 * de traitement
 *
 * @param string $output
 *     Sortie du buffer
 * @return string
 *     Sortie du buffer
 **/
function action_tester_taille_error_handler($output) {
	// on est ici, donc echec lors de la creation de l'image
	if (!empty($GLOBALS['redirect'])) {
		return redirige_formulaire($GLOBALS['redirect']);
	}

return $output;
}

/**
 * Tester nos capacités à redimensionner des images avec GD2 (taille mémoire)
 *
 * Ce test par dichotomie permet de calculer la taille (en pixels) de la
 * plus grande image traitable. Ce test se relance jusqu'à trouver cette
 * taille.
 *
 * La clé `arg` attendue est une chaîne indiquant les valeurs minimum et
 * maximum de taille à tester tel que '3000' (maximum) ou '3000-5000'
 * (minimum-maximum)
 *
 **/
function action_tester_taille_dist() {

if (!autoriser('configurer')) {
		return;
	}

$taille = _request('arg');
	$taille = explode('-', $taille);

$GLOBALS['taille_max'] = end($taille);
	$GLOBALS['taille_min'] = 0;
	if (count($taille) > 1) {
		$GLOBALS['taille_min'] = reset($taille);
	}

// si l'intervalle est assez petit, on garde la valeur min
	if ($GLOBALS['taille_max'] * $GLOBALS['taille_max'] - $GLOBALS['taille_min'] * $GLOBALS['taille_min'] < 50000) {
		$t = ($GLOBALS['taille_min'] * $GLOBALS['taille_min']);
		if ($GLOBALS['taille_min'] !== $GLOBALS['taille_max']) {
			$t = $t * 0.9; // marge de securite
			echo round($t / 1000000, 3) . ' Mpx';
		} else {
			// c'est un cas "on a reussi la borne max initiale, donc on a pas de limite connue"
			$t = 0;
			echo "&infin;";
		}
		ecrire_meta('max_taille_vignettes', $t, 'non');
		die();
	}

$taille = $GLOBALS['taille_test'] = round(($GLOBALS['taille_max'] + $GLOBALS['taille_min']) / 2);

include_spip('inc/filtres');
	// des inclusions representatives d'un hit prive et/ou public pour la conso memoire
	include_spip('public/assembler');
	include_spip('public/balises');
	include_spip('public/boucles');
	include_spip('public/cacher');
	include_spip('public/compiler');
	include_spip('public/composer');
	include_spip('public/criteres');
	include_spip('public/interfaces');
	include_spip('public/parametrer');
	include_spip('public/phraser_html');
	include_spip('public/references');

include_spip('inc/presentation');
	include_spip('inc/charsets');
	include_spip('inc/documents');
	include_spip('inc/header');
	propre("<doc1>"); // charger propre avec le trairement d'un modele

$i = _request('i') + 1;
	$image_source = chemin_image("test.png");
	$GLOBALS['redirect'] = generer_url_action("tester_taille",
		"i=$i&arg=" . $GLOBALS['taille_min'] . "-" . $GLOBALS['taille_test']);

ob_start('action_tester_taille_error_handler');
	filtrer('image_recadre', $image_source, $taille, $taille);
	$GLOBALS['redirect'] = generer_url_action("tester_taille", "i=$i&arg=$taille-" . $GLOBALS['taille_max']);

// si la valeur intermediaire a reussi, on teste la valeur maxi qui est peut etre sous estimee
	// si $GLOBALS['taille_min']==0 (car on est au premier coup)
	if ($GLOBALS['taille_min'] == 0) {
		$taille = $GLOBALS['taille_max'];
		filtrer('image_recadre', $image_source, $taille, $taille);
		$GLOBALS['redirect'] = generer_url_action("tester_taille", "i=$i&arg=$taille-" . $GLOBALS['taille_max']);
	}
	ob_end_clean();

// on est ici, donc pas de plantage
	echo redirige_formulaire($GLOBALS['redirect']);
}

/home/checkyd/./www/7b5d0/action.tar