New file |
0,0 → 1,575 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2002 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 2.02 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/2_02.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Author: Xavier Noguer <xnoguer@php.net> | |
// | Based on OLE::Storage_Lite by Kawai, Takanori | |
// +----------------------------------------------------------------------+ |
// |
// $Id: OLE.php 260165 2008-05-23 16:33:58Z schmidt $ |
|
|
/** |
* Constants for OLE package |
*/ |
define('OLE_PPS_TYPE_ROOT', 5); |
define('OLE_PPS_TYPE_DIR', 1); |
define('OLE_PPS_TYPE_FILE', 2); |
define('OLE_DATA_SIZE_SMALL', 0x1000); |
define('OLE_LONG_INT_SIZE', 4); |
define('OLE_PPS_SIZE', 0x80); |
|
require_once 'PEAR.php'; |
|
/** |
* Array for storing OLE instances that are accessed from |
* OLE_ChainedBlockStream::stream_open(). |
* @var array |
*/ |
$GLOBALS['_OLE_INSTANCES'] = array(); |
|
/** |
* OLE package base class. |
* |
* @category Structures |
* @package OLE |
* @author Xavier Noguer <xnoguer@php.net> |
* @author Christian Schmidt <schmidt@php.net> |
*/ |
class OLE extends PEAR |
{ |
|
/** |
* The file handle for reading an OLE container |
* @var resource |
*/ |
var $_file_handle; |
|
/** |
* Array of PPS's found on the OLE container |
* @var array |
*/ |
var $_list; |
|
/** |
* Root directory of OLE container |
* @var OLE_PPS_Root |
*/ |
var $root; |
|
/** |
* Big Block Allocation Table |
* @var array (blockId => nextBlockId) |
*/ |
var $bbat; |
|
/** |
* Short Block Allocation Table |
* @var array (blockId => nextBlockId) |
*/ |
var $sbat; |
|
/** |
* Size of big blocks. This is usually 512. |
* @var int number of octets per block. |
*/ |
var $bigBlockSize; |
|
/** |
* Size of small blocks. This is usually 64. |
* @var int number of octets per block |
*/ |
var $smallBlockSize; |
|
/** |
* Creates a new OLE object |
* @access public |
*/ |
function OLE() |
{ |
$this->_list = array(); |
} |
|
/** |
* Destructor (using PEAR) |
* Just closes the file handle on the OLE file. |
* |
* @access private |
*/ |
function _OLE() |
{ |
fclose($this->_file_handle); |
} |
|
/** |
* Reads an OLE container from the contents of the file given. |
* |
* @access public |
* @param string $file |
* @return mixed true on success, PEAR_Error on failure |
*/ |
function read($file) |
{ |
$fh = @fopen($file, "r"); |
if (!$fh) { |
return $this->raiseError("Can't open file $file"); |
} |
$this->_file_handle = $fh; |
|
$signature = fread($fh, 8); |
if ("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1" != $signature) { |
return $this->raiseError("File doesn't seem to be an OLE container."); |
} |
fseek($fh, 28); |
if (fread($fh, 2) != "\xFE\xFF") { |
// This shouldn't be a problem in practice |
return $this->raiseError("Only Little-Endian encoding is supported."); |
} |
// Size of blocks and short blocks in bytes |
$this->bigBlockSize = pow(2, $this->_readInt2($fh)); |
$this->smallBlockSize = pow(2, $this->_readInt2($fh)); |
|
// Skip UID, revision number and version number |
fseek($fh, 44); |
// Number of blocks in Big Block Allocation Table |
$bbatBlockCount = $this->_readInt4($fh); |
|
// Root chain 1st block |
$directoryFirstBlockId = $this->_readInt4($fh); |
|
// Skip unused bytes |
fseek($fh, 56); |
// Streams shorter than this are stored using small blocks |
$this->bigBlockThreshold = $this->_readInt4($fh); |
// Block id of first sector in Short Block Allocation Table |
$sbatFirstBlockId = $this->_readInt4($fh); |
// Number of blocks in Short Block Allocation Table |
$sbbatBlockCount = $this->_readInt4($fh); |
// Block id of first sector in Master Block Allocation Table |
$mbatFirstBlockId = $this->_readInt4($fh); |
// Number of blocks in Master Block Allocation Table |
$mbbatBlockCount = $this->_readInt4($fh); |
$this->bbat = array(); |
|
// Remaining 4 * 109 bytes of current block is beginning of Master |
// Block Allocation Table |
$mbatBlocks = array(); |
for ($i = 0; $i < 109; $i++) { |
$mbatBlocks[] = $this->_readInt4($fh); |
} |
|
// Read rest of Master Block Allocation Table (if any is left) |
$pos = $this->_getBlockOffset($mbatFirstBlockId); |
for ($i = 0; $i < $mbbatBlockCount; $i++) { |
fseek($fh, $pos); |
for ($j = 0; $j < $this->bigBlockSize / 4 - 1; $j++) { |
$mbatBlocks[] = $this->_readInt4($fh); |
} |
// Last block id in each block points to next block |
$pos = $this->_getBlockOffset($this->_readInt4($fh)); |
} |
|
// Read Big Block Allocation Table according to chain specified by |
// $mbatBlocks |
for ($i = 0; $i < $bbatBlockCount; $i++) { |
$pos = $this->_getBlockOffset($mbatBlocks[$i]); |
fseek($fh, $pos); |
for ($j = 0 ; $j < $this->bigBlockSize / 4; $j++) { |
$this->bbat[] = $this->_readInt4($fh); |
} |
} |
|
// Read short block allocation table (SBAT) |
$this->sbat = array(); |
$shortBlockCount = $sbbatBlockCount * $this->bigBlockSize / 4; |
$sbatFh = $this->getStream($sbatFirstBlockId); |
if (!$sbatFh) { |
// Avoid an infinite loop if ChainedBlockStream.php somehow is |
// missing |
return false; |
} |
for ($blockId = 0; $blockId < $shortBlockCount; $blockId++) { |
$this->sbat[$blockId] = $this->_readInt4($sbatFh); |
} |
fclose($sbatFh); |
|
$this->_readPpsWks($directoryFirstBlockId); |
|
return true; |
} |
|
/** |
* @param int $blockId block id |
* @return int byte offset from beginning of file |
* @access private |
*/ |
function _getBlockOffset($blockId) |
{ |
return 512 + $blockId * $this->bigBlockSize; |
} |
|
/** |
* Returns a stream for use with fread() etc. External callers should |
* use OLE_PPS_File::getStream(). |
* @param int|PPS $blockIdOrPps block id or PPS |
* @return resource read-only stream |
*/ |
function getStream($blockIdOrPps) |
{ |
include_once 'OLE/ChainedBlockStream.php'; |
static $isRegistered = false; |
if (!$isRegistered) { |
stream_wrapper_register('ole-chainedblockstream', |
'OLE_ChainedBlockStream'); |
$isRegistered = true; |
} |
|
// Store current instance in global array, so that it can be accessed |
// in OLE_ChainedBlockStream::stream_open(). |
// Object is removed from self::$instances in OLE_Stream::close(). |
$GLOBALS['_OLE_INSTANCES'][] = $this; |
$instanceId = end(array_keys($GLOBALS['_OLE_INSTANCES'])); |
|
$path = 'ole-chainedblockstream://oleInstanceId=' . $instanceId; |
if (is_a($blockIdOrPps, 'OLE_PPS')) { |
$path .= '&blockId=' . $blockIdOrPps->_StartBlock; |
$path .= '&size=' . $blockIdOrPps->Size; |
} else { |
$path .= '&blockId=' . $blockIdOrPps; |
} |
return fopen($path, 'r'); |
} |
|
/** |
* Reads a signed char. |
* @param resource $fh file handle |
* @return int |
* @access private |
*/ |
function _readInt1($fh) |
{ |
list(, $tmp) = unpack("c", fread($fh, 1)); |
return $tmp; |
} |
|
/** |
* Reads an unsigned short (2 octets). |
* @param resource $fh file handle |
* @return int |
* @access private |
*/ |
function _readInt2($fh) |
{ |
list(, $tmp) = unpack("v", fread($fh, 2)); |
return $tmp; |
} |
|
/** |
* Reads an unsigned long (4 octets). |
* @param resource file handle |
* @return int |
* @access private |
*/ |
function _readInt4($fh) |
{ |
list(, $tmp) = unpack("V", fread($fh, 4)); |
return $tmp; |
} |
|
/** |
* Gets information about all PPS's on the OLE container from the PPS WK's |
* creates an OLE_PPS object for each one. |
* |
* @access private |
* @param integer $blockId the block id of the first block |
* @return mixed true on success, PEAR_Error on failure |
*/ |
function _readPpsWks($blockId) |
{ |
$fh = $this->getStream($blockId); |
for ($pos = 0; ; $pos += 128) { |
fseek($fh, $pos, SEEK_SET); |
$nameUtf16 = fread($fh, 64); |
$nameLength = $this->_readInt2($fh); |
$nameUtf16 = substr($nameUtf16, 0, $nameLength - 2); |
// Simple conversion from UTF-16LE to ISO-8859-1 |
$name = str_replace("\x00", "", $nameUtf16); |
$type = $this->_readInt1($fh); |
switch ($type) { |
case OLE_PPS_TYPE_ROOT: |
require_once 'OLE/PPS/Root.php'; |
$pps = new OLE_PPS_Root(null, null, array()); |
$this->root = $pps; |
break; |
case OLE_PPS_TYPE_DIR: |
$pps = new OLE_PPS(null, null, null, null, null, |
null, null, null, null, array()); |
break; |
case OLE_PPS_TYPE_FILE: |
require_once 'OLE/PPS/File.php'; |
$pps = new OLE_PPS_File($name); |
break; |
default: |
continue; |
} |
fseek($fh, 1, SEEK_CUR); |
$pps->Type = $type; |
$pps->Name = $name; |
$pps->PrevPps = $this->_readInt4($fh); |
$pps->NextPps = $this->_readInt4($fh); |
$pps->DirPps = $this->_readInt4($fh); |
fseek($fh, 20, SEEK_CUR); |
$pps->Time1st = OLE::OLE2LocalDate(fread($fh, 8)); |
$pps->Time2nd = OLE::OLE2LocalDate(fread($fh, 8)); |
$pps->_StartBlock = $this->_readInt4($fh); |
$pps->Size = $this->_readInt4($fh); |
$pps->No = count($this->_list); |
$this->_list[] = $pps; |
|
// check if the PPS tree (starting from root) is complete |
if (isset($this->root) && |
$this->_ppsTreeComplete($this->root->No)) { |
|
break; |
} |
} |
fclose($fh); |
|
// Initialize $pps->children on directories |
foreach ($this->_list as $pps) { |
if ($pps->Type == OLE_PPS_TYPE_DIR || $pps->Type == OLE_PPS_TYPE_ROOT) { |
$nos = array($pps->DirPps); |
$pps->children = array(); |
while ($nos) { |
$no = array_pop($nos); |
if ($no != -1) { |
$childPps = $this->_list[$no]; |
$nos[] = $childPps->PrevPps; |
$nos[] = $childPps->NextPps; |
$pps->children[] = $childPps; |
} |
} |
} |
} |
|
return true; |
} |
|
/** |
* It checks whether the PPS tree is complete (all PPS's read) |
* starting with the given PPS (not necessarily root) |
* |
* @access private |
* @param integer $index The index of the PPS from which we are checking |
* @return boolean Whether the PPS tree for the given PPS is complete |
*/ |
function _ppsTreeComplete($index) |
{ |
return isset($this->_list[$index]) && |
($pps = $this->_list[$index]) && |
($pps->PrevPps == -1 || |
$this->_ppsTreeComplete($pps->PrevPps)) && |
($pps->NextPps == -1 || |
$this->_ppsTreeComplete($pps->NextPps)) && |
($pps->DirPps == -1 || |
$this->_ppsTreeComplete($pps->DirPps)); |
} |
|
/** |
* Checks whether a PPS is a File PPS or not. |
* If there is no PPS for the index given, it will return false. |
* @param integer $index The index for the PPS |
* @return bool true if it's a File PPS, false otherwise |
* @access public |
*/ |
function isFile($index) |
{ |
if (isset($this->_list[$index])) { |
return ($this->_list[$index]->Type == OLE_PPS_TYPE_FILE); |
} |
return false; |
} |
|
/** |
* Checks whether a PPS is a Root PPS or not. |
* If there is no PPS for the index given, it will return false. |
* @param integer $index The index for the PPS. |
* @return bool true if it's a Root PPS, false otherwise |
* @access public |
*/ |
function isRoot($index) |
{ |
if (isset($this->_list[$index])) { |
return ($this->_list[$index]->Type == OLE_PPS_TYPE_ROOT); |
} |
return false; |
} |
|
/** |
* Gives the total number of PPS's found in the OLE container. |
* @return integer The total number of PPS's found in the OLE container |
* @access public |
*/ |
function ppsTotal() |
{ |
return count($this->_list); |
} |
|
/** |
* Gets data from a PPS |
* If there is no PPS for the index given, it will return an empty string. |
* @param integer $index The index for the PPS |
* @param integer $position The position from which to start reading |
* (relative to the PPS) |
* @param integer $length The amount of bytes to read (at most) |
* @return string The binary string containing the data requested |
* @access public |
* @see OLE_PPS_File::getStream() |
*/ |
function getData($index, $position, $length) |
{ |
// if position is not valid return empty string |
if (!isset($this->_list[$index]) || |
$position >= $this->_list[$index]->Size || |
$position < 0) { |
|
return ''; |
} |
$fh = $this->getStream($this->_list[$index]); |
$data = stream_get_contents($fh, $length, $position); |
fclose($fh); |
return $data; |
} |
|
/** |
* Gets the data length from a PPS |
* If there is no PPS for the index given, it will return 0. |
* @param integer $index The index for the PPS |
* @return integer The amount of bytes in data the PPS has |
* @access public |
*/ |
function getDataLength($index) |
{ |
if (isset($this->_list[$index])) { |
return $this->_list[$index]->Size; |
} |
return 0; |
} |
|
/** |
* Utility function to transform ASCII text to Unicode |
* |
* @access public |
* @static |
* @param string $ascii The ASCII string to transform |
* @return string The string in Unicode |
*/ |
function Asc2Ucs($ascii) |
{ |
$rawname = ''; |
for ($i = 0; $i < strlen($ascii); $i++) { |
$rawname .= $ascii{$i} . "\x00"; |
} |
return $rawname; |
} |
|
/** |
* Utility function |
* Returns a string for the OLE container with the date given |
* |
* @access public |
* @static |
* @param integer $date A timestamp |
* @return string The string for the OLE container |
*/ |
function LocalDate2OLE($date = null) |
{ |
if (!isset($date)) { |
return "\x00\x00\x00\x00\x00\x00\x00\x00"; |
} |
|
// factor used for separating numbers into 4 bytes parts |
$factor = pow(2, 32); |
|
// days from 1-1-1601 until the beggining of UNIX era |
$days = 134774; |
// calculate seconds |
$big_date = $days * 24 * 3600 + |
gmmktime(date("H",$date),date("i",$date),date("s",$date), |
date("m",$date),date("d",$date),date("Y",$date)); |
// multiply just to make MS happy |
$big_date *= 10000000; |
|
$high_part = floor($big_date / $factor); |
// lower 4 bytes |
$low_part = floor((($big_date / $factor) - $high_part) * $factor); |
|
// Make HEX string |
$res = ''; |
|
for ($i = 0; $i < 4; $i++) { |
$hex = $low_part % 0x100; |
$res .= pack('c', $hex); |
$low_part /= 0x100; |
} |
for ($i = 0; $i < 4; $i++) { |
$hex = $high_part % 0x100; |
$res .= pack('c', $hex); |
$high_part /= 0x100; |
} |
return $res; |
} |
|
/** |
* Returns a timestamp from an OLE container's date |
* @param integer $string A binary string with the encoded date |
* @return string The timestamp corresponding to the string |
* @access public |
* @static |
*/ |
function OLE2LocalDate($string) |
{ |
if (strlen($string) != 8) { |
return new PEAR_Error("Expecting 8 byte string"); |
} |
|
// factor used for separating numbers into 4 bytes parts |
$factor = pow(2,32); |
$high_part = 0; |
for ($i = 0; $i < 4; $i++) { |
list(, $high_part) = unpack('C', $string{(7 - $i)}); |
if ($i < 3) { |
$high_part *= 0x100; |
} |
} |
$low_part = 0; |
for ($i = 4; $i < 8; $i++) { |
list(, $low_part) = unpack('C', $string{(7 - $i)}); |
if ($i < 7) { |
$low_part *= 0x100; |
} |
} |
$big_date = ($high_part * $factor) + $low_part; |
// translate to seconds |
$big_date /= 10000000; |
|
// days from 1-1-1601 until the beggining of UNIX era |
$days = 134774; |
|
// translate to seconds from beggining of UNIX era |
$big_date -= $days * 24 * 3600; |
return floor($big_date); |
} |
} |
?> |