Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
<?php
/**
< * CFPropertyList < * {@link http://developer.apple.com/documentation/Darwin/Reference/ManPages/man5/plist.5.html Property Lists}
> * LICENSE > * > * This file is part of CFPropertyList. > * > * The PHP implementation of Apple's PropertyList can handle XML PropertyLists > * as well as binary PropertyLists. It offers functionality to easily convert > * data between worlds, e.g. recalculating timestamps from unix epoch to apple > * epoch and vice versa. A feature to automagically create (guess) the plist > * structure from a normal PHP data structure will help you dump your data to > * plist in no time. > * > * Copyright (c) 2018 Teclib' > * > * Permission is hereby granted, free of charge, to any person obtaining a copy > * of this software and associated documentation files (the "Software"), to deal > * in the Software without restriction, including without limitation the rights > * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell > * copies of the Software, and to permit persons to whom the Software is > * furnished to do so, subject to the following conditions: > * > * The above copyright notice and this permission notice shall be included in all > * copies or substantial portions of the Software. > * > * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE > * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, > * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE > * SOFTWARE. > * > * ------------------------------------------------------------------------------
* @author Rodney Rehm <rodney.rehm@medialize.de> * @author Christian Kruse <cjk@wwwtech.de>
> * @copyright Copyright © 2018 Teclib
* @package plist
< * @version $Id$
> * @license MIT > * @link https://github.com/TECLIB/CFPropertyList/ > * @link http://developer.apple.com/documentation/Darwin/Reference/ManPages/man5/plist.5.html Property Lists > * ------------------------------------------------------------------------------
*/
>
namespace CFPropertyList; /** * Facility for reading and writing binary PropertyLists. Ported from {@link http://www.opensource.apple.com/source/CF/CF-476.15/CFBinaryPList.c CFBinaryPList.c}.
< * @author Rodney Rehm <rodney.rehm@medialize.de> < * @author Christian Kruse <cjk@wwwtech.de> < * @package plist
* @example example-read-02.php Read a Binary PropertyList * @example example-read-03.php Read a PropertyList without knowing the type */
< abstract class CFBinaryPropertyList {
> abstract class CFBinaryPropertyList > {
/** * Content of the plist (unparsed string) * @var string */
< protected $content = NULL;
> protected $content = null;
/** * position in the (unparsed) string * @var integer */ protected $pos = 0; /** * Table containing uniqued objects * @var array */
< protected $uniqueTable = Array();
> protected $uniqueTable = array();
/** * Number of objects in file * @var integer */ protected $countObjects = 0; /** * The length of all strings in the file (byte length, not character length) * @var integer */ protected $stringSize = 0; /** * The length of all ints in file (byte length) * @var integer */ protected $intSize = 0; /** * The length of misc objects (i.e. not integer and not string) in file * @var integer */ protected $miscSize = 0; /** * Number of object references in file (needed to calculate reference byte length) * @var integer */ protected $objectRefs = 0; /** * Number of objects written during save phase; needed to calculate the size of the object table * @var integer */ protected $writtenObjectCount = 0; /** * Table containing all objects in the file */
< protected $objectTable = Array();
> protected $objectTable = array();
/** * The size of object references */ protected $objectRefSize = 0; /** * The „offsets” (i.e. the different entries) in the file */
< protected $offsets = Array();
> protected $offsets = array();
/** * Read a „null type” (filler byte, true, false, 0 byte) * @param $length The byte itself * @return the byte value (e.g. CFBoolean(true), CFBoolean(false), 0 or 15) * @throws PListException on encountering an unknown null type */
< protected function readBinaryNullType($length) {
> protected function readBinaryNullType($length) > {
switch($length) {
< case 0: return 0; // null type < case 8: return new CFBoolean(false); < case 9: return new CFBoolean(true); < case 15: return 15; // fill type
> case 0: > return 0; // null type > case 8: > return new CFBoolean(false); > case 9: > return new CFBoolean(true); > case 15: > return 15; // fill type
} throw new PListException("unknown null type: $length"); } /** * Create an 64 bit integer using bcmath or gmp * @param int $hi The higher word * @param int $lo The lower word * @return mixed The integer (as int if possible, as string if not possible) * @throws PListException if neither gmp nor bc available */
< protected static function make64Int($hi,$lo) {
> protected static function make64Int($hi, $lo) > {
// on x64, we can just use int
< if(PHP_INT_SIZE > 4) return (((int)$hi)<<32) | ((int)$lo);
> if (PHP_INT_SIZE > 4) { > return (((int)$hi)<<32) | ((int)$lo); > }
// lower word has to be unsigned since we don't use bitwise or, we use bcadd/gmp_add $lo = sprintf("%u", $lo); // use GMP or bcmath if possible
< if(function_exists("gmp_mul")) return gmp_strval(gmp_add(gmp_mul($hi, "4294967296"), $lo));
> if (function_exists("gmp_mul")) { > return gmp_strval(gmp_add(gmp_mul($hi, "4294967296"), $lo)); > }
< if(function_exists("bcmul")) return bcadd(bcmul($hi,"4294967296"), $lo);
> if (function_exists("bcmul")) { > return bcadd(bcmul($hi, "4294967296"), $lo); > }
if(class_exists('Math_BigInteger')) { $bi = new \Math_BigInteger($hi); return $bi->multiply(new \Math_BigInteger("4294967296"))->add(new \Math_BigInteger($lo))->toString(); } throw new PListException("either gmp or bc has to be installed, or the Math_BigInteger has to be available!"); } /** * Read an integer value * @param integer $length The length (in bytes) of the integer value, coded as „set bit $length to 1” * @return CFNumber The integer value * @throws PListException if integer val is invalid * @throws IOException if read error occurs * @uses make64Int() to overcome PHP's big integer problems */
< protected function readBinaryInt($length) { < if($length > 3) throw new PListException("Integer greater than 8 bytes: $length");
> protected function readBinaryInt($length) > { > if ($length > 3) { > throw new PListException("Integer greater than 8 bytes: $length"); > }
$nbytes = 1 << $length; $val = null;
< if(strlen($buff = substr($this->content, $this->pos, $nbytes)) != $nbytes) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $nbytes)) != $nbytes) { > throw IOException::readError(""); > }
$this->pos += $nbytes; switch($length) { case 0: $val = unpack("C", $buff); $val = $val[1]; break; case 1: $val = unpack("n", $buff); $val = $val[1]; break; case 2: $val = unpack("N", $buff); $val = $val[1]; break; case 3: $words = unpack("Nhighword/Nlowword",$buff); //$val = $words['highword'] << 32 | $words['lowword']; $val = self::make64Int($words['highword'],$words['lowword']); break; } return new CFNumber($val); } /** * Read a real value * @param integer $length The length (in bytes) of the integer value, coded as „set bit $length to 1” * @return CFNumber The real value * @throws PListException if real val is invalid * @throws IOException if read error occurs */
< protected function readBinaryReal($length) { < if($length > 3) throw new PListException("Real greater than 8 bytes: $length");
> protected function readBinaryReal($length) > { > if ($length > 3) { > throw new PListException("Real greater than 8 bytes: $length"); > }
$nbytes = 1 << $length; $val = null;
< if(strlen($buff = substr($this->content,$this->pos, $nbytes)) != $nbytes) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $nbytes)) != $nbytes) { > throw IOException::readError(""); > }
$this->pos += $nbytes; switch($length) { case 0: // 1 byte float? must be an error case 1: // 2 byte float? must be an error $x = $length + 1; throw new PListException("got {$x} byte float, must be an error!"); case 2: $val = unpack("f", strrev($buff)); $val = $val[1]; break; case 3: $val = unpack("d", strrev($buff)); $val = $val[1]; break; } return new CFNumber($val); } /** * Read a date value * @param integer $length The length (in bytes) of the integer value, coded as „set bit $length to 1” * @return CFDate The date value * @throws PListException if date val is invalid * @throws IOException if read error occurs */
< protected function readBinaryDate($length) { < if($length > 3) throw new PListException("Date greater than 8 bytes: $length");
> protected function readBinaryDate($length) > { > if ($length > 3) { > throw new PListException("Date greater than 8 bytes: $length"); > }
$nbytes = 1 << $length; $val = null;
< if(strlen($buff = substr($this->content, $this->pos, $nbytes)) != $nbytes) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $nbytes)) != $nbytes) { > throw IOException::readError(""); > }
$this->pos += $nbytes; switch($length) { case 0: // 1 byte CFDate is an error case 1: // 2 byte CFDate is an error $x = $length + 1; throw new PListException("{$x} byte CFdate, error"); case 2: $val = unpack("f", strrev($buff)); $val = $val[1]; break; case 3: $val = unpack("d", strrev($buff)); $val = $val[1]; break; } return new CFDate($val,CFDate::TIMESTAMP_APPLE); } /** * Read a data value * @param integer $length The length (in bytes) of the integer value, coded as „set bit $length to 1” * @return CFData The data value * @throws IOException if read error occurs */
< protected function readBinaryData($length) { < if($length == 0) $buff = ""; < else {
> protected function readBinaryData($length) > { > if ($length == 0) { > $buff = ""; > } else {
$buff = substr($this->content, $this->pos, $length);
< if(strlen($buff) != $length) throw IOException::readError("");
> if (strlen($buff) != $length) { > throw IOException::readError(""); > }
$this->pos += $length; } return new CFData($buff,false); } /** * Read a string value, usually coded as utf8 * @param integer $length The length (in bytes) of the string value * @return CFString The string value, utf8 encoded * @throws IOException if read error occurs */
< protected function readBinaryString($length) { < if($length == 0) $buff = ""; < else { < if(strlen($buff = substr($this->content, $this->pos, $length)) != $length) throw IOException::readError("");
> protected function readBinaryString($length) > { > if ($length == 0) { > $buff = ""; > } else { > if (strlen($buff = substr($this->content, $this->pos, $length)) != $length) { > throw IOException::readError(""); > }
$this->pos += $length; }
< if(!isset($this->uniqueTable[$buff])) $this->uniqueTable[$buff] = true;
> if (!isset($this->uniqueTable[$buff])) { > $this->uniqueTable[$buff] = true; > }
return new CFString($buff); } /** * Convert the given string from one charset to another. * Trying to use MBString, Iconv, Recode - in that particular order. * @param string $string the string to convert * @param string $fromCharset the charset the given string is currently encoded in * @param string $toCharset the charset to convert to, defaults to UTF-8 * @return string the converted string * @throws PListException on neither MBString, Iconv, Recode being available */
< public static function convertCharset($string, $fromCharset, $toCharset='UTF-8') { < if(function_exists('mb_convert_encoding')) return mb_convert_encoding($string, $toCharset, $fromCharset); < if(function_exists('iconv')) return iconv($fromCharset, $toCharset, $string); < if(function_exists('recode_string')) return recode_string($fromCharset .'..'. $toCharset, $string);
> public static function convertCharset($string, $fromCharset, $toCharset = 'UTF-8') > { > if (function_exists('mb_convert_encoding')) { > return mb_convert_encoding($string, $toCharset, $fromCharset); > } > if (function_exists('iconv')) { > return iconv($fromCharset, $toCharset, $string); > } > if (function_exists('recode_string')) { > return recode_string($fromCharset .'..'. $toCharset, $string); > }
throw new PListException('neither iconv nor mbstring supported. how are we supposed to work on strings here?'); } /** * Count characters considering character set * Trying to use MBString, Iconv - in that particular order. * @param string $string the string to convert * @param string $charset the charset the given string is currently encoded in * @return integer The number of characters in that string * @throws PListException on neither MBString, Iconv being available */
< public static function charsetStrlen($string,$charset="UTF-8") { < if(function_exists('mb_strlen')) return mb_strlen($string, $charset); < if(function_exists('iconv_strlen')) return iconv_strlen($string,$charset);
> public static function charsetStrlen($string, $charset = "UTF-8") > { > if (function_exists('mb_strlen')) { > return mb_strlen($string, $charset); > } > if (function_exists('iconv_strlen')) { > return iconv_strlen($string, $charset); > }
throw new PListException('neither iconv nor mbstring supported. how are we supposed to work on strings here?'); } /** * Read a unicode string value, coded as UTF-16BE * @param integer $length The length (in bytes) of the string value * @return CFString The string value, utf8 encoded * @throws IOException if read error occurs */
< protected function readBinaryUnicodeString($length) {
> protected function readBinaryUnicodeString($length) > {
/* The problem is: we get the length of the string IN CHARACTERS; since a char in UTF-16 can be 16 or 32 bit long, we don't really know how long the string is in bytes */
< if(strlen($buff = substr($this->content, $this->pos, 2*$length)) != 2*$length) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, 2*$length)) != 2*$length) { > throw IOException::readError(""); > }
$this->pos += 2 * $length;
< if(!isset($this->uniqueTable[$buff])) $this->uniqueTable[$buff] = true;
> if (!isset($this->uniqueTable[$buff])) { > $this->uniqueTable[$buff] = true; > }
return new CFString(self::convertCharset($buff, "UTF-16BE", "UTF-8")); } /** * Read an array value, including contained objects * @param integer $length The number of contained objects * @return CFArray The array value, including the objects * @throws IOException if read error occurs */
< protected function readBinaryArray($length) {
> protected function readBinaryArray($length) > {
$ary = new CFArray(); // first: read object refs if($length != 0) {
< if(strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) { > throw IOException::readError(""); > }
$this->pos += $length * $this->objectRefSize; $objects = self::unpackWithSize($this->objectRefSize, $buff); // now: read objects for($i=0;$i<$length;++$i) { $object = $this->readBinaryObjectAt($objects[$i+1]+1); $ary->add($object); } } return $ary; } /** * Read a dictionary value, including contained objects * @param integer $length The number of contained objects * @return CFDictionary The dictionary value, including the objects * @throws IOException if read error occurs */
< protected function readBinaryDict($length) {
> protected function readBinaryDict($length) > {
$dict = new CFDictionary(); // first: read keys if($length != 0) {
< if(strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) { > throw IOException::readError(""); > }
$this->pos += $length * $this->objectRefSize; $keys = self::unpackWithSize($this->objectRefSize, $buff); // second: read object refs
< if(strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, $length * $this->objectRefSize)) != $length * $this->objectRefSize) { > throw IOException::readError(""); > }
$this->pos += $length * $this->objectRefSize; $objects = self::unpackWithSize($this->objectRefSize, $buff); // read real keys and objects for($i=0;$i<$length;++$i) { $key = $this->readBinaryObjectAt($keys[$i+1]+1); $object = $this->readBinaryObjectAt($objects[$i+1]+1); $dict->add($key->getValue(),$object); } } return $dict; } /** * Read an object type byte, decode it and delegate to the correct reader function * @return mixed The value of the delegate reader, so any of the CFType subclasses * @throws IOException if read error occurs */
< function readBinaryObject() {
> public function readBinaryObject() > {
// first: read the marker byte
< if(strlen($buff = substr($this->content,$this->pos,1)) != 1) throw IOException::readError("");
> if (strlen($buff = substr($this->content, $this->pos, 1)) != 1) { > throw IOException::readError(""); > }
$this->pos++; $object_length = unpack("C*", $buff); $object_length = $object_length[1] & 0xF; $buff = unpack("H*", $buff); $buff = $buff[1]; $object_type = substr($buff, 0, 1); if($object_type != "0" && $object_length == 15) {
< $object_length = $this->readBinaryObject($this->objectRefSize);
> $object_length = $this->readBinaryObject();
$object_length = $object_length->getValue(); } $retval = null; switch($object_type) { case '0': // null, false, true, fillbyte $retval = $this->readBinaryNullType($object_length); break; case '1': // integer $retval = $this->readBinaryInt($object_length); break; case '2': // real $retval = $this->readBinaryReal($object_length); break; case '3': // date $retval = $this->readBinaryDate($object_length); break; case '4': // data $retval = $this->readBinaryData($object_length); break; case '5': // byte string, usually utf8 encoded $retval = $this->readBinaryString($object_length); break; case '6': // unicode string (utf16be) $retval = $this->readBinaryUnicodeString($object_length); break; case '8': $num = $this->readBinaryInt($object_length); $retval = new CFUid($num->getValue()); break; case 'a': // array $retval = $this->readBinaryArray($object_length); break; case 'd': // dictionary $retval = $this->readBinaryDict($object_length); break; } return $retval; } /** * Read an object type byte at position $pos, decode it and delegate to the correct reader function * @param integer $pos The table position in the offsets table * @return mixed The value of the delegate reader, so any of the CFType subclasses */
< function readBinaryObjectAt($pos) {
> public function readBinaryObjectAt($pos) > {
$this->pos = $this->offsets[$pos]; return $this->readBinaryObject(); } /** * Parse a binary plist string * @return void * @throws IOException if read error occurs */
< public function parseBinaryString() { < $this->uniqueTable = Array();
> public function parseBinaryString() > { > $this->uniqueTable = array();
$this->countObjects = 0; $this->stringSize = 0; $this->intSize = 0; $this->miscSize = 0; $this->objectRefs = 0; $this->writtenObjectCount = 0;
< $this->objectTable = Array();
> $this->objectTable = array();
$this->objectRefSize = 0;
< $this->offsets = Array();
> $this->offsets = array();
// first, we read the trailer: 32 byte from the end $buff = substr($this->content,-32); if(strlen($buff) < 32) { throw new PListException('Error in PList format: content is less than at least necessary 32 bytes!'); } $infos = unpack("x6/Coffset_size/Cobject_ref_size/x4/Nnumber_of_objects/x4/Ntop_object/x4/Ntable_offset",$buff); // after that, get the offset table $coded_offset_table = substr($this->content,$infos['table_offset'],$infos['number_of_objects'] * $infos['offset_size']);
< if(strlen($coded_offset_table) != $infos['number_of_objects'] * $infos['offset_size']) throw IOException::readError("");
> if (strlen($coded_offset_table) != $infos['number_of_objects'] * $infos['offset_size']) { > throw IOException::readError(""); > }
$this->countObjects = $infos['number_of_objects']; // decode offset table
< $formats = Array("","C*","n*",NULL,"N*"); < if($infos['offset_size'] == 3) { # since PHP does not support parenthesis in pack/unpack expressions, < # "(H6)*" does not work and we have to work round this by repeating the < # expression as often as it fits in the string < $this->offsets = array(NULL);
> $formats = array("","C*","n*",null,"N*"); > if ($infos['offset_size'] == 3) { > /* since PHP does not support parenthesis in pack/unpack expressions, > "(H6)*" does not work and we have to work round this by repeating the > expression as often as it fits in the string > */ > $this->offsets = array(null);
while($coded_offset_table) { $str = unpack("H6",$coded_offset_table); $this->offsets[] = hexdec($str[1]); $coded_offset_table = substr($coded_offset_table,3); }
> } else { } > $this->offsets = unpack($formats[$infos['offset_size']], $coded_offset_table);
< else $this->offsets = unpack($formats[$infos['offset_size']],$coded_offset_table);
< $this->uniqueTable = Array();
> $this->uniqueTable = array();
$this->objectRefSize = $infos['object_ref_size']; $top = $this->readBinaryObjectAt($infos['top_object']+1); $this->add($top); } /** * Read a binary plist stream * @param resource $stream The stream to read * @return void * @throws IOException if read error occurs */
< function readBinaryStream($stream) {
> public function readBinaryStream($stream) > {
if(($str = stream_get_contents($stream)) === false || empty($str)) { throw new PListException("Error reading stream!"); } $this->parseBinary($str); } /** * parse a binary plist string * @param string $content The stream to read, defaults to {@link $this->content} * @return void * @throws IOException if read error occurs */
< function parseBinary($content=NULL) { < if($content !== NULL) {
> public function parseBinary($content = null) > { > if ($content !== null) {
$this->content = $content; } if(empty($this->content)) { throw new PListException("Content may not be empty!"); } if(substr($this->content,0,8) != 'bplist00') { throw new PListException("Invalid binary string!"); } $this->pos = 0; $this->parseBinaryString(); } /** * Read a binary plist file * @param string $file The file to read * @return void * @throws IOException if read error occurs */
< function readBinary($file) {
> public function readBinary($file) > {
if(!($fd = fopen($file,"rb"))) { throw new IOException("Could not open file {$file}!"); } $this->readBinaryStream($fd); fclose($fd); } /** * calculate the bytes needed for a size integer value * @param integer $int The integer value to calculate * @return integer The number of bytes needed */
< public static function bytesSizeInt($int) {
> public static function bytesSizeInt($int) > {
$nbytes = 0;
< if($int > 0xE) $nbytes += 2; // 2 size-bytes < if($int > 0xFF) $nbytes += 1; // 3 size-bytes < if($int > 0xFFFF) $nbytes += 2; // 5 size-bytes
> if ($int > 0xE) { > $nbytes += 2; // 2 size-bytes > } > if ($int > 0xFF) { > $nbytes += 1; // 3 size-bytes > } > if ($int > 0xFFFF) { > $nbytes += 2; // 5 size-bytes > }
return $nbytes; } /** * Calculate the byte needed for a „normal” integer value * @param integer $int The integer value * @return integer The number of bytes needed + 1 (because of the „marker byte”) */
< public static function bytesInt($int) {
> public static function bytesInt($int) > {
$nbytes = 1;
< if($int > 0xFF) $nbytes += 1; // 2 byte integer < if($int > 0xFFFF) $nbytes += 2; // 4 byte integer < if($int > 0xFFFFFFFF) $nbytes += 4; // 8 byte integer < if($int < 0) $nbytes += 7; // 8 byte integer (since it is signed)
> if ($int > 0xFF) { > $nbytes += 1; // 2 byte integer > } > if ($int > 0xFFFF) { > $nbytes += 2; // 4 byte integer > } > if ($int > 0xFFFFFFFF) { > $nbytes += 4; // 8 byte integer > } > if ($int < 0) { > $nbytes += 7; // 8 byte integer (since it is signed) > }
return $nbytes + 1; // one „marker” byte } /** * „pack” a value (i.e. write the binary representation as big endian to a string) with the specified size * @param integer $nbytes The number of bytes to pack * @param integer $int The integer value to pack * @return string The packed value as string */
< public static function packItWithSize($nbytes,$int) { < $formats = Array("C", "n", "N", "N");
> public static function packItWithSize($nbytes, $int) > { > $formats = array("C", "n", "N", "N");
$format = $formats[$nbytes-1];
< if($nbytes == 3) return substr(pack($format, $int), -3);
> if ($nbytes == 3) { > return substr(pack($format, $int), -3); > }
return pack($format, $int); } /** * „unpack” multiple values of the specified size (i.e. get the integers from their binary representation) from a string * @param integer $nbytes The number of bytes of each value to unpack * @param integer $buff The string packed with integer values * @return array The unpacked integers */
< public static function unpackWithSize($nbytes,$buff) { < $formats = Array("C*", "n*", "N*", "N*");
> public static function unpackWithSize($nbytes, $buff) > { > $formats = array("C*", "n*", "N*", "N*");
$format = $formats[$nbytes-1];
< if($nbytes == 3) $buff = "\0" . implode("\0", str_split($buff, 3));
> if ($nbytes == 3) { > $buff = "\0" . implode("\0", str_split($buff, 3)); > }
return unpack($format, $buff); } /** * Calculate the bytes needed to save the number of objects * @param integer $count_objects The number of objects * @return integer The number of bytes */
< public static function bytesNeeded($count_objects) {
> public static function bytesNeeded($count_objects) > {
$nbytes = 0; while($count_objects >= 1) { $nbytes++; $count_objects /= 256; } return $nbytes; } /** * Code an integer to byte representation * @param integer $int The integer value * @return string The packed byte value */
< public static function intBytes($int) {
> public static function intBytes($int) > {
$intbytes = "";
< if($int > 0xFFFF) $intbytes = "\x12".pack("N", $int); // 4 byte integer < elseif($int > 0xFF) $intbytes = "\x11".pack("n", $int); // 2 byte integer < else $intbytes = "\x10".pack("C", $int); // 8 byte integer
> if ($int > 0xFFFF) { > $intbytes = "\x12".pack("N", $int); // 4 byte integer > } elseif ($int > 0xFF) { > $intbytes = "\x11".pack("n", $int); // 2 byte integer > } else { > $intbytes = "\x10".pack("C", $int); // 8 byte integer > }
return $intbytes; } /** * Code an type byte, consisting of the type marker and the length of the type * @param string $type The type byte value (i.e. "d" for dictionaries) * @param integer $type_len The length of the type * @return string The packed type byte value */
< public static function typeBytes($type,$type_len) {
> public static function typeBytes($type, $type_len) > {
$optional_int = "";
< if($type_len < 15) $type .= sprintf("%x", $type_len); < else {
> if ($type_len < 15) { > $type .= sprintf("%x", $type_len); > } else {
$type .= "f"; $optional_int = self::intBytes($type_len); } return pack("H*", $type).$optional_int; } /** * Count number of objects and create a unique table for strings * @param $value The value to count and unique * @return void */
< protected function uniqueAndCountValues($value) {
> protected function uniqueAndCountValues($value) > {
// no uniquing for other types than CFString and CFData if($value instanceof CFNumber) { $val = $value->getValue();
< if(intval($val) == $val && !is_float($val) && strpos($val,'.') === false) $this->intSize += self::bytesInt($val); < else $this->miscSize += 9; // 9 bytes (8 + marker byte) for real
> if (intval($val) == $val && !is_float($val) && strpos($val, '.') === false) { > $this->intSize += self::bytesInt($val); > } else { > $this->miscSize += 9; // 9 bytes (8 + marker byte) for real > }
$this->countObjects++; return;
< } < elseif($value instanceof CFDate) {
> } elseif ($value instanceof CFDate) {
$this->miscSize += 9; // since date in plist is real, we need 9 byte (8 + marker byte) $this->countObjects++; return;
< } < elseif($value instanceof CFBoolean) {
> } elseif ($value instanceof CFBoolean) {
$this->countObjects++; $this->miscSize += 1; return;
< } < elseif($value instanceof CFArray) {
> } elseif ($value instanceof CFArray) {
$cnt = 0; foreach($value as $v) { ++$cnt; $this->uniqueAndCountValues($v); $this->objectRefs++; // each array member is a ref } $this->countObjects++; $this->intSize += self::bytesSizeInt($cnt); $this->miscSize++; // marker byte for array return;
< } < elseif($value instanceof CFDictionary) {
> } elseif ($value instanceof CFDictionary) {
$cnt = 0; foreach($value as $k => $v) { ++$cnt; if(!isset($this->uniqueTable[$k])) { $this->uniqueTable[$k] = 0; $len = self::binaryStrlen($k); $this->stringSize += $len + 1; $this->intSize += self::bytesSizeInt(self::charsetStrlen($k,'UTF-8')); } $this->objectRefs += 2; // both, key and value, are refs $this->uniqueTable[$k]++; $this->uniqueAndCountValues($v); } $this->countObjects++; $this->miscSize++; // marker byte for dict $this->intSize += self::bytesSizeInt($cnt); return;
< } < elseif($value instanceOf CFData) {
> } elseif ($value instanceof CFData) {
$val = $value->getValue(); $len = strlen($val); $this->intSize += self::bytesSizeInt($len); $this->miscSize += $len + 1; $this->countObjects++; return;
> } else { } > $val = $value->getValue();
< else $val = $value->getValue();
if(!isset($this->uniqueTable[$val])) { $this->uniqueTable[$val] = 0; $len = self::binaryStrlen($val); $this->stringSize += $len + 1; $this->intSize += self::bytesSizeInt(self::charsetStrlen($val,'UTF-8')); } $this->uniqueTable[$val]++; } /** * Convert CFPropertyList to binary format; since we have to count our objects we simply unique CFDictionary and CFArray * @return string The binary plist content */
< public function toBinary() { < $this->uniqueTable = Array();
> public function toBinary() > { > $this->uniqueTable = array();
$this->countObjects = 0; $this->stringSize = 0; $this->intSize = 0; $this->miscSize = 0; $this->objectRefs = 0; $this->writtenObjectCount = 0;
< $this->objectTable = Array();
> $this->objectTable = array();
$this->objectRefSize = 0;
< $this->offsets = Array();
> $this->offsets = array();
$binary_str = "bplist00"; $value = $this->getValue(true); $this->uniqueAndCountValues($value); $this->countObjects += count($this->uniqueTable); $this->objectRefSize = self::bytesNeeded($this->countObjects); $file_size = $this->stringSize + $this->intSize + $this->miscSize + $this->objectRefs * $this->objectRefSize + 40; $offset_size = self::bytesNeeded($file_size); $table_offset = $file_size - 32;
< $this->objectTable = Array();
> $this->objectTable = array();
$this->writtenObjectCount = 0;
< $this->uniqueTable = Array(); // we needed it to calculate several values
> $this->uniqueTable = array(); // we needed it to calculate several values
$value->toBinary($this); $object_offset = 8;
< $offsets = Array();
> $offsets = array();
for($i=0;$i<count($this->objectTable);++$i) { $binary_str .= $this->objectTable[$i]; $offsets[$i] = $object_offset; $object_offset += strlen($this->objectTable[$i]); } for($i=0;$i<count($offsets);++$i) { $binary_str .= self::packItWithSize($offset_size, $offsets[$i]); } $binary_str .= pack("x6CC", $offset_size, $this->objectRefSize); $binary_str .= pack("x4N", $this->countObjects); $binary_str .= pack("x4N", 0); $binary_str .= pack("x4N", $table_offset); return $binary_str; } /** * Counts the number of bytes the string will have when coded; utf-16be if non-ascii characters are present. * @param string $val The string value * @return integer The length of the coded string in bytes */
< protected static function binaryStrlen($val) {
> protected static function binaryStrlen($val) > { > $val = (string) $val; >
for($i=0;$i<strlen($val);++$i) { if(ord($val[$i]) >= 128) { $val = self::convertCharset($val, 'UTF-8', 'UTF-16BE'); return strlen($val); } } return strlen($val); } /** * Uniques and transforms a string value to binary format and adds it to the object table * @param string $val The string value * @return integer The position in the object table */
< public function stringToBinary($val) {
> public function stringToBinary($val) > {
$saved_object_count = -1; if(!isset($this->uniqueTable[$val])) { $saved_object_count = $this->writtenObjectCount++; $this->uniqueTable[$val] = $saved_object_count; $utf16 = false; for($i=0;$i<strlen($val);++$i) { if(ord($val[$i]) >= 128) { $utf16 = true; break; } } if($utf16) { $bdata = self::typeBytes("6", mb_strlen($val,'UTF-8')); // 6 is 0110, unicode string (utf16be) $val = self::convertCharset($val, 'UTF-8', 'UTF-16BE'); $this->objectTable[$saved_object_count] = $bdata.$val;
< } < else {
> } else {
$bdata = self::typeBytes("5", strlen($val)); // 5 is 0101 which is an ASCII string (seems to be ASCII encoded) $this->objectTable[$saved_object_count] = $bdata.$val; }
> } else { } > $saved_object_count = $this->uniqueTable[$val];
< else $saved_object_count = $this->uniqueTable[$val];
return $saved_object_count; } /** * Codes an integer to binary format * @param integer $value The integer value * @return string the coded integer */
< protected function intToBinary($value) {
> protected function intToBinary($value) > {
$nbytes = 0;
< if($value > 0xFF) $nbytes = 1; // 1 byte integer < if($value > 0xFFFF) $nbytes += 1; // 4 byte integer < if($value > 0xFFFFFFFF) $nbytes += 1; // 8 byte integer < if($value < 0) $nbytes = 3; // 8 byte integer, since signed
> if ($value > 0xFF) { > $nbytes = 1; // 1 byte integer > } > if ($value > 0xFFFF) { > $nbytes += 1; // 4 byte integer > } > if ($value > 0xFFFFFFFF) { > $nbytes += 1; // 8 byte integer > } > if ($value < 0) { > $nbytes = 3; // 8 byte integer, since signed > }
$bdata = self::typeBytes("1", $nbytes); // 1 is 0001, type indicator for integer $buff = ""; if($nbytes < 3) {
< if($nbytes == 0) $fmt = "C"; < elseif($nbytes == 1) $fmt = "n"; < else $fmt = "N";
> if ($nbytes == 0) { > $fmt = "C"; > } elseif ($nbytes == 1) { > $fmt = "n"; > } else { > $fmt = "N"; > }
$buff = pack($fmt, $value);
< } < else {
> } else {
if(PHP_INT_SIZE > 4) { // 64 bit signed integer; we need the higher and the lower 32 bit of the value $high_word = $value >> 32; $low_word = $value & 0xFFFFFFFF;
< } < else {
> } else {
// since PHP can only handle 32bit signed, we can only get 32bit signed values at this point - values above 0x7FFFFFFF are // floats. So we ignore the existance of 64bit on non-64bit-machines
< if($value < 0) $high_word = 0xFFFFFFFF; < else $high_word = 0;
> if ($value < 0) { > $high_word = 0xFFFFFFFF; > } else { > $high_word = 0; > }
$low_word = $value; } $buff = pack("N", $high_word).pack("N", $low_word); } return $bdata.$buff; } /** * Codes a real value to binary format * @param float $val The real value * @return string The coded real */
< protected function realToBinary($val) {
> protected function realToBinary($val) > {
$bdata = self::typeBytes("2", 3); // 2 is 0010, type indicator for reals return $bdata.strrev(pack("d", (float)$val)); }
< public function uidToBinary($value) {
> public function uidToBinary($value) > {
$saved_object_count = $this->writtenObjectCount++; $val = ""; $nbytes = 0;
< if($value > 0xFF) $nbytes = 1; // 1 byte integer < if($value > 0xFFFF) $nbytes += 1; // 4 byte integer < if($value > 0xFFFFFFFF) $nbytes += 1; // 8 byte integer < if($value < 0) $nbytes = 3; // 8 byte integer, since signed
> if ($value > 0xFF) { > $nbytes = 1; // 1 byte integer > } > if ($value > 0xFFFF) { > $nbytes += 1; // 4 byte integer > } > if ($value > 0xFFFFFFFF) { > $nbytes += 1; // 8 byte integer > } > if ($value < 0) { > $nbytes = 3; // 8 byte integer, since signed > }
$bdata = self::typeBytes("1000", $nbytes); // 1 is 0001, type indicator for integer $buff = ""; if($nbytes < 3) {
< if($nbytes == 0) $fmt = "C"; < elseif($nbytes == 1) $fmt = "n"; < else $fmt = "N";
> if ($nbytes == 0) { > $fmt = "C"; > } elseif ($nbytes == 1) { > $fmt = "n"; > } else { > $fmt = "N"; > }
$buff = pack($fmt, $value);
< } < else {
> } else {
if(PHP_INT_SIZE > 4) { // 64 bit signed integer; we need the higher and the lower 32 bit of the value $high_word = $value >> 32; $low_word = $value & 0xFFFFFFFF;
< } < else {
> } else {
// since PHP can only handle 32bit signed, we can only get 32bit signed values at this point - values above 0x7FFFFFFF are // floats. So we ignore the existance of 64bit on non-64bit-machines
< if($value < 0) $high_word = 0xFFFFFFFF; < else $high_word = 0;
> if ($value < 0) { > $high_word = 0xFFFFFFFF; > } else { > $high_word = 0; > }
$low_word = $value; } $buff = pack("N", $high_word).pack("N", $low_word); } $val = $bdata.$buff; $this->objectTable[$saved_object_count] = $val; return $saved_object_count; } /** * Converts a numeric value to binary and adds it to the object table * @param numeric $value The numeric value * @return integer The position in the object table */
< public function numToBinary($value) {
> public function numToBinary($value) > {
$saved_object_count = $this->writtenObjectCount++; $val = "";
< if(intval($value) == $value && !is_float($value) && strpos($value,'.') === false) $val = $this->intToBinary($value); < else $val = $this->realToBinary($value);
> if (intval($value) == $value && !is_float($value) && strpos($value, '.') === false) { > $val = $this->intToBinary($value); > } else { > $val = $this->realToBinary($value); > }
$this->objectTable[$saved_object_count] = $val; return $saved_object_count; } /** * Convert date value (apple format) to binary and adds it to the object table * @param integer $value The date value * @return integer The position of the coded value in the object table */
< public function dateToBinary($val) {
> public function dateToBinary($val) > {
$saved_object_count = $this->writtenObjectCount++; $hour = gmdate("H",$val); $min = gmdate("i",$val); $sec = gmdate("s",$val); $mday = gmdate("j",$val); $mon = gmdate("n",$val); $year = gmdate("Y",$val); $val = gmmktime($hour,$min,$sec,$mon,$mday,$year) - CFDate::DATE_DIFF_APPLE_UNIX; // CFDate is a real, number of seconds since 01/01/2001 00:00:00 GMT $bdata = self::typeBytes("3", 3); // 3 is 0011, type indicator for date $this->objectTable[$saved_object_count] = $bdata.strrev(pack("d", $val)); return $saved_object_count; } /** * Convert a bool value to binary and add it to the object table * @param bool $val The boolean value * @return integer The position in the object table */
< public function boolToBinary($val) {
> public function boolToBinary($val) > {
$saved_object_count = $this->writtenObjectCount++; $this->objectTable[$saved_object_count] = $val ? "\x9" : "\x8"; // 0x9 is 1001, type indicator for true; 0x8 is 1000, type indicator for false return $saved_object_count; } /** * Convert data value to binary format and add it to the object table * @param string $val The data value * @return integer The position in the object table */
< public function dataToBinary($val) {
> public function dataToBinary($val) > {
$saved_object_count = $this->writtenObjectCount++; $bdata = self::typeBytes("4", strlen($val)); // a is 1000, type indicator for data $this->objectTable[$saved_object_count] = $bdata.$val; return $saved_object_count; } /** * Convert array to binary format and add it to the object table * @param CFArray $val The array to convert * @return integer The position in the object table */
< public function arrayToBinary($val) {
> public function arrayToBinary($val) > {
$saved_object_count = $this->writtenObjectCount++; $bdata = self::typeBytes("a", count($val->getValue())); // a is 1010, type indicator for arrays foreach($val as $v) { $bval = $v->toBinary($this); $bdata .= self::packItWithSize($this->objectRefSize, $bval); } $this->objectTable[$saved_object_count] = $bdata; return $saved_object_count; } /** * Convert dictionary to binary format and add it to the object table * @param CFDictionary $val The dict to convert * @return integer The position in the object table */
< public function dictToBinary($val) {
> public function dictToBinary($val) > {
$saved_object_count = $this->writtenObjectCount++; $bdata = self::typeBytes("d", count($val->getValue())); // d=1101, type indicator for dictionary foreach($val as $k => $v) { $str = new CFString($k); $key = $str->toBinary($this); $bdata .= self::packItWithSize($this->objectRefSize, $key); } foreach($val as $k => $v) { $bval = $v->toBinary($this); $bdata .= self::packItWithSize($this->objectRefSize, $bval); } $this->objectTable[$saved_object_count] = $bdata; return $saved_object_count; }
<
} # eof