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         $this->setName(PMA_userDir($GLOBALS['cfg']['UploadDir']) . PMA_securePath($name));
 470         if (! $this->isReadable()) {
 471             $this->_error_message = $GLOBALS['strFileCouldNotBeRead'];
 472             $this->setName(null);
 473             return false;
 474         }
 475
 476         return true;
 477     }
 478
 479     /**
 480      * @access  public
 481      * @uses    PMA_File::getName()
 482      * @uses    is_readable()
 483      * @uses    ob_start()
 484      * @uses    ob_end_clean()
 485      * @return  boolean whether the file is readable or not
 486      */
 487     function isReadable()
 488     {
 489         // surpress warnings from beeing displayed, but not from beeing logged
 490         // any file access outside of open_basedir will issue a warning
 491         ob_start();
 492         $is_readable = is_readable($this->getName());
 493         ob_end_clean();
 494         return $is_readable;
 495     }
 496
 497     /**
 498      * If we are on a server with open_basedir, we must move the file
 499      * before opening it. The FAQ 1.11 explains how to create the "./tmp"
 500      * directory - if needed
 501      *
 502      * @todo replace error message with localized string
 503      * @todo move check of $cfg['TempDir'] into PMA_Config?
 504      * @access  public
 505      * @uses    $cfg['TempDir']
 506      * @uses    $GLOBALS['strFieldInsertFromFileTempDirNotExists']
 507      * @uses    PMA_File::isReadable()
 508      * @uses    PMA_File::getName()
 509      * @uses    PMA_File::setName()
 510      * @uses    PMA_File::isTemp()
 511      * @uses    PMA_File::$_error_message
 512      * @uses    is_dir()
 513      * @uses    mkdir()
 514      * @uses    chmod()
 515      * @uses    is_writable()
 516      * @uses    basename()
 517      * @uses    move_uploaded_file()
 518      * @uses    ob_start()
 519      * @uses    ob_end_clean()
 520      * @return  boolean whether uploaded fiel is fine or not
 521      */
 522     function checkUploadedFile()
 523     {
 524         if ($this->isReadable()) {
 525             return true;
 526         }
 527
 528         /**
 529          * it is not important if open_basedir is set - we just cannot read the file
 530          * so we try to move it
 531         if ('' != ini_get('open_basedir')) {
 532          */
 533
 534         // check tmp dir config
 535         if (empty($GLOBALS['cfg']['TempDir'])) {
 536             $GLOBALS['cfg']['TempDir'] = 'tmp/';
 537         }
 538
 539         // surpress warnings from beeing displayed, but not from beeing logged
 540         ob_start();
 541         // check tmp dir
 542         if (! is_dir($GLOBALS['cfg']['TempDir'])) {
 543             // try to create the tmp directory
 544             if (@mkdir($GLOBALS['cfg']['TempDir'], 0777)) {
 545                 chmod($GLOBALS['cfg']['TempDir'], 0777);
 546             } else {
 547                 // create tmp dir failed
 548                 $this->_error_message = $GLOBALS['strFieldInsertFromFileTempDirNotExists'];
 549                 ob_end_clean();
 550                 return false;
 551             }
 552         }
 553         ob_end_clean();
 554
 555         if (! is_writable($GLOBALS['cfg']['TempDir'])) {
 556             // cannot create directory or access, point user to FAQ 1.11
 557             $this->_error_message = $GLOBALS['strFieldInsertFromFileTempDirNotExists'];
 558             return false;
 559         }
 560
 561         $new_file_to_upload = $GLOBALS['cfg']['TempDir'] . '/' . basename($this->getName());
 562
 563         // surpress warnings from beeing displayed, but not from beeing logged
 564         // any file access outside of open_basedir will issue a warning
 565         ob_start();
 566         $move_uploaded_file_result = move_uploaded_file($this->getName(), $new_file_to_upload);
 567         ob_end_clean();
 568         if (! $move_uploaded_file_result) {
 569             $this->_error_message = 'error while moving uploaded file';
 570             return false;
 571         }
 572
 573         $this->setName($new_file_to_upload);
 574         $this->isTemp(true);
 575
 576         if (! $this->isReadable()) {
 577             $this->_error_message = 'cannot read (moved) upload file';
 578             return false;
 579         }
 580
 581         return true;
 582     }
 583
 584     /**
 585      * Detects what compression filse uses
 586      *
 587      * @todo    move file read part into readChunk() or getChunk()
 588      * @todo    add support for compression plugins
 589      * @uses    $GLOBALS['strFileCouldNotBeRead']
 590      * @uses    PMA_File::$_compression to set it
 591      * @uses    PMA_File::getName()
 592      * @uses    fopen()
 593      * @uses    fread()
 594      * @uses    strlen()
 595      * @uses    fclose()
 596      * @uses    chr()
 597      * @uses    substr()
 598      * @access  protected
 599      * @return  string MIME type of compression, none for none
 600      */
 601     function _detectCompression()
 602     {
 603         // surpress warnings from beeing displayed, but not from beeing logged
 604         // f.e. any file access outside of open_basedir will issue a warning
 605         ob_start();
 606         $file = fopen($this->getName(), 'rb');
 607         ob_end_clean();
 608
 609         if (! $file) {
 610             $this->_error_message = $GLOBALS['strFileCouldNotBeRead'];
 611             return false;
 612         }
 613
 614         /**
 615          * @todo
 616          * get registered plugins for file compression
 617
 618         foreach (PMA_getPlugins($type = 'compression') as $plugin) {
 619             if (call_user_func_array(array($plugin['classname'], 'canHandle'), array($this->getName()))) {
 620                 $this->setCompressionPlugin($plugin);
 621                 break;
 622             }
 623         }
 624          */
 625
 626         $test = fread($file, 4);
 627         $len = strlen($test);
 628         fclose($file);
 629
 630         if ($len >= 2 && $test[0] == chr(31) && $test[1] == chr(139)) {
 631             $this->_compression = 'application/gzip';
 632         } elseif ($len >= 3 && substr($test, 0, 3) == 'BZh') {
 633             $this->_compression = 'application/bzip2';
 634         } elseif ($len >= 4 && $test == "PK\003\004") {
 635             $this->_compression = 'application/zip';
 636         } else {
 637             $this->_compression = 'none';
 638         }
 639
 640         return $this->_compression;
 641     }
 642
 643     /**
 644      * whether the content should be decompressed before returned
 645      */
 646     function setDecompressContent($decompress)
 647     {
 648         $this->_decompress = (bool) $decompress;
 649     }
 650
 651     function getHandle()
 652     {
 653         if (null === $this->_handle) {
 654             $this->open();
 655         }
 656         return $this->_handle;
 657     }
 658
 659     function setHandle($handle)
 660     {
 661         $this->_handle = $handle;
 662     }
 663
 664     /**
 665      *
 666      */
 667     function open()
 668     {
 669         if (! $this->_decompress) {
 670             $this->_handle = @fopen($this->getName(), 'r');
 671         }
 672
 673         switch ($this->getCompression()) {
 674             case false:
 675                 return false;
 676             case 'application/bzip2':
 677                 if ($GLOBALS['cfg']['BZipDump'] && @function_exists('bzopen')) {
 678                     $this->_handle = @bzopen($this->getName(), 'r');
 679                 } else {
 680                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 681                     return false;
 682                 }
 683                 break;
 684             case 'application/gzip':
 685                 if ($GLOBALS['cfg']['GZipDump'] && @function_exists('gzopen')) {
 686                     $this->_handle = @gzopen($this->getName(), 'r');
 687                 } else {
 688                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 689                     return false;
 690                 }
 691                 break;
 692             case 'application/zip':
 693                 if ($GLOBALS['cfg']['GZipDump'] && @function_exists('gzinflate')) {
 694                     include_once './libraries/unzip.lib.php';
 695                     $this->_handle = new SimpleUnzip();
 696                     $this->_handle->ReadFile($this->getName());
 697                     if ($this->_handle->Count() == 0) {
 698                         $this->_error_message = $GLOBALS['strNoFilesFoundInZip'];
 699                         return false;
 700                     } elseif ($this->_handle->GetError(0) != 0) {
 701                         $this->_error_message = $GLOBALS['strErrorInZipFile'] . ' ' . $this->_handle->GetErrorMsg(0);
 702                         return false;
 703                     } else {
 704                         $this->content_uncompressed = $this->_handle->GetData(0);
 705                     }
 706                     // We don't need to store it further
 707                     $this->_handle = null;
 708                 } else {
 709                     $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 710                     return false;
 711                 }
 712                 break;
 713             case 'none':
 714                 $this->_handle = @fopen($this->getName(), 'r');
 715                 break;
 716             default:
 717                 $this->_error_message = sprintf($GLOBALS['strUnsupportedCompressionDetected'], $this->getCompression());
 718                 return false;
 719                 break;
 720         }
 721
 722
 723     }
 724
 725     function getCharset()
 726     {
 727         return $this->_charset;
 728     }
 729
 730     function setCharset($charset)
 731     {
 732         $this->_charset = $charset;
 733     }
 734
 735     /**
 736      * @uses    PMA_File::$_compression as return value
 737      * @uses    PMA_File::detectCompression()
 738      * @return  string MIME type of compression, none for none
 739      * @access  public
 740      */
 741     function getCompression()
 742     {
 743         if (null === $this->_compression) {
 744             return $this->_detectCompression();
 745         }
 746
 747         return $this->_compression;
 748     }
 749
 750     /**
 751      * advances the file pointer in the file handle by $length bytes/chars
 752      *
 753      * @param   integer $length numbers of chars/bytes to skip
 754      * @return  boolean
 755      */
 756     function advanceFilePointer($length)
 757     {
 758         while ($length > 0) {
 759             // Disable read progresivity, otherwise we eat all memory!
 760             $read_multiply = 1; // required?
 761             $this->getNextChunk($length);
 762             $length -= $this->getChunkSize();
 763         }
 764     }
 765
 766     /**
 767      * http://bugs.php.net/bug.php?id=29532
 768      * bzip reads a maximum of 8192 bytes on windows systems
 769      *
 770      */
 771     function getNextChunk($max_size = null)
 772     {
 773         if (null !== $max_size) {
 774             $size = min($max_size, $this->getChunkSize());
 775         } else {
 776             $size = $this->getChunkSize();
 777         }
 778
 779         // $result = $this->handler->getNextChunk($size);
 780         $result = '';
 781         switch ($this->getCompression()) {
 782             case 'application/bzip2':
 783                 $result = '';
 784                 while (strlen($result) < $size - 8192 && ! feof($this->getHandle())) {
 785                     $result .= bzread($this->getHandle(), $size);
 786                 }
 787                 break;
 788             case 'application/gzip':
 789                 $result = gzread($this->getHandle(), $size);
 790                 break;
 791             case 'application/zip':
 792                 include_once './libraries/unzip.lib.php';
 793                 $import_handle = new SimpleUnzip();
 794                 $import_handle->ReadFile($this->getName());
 795                 if ($import_handle->Count() == 0) {
 796                     $this->_error_message = $GLOBALS['strNoFilesFoundInZip'];
 797                     return false;
 798                 } elseif ($import_handle->GetError(0) != 0) {
 799                     $this->_error_message = $GLOBALS['strErrorInZipFile']
 800                         . ' ' . $import_handle->GetErrorMsg(0);
 801                     return false;
 802                 } else {
 803                     $result = $import_handle->GetData(0);
 804                 }
 805                 break;
 806             case 'none':
 807                 $result = fread($this->getHandle(), $size);
 808                 break;
 809             default:
 810                 return false;
 811         }
 812
 813         echo $size . ' - ';
 814         echo strlen($result) . ' - ';
 815         echo (@$GLOBALS['__len__'] += strlen($result)) . ' - ';
 816         echo $this->_error_message;
 817         echo '<hr />';
 818
 819         if ($GLOBALS['charset_conversion']) {
 820             $result = PMA_convert_string($this->getCharset(), $GLOBALS['charset'], $result);
 821         } else {
 822             /**
 823              * Skip possible byte order marks (I do not think we need more
 824              * charsets, but feel free to add more, you can use wikipedia for
 825              * reference: <http://en.wikipedia.org/wiki/Byte_Order_Mark>)
 826              *
 827              * @todo BOM could be used for charset autodetection
 828              */
 829             if ($this->getOffset() === 0) {
 830                 // UTF-8
 831                 if (strncmp($result, "\xEF\xBB\xBF", 3) == 0) {
 832                     $result = substr($result, 3);
 833                 // UTF-16 BE, LE
 834                 } elseif (strncmp($result, "\xFE\xFF", 2) == 0
 835                  || strncmp($result, "\xFF\xFE", 2) == 0) {
 836                     $result = substr($result, 2);
 837                 }
 838             }
 839         }
 840
 841         $this->_offset += $size;
 842         if (0 === $result) {
 843             return true;
 844         }
 845         return $result;
 846     }
 847
 848     function getOffset()
 849     {
 850         return $this->_offset;
 851     }
 852
 853     function getChunkSize()
 854     {
 855         return $this->_chunk_size;
 856     }
 857
 858     function setChunkSize($chunk_size)
 859     {
 860         $this->_chunk_size = (int) $chunk_size;
 861     }
 862
 863     function getContentLength()
 864     {
 865         return strlen($this->_content);
 866     }
 867
 868     function eof()
 869     {
 870         if ($this->getHandle()) {
 871             return feof($this->getHandle());
 872         } else {
 873             return ($this->getOffset() >= $this->getContentLength());
 874         }
 875
 876     }
 877 }
 878 ?>