www/plugins-dist/medias/inc/joindre_document.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2016                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) {
  14         return;
  15 }
  16
  17
  18 /**
  19  * Recuperer le nom du fichier selon le mode d'upload choisi
  20  * et mettre cela au format $_FILES
  21  *
  22  * Renvoie une liste de fichier ou un message en cas d'erreur
  23  *
  24  * @return string/array
  25  */
  26 function joindre_trouver_fichier_envoye() {
  27         static $files = array();
  28         // on est appele deux fois dans un hit, resservir ce qu'on a trouve a la verif
  29         // lorsqu'on est appelle au traitement
  30
  31         if (count($files)) {
  32                 return $files;
  33         }
  34
  35         if (_request('joindre_upload')) {
  36                 $post = isset($_FILES) ? $_FILES : $GLOBALS['HTTP_POST_FILES'];
  37                 $files = array();
  38                 if (is_array($post)) {
  39                         include_spip('action/ajouter_documents');
  40                         foreach ($post as $file) {
  41                                 if (is_array($file['name'])) {
  42                                         while (count($file['name'])) {
  43                                                 $test = array(
  44                                                         'error' => array_shift($file['error']),
  45                                                         'name' => array_shift($file['name']),
  46                                                         'tmp_name' => array_shift($file['tmp_name']),
  47                                                         'type' => array_shift($file['type']),
  48                                                 );
  49                                                 if (!($test['error'] == 4)) {
  50                                                         if (is_string($err = joindre_upload_error($test['error']))) {
  51                                                                 return $err;
  52                                                         } // un erreur upload
  53                                                         if (!is_array(verifier_upload_autorise($test['name']))) {
  54                                                                 return _T('medias:erreur_upload_type_interdit', array('nom' => $test['name']));
  55                                                         }
  56                                                         $files[] = $test;
  57                                                 }
  58                                         }
  59                                 } else {
  60                                         //UPLOAD_ERR_NO_FILE
  61                                         if (!($file['error'] == 4)) {
  62                                                 if (is_string($err = joindre_upload_error($file['error']))) {
  63                                                         return $err;
  64                                                 } // un erreur upload
  65                                                 if (!is_array(verifier_upload_autorise($file['name']))) {
  66                                                         return _T('medias:erreur_upload_type_interdit', array('nom' => $file['name']));
  67                                                 }
  68                                                 $files[] = $file;
  69                                         }
  70                                 }
  71                         }
  72                         if (!count($files)) {
  73                                 return _T('medias:erreur_indiquez_un_fichier');
  74                         }
  75                 }
  76
  77                 return $files;
  78         } elseif (_request('joindre_distant')) {
  79                 $path = _request('url');
  80                 if (!strlen($path) or $path == 'http://') {
  81                         return _T('medias:erreur_indiquez_un_fichier');
  82                 }
  83                 include_spip('action/ajouter_documents');
  84                 $infos = renseigner_source_distante($path);
  85                 if (!is_array($infos)) {
  86                         return $infos;
  87                 } // message d'erreur
  88                 else {
  89                         return array(
  90                                 array(
  91                                         'name' => basename($path),
  92                                         'tmp_name' => $path,
  93                                         'distant' => true,
  94                                 )
  95                         );
  96                 }
  97         } elseif (_request('joindre_ftp')) {
  98                 $path = _request('cheminftp');
  99                 if (!$path || strstr($path, '..')) {
 100                         return _T('medias:erreur_indiquez_un_fichier');
 101                 }
 102
 103                 include_spip('inc/documents');
 104                 include_spip('inc/actions');
 105                 $upload = determine_upload();
 106                 if ($path != '/' and $path != './') {
 107                         $upload .= $path;
 108                 }
 109
 110                 if (!is_dir($upload)) {
 111                         // seul un fichier est demande
 112                         return array(
 113                                 array(
 114                                         'name' => basename($upload),
 115                                         'tmp_name' => $upload
 116                                 )
 117                         );
 118                 } else {
 119                         // on upload tout un repertoire
 120                         $files = array();
 121                         foreach (preg_files($upload) as $fichier) {
 122                                 $files[] = array(
 123                                         'name' => basename($fichier),
 124                                         'tmp_name' => $fichier
 125                                 );
 126                         }
 127
 128                         return $files;
 129                 }
 130         } elseif (_request('joindre_zip') and $token_zip = _request('chemin_zip')) {
 131                 $zip_to_clean = (isset($GLOBALS['visiteur_session']['zip_to_clean']) ?
 132                         unserialize($GLOBALS['visiteur_session']['zip_to_clean']) : array());
 133                 if (!$zip_to_clean
 134                         or !isset($zip_to_clean[$token_zip])
 135                         or !$path = $zip_to_clean[$token_zip]) {
 136                         return _T('avis_operation_impossible');
 137                 }
 138
 139                 include_spip('inc/documents'); //pour creer_repertoire_documents
 140                 define('_TMP_ZIP', $path);
 141                 define('_TMP_DIR', creer_repertoire_documents(md5($path . $GLOBALS['visiteur_session']['id_auteur'])));
 142                 if (_TMP_DIR == _DIR_IMG) {
 143                         return _T('avis_operation_impossible');
 144                 }
 145
 146                 $files = array();
 147                 if (_request('options_upload_zip') == 'deballe') {
 148                         $files = joindre_deballer_lister_zip($path, _TMP_DIR);
 149                 }
 150
 151                 // si le zip doit aussi etre conserve, l'ajouter
 152                 if (_request('options_upload_zip') == 'upload' or _request('options_deballe_zip_conserver')) {
 153                         $files[] = array(
 154                                 'name' => basename($path),
 155                                 'tmp_name' => $path,
 156                         );
 157                 }
 158                 return $files;
 159         }
 160
 161         return array();
 162 }
 163
 164
 165 // Erreurs d'upload
 166 // renvoie false si pas d'erreur
 167 // et true si erreur = pas de fichier
 168 // pour les autres erreurs renvoie le message d'erreur
 169 function joindre_upload_error($error) {
 170
 171         if (!$error) {
 172                 return false;
 173         }
 174         spip_log("Erreur upload $error -- cf. http://php.net/manual/fr/features.file-upload.errors.php");
 175         switch ($error) {
 176                 case 4: /* UPLOAD_ERR_NO_FILE */
 177                         return true;
 178
 179                 # on peut affiner les differents messages d'erreur
 180                 case 1: /* UPLOAD_ERR_INI_SIZE */
 181                         $msg = _T(
 182                                 'medias:upload_limit',
 183                                 array('max' => ini_get('upload_max_filesize'))
 184                         );
 185                         break;
 186                 case 2: /* UPLOAD_ERR_FORM_SIZE */
 187                         $msg = _T(
 188                                 'medias:upload_limit',
 189                                 array('max' => ini_get('upload_max_filesize'))
 190                         );
 191                         break;
 192                 case 3: /* UPLOAD_ERR_PARTIAL  */
 193                         $msg = _T(
 194                                 'medias:upload_limit',
 195                                 array('max' => ini_get('upload_max_filesize'))
 196                         );
 197                         break;
 198                 case 6: /* UPLOAD_ERR_NO_TMP_DIR  */
 199                         $msg = _T('medias:erreur_dossier_tmp_manquant');
 200                         break;
 201                 case 7: /* UPLOAD_ERR_CANT_WRITE */
 202                         $msg = _T('medias:erreur_ecriture_fichier');
 203                         break;
 204                 default: /* autre */
 205                         if (!$msg) {
 206                                 $msg = _T('pass_erreur') . ' ' . $error
 207                                         . '<br />' . propre('[->http://php.net/manual/fr/features.file-upload.errors.php]');
 208                         }
 209                         break;
 210         }
 211         spip_log("erreur upload $error");
 212         return $msg;
 213 }
 214
 215 /**
 216  * Verifier si le fichier poste est un zip
 217  * Si on sait le deballer, proposer les options necessaires
 218  *
 219  * @param array $files
 220  * @return string
 221  */
 222 function joindre_verifier_zip($files) {
 223         if (function_exists('gzopen')
 224                 and (count($files) == 1)
 225                 and !isset($files[0]['distant'])
 226                 and
 227                 (preg_match('/\.zip$/i', $files[0]['name'])
 228                         or (isset($files[0]['type']) and $files[0]['type'] == 'application/zip'))
 229         ) {
 230                 // on pose le fichier dans le repertoire zip
 231                 // (nota : copier_document n'ecrase pas un fichier avec lui-meme
 232                 // ca autorise a boucler)
 233                 include_spip('inc/getdocument');
 234                 $desc = $files[0];
 235                 $zip = copier_document(
 236                         'zip',
 237                         $desc['name'],
 238                         $desc['tmp_name']
 239                 );
 240
 241                 // Est-ce qu'on sait le lire ?
 242                 include_spip('inc/pclzip');
 243                 if ($zip
 244                         and $archive = new PclZip($zip)
 245                         and $contenu = joindre_decrire_contenu_zip($archive)
 246                         and $tmp = sous_repertoire(_DIR_TMP, 'zip')
 247                         and rename($zip, $tmp = $tmp . basename($zip))
 248                 ) {
 249                         $zip_to_clean = (isset($GLOBALS['visiteur_session']['zip_to_clean']) ?
 250                                 unserialize($GLOBALS['visiteur_session']['zip_to_clean']) : array());
 251                         $zip_to_clean[md5($tmp)] = $tmp;
 252                         session_set('zip_to_clean', serialize($zip_to_clean));
 253                         $contenu[] = $tmp;
 254
 255                         return $contenu;
 256                 }
 257         }
 258
 259         // ce n'est pas un zip sur lequel il faut demander plus de precisions
 260         return false;
 261 }
 262
 263 /**
 264  * Verifier et decrire les fichiers de l'archive, en deux listes :
 265  * - une liste des noms de fichiers ajoutables
 266  * - une liste des erreurs (fichiers refuses)
 267  *
 268  * @param object $zip
 269  * @return array
 270  */
 271 function joindre_decrire_contenu_zip($zip) {
 272         include_spip('action/ajouter_documents');
 273         // si pas possible de decompacter: installer comme fichier zip joint
 274         if (!$list = $zip->listContent()) {
 275                 return false;
 276         }
 277
 278         // Verifier si le contenu peut etre uploade (verif extension)
 279         $fichiers = array();
 280         $erreurs = array();
 281         foreach ($list as $file) {
 282                 if (accepte_fichier_upload($f = $file['stored_filename'])) {
 283                         $fichiers[$f] = $file;
 284                 } else // pas de message pour les dossiers et fichiers caches
 285                 {
 286                         if (substr($f, -1) !== '/' and substr(basename($f), 0, 1) !== '.') {
 287                                 $erreurs[] = _T('medias:erreur_upload_type_interdit', array('nom' => $f));
 288                         }
 289                 }
 290         }
 291
 292         // si aucun fichier uploadable : installer comme fichier zip joint
 293         if (!count($fichiers)) {
 294                 return false;
 295         }
 296
 297         ksort($fichiers);
 298
 299         return array($fichiers, $erreurs);
 300 }
 301
 302
 303 // https://code.spip.net/@joindre_deballes
 304 function joindre_deballer_lister_zip($path, $tmp_dir) {
 305         include_spip('inc/pclzip');
 306         $archive = new PclZip($path);
 307         $archive->extract(
 308                 PCLZIP_OPT_PATH,
 309                 _TMP_DIR,
 310                 PCLZIP_CB_PRE_EXTRACT,
 311                 'callback_deballe_fichier'
 312         );
 313         if ($contenu = joindre_decrire_contenu_zip($archive)) {
 314                 $files = array();
 315                 $fichiers = reset($contenu);
 316                 foreach ($fichiers as $fichier) {
 317                         $f = basename($fichier['filename']);
 318                         $files[] = array(
 319                                 'tmp_name' => $tmp_dir . $f,
 320                                 'name' => $f,
 321                                 'titrer' => _request('options_deballe_zip_titrer'),
 322                                 'mode' => _request('options_deballe_zip_mode_document') ? 'document' : null
 323                         );
 324                 }
 325
 326                 return $files;
 327         }
 328
 329         return _T('avis_operation_impossible');
 330 }
 331
 332 if (!function_exists('fixer_extension_document')) {
 333         /**
 334          * Cherche dans la base le type-mime du tableau representant le document
 335          * et corrige le nom du fichier ; retourne array(extension, nom corrige)
 336          * s'il ne trouve pas, retourne '' et le nom inchange
 337          *
 338          * @param unknown_type $doc
 339          * @return unknown
 340          */
 341 // https://code.spip.net/@fixer_extension_document
 342         function fixer_extension_document($doc) {
 343                 $extension = '';
 344                 $name = $doc['name'];
 345                 if (preg_match(',\.([^.]+)$,', $name, $r)
 346                         and $t = sql_fetsel(
 347                                 'extension',
 348                                 'spip_types_documents',
 349                                 'extension=' . sql_quote(corriger_extension($r[1]))
 350                         )
 351                 ) {
 352                         $extension = $t['extension'];
 353                         $name = preg_replace(',\.[^.]*$,', '', $doc['name']) . '.' . $extension;
 354                 } else {
 355                         if ($t = sql_fetsel('extension', 'spip_types_documents', 'mime_type=' . sql_quote($doc['type']))) {
 356                                 $extension = $t['extension'];
 357                                 $name = preg_replace(',\.[^.]*$,', '', $doc['name']) . '.' . $extension;
 358                         }
 359                 }
 360
 361                 return array($extension, $name);
 362         }
 363 }
 364
 365 //
 366 // Gestion des fichiers ZIP
 367 //
 368 // https://code.spip.net/@accepte_fichier_upload
 369
 370 function accepte_fichier_upload($f) {
 371         if (!preg_match(',.*__MACOSX/,', $f)
 372                 and !preg_match(',^\.,', basename($f))
 373         ) {
 374                 include_spip('action/ajouter_documents');
 375                 $ext = corriger_extension((strtolower(substr(strrchr($f, '.'), 1))));
 376
 377                 return sql_countsel(
 378                         'spip_types_documents',
 379                         'extension=' . sql_quote($ext) . " AND upload='oui'"
 380                 );
 381         }
 382 }
 383
 384 # callback pour le deballage d'un zip telecharge
 385 # http://www.phpconcept.net/pclzip/man/en/?options-pclzip_cb_pre_extractfunction
 386 // https://code.spip.net/@callback_deballe_fichier
 387
 388 function callback_deballe_fichier($p_event, &$p_header) {
 389         if (accepte_fichier_upload($p_header['filename'])) {
 390                 $p_header['filename'] = _TMP_DIR . basename($p_header['filename']);
 391
 392                 return 1;
 393         } else {
 394                 return 0;
 395         }
 396 }