OLE.php

Go to the documentation of this file.

<?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,v 1.15 2007/12/18 20:59:11 schmidt Exp $
 
 
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';
 
$GLOBALS['_OLE_INSTANCES'] = array();
 
class OLE extends PEAR
{
 
    var $_file_handle;
 
    var $_list;
 
    var $root;
 
    var $bbat;
 
    var $sbat;
 
    var $bigBlockSize;
 
    var $smallBlockSize;
 
    function OLE()
    {
        $this->_list = array();
    }
 
    function _OLE()
    {
        fclose($this->_file_handle);
    }
 
    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);
        for ($blockId = 0; $blockId < $shortBlockCount; $blockId++) {
            $this->sbat[$blockId] = $this->_readInt4($sbatFh);
        }
        fclose($sbatFh);
 
        $this->_readPpsWks($directoryFirstBlockId);
 
        return true;
    }
 
    function _getBlockOffset($blockId)
    {
        return 512 + $blockId * $this->bigBlockSize;
    }
 
    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');
    }
 
    function _readInt1($fh)
    {
        list(, $tmp) = unpack("c", fread($fh, 1));
        return $tmp;
    }
 
    function _readInt2($fh)
    {
        list(, $tmp) = unpack("v", fread($fh, 2));
        return $tmp;
    }
 
    function _readInt4($fh)
    {
        list(, $tmp) = unpack("V", fread($fh, 4));
        return $tmp;
    }
 
    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;
    }
 
    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));
    }
 
    function isFile($index)
    {
        if (isset($this->_list[$index])) {
            return ($this->_list[$index]->Type == OLE_PPS_TYPE_FILE);
        }
        return false;
    }
 
    function isRoot($index)
    {
        if (isset($this->_list[$index])) {
            return ($this->_list[$index]->Type == OLE_PPS_TYPE_ROOT);
        }
        return false;
    }
 
    function ppsTotal()
    {
        return count($this->_list);
    }
 
    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;
    }
 
    function getDataLength($index)
    {
        if (isset($this->_list[$index])) {
            return $this->_list[$index]->Size;
        }
        return 0;
    }
 
    function Asc2Ucs($ascii)
    {
        $rawname = '';
        for ($i = 0; $i < strlen($ascii); $i++) {
            $rawname .= $ascii{$i} . "\x00";
        }
        return $rawname;
    }
 
    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;
    }
 
    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);
    }
}
?>