source: spip-zone/_plugins_/formidable/trunk/inc/formidable_fichiers.php @ 102484

Last change on this file since 102484 was 102484, checked in by kent1@…, 3 years ago

recuperer_page peut renvoyer NULL et donc passe dans ce test

File size: 18.4 KB
Line 
1<?php
2
3// Sécurité
4if (!defined('_ECRIRE_INC_VERSION')) {
5        return;
6}
7include_spip('inc/flock');
8include_spip('inc/documents');
9if (!defined('_DIR_FICHIERS')) { // En attendant que ce soit natif spip
10        define('_DIR_FICHIERS', _DIR_ETC.'fichiers/');
11}
12
13if (!defined('_DIR_FICHIERS_FORMIDABLE')) {
14        define('_DIR_FICHIERS_FORMIDABLE', _DIR_FICHIERS.'formidable/');
15}
16if (!defined('_FORMIDABLE_EXPIRATION_FICHIERS_EMAIL')) {
17        // Combien de temps un lien par email dans fichier est valable (en seconde)
18        define('_FORMIDABLE_EXPIRATION_FICHIERS_EMAIL', 24*3600);
19}
20if (!defined('_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL')) {
21        // Au bout de combien de temps efface-t-on les fichiers enregistrés lorsque le traitement est uniquement email?
22        define('_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL', _FORMIDABLE_EXPIRATION_FICHIERS_EMAIL);
23}
24if (!defined('_FORMIDABLE_LIENS_FICHIERS_ACCUSE_RECEPTION')) {
25        // mettre à false si on ne veut pas de lien vers les fichiers dans l'accusé de réception
26        define('_FORMIDABLE_LIENS_FICHIERS_ACCUSE_RECEPTION', true);
27}
28/**
29 * Créer, si le formulaire contient des saisies de type fichiers, un dossier pour stocker les fichiers.
30 * Vérifier que ce dossier soit accessible en écriture.
31 * Vérifier qu'on ne puisse pas y accéder de l'exterieur.
32 *
33 * @param int $id_formulaire
34 * @param bool $forcer, pour forcer la création du dossier même si pas de saisie fichiers
35 * @return $erreur
36 **/
37function formidable_creer_dossier_formulaire($id_formulaire, $forcer = false) {
38        if (!$forcer) {
39                include_spip('formulaires/formidable');
40                // Récuperer la liste des saisies de type fichier
41                $saisies_fichiers = formulaires_formidable_fichiers($id_formulaire);
42
43                if (!is_array($saisies_fichiers) or $saisies_fichiers == array ()) {
44                        //pas de saisie fichiers?
45                        return '';
46                }
47        }
48        $nom_dossier = "formulaire_$id_formulaire";
49
50        // On crée le dossier
51        sous_repertoire(_DIR_FICHIERS, '', true, true);
52        sous_repertoire(_DIR_FICHIERS_FORMIDABLE, '', true, true);
53        $dossier = sous_repertoire(_DIR_FICHIERS_FORMIDABLE, $nom_dossier, false, true);
54        if (strpos($dossier, "$nom_dossier/") === false) {
55                spip_log("Impossible d'écrire $nom_dossier", 'formidable'._LOG_ERREUR);
56                return _T(
57                        'formidable:creer_dossier_formulaire_erreur_impossible_creer',
58                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
59                );
60        }
61
62        // on crée un fichier de test, pour s'assurer
63        // 1. Qu'on puisse écrire dans le rep
64        // 2. Qu'on ne puisse pas accéder à ce fichier depuis l'exterieur.
65        $fichier = $dossier.'test.txt';
66        $ecriture_ok = ecrire_fichier(
67                $fichier,
68                "Ce fichier n'est normalement pas lisible de l'extérieur. Si tel est le cas, il y a un souci de confidentialité.",
69                false
70        );
71        if ($ecriture_ok == false) {
72                spip_log("Impossible d'écrire dans $nom_dossier", 'formidable'._LOG_ERREUR);
73                return _T(
74                        'formidable:creer_dossier_formulaire_erreur_impossible_ecrire',
75                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
76                );
77        }
78
79        include_spip('inc/distant');
80        $url = url_absolue($fichier);
81        if ($data = recuperer_page($url) && $data != NULL) {
82                // si on peut récuperer la page avec un statut http 200,
83                // c'est qu'il y a un problème. recuperer_page() est obsolète en 3.1, mais recuperer_url() n'existe pas en 3.0
84                spip_log("$nom_dossier accessible en lecture depuis le web", 'formidable'._LOG_CRITIQUE);
85                return _T(
86                        'formidable:creer_dossier_formulaire_erreur_possible_lire_exterieur',
87                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
88                );
89        }
90        // Et si tout va bien
91        spip_log("Création du dossier $nom_dossier", 'formidable');
92        return '';
93}
94
95/**
96 * Déplace un fichier uploadé de son adresse temporaire vers son adresse définitive.
97 * Crée si besoin les dossiers de stockage.
98 *
99 * @param string $fichier l'adresse temporaire du fichier
100 * @param string $nom le nom du fichier
101 * @param string $mime le mime du fichier
102 * @param string $extension l'extension du fichier
103 * @param string $champ le champ concerné
104 * @return string $nom_definitif
105 *              le nom définitif du fichier tel que stocké dans son dossier,
106 *              vide s'il y a eu un souci lors du déplacement (dans ce cas un courriel sera envoyé au webmestre)
107 *
108 **/
109function formidable_deplacer_fichier_emplacement_definitif($fichier, $nom, $mime, $extension, $champ, $options) {
110        if (isset($options['id_formulaire'])) {
111                $id_formulaire = $options['id_formulaire'];
112                $dossier_formulaire =  "formulaire_$id_formulaire";
113        } else {
114                // si c'est pas set, c'est qu'il y a une erreur
115                return '';
116        }
117
118        if (isset($options['id_formulaires_reponse'])) {
119                $dossier_reponse = 'reponse_'.$options['id_formulaires_reponse'];
120        } elseif (isset($options['timestamp'])) {
121                $dossier_reponse = 'reponse_'.$options['timestamp'];
122        } else { // si ni timestamp, ni id_formulaires_reponse => erreur
123                return '';
124        }
125        // déterminer le basename
126        $basename = pathinfo($nom, PATHINFO_BASENAME);
127
128        // sécurité : si la combinaison extension/mime_type est inconnu de SPIP (spip_documents_type), on zip.
129        // On n'utilise volontairement pas verifier/fichiers.php, dès fois que celui-ci évolue dans le future
130        $res = sql_select(
131                'mime_type',
132                'spip_types_documents',
133                'mime_type='.sql_quote($mime).' and extension='.sql_quote($extension)
134        );
135        if (sql_count($res) == 0) {
136                $zipper = true;
137                $nom_dans_zip = $nom;
138                // pas de fichier nom de zip commencant par point
139                while (strpos($basename, '.') === 0) {
140                        $basename = substr($basename, 1);
141                }
142                $nom = "$basename.zip";
143        } else {
144                $zipper = false;
145        }
146        if (!isset($options['timestamp'])) { // si on enregistre la réponse en base
147
148                // d'abord, créer si besoin le dossier pour le formulaire, si on a une erreur, on ne déplace pas le fichier
149                if (formidable_creer_dossier_formulaire($id_formulaire, true) != '') {
150                        return '';
151                }
152
153                // puis on créer le dossier pour la réponse
154                $dossier_reponse = sous_repertoire(
155                        _DIR_FICHIERS_FORMIDABLE.$dossier_formulaire.'/',
156                        $dossier_reponse,
157                        false,
158                        true
159                );
160
161                // puis le dossier pour le champ
162                $dossier_champ = sous_repertoire($dossier_reponse, $champ, false, true);
163                $appendice_nom = 0;
164        } else { // si on enregistre sous forme de timestamp
165                sous_repertoire(_DIR_FICHIERS, '', true, true);
166                sous_repertoire(_DIR_FICHIERS_FORMIDABLE, '', true, true);
167                $dossier = sous_repertoire(_DIR_FICHIERS_FORMIDABLE, 'timestamp', false, true);
168                $dossier = sous_repertoire($dossier, $options['timestamp'], false, true);
169                $dossier_champ = sous_repertoire($dossier, $champ, false, true);
170                // on crée un fichier de test, pour s'assurer
171                // 1. Qu'on puisse écrire dans le rep
172                // 2. Qu'on ne puisse pas accéder à ce fichier depuis l'exterieur.
173                $fichier_test = $dossier.'test.txt';
174                $ecriture_ok = ecrire_fichier(
175                        $fichier_test,
176                        "Ce fichier n'est normalement pas lisible de l'extérieur. Si tel est le cas, il y a un souci de confidentialité.",
177                        false
178                );
179                if ($ecriture_ok == false) {
180                        spip_log("Impossible d'écrire dans $dossier", 'formidable'._LOG_ERREUR);
181                        return '';
182                }
183                include_spip('inc/distant');
184                $url = url_absolue($fichier_test);
185                if ($data = recuperer_page($url) && $data != NULL) {
186                        // si on peut récuperer la page avec un statut http 200,
187                        // c'est qu'il y a un problème.
188                        // recuperer_page() est obsolète en 3.1, mais recuperer_url() n'existe pas en 3.0
189                        spip_log("$dossier accessible en lecture depuis le web", 'formidable'._LOG_CRITIQUE);
190                        return '';
191                }
192        }
193        // S'assurer qu'il n'y a pas un fichier du même nom à destination
194        $chemin_final = $dossier_champ.$nom;
195        $n = 1;
196        //la constante PATHINFO_FILENAME n'est qu'à partir de PHP 5.2, or SPIP 3 peut fonctionne en PHP 5.1
197        $basename_sans_extension = substr_replace($basename, '', -strlen($extension)-1);
198        while (@file_exists($chemin_final)) {
199                $nom = $basename_sans_extension."_$n.".$extension;
200                $chemin_final = $dossier_champ.$nom;
201                $n++;
202        }
203        if (!$zipper) { // si on ne zippe pas, c'est simple
204                if ($fichier = deplacer_fichier_upload($fichier, $chemin_final, true)) {
205                        spip_log("Enregistrement du fichier $chemin_final", 'formidable');
206                        return $nom;
207                } else {
208                        spip_log("Pb lors de l'enregistrement du fichier $chemin_final", 'formidable'._LOG_ERREUR);
209                        return '';
210                }
211        } else { // si on doit zipper, c'est plus complexe
212                include_spip('inc/pclzip');
213                $zip = new PclZip($chemin_final);
214                // mettre à jour le fichier dans le dossier cvtupload
215                if (!$tmp_dir = tempnam($dossier_champ, 'tmp_upload')) {
216                        return '';
217                }
218                spip_unlink($tmp_dir);
219                @mkdir($tmp_dir);
220                $old_fichier = $fichier;
221                if (!$fichier = deplacer_fichier_upload($fichier, $tmp_dir.'/'.$nom_dans_zip, false)) {
222                        spip_log("Pb lors de l'enregistrement du fichier $tmp_dir/$nom_dans_zip", 'formidable'._LOG_ERREUR);
223                        return '';
224                }
225                $zip_final = $zip -> create(
226                        $fichier,
227                        PCLZIP_OPT_REMOVE_PATH,
228                        $tmp_dir,
229                        PCLZIP_OPT_ADD_PATH,
230                        ''
231                );
232                if (!$zip_final) {
233                        spip_log("Pb lors de l'enregistrement du fichier $fichier", 'formidable'._LOG_ERREUR);
234                        return '';
235                } else {
236                        spip_unlink($old_fichier);
237                        supprimer_repertoire($tmp_dir);
238                        spip_log("Enregistrement du fichier $fichier, automatiquement zippé", 'formidable');
239                        return $nom;
240                }
241        }
242
243        return $nom;
244}
245
246/**
247 * Fournit à l'utilisateur·trice un fichier qui se trouve normalement dans un endroit inaccessible,
248 * par exemple dans config.
249 * La fonction ne vérifie ni l'existence effective du fichier,
250 * ni le droit effectif de l'utilisateur.
251 * Ceci doit être fait dans l'action qui appelle cette fonction
252 * @param string $chemin le chemin du fichier
253 * @param string $f le nom du fichier qui sera envoyé à l'utilisateur·trice.
254 *
255**/
256function formidable_retourner_fichier($chemin, $f) {
257        header('Content-Type: '.mime_content_type($chemin));
258        header("Content-Disposition: attachment; filename=\"$f\";");
259        header('Content-Transfer-Encoding: binary');
260        // fix for IE catching or PHP bug issue (inspiré de plugins-dist/dump/action/telecharger_dump.php
261        header('Pragma: public');
262        header('Expires: 0'); // set expiration time
263        header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
264        if ($cl = filesize($chemin)) {
265                header('Content-Length: '.$cl);
266        }
267        readfile($chemin);
268        exit;
269}
270/**
271 * Déplacer un fichier temporaire à son emplacement définif.
272 * Produire un tableau de description des fichiers déplacés.
273 * Le tout à partir de la description d'une saisies 'fichiers'
274 * @param array $saisie la description de la saisie fichiers
275 * @param array $options
276 *              des options, dépendantes du type de traitement,
277 *              qui permettent d'indiquer où l'on déplace le fichier
278 * return array un tableau de "vue" de la saisie
279**/
280function formidable_deplacer_fichiers_produire_vue_saisie($saisie, $options) {
281        $nb_fichiers_max = $saisie['options']['nb_fichiers'];
282        // on va parcourir $_FILES en nous limitant aux nombres de fichiers définies par la saisie,
283        // pour éviter les éventuelles ajout supplémentaire de fichiers par modif du html
284        $champ = $saisie['options']['nom'];
285        if (!isset($_FILES[$champ])) {//précaution
286                return null;
287        }
288        $description_fichiers = array();
289        $mon_file = $_FILES[$champ];
290        $i = 0;
291        while ($i < $nb_fichiers_max) {
292                if ($mon_file['error'][$i] == 0) {
293                        // la saisie fichiers est forcément structurée sous la forme d'un tableau,
294                        // on peut donc vérifier qu'il n'y a pas d'erreur facilement
295                        $description = array(); // tableau pour stocker la description de ce fichier
296
297                        // les infos qu'on peut récuperer directement de $files
298                        $description['taille'] = $mon_file['size'][$i];
299                        $description['mime'] = $mon_file['type'][$i];
300
301                        // l'adresse du nouveau fichier, sans le chemin
302                        if ($nouveau_nom = formidable_deplacer_fichier_emplacement_definitif(
303                                $mon_file['tmp_name'][$i],
304                                $mon_file['name'][$i],
305                                $mon_file['type'][$i],
306                                pathinfo($mon_file['name'][$i], PATHINFO_EXTENSION),
307                                $champ,
308                                $options
309                        )) {
310                                        $description['nom'] = $nouveau_nom;
311                                        $description['extension'] = pathinfo($nouveau_nom, PATHINFO_EXTENSION);
312                        } else {
313                                $description['erreur'] = _T(
314                                        'formidable:erreur_deplacement_fichier',
315                                        array('nom'=>$mon_file['name'][$i])
316                                );
317                                $description['nom'] = $mon_file['name'][$i];
318                                $description['tmp_name'] = $mon_file['tmp_name'][$i];
319                        }
320                        //on ajoute la description au tableau global
321                        $description_fichiers[] = $description;
322                }
323                $i++;
324        }
325        return $description_fichiers;
326}
327/**
328 * Efface les fichiers d'un formulaire
329 * @param $str $id_formulaire
330 * @return int 1 ou 0 selon que l'on a effacé ou non un répertoire
331**/
332function formidable_effacer_fichiers_formulaire($id_formulaire) {
333        $chemin = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire";
334        if (file_exists($chemin)) {// par sécurité
335                if (supprimer_repertoire($chemin)) {
336                        spip_log("Effacement du dossier $chemin", 'formidable');
337                        return 1;
338                } else {
339                        spip_log("Pb lors de l'effacement du dossier $chemin", 'formidable'._LOG_ERREUR);
340                        return 0;
341                }
342        }
343        return 0;
344}
345
346/**
347 * efface les fichiers d'une réponse formidable
348 * @param $str $id_formulaire
349 * @param $str $id_formulaires_reponse
350 * @return int 1 ou 0 selon que l'on a effacé ou non un répertoire
351**/
352function formidable_effacer_fichiers_reponse($id_formulaire, $id_formulaires_reponse) {
353        $chemin = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire/reponse_$id_formulaires_reponse";
354        if (file_exists($chemin)) {// par sécurité
355                if (supprimer_repertoire($chemin)) {
356                        spip_log("Effacement du dossier $chemin", 'formidable');
357                        return 1;
358                } else {
359                        spip_log("Pb lors de l'effacement du dossier $chemin", 'formidable'._LOG_ERREUR);
360                        return 0;
361                }
362        }
363        return 0;
364}
365
366/** Efface les fichiers d'un champ pour les réponses d'un formulaire
367 * @param str $id_formulaire
368 * @param array|str $reponses
369 * @param str $champ
370**/
371function formidable_effacer_fichiers_champ($id_formulaire, $reponses, $champ) {
372        if ($champ != '') { // on devrait pas arriver ici avec un $champ vide, mais prenons nos précaution
373
374                if (!is_array($reponses)) {
375                        $reponses = array($reponses);
376                }
377
378                $rep_vide = array('.', '..', '.ok'); // si scandire retourne cela où inférieur, alors le dossier est vide
379                foreach ($reponses as $rep) {
380                        $chemin_reponse = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire/reponse_$rep";
381                        $chemin_champ = $chemin_reponse.'/'.$champ;
382
383                        if (file_exists($chemin_champ)) {
384                                if (supprimer_repertoire($chemin_champ)) {
385                                        spip_log("Effacement du dossier $chemin_champ", 'formidable');
386                                } else {
387                                        spip_log("Pb lors de l'effacement du dossier $chemin_champ", 'formidable'._LOG_ERREUR);
388                                }
389                                if (count(array_diff(scandir($chemin_reponse), $rep_vide)) == 0) {
390                                        // si jamais il ne reste plus aucun fichiers pour cette réponse,
391                                        // on peut effacer le repertoire de celle-ci
392                                        if (supprimer_repertoire($chemin_reponse)) {
393                                                spip_log("Effacement du dossier $chemin_reponse", 'formidable');
394                                        } else {
395                                                spip_log("Pb lors de l'effacement du dossier $chemin_reponse", 'formidable'._LOG_ERREUR);
396                                        }
397                                }
398                        }
399                }
400        }
401}
402
403/** Efface les fichiers des réponses par email
404 * lorsque la constante _FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL est différent de 0 et que le temps est écoulé
405 * @return int nombre de dossiers effacés
406 **/
407function formidable_effacer_fichiers_email() {
408        if (_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL == 0) {
409                return 0;
410        }
411        $dossiers_effaces = 0;
412        $chemin = _DIR_FICHIERS_FORMIDABLE.'timestamp';
413        $timestamp = time();
414        foreach (scandir($chemin) as $dossier) {
415                if (strval(intval($dossier))!=$dossier) { // on ne traite que les dossiers qui ont comme nom un entier
416                        continue;
417                }
418                if ($timestamp - intval($dossier) >= _FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL) {
419                        $chemin_complet = "$chemin/$dossier";
420                        if (supprimer_repertoire($chemin_complet)) {
421                                spip_log("Effacement du dossier $chemin_complet", 'formidable');
422                                $dossiers_effaces++;
423                        } else {
424                                spip_log("Pb lors de l'effacement du dossier $chemin_complet", 'formidable'._LOG_ERREUR);
425                        }
426                }
427        }
428        return $dossiers_effaces;
429}
430/**
431 * Génerer un zip des réponses d'un formulaire
432 * @param int $id_formulaire  (identifiant numérique)
433 * @param str $chemin_du_zip chemin complet du zip
434 * @param str $fichier_csv un fichier csv à ajouter, contenant les réponses
435 * @return str|int chemin complet du zip ou 0 si erreur lors de la création
436**/
437function formidable_zipper_reponses_formulaire($id_formulaire, $chemin_du_zip, $fichier_csv, $saisies_fichiers) {
438        include_spip('inc/pclzip');
439        $zip = new PclZip("$chemin_du_zip");
440        $chemin_fichiers = _DIR_FICHIERS_FORMIDABLE . 'formulaire_' . $id_formulaire;
441        if (!$zip->create($saisies_fichiers, PCLZIP_OPT_REMOVE_PATH, $chemin_fichiers)) {
442                spip_log(
443                        "Impossible de créer le zip pour l'export des réponses du formulaire $id_formulaire",
444                        'formidable'._LOG_ERREUR
445                );
446                return 0;
447        } else {
448                $zip->add($fichier_csv, PCLZIP_OPT_REMOVE_ALL_PATH);
449                return $chemin_du_zip;
450        }
451}
452/**
453 * Générer une url d'action pour la récupération d'un fichier lié à une réponse
454 * @param int|str $id_formulaire
455 * @param int|str $id_formulaires_reponse
456 * @param str $saisie
457 * @param str $fichier
458 **/
459function formidable_generer_url_action_recuperer_fichier($id_formulaire, $id_formulaires_reponse, $saisie, $fichier) {
460        $param = array(
461                'formulaire' => $id_formulaire,
462                'reponse' => $id_formulaires_reponse,
463                'saisie' => $saisie,
464                'fichier' => $fichier
465        );
466
467        // Pour les utilisateurs non authentifiés, on se base sur le cookier
468        $nom_cookie = formidable_generer_nom_cookie($id_formulaire);
469        if (isset($_COOKIE[$nom_cookie])) {
470                include_spip('inc/securiser_action');
471                $param['cookie'] = sha1($_COOKIE[$nom_cookie].secret_du_site());
472        }
473
474        $param = serialize($param);
475        $securiser_action = charger_fonction('securiser_action', 'inc');
476        return $securiser_action('formidable_recuperer_fichier', $param, '', false);
477}
478
479/** Générer une url d'action pour récuperer un fichier à partir d'un lien email
480 * @param string $saisie
481 * @param string $fichier
482 * @param array $options décrivant si on récupère par id de réponse ou par timestamp
483 * @return string $url
484 *
485**/
486function formidable_generer_url_action_recuperer_fichier_email($saisie, $fichier, $options) {
487        if (isset($options['id_formulaires_reponse'])) {//si reponses enregistrées
488                $arg = serialize(array(
489                        'formulaire' => strval($options['id_formulaire']),
490                        'reponse' => strval($options['id_formulaires_reponse']),
491                        'fichier' => $fichier,
492                        'saisie' => $saisie
493                ));
494        } elseif (isset($options['timestamp'])) {//si par timestamp
495                $arg = serialize(array(
496                        'timestamp' => strval($options['timestamp']),
497                        'fichier' => $fichier,
498                        'saisie' => $saisie
499                ));
500        }
501        $pass = secret_du_site();
502        $action = 'formidable_recuperer_fichier_par_email';
503        $hash = _action_auteur("$action-$arg", '', $pass, 'alea_ephemere');
504        $url = generer_url_action($action, "arg=$arg&hash=$hash", true, true);
505        return $url;
506}
Note: See TracBrowser for help on using the repository browser.