libraries/File.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * file upload functions
   5  *
   6  * @version $Id$
   7  */
   8
   9 /**
  10  *
  11  * @todo replace error messages with localized string
  12  * @todo when uploading a file into a blob field, should we also consider using
  13  *       chunks like in import? UPDATE `table` SET `field` = `field` + [chunk]
  14  */
  15 class PMA_File
  16 {
  17     /**
  18      * @var string the temporary file name
  19      * @access protected
  20      */
  21     var $_name = null;
  22
  23     /**
  24      * @var string the content
  25      * @access protected
  26      */
  27     var $_content = null;
  28
  29     /**
  30      * @var string the error message
  31      * @access protected
  32      */
  33     var $_error_message = '';
  34
  35     /**
  36      * @var bool whether the file is temporary or not
  37      * @access protected
  38      */
  39     var $_is_temp = false;
  40
  41     /**
  42      * @var string type of compression
  43      * @access protected
  44      */
  45     var $_compression = null;
  46
  47     /**
  48      * @var integer
  49      */
  50     var $_offset = 0;
  51
  52     /**
  53      * @var integer size of chunk to read with every step
  54      */
  55     var $_chunk_size = 32768;
  56
  57     /**
  58      * @var resource file handle
  59      */
  60     var $_handle = null;
  61
  62     /**
  63      * @var boolean whether to decompress content before returning
  64      */
  65     var $_decompress = false;
  66
  67     /**
  68      * @var string charset of file
  69      */
  70     var $_charset = null;
  71
  72     /**
  73      * old PHP 4 style constructor
  74      *
  75      * @see     PMA_File::__construct()
  76      * @uses    PMA_File::__construct()
  77      * @access  public
  78      */
  79     function PMA_File($name = false)
  80     {
  81         $this->__construct($name);
  82     }
  83
  84     /**
  85      * constructor
  86      *
  87      * @access  public
  88      * @uses    PMA_File::setName()
  89      * @param   string  $name   file name
  90      */
  91     function __construct($name = false)
  92     {
  93         if ($name) {
  94             $this->setName($name);
  95         }
  96     }
  97
  98     /**
  99      * destructor
 100      *
 101      * @see     PMA_File::cleanUp()
 102      * @access  public
 103      * @uses    PMA_File::cleanUp()
 104      */
 105     function __destruct()
 106     {
 107         $this->cleanUp();
 108     }
 109
 110     /**
 111      * deletes file if it is temporary, usally from a moved upload file
 112      *
 113      * @access  public
 114      * @uses    PMA_File::delet()
 115      * @uses    PMA_File::isTemp()
 116      * @return  boolean success
 117      */
 118     function cleanUp()
 119     {
 120         if ($this->isTemp()) {
 121             return $this->delete();
 122         }
 123
 124         return true;
 125     }
 126
 127     /**
 128      * deletes the file
 129      *
 130      * @access  public
 131      * @uses    PMA_File::getName()
 132      * @uses    unlink()
 133      * @return  boolean success
 134      */
 135     function delete()
 136     {
 137         return unlink($this->getName());
 138     }
 139
 140     /**
 141      * checks or sets the temp flag for this file
 142      * file objects with temp flags are deleted with object destruction
 143      *
 144      * @access  public
 145      * @uses    PMA_File::$_is_temp to set and read it
 146      * @param   boolean sets the temp flag
 147      * @return  boolean PMA_File::$_is_temp
 148      */
 149     function isTemp($is_temp = null)
 150     {
 151         if (null !== $is_temp) {
 152             $this->_is_temp = (bool) $is_temp;
 153         }
 154
 155         return $this->_is_temp;
 156     }
 157
 158     /**
 159      * accessor
 160      *
 161      * @access  public
 162      * @uses    PMA_File::$_name
 163      * @param   string  $name   file name
 164      * @access  public
 165      */
 166     function setName($name)
 167     {
 168         $this->_name = trim($name);
 169     }
 170
 171     /**
 172      * @access  public
 173      * @uses    PMA_File::getName()
 174      * @uses    PMA_File::isUploaded()
 175      * @uses    PMA_File::checkUploadedFile()
 176      * @uses    PMA_File::isReadable()
 177      * @uses    PMA_File::$_content
 178      * @uses    function_exists()
 179      * @uses    file_get_contents()
 180      * @uses    filesize()
 181      * @uses    fread()
 182      * @uses    fopen()
 183      * @uses    bin2hex()
 184      * @return  string  binary file content
 185      */
 186     function getContent($as_binary = true, $offset = 0, $length = null)
 187     {
 188         if (null === $this->_content) {
 189             if ($this->isUploaded() && ! $this->checkUploadedFile()) {
 190                 return false;
 191             }
 192
 193             if (! $this->isReadable()) {
 194                 return false;
 195             }
 196
 197             if (function_exists('file_get_contents')) {
 198                 $this->_content = file_get_contents($this->getName());
 199             } elseif ($size = filesize($this->getName())) {
 200                 $this->_content = fread(fopen($this->getName(), 'rb'), $size);
 201             }
 202         }
 203
 204         if (! empty($this->_content) && $as_binary) {
 205             return '0x' . bin2hex($this->_content);
 206         }
 207
 208         if (null !== $length) {
 209             return substr($this->_content, $offset, $length);
 210         } elseif ($offset > 0) {
 211             return substr($this->_content, $offset);
 212         }
 213
 214         return $this->_content;
 215     }
 216
 217     /**
 218      * @access  public
 219      * @uses    PMA_File::getName()
 220      * @uses    is_uploaded_file()
 221      */
 222     function isUploaded()
 223     {
 224         return is_uploaded_file($this->getName());
 225     }
 226
 227     /**
 228      * accessor
 229      *
 230      * @access  public
 231      * @uses    PMA_File::$name as return value
 232      * @return  string  PMA_File::$_name
 233      */
 234     function getName()
 235     {
 236         return $this->_name;
 237     }
 238
 239     /**
 240      * @todo replace error message with localized string
 241      * @access  public
 242      * @uses    PMA_File::isUploaded()
 243      * @uses    PMA_File::setName()
 244      * @uses    PMA_File::$_error_message
 245      * @param   string  name of file uploaded
 246      * @return  boolean success
 247      */
 248     function setUploadedFile($name)
 249     {
 250         $this->setName($name);
 251
 252         if (! $this->isUploaded()) {
 253             $this->setName(null);
 254             $this->_error_message = 'not an uploaded file';
 255             return false;
 256         }
 257
 258         return true;
 259     }
 260
 261     /**
 262      * @access  public
 263      * @uses    PMA_File::fetchUploadedFromTblChangeRequestMultiple()
 264      * @uses    PMA_File::setUploadedFile()
 265      * @uses    PMA_File::$_error_message
 266      * @uses    $GLOBALS['strUploadErrorIniSize']
 267      * @uses    $GLOBALS['strUploadErrorFormSize']
 268      * @uses    $GLOBALS['strUploadErrorPartial']
 269      * @uses    $GLOBALS['strUploadErrorNoTempDir']
 270      * @uses    $GLOBALS['strUploadErrorCantWrite']
 271      * @uses    $GLOBALS['strUploadErrorExtension']
 272      * @uses    $GLOBALS['strUploadErrorUnknown']
 273      * @uses    $_FILES
 274      * @param   string  $key    a numeric key used to identify the different rows
 275      * @param   string  $primary_key
 276      * @return  boolean success
 277      */
 278     function setUploadedFromTblChangeRequest($key, $primary = null)
 279     {
 280         if (! isset($_FILES['fields_upload_' . $key])) {
 281             return false;
 282         }
 283
 284         $file = $_FILES['fields_upload_' . $key];
 285         if (null !== $primary) {
 286             $file = PMA_File::fetchUploadedFromTblChangeRequestMultiple($file, $primary);
 287         }
 288
 289         // check for file upload errors
 290         switch ($file['error']) {
 291             // cybot_tm: we do not use the PHP constants here cause not all constants
 292             // are defined in all versions of PHP - but the correct constants names
 293             // are given as comment
 294             case 0: //UPLOAD_ERR_OK:
 295                 return $this->setUploadedFile($file['tmp_name']);
 296                 break;
 297             case 4: //UPLOAD_ERR_NO_FILE:
 298                 break;
 299             case 1: //UPLOAD_ERR_INI_SIZE:
 300                 $this->_error_message = $GLOBALS['strUploadErrorIniSize'];
 301                 break;
 302             case 2: //UPLOAD_ERR_FORM_SIZE:
 303                 $this->_error_message = $GLOBALS['strUploadErrorFormSize'];
 304                 break;
 305             case 3: //UPLOAD_ERR_PARTIAL:
 306                 $this->_error_message = $GLOBALS['strUploadErrorPartial'];
 307                 break;
 308             case 6: //UPLOAD_ERR_NO_TMP_DIR:
 309                 $this->_error_message = $GLOBALS['strUploadErrorNoTempDir'];
 310                 break;
 311             case 7: //UPLOAD_ERR_CANT_WRITE:
 312                 $this->_error_message = $GLOBALS['strUploadErrorCantWrite'];
 313                 break;
 314             case 8: //UPLOAD_ERR_EXTENSION:
 315                 $this->_error_message = $GLOBALS['strUploadErrorExtension'];
 316                 break;
 317             default:
 318                 $this->_error_message = $GLOBALS['strUploadErrorUnknown'];
 319         } // end switch
 320
 321         return false;
 322     }
 323
 324     /**
 325      * strips some dimension from the multi-dimensional array from $_FILES
 326      *
 327      * <code>
 328      * $file['name']['multi_edit'][$primary] = [value]
 329      * $file['type']['multi_edit'][$primary] = [value]
 330      * $file['size']['multi_edit'][$primary] = [value]
 331      * $file['tmp_name']['multi_edit'][$primary] = [value]
 332      * $file['error']['multi_edit'][$primary] = [value]
 333      *
 334      * // becomes:
 335      *
 336      * $file['name'] = [value]
 337      * $file['type'] = [value]
 338      * $file['size'] = [value]
 339      * $file['tmp_name'] = [value]
 340      * $file['error'] = [value]
 341      * </code>
 342      *
 343      * @todo re-check if requirements changes to PHP >= 4.2.0
 344      * @access  public
 345      * @static
 346      * @param   array   $file       the array
 347      * @param   string  $primary
 348      * @return  array
 349      */
 350     function fetchUploadedFromTblChangeRequestMultiple($file, $primary)
 351     {
 352         $new_file = array(
 353             'name' => $file['name']['multi_edit'][$primary],
 354             'type' => $file['type']['multi_edit'][$primary],
 355             'size' => $file['size']['multi_edit'][$primary],
 356             'tmp_name' => $file['tmp_name']['multi_edit'][$primary],
 357             //'error' => $file['error']['multi_edit'][$primary],
 358         );
 359
 360         // ['error'] exists since PHP 4.2.0
 361         if (isset($file['error'])) {
 362             $new_file['error'] = $file['error']['multi_edit'][$primary];
 363         }
 364
 365         return $new_file;
 366     }
 367
 368     /**
 369      * sets the name if the file to the one selected in the tbl_change form
 370      *
 371      * @access  public
 372      * @uses    $_REQUEST
 373      * @uses    PMA_File::setLocalSelectedFile()
 374      * @uses    is_string()
 375      * @param   string  $key    a numeric key used to identify the different rows
 376      * @param   string  $primary_key
 377      * @return  boolean success
 378      */
 379     function setSelectedFromTblChangeRequest($key, $primary = null)
 380     {
 381         if (null !== $primary) {
 382             if (! empty($_REQUEST['fields_uploadlocal_' . $key]['multi_edit'][$primary])
 383              && is_string($_REQUEST['fields_uploadlocal_' . $key]['multi_edit'][$primary])) {
 384                 // ... whether with multiple rows ...
 385                 return $this->setLocalSelectedFile($_REQUEST['fields_uploadlocal_' . $key]['multi_edit'][$primary]);
 386             } else {
 387                 return false;
 388             }
 389         } elseif (! empty($_REQUEST['fields_uploadlocal_' . $key])
 390          && is_string($_REQUEST['fields_uploadlocal_' . $key])) {
 391             return $this->setLocalSelectedFile($_REQUEST['fields_uploadlocal_' . $key]);
 392         }
 393
 394          return false;
 395     }
 396
 397     /**
 398      * @access  public
 399      * @uses    PMA_File->$_error_message as return value
 400      * @return  string  error message
 401      */
 402     function getError()
 403     {
 404         return $this->_error_message;
 405     }
 406
 407     /**
 408      * @access  public
 409      * @uses    PMA_File->$_error_message to check it
 410      * @return  boolean whether an error occured or not
 411      */
 412     function isError()
 413     {
 414         return ! empty($this->_error_message);
 415     }
 416
 417     /**
 418      * checks the superglobals provided if the tbl_change form is submitted
 419      * and uses the submitted/selected file
 420      *
 421      * @access  public
 422      * @uses    PMA_File::setUploadedFromTblChangeRequest()
 423      * @uses    PMA_File::setSelectedFromTblChangeRequest()
 424      * @param   string  $key    a numeric key used to identify the different rows
 425      * @param   string  $primary_key
 426      * @return  boolean success
 427      */
 428     function checkTblChangeForm($key, $primary_key)
 429     {
 430         if ($this->setUploadedFromTblChangeRequest($key, $primary_key)) {
 431             // well done ...
 432             $this->_error_message = '';
 433             return true;
 434 /*
 435         } elseif ($this->setUploadedFromTblChangeRequest($key)) {
 436             // well done ...
 437             $this->_error_message = '';
 438             return true;
 439 */
 440         } elseif ($this->setSelectedFromTblChangeRequest($key, $primary_key)) {
 441             // well done ...
 442             $this->_error_message = '';
 443             return true;
 444 /*
 445         } elseif ($this->setSelectedFromTblChangeRequest($key)) {
 446             // well done ...
 447             $this->_error_message = '';
 448             return true;
 449 */
 450         }
 451         // all failed, whether just no file uploaded/selected or an error
 452
 453         return false;
 454     }
 455
 456     /**
 457      *
 458      * @access  public
 459      * @uses    $GLOBALS['strFileCouldNotBeRead']
 460      * @uses    PMA_File::setName()
 461      * @uses    PMA_securePath()
 462      * @uses    PMA_userDir()
 463      * @uses    $GLOBALS['cfg']['UploadDir']
 464      * @param   string  $name
 465      * @return  boolean success
 466      */
 467     function setLocalSelectedFile($name)
 468     {
 469         if (empty($GLOBALS['cfg']['UploadDir'])) return false;
 470
 471         $this->setName(PMA_userDir($GLOBALS['cfg']['UploadDir']) . PMA_securePath($name));
 472         if (! $this->isReadable()) {
 473             $this->_error_message = $GLOBALS['strFileCouldNotBeRead'];
 474             $this->setName(null);
 475             return false;
 476         }
 477
 478         return true;
 479     }
 480
 481     /**
 482      * @access  public
 483      * @uses    PMA_File::getName()
 484      * @uses    is_readable()
 485      * @uses    ob_start()
 486      * @uses    ob_end_clean()
 487      * @return  boolean whether the file is readable or not
 488      */
 489     function isReadable()
 490     {
 491         // surpress warnings from beeing displayed, but not from beeing logged
 492         // any file access outside of open_basedir will issue a warning
 493         ob_start();
 494         $is_readable = is_readable($this->getName());
 495         ob_end_clean();
 496         return $is_readable;
 497     }
 498
 499     /**
 500      * If we are on a server with open_basedir, we must move the file
 501      * before opening it. The FAQ 1.11 explains how to create the "./tmp"
 502      * directory - if needed
 503      *
 504      * @todo replace error message with localized string
 505      * @todo move check of $cfg['TempDir'] into PMA_Config?
 506      * @access  public
 507      * @uses    $cfg['TempDir']
 508      * @uses    $GLOBALS['strFieldInsertFromFileTempDirNotExists']
 509      * @uses    PMA_File::isReadable()
 510      * @uses    PMA_File::getName()
 511      * @uses    PMA_File::setName()
 512      * @uses    PMA_File::isTemp()
 513      * @uses    PMA_File::$_error_message
 514      * @uses    is_dir()
 515      * @uses    mkdir()
 516      * @uses    chmod()
 517      * @uses    is_writable()
 518      * @uses    basename()
 519      * @uses    move_uploaded_file()
 520      * @uses    ob_start()
 521      * @uses    ob_end_clean()
 522      * @return  boolean whether uploaded fiel is fine or not
 523      */
 524     function checkUploadedFile()
 525     {
 526         if ($this->isReadable()) {
 527             return true;
 528         }
 529
 530         /**
 531          * it is not important if open_basedir is set - we just cannot read the file
 532          * so we try to move it
 533         if ('' != ini_get('open_basedir')) {
 534          */
 535
 536         // check tmp dir config
 537         if (empty($GLOBALS['cfg']['TempDir'])) {
 538             $GLOBALS['cfg']['TempDir'] = 'tmp/';
 539         }
 540
 541         // surpress warnings from beeing displayed, but not from beeing logged
 542         ob_start();
 543         // check tmp dir
 544         if (! is_dir($GLOBALS['cfg']['TempDir'])) {
 545             // try to create the tmp directory
 546             if (@mkdir($GLOBALS['cfg']['TempDir'], 0777)) {
 547                 chmod($GLOBALS['cfg']['TempDir'], 0777);
 548             } else {
 549                 // create tmp dir failed
 550                 $this->_error_message = $GLOBALS['strFieldInsertFromFileTempDirNotExists'];
 551                 ob_end_clean();
 552                 return false;
 553             }
 554         }
 555         ob_end_clean();
 556
 557         if (! is_writable($GLOBALS['cfg']['TempDir'])) {
 558             // cannot create directory or access, point user to FAQ 1.11
 559             $this->_error_message = $GLOBALS['strFieldInsertFromFileTempDirNotExists'];
 560             return false;
 561         }
 562
 563         $new_file_to_upload = $GLOBALS['cfg']['TempDir'] . '/' . basename($this->getName());
 564
 565         // surpress warnings from beeing displayed, but not from beeing logged
 566         // any file access outside of open_basedir will issue a warning
 567         ob_start();
 568         $move_uploaded_file_result = move_uploaded_file($this->getName(), $new_file_to_upload);
 569         ob_end_clean();
 570         if (! $move_uploaded_file_result) {
 571             $this->_error_message = 'error while moving uploaded file';
 572             return false;
 573         }
 574
 575         $this->setName($new_file_to_upload);
 576         $this->isTemp(true);
 577
 578         if (! $this->isReadable()) {
 579             $this->_error_message = 'cannot read (moved) upload file';
 580             return false;
 581         }
 582
 583         return true;
 584     }
 585
 586     /**
 587      * Detects what compression filse uses
 588      *
 589      * @todo    move file read part into readChunk() or getChunk()
 590      * @todo    add support for compression plugins
 591      * @uses    $GLOBALS['strFileCouldNotBeRead']
 592      * @uses    PMA_File::$_compression to set it
 593      * @uses    PMA_File::getName()
 594      * @uses    fopen()
 595      * @uses    fread()
 596      * @uses    strlen()
 597      * @uses    fclose()
 598      * @uses    chr()
 599      * @uses    substr()
 600      * @access  protected
 601      * @return  string MIME type of compression, none for none
 602      */
 603     function _detectCompression()
 604     {
 605         // surpress warnings from beeing displayed, but not from beeing logged
 606         // f.e. any file access outside of open_basedir will issue a warning
 607         ob_start();
 608         $file = fopen($this->getName(), 'rb');
 609         ob_end_clean();
 610
 611         if (! $file) {
 612             $this->_error_message = $GLOBALS['strFileCouldNotBeRead'];
 613             return false;
 614         }
 615
 616         /**
 617          * @todo
 618          * get registered plugins for file compression
 619
 620         foreach (PMA_getPlugins($type = 'compression') as $plugin) {
 621             if (call_user_func_array(array($plugin['classname'], 'canHandle'), array($this->getName()))) {
 622                 $this->setCompressionPlugin($plugin);
 623                 break;
 624             }
 625         }
 626          */
 627
 628         $test = fread($file, 4);
 629         $len = strlen($test);
 630         fclose($file);
 631
 632         if ($len >= 2 && $test[0] == chr(31) && $test[1] == chr(139)) {
 633             $this->_compression = 'application/gzip';
 634         } elseif ($len >= 3 && substr($test, 0, 3) == 'BZh') {
 635             $this->_compression = 'application/bzip2';
 636         } elseif ($len >= 4 && $test == "PK\003\004") {
 637             $this->_compression = 'application/zip';
 638         } else {
 639             $this->_compression = 'none';
 640         }
 641
 642         return $this->_compression;
 643     }
 644
 645     /**
 646      * whether the content should be decompressed before returned
 647      */
 648     function setDecompressContent($decompress)
 649     {
 650         $this->_decompress = (bool) $decompress;
 651     }
 652
 653     function getHandle()
 654     {
 655         if (null === $this->_handle) {
 656             $this->open();
 657         }
 658         return $this->_handle;
 659     }
 660
 661     function setHandle($handle)
 662     {
 663         $this->_handle = $handle;
 664     }
 665
 666     /**
 667      *
 668      */
 669     function open()
 670     {
 671         if (! $this->_decompress) {
 672             $this->_handle = @fopen($this->getName(), 'r');
 673         }
 674
 675         switch ($this->getCompression()) {
 676             case false:
 677                 return false;
 678             case 'application/bzip2':
 679                 if ($GLOBALS['cfg']['BZipDump'] && @function_exists('bzopen')) {
 680                     $this->_handle = @bzopen($this->getName(), 'r');
 681                 } else {
 682                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 683                     return false;
 684                 }
 685                 break;
 686             case 'application/gzip':
 687                 if ($GLOBALS['cfg']['GZipDump'] && @function_exists('gzopen')) {
 688                     $this->_handle = @gzopen($this->getName(), 'r');
 689                 } else {
 690                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 691                     return false;
 692                 }
 693                 break;
 694             case 'application/zip':
 695                 if ($GLOBALS['cfg']['GZipDump'] && @function_exists('gzinflate')) {
 696                     include_once './libraries/unzip.lib.php';
 697                     $this->_handle = new SimpleUnzip();
 698                     $this->_handle->ReadFile($this->getName());
 699                     if ($this->_handle->Count() == 0) {
 700                         $this->_error_message = $GLOBALS['strNoFilesFoundInZip'];
 701                         return false;
 702                     } elseif ($this->_handle->GetError(0) != 0) {
 703                         $this->_error_message = $GLOBALS['strErrorInZipFile'] . ' ' . $this->_handle->GetErrorMsg(0);
 704                         return false;
 705                     } else {
 706                         $this->content_uncompressed = $this->_handle->GetData(0);
 707                     }
 708                     // We don't need to store it further
 709                     $this->_handle = null;
 710                 } else {
 711                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 712                     return false;
 713                 }
 714                 break;
 715             case 'none':
 716                 $this->_handle = @fopen($this->getName(), 'r');
 717                 break;
 718             default:
 719                 $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 720                 return false;
 721                 break;
 722         }
 723
 724
 725     }
 726
 727     function getCharset()
 728     {
 729         return $this->_charset;
 730     }
 731
 732     function setCharset($charset)
 733     {
 734         $this->_charset = $charset;
 735     }
 736
 737     /**
 738      * @uses    PMA_File::$_compression as return value
 739      * @uses    PMA_File::detectCompression()
 740      * @return  string MIME type of compression, none for none
 741      * @access  public
 742      */
 743     function getCompression()
 744     {
 745         if (null === $this->_compression) {
 746             return $this->_detectCompression();
 747         }
 748
 749         return $this->_compression;
 750     }
 751
 752     /**
 753      * advances the file pointer in the file handle by $length bytes/chars
 754      *
 755      * @param   integer $length numbers of chars/bytes to skip
 756      * @return  boolean
 757      */
 758     function advanceFilePointer($length)
 759     {
 760         while ($length > 0) {
 761             // Disable read progresivity, otherwise we eat all memory!
 762             $read_multiply = 1; // required?
 763             $this->getNextChunk($length);
 764             $length -= $this->getChunkSize();
 765         }
 766     }
 767
 768     /**
 769      * http://bugs.php.net/bug.php?id=29532
 770      * bzip reads a maximum of 8192 bytes on windows systems
 771      *
 772      */
 773     function getNextChunk($max_size = null)
 774     {
 775         if (null !== $max_size) {
 776             $size = min($max_size, $this->getChunkSize());
 777         } else {
 778             $size = $this->getChunkSize();
 779         }
 780
 781         // $result = $this->handler->getNextChunk($size);
 782         $result = '';
 783         switch ($this->getCompression()) {
 784             case 'application/bzip2':
 785                 $result = '';
 786                 while (strlen($result) < $size - 8192 && ! feof($this->getHandle())) {
 787                     $result .= bzread($this->getHandle(), $size);
 788                 }
 789                 break;
 790             case 'application/gzip':
 791                 $result = gzread($this->getHandle(), $size);
 792                 break;
 793             case 'application/zip':
 794                 include_once './libraries/unzip.lib.php';
 795                 $import_handle = new SimpleUnzip();
 796                 $import_handle->ReadFile($this->getName());
 797                 if ($import_handle->Count() == 0) {
 798                     $this->_error_message = $GLOBALS['strNoFilesFoundInZip'];
 799                     return false;
 800                 } elseif ($import_handle->GetError(0) != 0) {
 801                     $this->_error_message = $GLOBALS['strErrorInZipFile']
 802                         . ' ' . $import_handle->GetErrorMsg(0);
 803                     return false;
 804                 } else {
 805                     $result = $import_handle->GetData(0);
 806                 }
 807                 break;
 808             case 'none':
 809                 $result = fread($this->getHandle(), $size);
 810                 break;
 811             default:
 812                 return false;
 813         }
 814
 815         echo $size . ' - ';
 816         echo strlen($result) . ' - ';
 817         echo (@$GLOBALS['__len__'] += strlen($result)) . ' - ';
 818         echo $this->_error_message;
 819         echo '<hr />';
 820
 821         if ($GLOBALS['charset_conversion']) {
 822             $result = PMA_convert_string($this->getCharset(), $GLOBALS['charset'], $result);
 823         } else {
 824             /**
 825              * Skip possible byte order marks (I do not think we need more
 826              * charsets, but feel free to add more, you can use wikipedia for
 827              * reference: <http://en.wikipedia.org/wiki/Byte_Order_Mark>)
 828              *
 829              * @todo BOM could be used for charset autodetection
 830              */
 831             if ($this->getOffset() === 0) {
 832                 // UTF-8
 833                 if (strncmp($result, "\xEF\xBB\xBF", 3) == 0) {
 834                     $result = substr($result, 3);
 835                 // UTF-16 BE, LE
 836                 } elseif (strncmp($result, "\xFE\xFF", 2) == 0
 837                  || strncmp($result, "\xFF\xFE", 2) == 0) {
 838                     $result = substr($result, 2);
 839                 }
 840             }
 841         }
 842
 843         $this->_offset += $size;
 844         if (0 === $result) {
 845             return true;
 846         }
 847         return $result;
 848     }
 849
 850     function getOffset()
 851     {
 852         return $this->_offset;
 853     }
 854
 855     function getChunkSize()
 856     {
 857         return $this->_chunk_size;
 858     }
 859
 860     function setChunkSize($chunk_size)
 861     {
 862         $this->_chunk_size = (int) $chunk_size;
 863     }
 864
 865     function getContentLength()
 866     {
 867         return strlen($this->_content);
 868     }
 869
 870     function eof()
 871     {
 872         if ($this->getHandle()) {
 873             return feof($this->getHandle());
 874         } else {
 875             return ($this->getOffset() >= $this->getContentLength());
 876         }
 877
 878     }
 879 }
 880 ?>