2
/* vim: set expandtab tabstop=4 shiftwidth=4: */
3
// +----------------------------------------------------------------------+
5
// +----------------------------------------------------------------------+
6
// | Copyright (c) 1997-2002 The PHP Group |
7
// +----------------------------------------------------------------------+
8
// | This source file is subject to version 2.02 of the PHP license, |
9
// | that is bundled with this package in the file LICENSE, and is |
10
// | available at through the world-wide-web at |
11
// | http://www.php.net/license/2_02.txt. |
12
// | If you did not receive a copy of the PHP license and are unable to |
13
// | obtain it through the world-wide-web, please send a note to |
14
// | license@php.net so we can mail you a copy immediately. |
15
// +----------------------------------------------------------------------+
16
// | Author: Xavier Noguer <xnoguer@php.net> |
17
// | Based on OLE::Storage_Lite by Kawai, Takanori |
18
// +----------------------------------------------------------------------+
20
// $Id: OLE.php,v 1.13 2007/03/07 14:38:25 schmidt Exp $
24
* Array for storing OLE instances that are accessed from
25
* OLE_ChainedBlockStream::stream_open().
28
$GLOBALS['_OLE_INSTANCES'] = array();
31
* OLE package base class.
33
* @author Xavier Noguer <xnoguer@php.net>
34
* @author Christian Schmidt <schmidt@php.net>
36
* @package PHPExcel_Shared_OLE
38
class PHPExcel_Shared_OLE
40
const OLE_PPS_TYPE_ROOT = 5;
41
const OLE_PPS_TYPE_DIR = 1;
42
const OLE_PPS_TYPE_FILE = 2;
43
const OLE_DATA_SIZE_SMALL = 0x1000;
44
const OLE_LONG_INT_SIZE = 4;
45
const OLE_PPS_SIZE = 0x80;
48
* The file handle for reading an OLE container
54
* Array of PPS's found on the OLE container
57
public $_list = array();
60
* Root directory of OLE container
66
* Big Block Allocation Table
67
* @var array (blockId => nextBlockId)
72
* Short Block Allocation Table
73
* @var array (blockId => nextBlockId)
78
* Size of big blocks. This is usually 512.
79
* @var int number of octets per block.
84
* Size of small blocks. This is usually 64.
85
* @var int number of octets per block
87
public $smallBlockSize;
90
* Reads an OLE container from the contents of the file given.
94
* @return mixed true on success, PEAR_Error on failure
96
public function read($file)
98
$fh = fopen($file, "r");
100
throw new PHPExcel_Reader_Exception("Can't open file $file");
102
$this->_file_handle = $fh;
104
$signature = fread($fh, 8);
105
if ("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1" != $signature) {
106
throw new PHPExcel_Reader_Exception("File doesn't seem to be an OLE container.");
109
if (fread($fh, 2) != "\xFE\xFF") {
110
// This shouldn't be a problem in practice
111
throw new PHPExcel_Reader_Exception("Only Little-Endian encoding is supported.");
113
// Size of blocks and short blocks in bytes
114
$this->bigBlockSize = pow(2, self::_readInt2($fh));
115
$this->smallBlockSize = pow(2, self::_readInt2($fh));
117
// Skip UID, revision number and version number
119
// Number of blocks in Big Block Allocation Table
120
$bbatBlockCount = self::_readInt4($fh);
122
// Root chain 1st block
123
$directoryFirstBlockId = self::_readInt4($fh);
127
// Streams shorter than this are stored using small blocks
128
$this->bigBlockThreshold = self::_readInt4($fh);
129
// Block id of first sector in Short Block Allocation Table
130
$sbatFirstBlockId = self::_readInt4($fh);
131
// Number of blocks in Short Block Allocation Table
132
$sbbatBlockCount = self::_readInt4($fh);
133
// Block id of first sector in Master Block Allocation Table
134
$mbatFirstBlockId = self::_readInt4($fh);
135
// Number of blocks in Master Block Allocation Table
136
$mbbatBlockCount = self::_readInt4($fh);
137
$this->bbat = array();
139
// Remaining 4 * 109 bytes of current block is beginning of Master
140
// Block Allocation Table
141
$mbatBlocks = array();
142
for ($i = 0; $i < 109; ++$i) {
143
$mbatBlocks[] = self::_readInt4($fh);
146
// Read rest of Master Block Allocation Table (if any is left)
147
$pos = $this->_getBlockOffset($mbatFirstBlockId);
148
for ($i = 0; $i < $mbbatBlockCount; ++$i) {
150
for ($j = 0; $j < $this->bigBlockSize / 4 - 1; ++$j) {
151
$mbatBlocks[] = self::_readInt4($fh);
153
// Last block id in each block points to next block
154
$pos = $this->_getBlockOffset(self::_readInt4($fh));
157
// Read Big Block Allocation Table according to chain specified by
159
for ($i = 0; $i < $bbatBlockCount; ++$i) {
160
$pos = $this->_getBlockOffset($mbatBlocks[$i]);
162
for ($j = 0; $j < $this->bigBlockSize / 4; ++$j) {
163
$this->bbat[] = self::_readInt4($fh);
167
// Read short block allocation table (SBAT)
168
$this->sbat = array();
169
$shortBlockCount = $sbbatBlockCount * $this->bigBlockSize / 4;
170
$sbatFh = $this->getStream($sbatFirstBlockId);
171
for ($blockId = 0; $blockId < $shortBlockCount; ++$blockId) {
172
$this->sbat[$blockId] = self::_readInt4($sbatFh);
176
$this->_readPpsWks($directoryFirstBlockId);
182
* @param int block id
183
* @param int byte offset from beginning of file
186
public function _getBlockOffset($blockId)
188
return 512 + $blockId * $this->bigBlockSize;
192
* Returns a stream for use with fread() etc. External callers should
193
* use PHPExcel_Shared_OLE_PPS_File::getStream().
194
* @param int|PPS block id or PPS
195
* @return resource read-only stream
197
public function getStream($blockIdOrPps)
199
static $isRegistered = false;
200
if (!$isRegistered) {
201
stream_wrapper_register('ole-chainedblockstream', 'PHPExcel_Shared_OLE_ChainedBlockStream');
202
$isRegistered = true;
205
// Store current instance in global array, so that it can be accessed
206
// in OLE_ChainedBlockStream::stream_open().
207
// Object is removed from self::$instances in OLE_Stream::close().
208
$GLOBALS['_OLE_INSTANCES'][] = $this;
209
$instanceId = end(array_keys($GLOBALS['_OLE_INSTANCES']));
211
$path = 'ole-chainedblockstream://oleInstanceId=' . $instanceId;
212
if ($blockIdOrPps instanceof PHPExcel_Shared_OLE_PPS) {
213
$path .= '&blockId=' . $blockIdOrPps->_StartBlock;
214
$path .= '&size=' . $blockIdOrPps->Size;
216
$path .= '&blockId=' . $blockIdOrPps;
218
return fopen($path, 'r');
222
* Reads a signed char.
223
* @param resource file handle
227
private static function _readInt1($fh)
229
list(, $tmp) = unpack("c", fread($fh, 1));
234
* Reads an unsigned short (2 octets).
235
* @param resource file handle
239
private static function _readInt2($fh)
241
list(, $tmp) = unpack("v", fread($fh, 2));
246
* Reads an unsigned long (4 octets).
247
* @param resource file handle
251
private static function _readInt4($fh)
253
list(, $tmp) = unpack("V", fread($fh, 4));
258
* Gets information about all PPS's on the OLE container from the PPS WK's
259
* creates an OLE_PPS object for each one.
262
* @param integer the block id of the first block
263
* @return mixed true on success, PEAR_Error on failure
265
public function _readPpsWks($blockId)
267
$fh = $this->getStream($blockId);
268
for ($pos = 0;; $pos += 128) {
269
fseek($fh, $pos, SEEK_SET);
270
$nameUtf16 = fread($fh, 64);
271
$nameLength = self::_readInt2($fh);
272
$nameUtf16 = substr($nameUtf16, 0, $nameLength - 2);
273
// Simple conversion from UTF-16LE to ISO-8859-1
274
$name = str_replace("\x00", "", $nameUtf16);
275
$type = self::_readInt1($fh);
277
case self::OLE_PPS_TYPE_ROOT:
278
$pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
281
case self::OLE_PPS_TYPE_DIR:
282
$pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null, null, null, null, null, array());
284
case self::OLE_PPS_TYPE_FILE:
285
$pps = new PHPExcel_Shared_OLE_PPS_File($name);
290
fseek($fh, 1, SEEK_CUR);
293
$pps->PrevPps = self::_readInt4($fh);
294
$pps->NextPps = self::_readInt4($fh);
295
$pps->DirPps = self::_readInt4($fh);
296
fseek($fh, 20, SEEK_CUR);
297
$pps->Time1st = self::OLE2LocalDate(fread($fh, 8));
298
$pps->Time2nd = self::OLE2LocalDate(fread($fh, 8));
299
$pps->_StartBlock = self::_readInt4($fh);
300
$pps->Size = self::_readInt4($fh);
301
$pps->No = count($this->_list);
302
$this->_list[] = $pps;
304
// check if the PPS tree (starting from root) is complete
305
if (isset($this->root) && $this->_ppsTreeComplete($this->root->No)) {
311
// Initialize $pps->children on directories
312
foreach ($this->_list as $pps) {
313
if ($pps->Type == self::OLE_PPS_TYPE_DIR || $pps->Type == self::OLE_PPS_TYPE_ROOT) {
314
$nos = array($pps->DirPps);
315
$pps->children = array();
317
$no = array_pop($nos);
319
$childPps = $this->_list[$no];
320
$nos[] = $childPps->PrevPps;
321
$nos[] = $childPps->NextPps;
322
$pps->children[] = $childPps;
332
* It checks whether the PPS tree is complete (all PPS's read)
333
* starting with the given PPS (not necessarily root)
336
* @param integer $index The index of the PPS from which we are checking
337
* @return boolean Whether the PPS tree for the given PPS is complete
339
public function _ppsTreeComplete($index)
341
return isset($this->_list[$index]) &&
342
($pps = $this->_list[$index]) &&
343
($pps->PrevPps == -1 ||
344
$this->_ppsTreeComplete($pps->PrevPps)) &&
345
($pps->NextPps == -1 ||
346
$this->_ppsTreeComplete($pps->NextPps)) &&
347
($pps->DirPps == -1 ||
348
$this->_ppsTreeComplete($pps->DirPps));
352
* Checks whether a PPS is a File PPS or not.
353
* If there is no PPS for the index given, it will return false.
356
* @param integer $index The index for the PPS
357
* @return bool true if it's a File PPS, false otherwise
359
public function isFile($index)
361
if (isset($this->_list[$index])) {
362
return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_FILE);
368
* Checks whether a PPS is a Root PPS or not.
369
* If there is no PPS for the index given, it will return false.
372
* @param integer $index The index for the PPS.
373
* @return bool true if it's a Root PPS, false otherwise
375
public function isRoot($index)
377
if (isset($this->_list[$index])) {
378
return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_ROOT);
384
* Gives the total number of PPS's found in the OLE container.
387
* @return integer The total number of PPS's found in the OLE container
389
public function ppsTotal()
391
return count($this->_list);
395
* Gets data from a PPS
396
* If there is no PPS for the index given, it will return an empty string.
399
* @param integer $index The index for the PPS
400
* @param integer $position The position from which to start reading
401
* (relative to the PPS)
402
* @param integer $length The amount of bytes to read (at most)
403
* @return string The binary string containing the data requested
404
* @see OLE_PPS_File::getStream()
406
public function getData($index, $position, $length)
408
// if position is not valid return empty string
409
if (!isset($this->_list[$index]) || ($position >= $this->_list[$index]->Size) || ($position < 0)) {
412
$fh = $this->getStream($this->_list[$index]);
413
$data = stream_get_contents($fh, $length, $position);
419
* Gets the data length from a PPS
420
* If there is no PPS for the index given, it will return 0.
423
* @param integer $index The index for the PPS
424
* @return integer The amount of bytes in data the PPS has
426
public function getDataLength($index)
428
if (isset($this->_list[$index])) {
429
return $this->_list[$index]->Size;
435
* Utility function to transform ASCII text to Unicode
439
* @param string $ascii The ASCII string to transform
440
* @return string The string in Unicode
442
public static function Asc2Ucs($ascii)
445
for ($i = 0; $i < strlen($ascii); ++$i) {
446
$rawname .= $ascii{$i} . "\x00";
453
* Returns a string for the OLE container with the date given
457
* @param integer $date A timestamp
458
* @return string The string for the OLE container
460
public static function LocalDate2OLE($date = null)
463
return "\x00\x00\x00\x00\x00\x00\x00\x00";
466
// factor used for separating numbers into 4 bytes parts
467
$factor = pow(2, 32);
469
// days from 1-1-1601 until the beggining of UNIX era
472
$big_date = $days*24*3600 + gmmktime(date("H", $date), date("i", $date), date("s", $date), date("m", $date), date("d", $date), date("Y", $date));
473
// multiply just to make MS happy
474
$big_date *= 10000000;
476
$high_part = floor($big_date / $factor);
478
$low_part = floor((($big_date / $factor) - $high_part) * $factor);
483
for ($i = 0; $i < 4; ++$i) {
484
$hex = $low_part % 0x100;
485
$res .= pack('c', $hex);
488
for ($i = 0; $i < 4; ++$i) {
489
$hex = $high_part % 0x100;
490
$res .= pack('c', $hex);
497
* Returns a timestamp from an OLE container's date
501
* @param integer $string A binary string with the encoded date
502
* @return string The timestamp corresponding to the string
504
public static function OLE2LocalDate($string)
506
if (strlen($string) != 8) {
507
return new PEAR_Error("Expecting 8 byte string");
510
// factor used for separating numbers into 4 bytes parts
511
$factor = pow(2, 32);
512
list(, $high_part) = unpack('V', substr($string, 4, 4));
513
list(, $low_part) = unpack('V', substr($string, 0, 4));
515
$big_date = ($high_part * $factor) + $low_part;
516
// translate to seconds
517
$big_date /= 10000000;
519
// days from 1-1-1601 until the beggining of UNIX era
522
// translate to seconds from beggining of UNIX era
523
$big_date -= $days * 24 * 3600;
524
return floor($big_date);
added
removed
tools/PHPExcel/PHPExcel/Shared/OLE.php
