Collaboration diagram for PHPExcel_Shared_OLE:

Public Member Functions
	read ($file)
	Reads an OLE container from the contents of the file given.
	_getBlockOffset ($blockId)
	getStream ($blockIdOrPps)
	Returns a stream for use with fread() etc.
	_readPpsWks ($blockId)
	Gets information about all PPS's on the OLE container from the PPS WK's creates an OLE_PPS object for each one.
	_ppsTreeComplete ($index)
	It checks whether the PPS tree is complete (all PPS's read) starting with the given PPS (not necessarily root)
	isFile ($index)
	Checks whether a PPS is a File PPS or not.
	isRoot ($index)
	Checks whether a PPS is a Root PPS or not.
	ppsTotal ()
	Gives the total number of PPS's found in the OLE container.
	getData ($index, $position, $length)
	Gets data from a PPS If there is no PPS for the index given, it will return an empty string.
	getDataLength ($index)
	Gets the data length from a PPS If there is no PPS for the index given, it will return 0.

Static Public Member Functions
static	Asc2Ucs ($ascii)
	Utility function to transform ASCII text to Unicode.
static	LocalDate2OLE ($date=null)
	Utility function Returns a string for the OLE container with the date given.
static	OLE2LocalDate ($string)
	Returns a timestamp from an OLE container's date.

Data Fields
const	OLE_PPS_TYPE_ROOT = 5
const	OLE_PPS_TYPE_DIR = 1
const	OLE_PPS_TYPE_FILE = 2
const	OLE_DATA_SIZE_SMALL = 0x1000
const	OLE_LONG_INT_SIZE = 4
const	OLE_PPS_SIZE = 0x80
	$_file_handle
	$_list = array()
	$root
	$bbat
	$sbat
	$bigBlockSize
	$smallBlockSize

Static Private Member Functions
static	_readInt1 ($fh)
	Reads a signed char.
static	_readInt2 ($fh)
	Reads an unsigned short (2 octets).
static	_readInt4 ($fh)
	Reads an unsigned long (4 octets).

Detailed Description

Definition at line 38 of file OLE.php.

Member Function Documentation

PHPExcel_Shared_OLE::_getBlockOffset ( $blockId )

Parameters

int	block id
int	byte offset from beginning of file public

Definition at line 186 of file OLE.php.

References $bigBlockSize.

Referenced by read().

        {
                return 512 + $blockId * $this->bigBlockSize;
        }

Here is the caller graph for this function:

PHPExcel_Shared_OLE::_ppsTreeComplete ( $index )

It checks whether the PPS tree is complete (all PPS's read) starting with the given PPS (not necessarily root)

public

Parameters

integer $index The index of the PPS from which we are checking

Returns: boolean Whether the PPS tree for the given PPS is complete

Definition at line 343 of file OLE.php.

Referenced by _readPpsWks().

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

Here is the caller graph for this function:

static PHPExcel_Shared_OLE::_readInt1 ( $fh )

staticprivate

Reads a signed char.

Parameters

resource file handle

Returns: int public

Definition at line 228 of file OLE.php.

Referenced by _readPpsWks().

        {
                list(, $tmp) = unpack("c", fread($fh, 1));
                return $tmp;
        }

Here is the caller graph for this function:

static PHPExcel_Shared_OLE::_readInt2 ( $fh )

staticprivate

Reads an unsigned short (2 octets).

Parameters

resource file handle

Returns: int public

Definition at line 240 of file OLE.php.

Referenced by _readPpsWks().

        {
                list(, $tmp) = unpack("v", fread($fh, 2));
                return $tmp;
        }

Here is the caller graph for this function:

static PHPExcel_Shared_OLE::_readInt4 ( $fh )

staticprivate

Reads an unsigned long (4 octets).

Parameters

resource file handle

Returns: int public

Definition at line 252 of file OLE.php.

Referenced by _readPpsWks(), and read().

        {
                list(, $tmp) = unpack("V", fread($fh, 4));
                return $tmp;
        }

Here is the caller graph for this function:

PHPExcel_Shared_OLE::_readPpsWks ( $blockId )

Gets information about all PPS's on the OLE container from the PPS WK's creates an OLE_PPS object for each one.

public

Parameters

integer the block id of the first block

Returns: mixed true on success, PEAR_Error on failure

Definition at line 266 of file OLE.php.

References $name, $pos, $type, _ppsTreeComplete(), _readInt1(), _readInt2(), _readInt4(), getStream(), OLE2LocalDate(), OLE_PPS_TYPE_DIR, OLE_PPS_TYPE_FILE, and OLE_PPS_TYPE_ROOT.

Referenced by read().

        {
                $fh = $this->getStream($blockId);
                for ($pos = 0; ; $pos += 128) {
                        fseek($fh, $pos, SEEK_SET);
                        $nameUtf16 = fread($fh, 64);
                        $nameLength = self::_readInt2($fh);
                        $nameUtf16 = substr($nameUtf16, 0, $nameLength - 2);
                        // Simple conversion from UTF-16LE to ISO-8859-1
                        $name = str_replace("\x00", "", $nameUtf16);
                        $type = self::_readInt1($fh);
                        switch ($type) {
                        case self::OLE_PPS_TYPE_ROOT:
                                $pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
                                $this->root = $pps;
                                break;
                        case self::OLE_PPS_TYPE_DIR:
                                $pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null,
                                                                   null, null, null, null, array());
                                break;
                        case self::OLE_PPS_TYPE_FILE:
                                $pps = new PHPExcel_Shared_OLE_PPS_File($name);
                                break;
                        default:
                                continue;
                        }
                        fseek($fh, 1, SEEK_CUR);
                        $pps->Type    = $type;
                        $pps->Name    = $name;
                        $pps->PrevPps = self::_readInt4($fh);
                        $pps->NextPps = self::_readInt4($fh);
                        $pps->DirPps  = self::_readInt4($fh);
                        fseek($fh, 20, SEEK_CUR);
                        $pps->Time1st = self::OLE2LocalDate(fread($fh, 8));
                        $pps->Time2nd = self::OLE2LocalDate(fread($fh, 8));
                        $pps->_StartBlock = self::_readInt4($fh);
                        $pps->Size = self::_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 == self::OLE_PPS_TYPE_DIR || $pps->Type == self::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;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

static PHPExcel_Shared_OLE::Asc2Ucs ( $ascii )

static

Utility function to transform ASCII text to Unicode.

public

Parameters

string $ascii The ASCII string to transform

Returns: string The string in Unicode

Definition at line 446 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\__construct(), and PHPExcel_Writer_Excel5\save().

        {
                $rawname = '';
                for ($i = 0; $i < strlen($ascii); ++$i) {
                        $rawname .= $ascii{$i} . "\x00";
                }
                return $rawname;
        }

Here is the caller graph for this function:

PHPExcel_Shared_OLE::getData	(	$index,
		$position,
		$length
	)

Gets data from a PPS If there is no PPS for the index given, it will return an empty string.

public

Parameters

integer	$index	The index for the PPS
integer	$position	The position from which to start reading (relative to the PPS)
integer	$length	The amount of bytes to read (at most)

Returns: string The binary string containing the data requested

See Also: OLE_PPS_File::getStream()

Definition at line 410 of file OLE.php.

References $data, and getStream().

        {
                // 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;
        }

Here is the call graph for this function:

PHPExcel_Shared_OLE::getDataLength ( $index )

Gets the data length from a PPS If there is no PPS for the index given, it will return 0.

public

Parameters

integer $index The index for the PPS

Returns: integer The amount of bytes in data the PPS has

Definition at line 430 of file OLE.php.

        {
                if (isset($this->_list[$index])) {
                        return $this->_list[$index]->Size;
                }
                return 0;
        }

PHPExcel_Shared_OLE::getStream ( $blockIdOrPps )

Returns a stream for use with fread() etc.

External callers should use PHPExcel_Shared_OLE_PPS_File::getStream().

Parameters

int|PPS block id or PPS

Returns: resource read-only stream

Definition at line 197 of file OLE.php.

References $GLOBALS, and $path.

Referenced by _readPpsWks(), getData(), and read().

        {
                static $isRegistered = false;
                if (!$isRegistered) {
                        stream_wrapper_register('ole-chainedblockstream',
                                'PHPExcel_Shared_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 ($blockIdOrPps instanceof PHPExcel_Shared_OLE_PPS) {
                        $path .= '&blockId=' . $blockIdOrPps->_StartBlock;
                        $path .= '&size=' . $blockIdOrPps->Size;
                } else {
                        $path .= '&blockId=' . $blockIdOrPps;
                }
                return fopen($path, 'r');
        }

Here is the caller graph for this function:

PHPExcel_Shared_OLE::isFile ( $index )

Checks whether a PPS is a File PPS or not.

If there is no PPS for the index given, it will return false.

public

Parameters

integer $index The index for the PPS

Returns: bool true if it's a File PPS, false otherwise

Definition at line 363 of file OLE.php.

References OLE_PPS_TYPE_FILE.

        {
                if (isset($this->_list[$index])) {
                        return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_FILE);
                }
                return false;
        }

PHPExcel_Shared_OLE::isRoot ( $index )

Checks whether a PPS is a Root PPS or not.

If there is no PPS for the index given, it will return false.

public

Parameters

integer $index The index for the PPS.

Returns: bool true if it's a Root PPS, false otherwise

Definition at line 379 of file OLE.php.

References OLE_PPS_TYPE_ROOT.

        {
                if (isset($this->_list[$index])) {
                        return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_ROOT);
                }
                return false;
        }

static PHPExcel_Shared_OLE::LocalDate2OLE ( $date = null )

static

Utility function Returns a string for the OLE container with the date given.

public

Parameters

integer $date A timestamp

Returns: string The string for the OLE container

Definition at line 464 of file OLE.php.

References $res.

Referenced by PHPExcel_Shared_OLE_PPS\_getPpsWk().

        {
                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;
        }

Here is the caller graph for this function:

static PHPExcel_Shared_OLE::OLE2LocalDate ( $string )

static

Returns a timestamp from an OLE container's date.

public

Parameters

integer $string A binary string with the encoded date

Returns: string The timestamp corresponding to the string

Definition at line 509 of file OLE.php.

Referenced by PHPExcel_Reader_Excel5\_readDocumentSummaryInformation(), _readPpsWks(), and PHPExcel_Reader_Excel5\_readSummaryInformation().

        {
                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);
                list(, $high_part) = unpack('V', substr($string, 4, 4));
                list(, $low_part) = unpack('V', substr($string, 0, 4));
                $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);
        }

Here is the caller graph for this function:

PHPExcel_Shared_OLE::ppsTotal ( )

Gives the total number of PPS's found in the OLE container.

public

Returns: integer The total number of PPS's found in the OLE container

Definition at line 393 of file OLE.php.

        {
                return count($this->_list);
        }

PHPExcel_Shared_OLE::read ( $file )

Reads an OLE container from the contents of the file given.

public

Parameters

string $file

Returns: mixed true on success, PEAR_Error on failure

Definition at line 96 of file OLE.php.

References $file, $pos, _getBlockOffset(), _readInt4(), _readPpsWks(), and getStream().

        {
                $fh = fopen($file, "r");
                if (!$fh) {
                        throw new Exception("Can't open file $file");
                }
                $this->_file_handle = $fh;
                $signature = fread($fh, 8);
                if ("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1" != $signature) {
                        throw new Exception("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
                        throw new Exception("Only Little-Endian encoding is supported.");
                }
                // Size of blocks and short blocks in bytes
                $this->bigBlockSize = pow(2, self::_readInt2($fh));
                $this->smallBlockSize  = pow(2, self::_readInt2($fh));
                // Skip UID, revision number and version number
                fseek($fh, 44);
                // Number of blocks in Big Block Allocation Table
                $bbatBlockCount = self::_readInt4($fh);
                // Root chain 1st block
                $directoryFirstBlockId = self::_readInt4($fh);
                // Skip unused bytes
                fseek($fh, 56);
                // Streams shorter than this are stored using small blocks
                $this->bigBlockThreshold = self::_readInt4($fh);
                // Block id of first sector in Short Block Allocation Table
                $sbatFirstBlockId = self::_readInt4($fh);
                // Number of blocks in Short Block Allocation Table
                $sbbatBlockCount = self::_readInt4($fh);
                // Block id of first sector in Master Block Allocation Table
                $mbatFirstBlockId = self::_readInt4($fh);
                // Number of blocks in Master Block Allocation Table
                $mbbatBlockCount = self::_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[] = self::_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[] = self::_readInt4($fh);
                        }
                        // Last block id in each block points to next block
                        $pos = $this->_getBlockOffset(self::_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[] = self::_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] = self::_readInt4($sbatFh);
                }
                fclose($sbatFh);
                $this->_readPpsWks($directoryFirstBlockId);
                return true;
        }