| 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); |
| } |
| } |
| ?> |