[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * PHPExcel
   4   *
   5   * Copyright (C) 2006 - 2012 PHPExcel
   6   *
   7   * This library is free software; you can redistribute it and/or
   8   * modify it under the terms of the GNU Lesser General Public
   9   * License as published by the Free Software Foundation; either
  10   * version 2.1 of the License, or (at your option) any later version.
  11   *
  12   * This library is distributed in the hope that it will be useful,
  13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15   * Lesser General Public License for more details.
  16   *
  17   * You should have received a copy of the GNU Lesser General Public
  18   * License along with this library; if not, write to the Free Software
  19   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20   *
  21   * @category   PHPExcel
  22   * @package    PHPExcel_Shared_OLE
  23   * @copyright  Copyright (c) 2006 - 2007 Christian Schmidt
  24   * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  25   * @version 1.7.7, 2012-05-19
  26   */
  27  
  28  /**
  29   * PHPExcel_Shared_OLE_ChainedBlockStream
  30   *
  31   * Stream wrapper for reading data stored in an OLE file. Implements methods
  32   * for PHP's stream_wrapper_register(). For creating streams using this
  33   * wrapper, use PHPExcel_Shared_OLE_PPS_File::getStream().
  34   *
  35   * @category   PHPExcel
  36   * @package    PHPExcel_Shared_OLE
  37   */
  38  class PHPExcel_Shared_OLE_ChainedBlockStream
  39  {
  40      /**
  41       * The OLE container of the file that is being read.
  42       * @var OLE
  43       */
  44      public $ole;
  45  
  46      /**
  47       * Parameters specified by fopen().
  48       * @var array
  49       */
  50      public $params;
  51  
  52      /**
  53       * The binary data of the file.
  54       * @var  string
  55       */
  56      public $data;
  57  
  58      /**
  59       * The file pointer.
  60       * @var  int  byte offset
  61       */
  62      public $pos;
  63  
  64      /**
  65       * Implements support for fopen().
  66       * For creating streams using this wrapper, use OLE_PPS_File::getStream().
  67       *
  68       * @param    string    $path            resource name including scheme, e.g.
  69       *                                    ole-chainedblockstream://oleInstanceId=1
  70       * @param    string    $mode            only "r" is supported
  71       * @param    int        $options        mask of STREAM_REPORT_ERRORS and STREAM_USE_PATH
  72       * @param    string  &$openedPath    absolute path of the opened stream (out parameter)
  73       * @return    bool    true on success
  74       */
  75  	public function stream_open($path, $mode, $options, &$openedPath)
  76      {
  77          if ($mode != 'r') {
  78              if ($options & STREAM_REPORT_ERRORS) {
  79                  trigger_error('Only reading is supported', E_USER_WARNING);
  80              }
  81              return false;
  82          }
  83  
  84          // 25 is length of "ole-chainedblockstream://"
  85          parse_str(substr($path, 25), $this->params);
  86          if (!isset($this->params['oleInstanceId'],
  87                     $this->params['blockId'],
  88                     $GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']])) {
  89  
  90              if ($options & STREAM_REPORT_ERRORS) {
  91                  trigger_error('OLE stream not found', E_USER_WARNING);
  92              }
  93              return false;
  94          }
  95          $this->ole = $GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']];
  96  
  97          $blockId = $this->params['blockId'];
  98          $this->data = '';
  99          if (isset($this->params['size']) &&
 100              $this->params['size'] < $this->ole->bigBlockThreshold &&
 101              $blockId != $this->ole->root->_StartBlock) {
 102  
 103              // Block id refers to small blocks
 104              $rootPos = $this->ole->_getBlockOffset($this->ole->root->_StartBlock);
 105              while ($blockId != -2) {
 106                  $pos = $rootPos + $blockId * $this->ole->bigBlockSize;
 107                  $blockId = $this->ole->sbat[$blockId];
 108                  fseek($this->ole->_file_handle, $pos);
 109                  $this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
 110              }
 111          } else {
 112              // Block id refers to big blocks
 113              while ($blockId != -2) {
 114                  $pos = $this->ole->_getBlockOffset($blockId);
 115                  fseek($this->ole->_file_handle, $pos);
 116                  $this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
 117                  $blockId = $this->ole->bbat[$blockId];
 118              }
 119          }
 120          if (isset($this->params['size'])) {
 121              $this->data = substr($this->data, 0, $this->params['size']);
 122          }
 123  
 124          if ($options & STREAM_USE_PATH) {
 125              $openedPath = $path;
 126          }
 127  
 128          return true;
 129      }
 130  
 131      /**
 132       * Implements support for fclose().
 133       *
 134       */
 135  	public function stream_close()
 136      {
 137          $this->ole = null;
 138          unset($GLOBALS['_OLE_INSTANCES']);
 139      }
 140  
 141      /**
 142       * Implements support for fread(), fgets() etc.
 143       *
 144       * @param   int        $count    maximum number of bytes to read
 145       * @return  string
 146       */
 147  	public function stream_read($count)
 148      {
 149          if ($this->stream_eof()) {
 150              return false;
 151          }
 152          $s = substr($this->data, $this->pos, $count);
 153          $this->pos += $count;
 154          return $s;
 155      }
 156  
 157      /**
 158       * Implements support for feof().
 159       *
 160       * @return  bool  TRUE if the file pointer is at EOF; otherwise FALSE
 161       */
 162  	public function stream_eof()
 163      {
 164          $eof = $this->pos >= strlen($this->data);
 165          // Workaround for bug in PHP 5.0.x: http://bugs.php.net/27508
 166          if (version_compare(PHP_VERSION, '5.0', '>=') &&
 167              version_compare(PHP_VERSION, '5.1', '<')) {
 168  
 169             $eof = !$eof;
 170          }
 171          return $eof;
 172      }
 173  
 174      /**
 175       * Returns the position of the file pointer, i.e. its offset into the file
 176       * stream. Implements support for ftell().
 177       *
 178       * @return  int
 179       */
 180  	public function stream_tell()
 181      {
 182          return $this->pos;
 183      }
 184  
 185      /**
 186       * Implements support for fseek().
 187       *
 188       * @param    int        $offset    byte offset
 189       * @param    int        $whence    SEEK_SET, SEEK_CUR or SEEK_END
 190       * @return    bool
 191       */
 192  	public function stream_seek($offset, $whence)
 193      {
 194          if ($whence == SEEK_SET && $offset >= 0) {
 195              $this->pos = $offset;
 196          } elseif ($whence == SEEK_CUR && -$offset <= $this->pos) {
 197              $this->pos += $offset;
 198          } elseif ($whence == SEEK_END && -$offset <= sizeof($this->data)) {
 199              $this->pos = strlen($this->data) + $offset;
 200          } else {
 201              return false;
 202          }
 203          return true;
 204      }
 205  
 206      /**
 207       * Implements support for fstat(). Currently the only supported field is
 208       * "size".
 209       * @return  array
 210       */
 211  	public function stream_stat()
 212      {
 213          return array(
 214              'size' => strlen($this->data),
 215              );
 216      }
 217  
 218      // Methods used by stream_wrapper_register() that are not implemented:
 219      // bool stream_flush ( void )
 220      // int stream_write ( string data )
 221      // bool rename ( string path_from, string path_to )
 222      // bool mkdir ( string path, int mode, int options )
 223      // bool rmdir ( string path, int options )
 224      // bool dir_opendir ( string path, int options )
 225      // array url_stat ( string path, int flags )
 226      // string dir_readdir ( void )
 227      // bool dir_rewinddir ( void )
 228      // bool dir_closedir ( void )
 229  }