libraries/File.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * file upload functions
   5  *
   6  * @package PMA\libraries
   7  */
   8 namespace PMA\libraries;
   9
  10 use PMA\libraries\config\ConfigFile;
  11
  12 /**
  13  * File wrapper class
  14  *
  15  * @todo when uploading a file into a blob field, should we also consider using
  16  *       chunks like in import? UPDATE `table` SET `field` = `field` + [chunk]
  17  *
  18  * @package PMA\libraries
  19  */
  20 class File
  21 {
  22     /**
  23      * @var string the temporary file name
  24      * @access protected
  25      */
  26     var $_name = null;
  27
  28     /**
  29      * @var string the content
  30      * @access protected
  31      */
  32     var $_content = null;
  33
  34     /**
  35      * @var Message|null the error message
  36      * @access protected
  37      */
  38     var $_error_message = null;
  39
  40     /**
  41      * @var bool whether the file is temporary or not
  42      * @access protected
  43      */
  44     var $_is_temp = false;
  45
  46     /**
  47      * @var string type of compression
  48      * @access protected
  49      */
  50     var $_compression = null;
  51
  52     /**
  53      * @var integer
  54      */
  55     var $_offset = 0;
  56
  57     /**
  58      * @var integer size of chunk to read with every step
  59      */
  60     var $_chunk_size = 32768;
  61
  62     /**
  63      * @var resource file handle
  64      */
  65     var $_handle = null;
  66
  67     /**
  68      * @var boolean whether to decompress content before returning
  69      */
  70     var $_decompress = false;
  71
  72     /**
  73      * @var string charset of file
  74      */
  75     var $_charset = null;
  76
  77     /**
  78      * constructor
  79      *
  80      * @param boolean|string $name file name or false
  81      *
  82      * @access public
  83      */
  84     public function __construct($name = false)
  85     {
  86         if ($name && is_string($name)) {
  87             $this->setName($name);
  88         }
  89     }
  90
  91     /**
  92      * destructor
  93      *
  94      * @see     File::cleanUp()
  95      * @access  public
  96      */
  97     public function __destruct()
  98     {
  99         $this->cleanUp();
 100     }
 101
 102     /**
 103      * deletes file if it is temporary, usually from a moved upload file
 104      *
 105      * @access  public
 106      * @return boolean success
 107      */
 108     public function cleanUp()
 109     {
 110         if ($this->isTemp()) {
 111             return $this->delete();
 112         }
 113
 114         return true;
 115     }
 116
 117     /**
 118      * deletes the file
 119      *
 120      * @access  public
 121      * @return boolean success
 122      */
 123     public function delete()
 124     {
 125         return unlink($this->getName());
 126     }
 127
 128     /**
 129      * checks or sets the temp flag for this file
 130      * file objects with temp flags are deleted with object destruction
 131      *
 132      * @param boolean $is_temp sets the temp flag
 133      *
 134      * @return boolean File::$_is_temp
 135      * @access  public
 136      */
 137     public function isTemp($is_temp = null)
 138     {
 139         if (null !== $is_temp) {
 140             $this->_is_temp = (bool) $is_temp;
 141         }
 142
 143         return $this->_is_temp;
 144     }
 145
 146     /**
 147      * accessor
 148      *
 149      * @param string $name file name
 150      *
 151      * @return void
 152      * @access  public
 153      */
 154     public function setName($name)
 155     {
 156         $this->_name = trim($name);
 157     }
 158
 159     /**
 160      * Gets file content
 161      *
 162      * @return string|false the binary file content,
 163      *                      or false if no content
 164      *
 165      * @access  public
 166      */
 167     public function getRawContent()
 168     {
 169         if (null === $this->_content) {
 170             if ($this->isUploaded() && ! $this->checkUploadedFile()) {
 171                 return false;
 172             }
 173
 174             if (! $this->isReadable()) {
 175                 return false;
 176             }
 177
 178             if (function_exists('file_get_contents')) {
 179                 $this->_content = file_get_contents($this->getName());
 180             } elseif ($size = filesize($this->getName())) {
 181                 $handle = fopen($this->getName(), 'rb');
 182                 $this->_content = fread($handle, $size);
 183                 fclose($handle);
 184             }
 185         }
 186
 187         return $this->_content;
 188     }
 189
 190     /**
 191      * Gets file content
 192      *
 193      * @return string|false the binary file content as a string,
 194      *                      or false if no content
 195      *
 196      * @access  public
 197      */
 198     public function getContent()
 199     {
 200         $result = $this->getRawContent();
 201         if ($result === false) {
 202             return false;
 203         }
 204         return '0x' . bin2hex($result);
 205     }
 206
 207     /**
 208      * Whether file is uploaded.
 209      *
 210      * @access  public
 211      *
 212      * @return bool
 213      */
 214     public function isUploaded()
 215     {
 216         return is_uploaded_file($this->getName());
 217     }
 218
 219     /**
 220      * accessor
 221      *
 222      * @access  public
 223      * @return string  File::$_name
 224      */
 225     public function getName()
 226     {
 227         return $this->_name;
 228     }
 229
 230     /**
 231      * Initializes object from uploaded file.
 232      *
 233      * @param string $name name of file uploaded
 234      *
 235      * @return boolean success
 236      * @access  public
 237      */
 238     public function setUploadedFile($name)
 239     {
 240         $this->setName($name);
 241
 242         if (! $this->isUploaded()) {
 243             $this->setName(null);
 244             $this->_error_message = Message::error(__('File was not an uploaded file.'));
 245             return false;
 246         }
 247
 248         return true;
 249     }
 250
 251     /**
 252      * Loads uploaded file from table change request.
 253      *
 254      * @param string $key       the md5 hash of the column name
 255      * @param string $rownumber number of row to process
 256      *
 257      * @return boolean success
 258      * @access  public
 259      */
 260     public function setUploadedFromTblChangeRequest($key, $rownumber)
 261     {
 262         if (! isset($_FILES['fields_upload'])
 263             || empty($_FILES['fields_upload']['name']['multi_edit'][$rownumber][$key])
 264         ) {
 265             return false;
 266         }
 267         $file = File::fetchUploadedFromTblChangeRequestMultiple(
 268             $_FILES['fields_upload'],
 269             $rownumber,
 270             $key
 271         );
 272
 273         // check for file upload errors
 274         switch ($file['error']) {
 275         // we do not use the PHP constants here cause not all constants
 276         // are defined in all versions of PHP - but the correct constants names
 277         // are given as comment
 278         case 0: //UPLOAD_ERR_OK:
 279             return $this->setUploadedFile($file['tmp_name']);
 280         case 4: //UPLOAD_ERR_NO_FILE:
 281             break;
 282         case 1: //UPLOAD_ERR_INI_SIZE:
 283             $this->_error_message = Message::error(__(
 284                 'The uploaded file exceeds the upload_max_filesize directive in '
 285                 . 'php.ini.'
 286             ));
 287             break;
 288         case 2: //UPLOAD_ERR_FORM_SIZE:
 289             $this->_error_message = Message::error(__(
 290                 'The uploaded file exceeds the MAX_FILE_SIZE directive that was '
 291                 . 'specified in the HTML form.'
 292             ));
 293             break;
 294         case 3: //UPLOAD_ERR_PARTIAL:
 295             $this->_error_message = Message::error(__(
 296                 'The uploaded file was only partially uploaded.'
 297             ));
 298             break;
 299         case 6: //UPLOAD_ERR_NO_TMP_DIR:
 300             $this->_error_message = Message::error(__('Missing a temporary folder.'));
 301             break;
 302         case 7: //UPLOAD_ERR_CANT_WRITE:
 303             $this->_error_message = Message::error(__('Failed to write file to disk.'));
 304             break;
 305         case 8: //UPLOAD_ERR_EXTENSION:
 306             $this->_error_message = Message::error(__('File upload stopped by extension.'));
 307             break;
 308         default:
 309             $this->_error_message = Message::error(__('Unknown error in file upload.'));
 310         } // end switch
 311
 312         return false;
 313     }
 314
 315     /**
 316      * strips some dimension from the multi-dimensional array from $_FILES
 317      *
 318      * <code>
 319      * $file['name']['multi_edit'][$rownumber][$key] = [value]
 320      * $file['type']['multi_edit'][$rownumber][$key] = [value]
 321      * $file['size']['multi_edit'][$rownumber][$key] = [value]
 322      * $file['tmp_name']['multi_edit'][$rownumber][$key] = [value]
 323      * $file['error']['multi_edit'][$rownumber][$key] = [value]
 324      *
 325      * // becomes:
 326      *
 327      * $file['name'] = [value]
 328      * $file['type'] = [value]
 329      * $file['size'] = [value]
 330      * $file['tmp_name'] = [value]
 331      * $file['error'] = [value]
 332      * </code>
 333      *
 334      * @param array  $file      the array
 335      * @param string $rownumber number of row to process
 336      * @param string $key       key to process
 337      *
 338      * @return array
 339      * @access  public
 340      * @static
 341      */
 342     public function fetchUploadedFromTblChangeRequestMultiple(
 343         $file, $rownumber, $key
 344     ) {
 345         $new_file = array(
 346             'name' => $file['name']['multi_edit'][$rownumber][$key],
 347             'type' => $file['type']['multi_edit'][$rownumber][$key],
 348             'size' => $file['size']['multi_edit'][$rownumber][$key],
 349             'tmp_name' => $file['tmp_name']['multi_edit'][$rownumber][$key],
 350             'error' => $file['error']['multi_edit'][$rownumber][$key],
 351         );
 352
 353         return $new_file;
 354     }
 355
 356     /**
 357      * sets the name if the file to the one selected in the tbl_change form
 358      *
 359      * @param string $key       the md5 hash of the column name
 360      * @param string $rownumber number of row to process
 361      *
 362      * @return boolean success
 363      * @access  public
 364      */
 365     public function setSelectedFromTblChangeRequest($key, $rownumber = null)
 366     {
 367         if (! empty($_REQUEST['fields_uploadlocal']['multi_edit'][$rownumber][$key])
 368             && is_string($_REQUEST['fields_uploadlocal']['multi_edit'][$rownumber][$key])
 369         ) {
 370             // ... whether with multiple rows ...
 371             return $this->setLocalSelectedFile(
 372                 $_REQUEST['fields_uploadlocal']['multi_edit'][$rownumber][$key]
 373             );
 374         } else {
 375             return false;
 376         }
 377     }
 378
 379     /**
 380      * Returns possible error message.
 381      *
 382      * @access  public
 383      * @return Message|null error message
 384      */
 385     public function getError()
 386     {
 387         return $this->_error_message;
 388     }
 389
 390     /**
 391      * Checks whether there was any error.
 392      *
 393      * @access  public
 394      * @return boolean whether an error occurred or not
 395      */
 396     public function isError()
 397     {
 398         return ! is_null($this->_error_message);
 399     }
 400
 401     /**
 402      * checks the superglobals provided if the tbl_change form is submitted
 403      * and uses the submitted/selected file
 404      *
 405      * @param string $key       the md5 hash of the column name
 406      * @param string $rownumber number of row to process
 407      *
 408      * @return boolean success
 409      * @access  public
 410      */
 411     public function checkTblChangeForm($key, $rownumber)
 412     {
 413         if ($this->setUploadedFromTblChangeRequest($key, $rownumber)) {
 414             // well done ...
 415             $this->_error_message = null;
 416             return true;
 417         } elseif ($this->setSelectedFromTblChangeRequest($key, $rownumber)) {
 418             // well done ...
 419             $this->_error_message = null;
 420             return true;
 421         }
 422         // all failed, whether just no file uploaded/selected or an error
 423
 424         return false;
 425     }
 426
 427     /**
 428      * Sets named file to be read from UploadDir.
 429      *
 430      * @param string $name file name
 431      *
 432      * @return boolean success
 433      * @access  public
 434      */
 435     public function setLocalSelectedFile($name)
 436     {
 437         if (empty($GLOBALS['cfg']['UploadDir'])) {
 438             return false;
 439         }
 440
 441         $this->setName(
 442             Util::userDir($GLOBALS['cfg']['UploadDir']) . PMA_securePath($name)
 443         );
 444         if (@is_link($this->getName())) {
 445             $this->_error_message = __('File is a symbolic link');
 446             $this->setName(null);
 447             return false;
 448         }
 449         if (! $this->isReadable()) {
 450             $this->_error_message = Message::error(__('File could not be read!'));
 451             $this->setName(null);
 452             return false;
 453         }
 454
 455         return true;
 456     }
 457
 458     /**
 459      * Checks whether file can be read.
 460      *
 461      * @access  public
 462      * @return boolean whether the file is readable or not
 463      */
 464     public function isReadable()
 465     {
 466         // suppress warnings from being displayed, but not from being logged
 467         // any file access outside of open_basedir will issue a warning
 468         return @is_readable($this->getName());
 469     }
 470
 471     /**
 472      * If we are on a server with open_basedir, we must move the file
 473      * before opening it. The FAQ 1.11 explains how to create the "./tmp"
 474      * directory - if needed
 475      *
 476      * @todo move check of $cfg['TempDir'] into Config?
 477      * @access  public
 478      * @return boolean whether uploaded file is fine or not
 479      */
 480     public function checkUploadedFile()
 481     {
 482         if ($this->isReadable()) {
 483             return true;
 484         }
 485
 486         $tmp_subdir = ConfigFile::getDefaultTempDirectory();
 487         if (is_null($tmp_subdir)) {
 488             // cannot create directory or access, point user to FAQ 1.11
 489             $this->_error_message = Message::error(__(
 490                 'Error moving the uploaded file, see [doc@faq1-11]FAQ 1.11[/doc].'
 491             ));
 492             return false;
 493         }
 494
 495         $new_file_to_upload = tempnam(
 496             $tmp_subdir,
 497             basename($this->getName())
 498         );
 499
 500         // suppress warnings from being displayed, but not from being logged
 501         // any file access outside of open_basedir will issue a warning
 502         ob_start();
 503         $move_uploaded_file_result = move_uploaded_file(
 504             $this->getName(),
 505             $new_file_to_upload
 506         );
 507         ob_end_clean();
 508         if (! $move_uploaded_file_result) {
 509             $this->_error_message = Message::error(__('Error while moving uploaded file.'));
 510             return false;
 511         }
 512
 513         $this->setName($new_file_to_upload);
 514         $this->isTemp(true);
 515
 516         if (! $this->isReadable()) {
 517             $this->_error_message = Message::error(__('Cannot read uploaded file.'));
 518             return false;
 519         }
 520
 521         return true;
 522     }
 523
 524     /**
 525      * Detects what compression the file uses
 526      *
 527      * @todo    move file read part into readChunk() or getChunk()
 528      * @todo    add support for compression plugins
 529      * @access  protected
 530      * @return  string|false false on error, otherwise string MIME type of
 531      *                       compression, none for none
 532      */
 533     protected function detectCompression()
 534     {
 535         // suppress warnings from being displayed, but not from being logged
 536         // f.e. any file access outside of open_basedir will issue a warning
 537         ob_start();
 538         $file = fopen($this->getName(), 'rb');
 539         ob_end_clean();
 540
 541         if (! $file) {
 542             $this->_error_message = Message::error(__('File could not be read!'));
 543             return false;
 544         }
 545
 546         /**
 547          * @todo
 548          * get registered plugins for file compression
 549
 550         foreach (PMA_getPlugins($type = 'compression') as $plugin) {
 551             if ($plugin['classname']::canHandle($this->getName())) {
 552                 $this->setCompressionPlugin($plugin);
 553                 break;
 554             }
 555         }
 556          */
 557
 558         $this->_compression = Util::getCompressionMimeType($file);
 559         return $this->_compression;
 560     }
 561
 562     /**
 563      * Sets whether the content should be decompressed before returned
 564      *
 565      * @param boolean $decompress whether to decompress
 566      *
 567      * @return void
 568      */
 569     public function setDecompressContent($decompress)
 570     {
 571         $this->_decompress = (bool) $decompress;
 572     }
 573
 574     /**
 575      * Returns the file handle
 576      *
 577      * @return resource file handle
 578      */
 579     public function getHandle()
 580     {
 581         if (null === $this->_handle) {
 582             $this->open();
 583         }
 584         return $this->_handle;
 585     }
 586
 587     /**
 588      * Sets the file handle
 589      *
 590      * @param object $handle file handle
 591      *
 592      * @return void
 593      */
 594     public function setHandle($handle)
 595     {
 596         $this->_handle = $handle;
 597     }
 598
 599
 600     /**
 601      * Sets error message for unsupported compression.
 602      *
 603      * @return void
 604      */
 605     public function errorUnsupported()
 606     {
 607         $this->_error_message = Message::error(sprintf(
 608             __(
 609                 'You attempted to load file with unsupported compression (%s). '
 610                 . 'Either support for it is not implemented or disabled by your '
 611                 . 'configuration.'
 612             ),
 613             $this->getCompression()
 614         ));
 615     }
 616
 617     /**
 618      * Attempts to open the file.
 619      *
 620      * @return bool
 621      */
 622     public function open()
 623     {
 624         if (! $this->_decompress) {
 625             $this->_handle = @fopen($this->getName(), 'r');
 626         }
 627
 628         switch ($this->getCompression()) {
 629         case false:
 630             return false;
 631         case 'application/bzip2':
 632             if ($GLOBALS['cfg']['BZipDump'] && @function_exists('bzopen')) {
 633                 $this->_handle = @bzopen($this->getName(), 'r');
 634             } else {
 635                 $this->errorUnsupported();
 636                 return false;
 637             }
 638             break;
 639         case 'application/gzip':
 640             if ($GLOBALS['cfg']['GZipDump'] && @function_exists('gzopen')) {
 641                 $this->_handle = @gzopen($this->getName(), 'r');
 642             } else {
 643                 $this->errorUnsupported();
 644                 return false;
 645             }
 646             break;
 647         case 'application/zip':
 648             if ($GLOBALS['cfg']['ZipDump'] && @function_exists('zip_open')) {
 649                 return $this->openZip();
 650             } else {
 651                 $this->errorUnsupported();
 652                 return false;
 653             }
 654         case 'none':
 655             $this->_handle = @fopen($this->getName(), 'r');
 656             break;
 657         default:
 658             $this->errorUnsupported();
 659             return false;
 660         }
 661
 662         return ($this->_handle !== false);
 663     }
 664
 665     /**
 666      * Opens file from zip
 667      *
 668      * @param string|null $specific_entry Entry to open
 669      *
 670      * @return bool
 671      */
 672     public function openZip($specific_entry = null)
 673     {
 674         include_once './libraries/zip_extension.lib.php';
 675         $result = PMA_getZipContents($this->getName(), $specific_entry);
 676         if (! empty($result['error'])) {
 677             $this->_error_message = Message::rawError($result['error']);
 678             return false;
 679         }
 680         $this->_content = $result['data'];
 681         $this->_offset = 0;
 682         return true;
 683     }
 684
 685     /**
 686      * Checks whether we've reached end of file
 687      *
 688      * @return bool
 689      */
 690     public function eof()
 691     {
 692         if (! is_null($this->_handle)) {
 693             return feof($this->_handle);
 694         }
 695         return $this->_offset == strlen($this->_content);
 696     }
 697
 698     /**
 699      * Closes the file
 700      *
 701      * @return void
 702      */
 703     public function close()
 704     {
 705         if (! is_null($this->_handle)) {
 706             fclose($this->_handle);
 707             $this->_handle = null;
 708         } else {
 709             $this->_content = '';
 710             $this->_offset = 0;
 711         }
 712         $this->cleanUp();
 713     }
 714
 715     /**
 716      * Reads data from file
 717      *
 718      * @param int $size Number of bytes to read
 719      *
 720      * @return string
 721      */
 722     public function read($size)
 723     {
 724         switch ($this->_compression) {
 725         case 'application/bzip2':
 726             return bzread($this->_handle, $size);
 727         case 'application/gzip':
 728             return gzread($this->_handle, $size);
 729         case 'application/zip':
 730             $result = mb_strcut($this->_content, $this->_offset, $size);
 731             $this->_offset += strlen($result);
 732             return $result;
 733         case 'none':
 734         default:
 735             return fread($this->_handle, $size);
 736         }
 737     }
 738
 739     /**
 740      * Returns the character set of the file
 741      *
 742      * @return string character set of the file
 743      */
 744     public function getCharset()
 745     {
 746         return $this->_charset;
 747     }
 748
 749     /**
 750      * Sets the character set of the file
 751      *
 752      * @param string $charset character set of the file
 753      *
 754      * @return void
 755      */
 756     public function setCharset($charset)
 757     {
 758         $this->_charset = $charset;
 759     }
 760
 761     /**
 762      * Returns compression used by file.
 763      *
 764      * @return string MIME type of compression, none for none
 765      * @access  public
 766      */
 767     public function getCompression()
 768     {
 769         if (null === $this->_compression) {
 770             return $this->detectCompression();
 771         }
 772
 773         return $this->_compression;
 774     }
 775
 776     /**
 777      * Returns the offset
 778      *
 779      * @return integer the offset
 780      */
 781     public function getOffset()
 782     {
 783         return $this->_offset;
 784     }
 785
 786     /**
 787      * Returns the chunk size
 788      *
 789      * @return integer the chunk size
 790      */
 791     public function getChunkSize()
 792     {
 793         return $this->_chunk_size;
 794     }
 795
 796     /**
 797      * Sets the chunk size
 798      *
 799      * @param integer $chunk_size the chunk size
 800      *
 801      * @return void
 802      */
 803     public function setChunkSize($chunk_size)
 804     {
 805         $this->_chunk_size = (int) $chunk_size;
 806     }
 807
 808     /**
 809      * Returns the length of the content in the file
 810      *
 811      * @return integer the length of the file content
 812      */
 813     public function getContentLength()
 814     {
 815         return strlen($this->_content);
 816     }
 817 }