Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2388 jpm 1
<?php
2
/* vim: set expandtab tabstop=4 shiftwidth=4: */
3
// +----------------------------------------------------------------------+
4
// | PHP Version 4                                                        |
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
// +----------------------------------------------------------------------+
19
//
20
// $Id: OLE.php,v 1.13 2007/03/07 14:38:25 schmidt Exp $
21
 
22
 
23
/**
24
* Array for storing OLE instances that are accessed from
25
* OLE_ChainedBlockStream::stream_open().
26
* @var  array
27
*/
28
$GLOBALS['_OLE_INSTANCES'] = array();
29
 
30
/**
31
* OLE package base class.
32
*
33
* @author   Xavier Noguer <xnoguer@php.net>
34
* @author   Christian Schmidt <schmidt@php.net>
35
* @category   PHPExcel
36
* @package    PHPExcel_Shared_OLE
37
*/
38
class PHPExcel_Shared_OLE
39
{
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;
46
 
47
	/**
48
	 * The file handle for reading an OLE container
49
	 * @var resource
50
	*/
51
	public $_file_handle;
52
 
53
	/**
54
	* Array of PPS's found on the OLE container
55
	* @var array
56
	*/
57
	public $_list = array();
58
 
59
	/**
60
	 * Root directory of OLE container
61
	 * @var OLE_PPS_Root
62
	*/
63
	public $root;
64
 
65
	/**
66
	 * Big Block Allocation Table
67
	 * @var array  (blockId => nextBlockId)
68
	*/
69
	public $bbat;
70
 
71
	/**
72
	 * Short Block Allocation Table
73
	 * @var array  (blockId => nextBlockId)
74
	*/
75
	public $sbat;
76
 
77
	/**
78
	 * Size of big blocks. This is usually 512.
79
	 * @var  int  number of octets per block.
80
	*/
81
	public $bigBlockSize;
82
 
83
	/**
84
	 * Size of small blocks. This is usually 64.
85
	 * @var  int  number of octets per block
86
	*/
87
	public $smallBlockSize;
88
 
89
	/**
90
	 * Reads an OLE container from the contents of the file given.
91
	 *
92
	 * @acces public
93
	 * @param string $file
94
	 * @return mixed true on success, PEAR_Error on failure
95
	*/
96
	public function read($file)
97
	{
98
		$fh = fopen($file, "r");
99
		if (!$fh) {
100
			throw new PHPExcel_Reader_Exception("Can't open file $file");
101
		}
102
		$this->_file_handle = $fh;
103
 
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.");
107
		}
108
		fseek($fh, 28);
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.");
112
		}
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));
116
 
117
		// Skip UID, revision number and version number
118
		fseek($fh, 44);
119
		// Number of blocks in Big Block Allocation Table
120
		$bbatBlockCount = self::_readInt4($fh);
121
 
122
		// Root chain 1st block
123
		$directoryFirstBlockId = self::_readInt4($fh);
124
 
125
		// Skip unused bytes
126
		fseek($fh, 56);
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();
138
 
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);
144
		}
145
 
146
		// Read rest of Master Block Allocation Table (if any is left)
147
		$pos = $this->_getBlockOffset($mbatFirstBlockId);
148
		for ($i = 0; $i < $mbbatBlockCount; ++$i) {
149
			fseek($fh, $pos);
150
			for ($j = 0; $j < $this->bigBlockSize / 4 - 1; ++$j) {
151
				$mbatBlocks[] = self::_readInt4($fh);
152
			}
153
			// Last block id in each block points to next block
154
			$pos = $this->_getBlockOffset(self::_readInt4($fh));
155
		}
156
 
157
		// Read Big Block Allocation Table according to chain specified by
158
		// $mbatBlocks
159
		for ($i = 0; $i < $bbatBlockCount; ++$i) {
160
			$pos = $this->_getBlockOffset($mbatBlocks[$i]);
161
			fseek($fh, $pos);
162
			for ($j = 0 ; $j < $this->bigBlockSize / 4; ++$j) {
163
				$this->bbat[] = self::_readInt4($fh);
164
			}
165
		}
166
 
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);
173
		}
174
		fclose($sbatFh);
175
 
176
		$this->_readPpsWks($directoryFirstBlockId);
177
 
178
		return true;
179
	}
180
 
181
	/**
182
	 * @param  int  block id
183
	 * @param  int  byte offset from beginning of file
184
	 * @access public
185
	 */
186
	public function _getBlockOffset($blockId)
187
	{
188
		return 512 + $blockId * $this->bigBlockSize;
189
	}
190
 
191
	/**
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
196
	*/
197
	public function getStream($blockIdOrPps)
198
	{
199
		static $isRegistered = false;
200
		if (!$isRegistered) {
201
			stream_wrapper_register('ole-chainedblockstream',
202
				'PHPExcel_Shared_OLE_ChainedBlockStream');
203
			$isRegistered = true;
204
		}
205
 
206
		// Store current instance in global array, so that it can be accessed
207
		// in OLE_ChainedBlockStream::stream_open().
208
		// Object is removed from self::$instances in OLE_Stream::close().
209
		$GLOBALS['_OLE_INSTANCES'][] = $this;
210
		$instanceId = end(array_keys($GLOBALS['_OLE_INSTANCES']));
211
 
212
		$path = 'ole-chainedblockstream://oleInstanceId=' . $instanceId;
213
		if ($blockIdOrPps instanceof PHPExcel_Shared_OLE_PPS) {
214
			$path .= '&blockId=' . $blockIdOrPps->_StartBlock;
215
			$path .= '&size=' . $blockIdOrPps->Size;
216
		} else {
217
			$path .= '&blockId=' . $blockIdOrPps;
218
		}
219
		return fopen($path, 'r');
220
	}
221
 
222
	/**
223
	 * Reads a signed char.
224
	 * @param   resource  file handle
225
	 * @return  int
226
	 * @access public
227
	 */
228
	private static function _readInt1($fh)
229
	{
230
		list(, $tmp) = unpack("c", fread($fh, 1));
231
		return $tmp;
232
	}
233
 
234
	/**
235
	 * Reads an unsigned short (2 octets).
236
	 * @param   resource  file handle
237
	 * @return  int
238
	 * @access public
239
	 */
240
	private static function _readInt2($fh)
241
	{
242
		list(, $tmp) = unpack("v", fread($fh, 2));
243
		return $tmp;
244
	}
245
 
246
	/**
247
	 * Reads an unsigned long (4 octets).
248
	 * @param   resource  file handle
249
	 * @return  int
250
	 * @access public
251
	 */
252
	private static function _readInt4($fh)
253
	{
254
		list(, $tmp) = unpack("V", fread($fh, 4));
255
		return $tmp;
256
	}
257
 
258
	/**
259
	* Gets information about all PPS's on the OLE container from the PPS WK's
260
	* creates an OLE_PPS object for each one.
261
	*
262
	* @access public
263
	* @param  integer  the block id of the first block
264
	* @return mixed true on success, PEAR_Error on failure
265
	*/
266
	public function _readPpsWks($blockId)
267
	{
268
		$fh = $this->getStream($blockId);
269
		for ($pos = 0; ; $pos += 128) {
270
			fseek($fh, $pos, SEEK_SET);
271
			$nameUtf16 = fread($fh, 64);
272
			$nameLength = self::_readInt2($fh);
273
			$nameUtf16 = substr($nameUtf16, 0, $nameLength - 2);
274
			// Simple conversion from UTF-16LE to ISO-8859-1
275
			$name = str_replace("\x00", "", $nameUtf16);
276
			$type = self::_readInt1($fh);
277
			switch ($type) {
278
			case self::OLE_PPS_TYPE_ROOT:
279
				$pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
280
				$this->root = $pps;
281
				break;
282
			case self::OLE_PPS_TYPE_DIR:
283
				$pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null,
284
								   null, null, null, null, array());
285
				break;
286
			case self::OLE_PPS_TYPE_FILE:
287
				$pps = new PHPExcel_Shared_OLE_PPS_File($name);
288
				break;
289
			default:
290
				continue;
291
			}
292
			fseek($fh, 1, SEEK_CUR);
293
			$pps->Type    = $type;
294
			$pps->Name    = $name;
295
			$pps->PrevPps = self::_readInt4($fh);
296
			$pps->NextPps = self::_readInt4($fh);
297
			$pps->DirPps  = self::_readInt4($fh);
298
			fseek($fh, 20, SEEK_CUR);
299
			$pps->Time1st = self::OLE2LocalDate(fread($fh, 8));
300
			$pps->Time2nd = self::OLE2LocalDate(fread($fh, 8));
301
			$pps->_StartBlock = self::_readInt4($fh);
302
			$pps->Size = self::_readInt4($fh);
303
			$pps->No = count($this->_list);
304
			$this->_list[] = $pps;
305
 
306
			// check if the PPS tree (starting from root) is complete
307
			if (isset($this->root) &&
308
				$this->_ppsTreeComplete($this->root->No)) {
309
 
310
				break;
311
			}
312
		}
313
		fclose($fh);
314
 
315
		// Initialize $pps->children on directories
316
		foreach ($this->_list as $pps) {
317
			if ($pps->Type == self::OLE_PPS_TYPE_DIR || $pps->Type == self::OLE_PPS_TYPE_ROOT) {
318
				$nos = array($pps->DirPps);
319
				$pps->children = array();
320
				while ($nos) {
321
					$no = array_pop($nos);
322
					if ($no != -1) {
323
						$childPps = $this->_list[$no];
324
						$nos[] = $childPps->PrevPps;
325
						$nos[] = $childPps->NextPps;
326
						$pps->children[] = $childPps;
327
					}
328
				}
329
			}
330
		}
331
 
332
		return true;
333
	}
334
 
335
	/**
336
	* It checks whether the PPS tree is complete (all PPS's read)
337
	* starting with the given PPS (not necessarily root)
338
	*
339
	* @access public
340
	* @param integer $index The index of the PPS from which we are checking
341
	* @return boolean Whether the PPS tree for the given PPS is complete
342
	*/
343
	public function _ppsTreeComplete($index)
344
	{
345
		return isset($this->_list[$index]) &&
346
			   ($pps = $this->_list[$index]) &&
347
			   ($pps->PrevPps == -1 ||
348
				$this->_ppsTreeComplete($pps->PrevPps)) &&
349
			   ($pps->NextPps == -1 ||
350
				$this->_ppsTreeComplete($pps->NextPps)) &&
351
			   ($pps->DirPps == -1 ||
352
				$this->_ppsTreeComplete($pps->DirPps));
353
	}
354
 
355
	/**
356
	* Checks whether a PPS is a File PPS or not.
357
	* If there is no PPS for the index given, it will return false.
358
	*
359
	* @access public
360
	* @param integer $index The index for the PPS
361
	* @return bool true if it's a File PPS, false otherwise
362
	*/
363
	public function isFile($index)
364
	{
365
		if (isset($this->_list[$index])) {
366
			return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_FILE);
367
		}
368
		return false;
369
	}
370
 
371
	/**
372
	* Checks whether a PPS is a Root PPS or not.
373
	* If there is no PPS for the index given, it will return false.
374
	*
375
	* @access public
376
	* @param integer $index The index for the PPS.
377
	* @return bool true if it's a Root PPS, false otherwise
378
	*/
379
	public function isRoot($index)
380
	{
381
		if (isset($this->_list[$index])) {
382
			return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_ROOT);
383
		}
384
		return false;
385
	}
386
 
387
	/**
388
	* Gives the total number of PPS's found in the OLE container.
389
	*
390
	* @access public
391
	* @return integer The total number of PPS's found in the OLE container
392
	*/
393
	public function ppsTotal()
394
	{
395
		return count($this->_list);
396
	}
397
 
398
	/**
399
	* Gets data from a PPS
400
	* If there is no PPS for the index given, it will return an empty string.
401
	*
402
	* @access public
403
	* @param integer $index    The index for the PPS
404
	* @param integer $position The position from which to start reading
405
	*                          (relative to the PPS)
406
	* @param integer $length   The amount of bytes to read (at most)
407
	* @return string The binary string containing the data requested
408
	* @see OLE_PPS_File::getStream()
409
	*/
410
	public function getData($index, $position, $length)
411
	{
412
		// if position is not valid return empty string
413
		if (!isset($this->_list[$index]) || ($position >= $this->_list[$index]->Size) || ($position < 0)) {
414
			return '';
415
		}
416
		$fh = $this->getStream($this->_list[$index]);
417
		$data = stream_get_contents($fh, $length, $position);
418
		fclose($fh);
419
		return $data;
420
	}
421
 
422
	/**
423
	* Gets the data length from a PPS
424
	* If there is no PPS for the index given, it will return 0.
425
	*
426
	* @access public
427
	* @param integer $index    The index for the PPS
428
	* @return integer The amount of bytes in data the PPS has
429
	*/
430
	public function getDataLength($index)
431
	{
432
		if (isset($this->_list[$index])) {
433
			return $this->_list[$index]->Size;
434
		}
435
		return 0;
436
	}
437
 
438
	/**
439
	* Utility function to transform ASCII text to Unicode
440
	*
441
	* @access public
442
	* @static
443
	* @param string $ascii The ASCII string to transform
444
	* @return string The string in Unicode
445
	*/
446
	public static function Asc2Ucs($ascii)
447
	{
448
		$rawname = '';
449
		for ($i = 0; $i < strlen($ascii); ++$i) {
450
			$rawname .= $ascii{$i} . "\x00";
451
		}
452
		return $rawname;
453
	}
454
 
455
	/**
456
	* Utility function
457
	* Returns a string for the OLE container with the date given
458
	*
459
	* @access public
460
	* @static
461
	* @param integer $date A timestamp
462
	* @return string The string for the OLE container
463
	*/
464
	public static function LocalDate2OLE($date = null)
465
	{
466
		if (!isset($date)) {
467
			return "\x00\x00\x00\x00\x00\x00\x00\x00";
468
		}
469
 
470
		// factor used for separating numbers into 4 bytes parts
471
		$factor = pow(2, 32);
472
 
473
		// days from 1-1-1601 until the beggining of UNIX era
474
		$days = 134774;
475
		// calculate seconds
476
		$big_date = $days*24*3600 + gmmktime(date("H",$date),date("i",$date),date("s",$date),
477
											 date("m",$date),date("d",$date),date("Y",$date));
478
		// multiply just to make MS happy
479
		$big_date *= 10000000;
480
 
481
		$high_part = floor($big_date / $factor);
482
		// lower 4 bytes
483
		$low_part = floor((($big_date / $factor) - $high_part) * $factor);
484
 
485
		// Make HEX string
486
		$res = '';
487
 
488
		for ($i = 0; $i < 4; ++$i) {
489
			$hex = $low_part % 0x100;
490
			$res .= pack('c', $hex);
491
			$low_part /= 0x100;
492
		}
493
		for ($i = 0; $i < 4; ++$i) {
494
			$hex = $high_part % 0x100;
495
			$res .= pack('c', $hex);
496
			$high_part /= 0x100;
497
		}
498
		return $res;
499
	}
500
 
501
	/**
502
	* Returns a timestamp from an OLE container's date
503
	*
504
	* @access public
505
	* @static
506
	* @param integer $string A binary string with the encoded date
507
	* @return string The timestamp corresponding to the string
508
	*/
509
	public static function OLE2LocalDate($string)
510
	{
511
		if (strlen($string) != 8) {
512
			return new PEAR_Error("Expecting 8 byte string");
513
		}
514
 
515
		// factor used for separating numbers into 4 bytes parts
516
		$factor = pow(2,32);
517
		list(, $high_part) = unpack('V', substr($string, 4, 4));
518
		list(, $low_part) = unpack('V', substr($string, 0, 4));
519
 
520
		$big_date = ($high_part * $factor) + $low_part;
521
		// translate to seconds
522
		$big_date /= 10000000;
523
 
524
		// days from 1-1-1601 until the beggining of UNIX era
525
		$days = 134774;
526
 
527
		// translate to seconds from beggining of UNIX era
528
		$big_date -= $days * 24 * 3600;
529
		return floor($big_date);
530
	}
531
}