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