PHPExcel_Shared_OLE Class Reference

Collaboration diagram for PHPExcel_Shared_OLE:

Public Member Functions
	read ($file)
	Reads an OLE container from the contents of the file given. More...
	_getBlockOffset ($blockId)
	getStream ($blockIdOrPps)
	Returns a stream for use with fread() etc. More...
	_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. More...
	_ppsTreeComplete ($index)
	It checks whether the PPS tree is complete (all PPS's read) starting with the given PPS (not necessarily root) More...
	isFile ($index)
	Checks whether a PPS is a File PPS or not. More...
	isRoot ($index)
	Checks whether a PPS is a Root PPS or not. More...
	ppsTotal ()
	Gives the total number of PPS's found in the OLE container. More...
	getData ($index, $position, $length)
	Gets data from a PPS If there is no PPS for the index given, it will return an empty string. More...
	getDataLength ($index)
	Gets the data length from a PPS If there is no PPS for the index given, it will return 0. More...

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

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. More...
static	_readInt2 ($fh)
	Reads an unsigned short (2 octets). More...
static	_readInt4 ($fh)
	Reads an unsigned long (4 octets). More...

Detailed Description

Definition at line 38 of file OLE.php.

Member Function Documentation

_getBlockOffset()

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:

_ppsTreeComplete()

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:

_readInt1()

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.

References $fh.

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

_readInt2()

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.

References $fh.

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

_readInt4()

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.

References $fh.

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

_readPpsWks()

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 $fh, _ppsTreeComplete(), array, and getStream().

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:

Asc2Ucs()

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:

getData()

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, $fh, 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:

getDataLength()

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

getStream()

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:

isFile()

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.

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

isRoot()

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.

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

LocalDate2OLE()

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, and date.

Referenced by PHPExcel_Shared_OLE_PPS\_getPpsWk(), and PHPExcel_Writer_Excel5\_writeSummaryInformation().

        {
                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:

OLE2LocalDate()

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(), 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:

ppsTotal()

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

read()

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 $fh, $file, _getBlockOffset(), _readPpsWks(), array, and getStream().

        {
                $fh = fopen($file, "r");
                if (!$fh) {
                        throw new PHPExcel_Reader_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 PHPExcel_Reader_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 PHPExcel_Reader_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;
        }

Here is the call graph for this function:

Field Documentation

$_file_handle

PHPExcel_Shared_OLE::$_file_handle

Definition at line 51 of file OLE.php.

$_list

PHPExcel_Shared_OLE::$_list = array()

Definition at line 57 of file OLE.php.

$bbat

PHPExcel_Shared_OLE::$bbat

Definition at line 69 of file OLE.php.

$bigBlockSize

PHPExcel_Shared_OLE::$bigBlockSize

Definition at line 81 of file OLE.php.

Referenced by _getBlockOffset().

$root

PHPExcel_Shared_OLE::$root

Definition at line 63 of file OLE.php.

$sbat

PHPExcel_Shared_OLE::$sbat

Definition at line 75 of file OLE.php.

$smallBlockSize

PHPExcel_Shared_OLE::$smallBlockSize

Definition at line 87 of file OLE.php.

OLE_DATA_SIZE_SMALL

const PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL = 0x1000

Definition at line 43 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\_calcSize(), PHPExcel_Shared_OLE_PPS_Root\_makeSmallData(), and PHPExcel_Shared_OLE_PPS_Root\_saveBigData().

OLE_LONG_INT_SIZE

const PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE = 4

Definition at line 44 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\_calcSize(), PHPExcel_Shared_OLE_PPS_Root\_makeSmallData(), PHPExcel_Shared_OLE_PPS_Root\_saveBbd(), and PHPExcel_Shared_OLE_PPS_Root\_saveHeader().

OLE_PPS_SIZE

const PHPExcel_Shared_OLE::OLE_PPS_SIZE = 0x80

Definition at line 45 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\_calcSize(), and PHPExcel_Shared_OLE_PPS_Root\_savePps().

OLE_PPS_TYPE_DIR

const PHPExcel_Shared_OLE::OLE_PPS_TYPE_DIR = 1

Definition at line 41 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\_saveBigData().

OLE_PPS_TYPE_FILE

const PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE = 2

Definition at line 42 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_File\__construct(), PHPExcel_Shared_OLE_PPS_Root\_calcSize(), and PHPExcel_Shared_OLE_PPS_Root\_makeSmallData().

OLE_PPS_TYPE_ROOT

const PHPExcel_Shared_OLE::OLE_PPS_TYPE_ROOT = 5

Definition at line 40 of file OLE.php.

Referenced by PHPExcel_Shared_OLE_PPS_Root\__construct(), and PHPExcel_Shared_OLE_PPS_Root\_saveBigData().

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/phpoffice/phpexcel/Classes/PHPExcel/Shared/OLE.php