1 <?php

     2 /**

     3  * Zend Framework

     4  *

     5  * LICENSE

     6  *

     7  * This source file is subject to the new BSD license that is bundled

     8  * with this package in the file LICENSE.txt.

     9  * It is also available through the world-wide-web at this URL:

    10  * http://framework.zend.com/license/new-bsd

    11  * If you did not receive a copy of the license and are unable to

    12  * obtain it through the world-wide-web, please send an email

    13  * to license@zend.com so we can send you a copy immediately.

    14  *

    15  * @category   Zend

    16  * @package    Zend_Amf

    17  * @subpackage Parse_Amf3

    18  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    19  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    20  * @version    $Id: Deserializer.php 21968 2010-04-22 03:53:34Z matthew $

    21  */

    22 

    23 /** Zend_Amf_Parse_Deserializer */

    24 require_once 'Zend/Amf/Parse/Deserializer.php';

    25 

    26 /** Zend_Amf_Parse_TypeLoader */

    27 require_once 'Zend/Amf/Parse/TypeLoader.php';

    28 

    29 /**

    30  * Read an AMF3 input stream and convert it into PHP data types.

    31  *

    32  * @todo       readObject to handle Typed Objects

    33  * @todo       readXMLStrimg to be implemented.

    34  * @todo       Class could be implemented as Factory Class with each data type it's own class.

    35  * @package    Zend_Amf

    36  * @subpackage Parse_Amf3

    37  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    38  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    39  */

    40 class Zend_Amf_Parse_Amf3_Deserializer extends Zend_Amf_Parse_Deserializer

    41 {

    42     /**

    43      * Total number of objects in the referenceObject array

    44      * @var int

    45      */

    46     protected $_objectCount;

    47 

    48     /**

    49      * An array of reference objects per amf body

    50      * @var array

    51      */

    52     protected $_referenceObjects = array();

    53 

    54     /**

    55      * An array of reference strings per amf body

    56      * @var array

    57      */

    58     protected $_referenceStrings = array();

    59 

    60     /**

    61      * An array of reference class definitions per body

    62      * @var array

    63      */

    64     protected $_referenceDefinitions = array();

    65 

    66     /**

    67      * Read AMF markers and dispatch for deserialization

    68      *

    69      * Checks for AMF marker types and calls the appropriate methods

    70      * for deserializing those marker types. markers are the data type of

    71      * the following value.

    72      *

    73      * @param  integer $typeMarker

    74      * @return mixed Whatever the corresponding PHP data type is

    75      * @throws Zend_Amf_Exception for unidentified marker type

    76      */

    77     public function readTypeMarker($typeMarker = null)

    78     {

    79         if(null === $typeMarker) {

    80             $typeMarker = $this->_stream->readByte();

    81         }

    82 

    83         switch($typeMarker) {

    84             case Zend_Amf_Constants::AMF3_UNDEFINED:

    85                  return null;

    86             case Zend_Amf_Constants::AMF3_NULL:

    87                  return null;

    88             case Zend_Amf_Constants::AMF3_BOOLEAN_FALSE:

    89                  return false;

    90             case Zend_Amf_Constants::AMF3_BOOLEAN_TRUE:

    91                  return true;

    92             case Zend_Amf_Constants::AMF3_INTEGER:

    93                  return $this->readInteger();

    94             case Zend_Amf_Constants::AMF3_NUMBER:

    95                  return $this->_stream->readDouble();

    96             case Zend_Amf_Constants::AMF3_STRING:

    97                  return $this->readString();

    98             case Zend_Amf_Constants::AMF3_DATE:

    99                  return $this->readDate();

   100             case Zend_Amf_Constants::AMF3_ARRAY:

   101                  return $this->readArray();

   102             case Zend_Amf_Constants::AMF3_OBJECT:

   103                  return $this->readObject();

   104             case Zend_Amf_Constants::AMF3_XML:

   105             case Zend_Amf_Constants::AMF3_XMLSTRING:

   106                  return $this->readXmlString();

   107             case Zend_Amf_Constants::AMF3_BYTEARRAY:

   108                  return $this->readString();

   109             default:

   110                 require_once 'Zend/Amf/Exception.php';

   111                 throw new Zend_Amf_Exception('Unsupported type marker: ' . $typeMarker);

   112         }

   113     }

   114 

   115     /**

   116      * Read and deserialize an integer

   117      *

   118      * AMF 3 represents smaller integers with fewer bytes using the most

   119      * significant bit of each byte. The worst case uses 32-bits

   120      * to represent a 29-bit number, which is what we would have

   121      * done with no compression.

   122      * - 0x00000000 - 0x0000007F : 0xxxxxxx

   123      * - 0x00000080 - 0x00003FFF : 1xxxxxxx 0xxxxxxx

   124      * - 0x00004000 - 0x001FFFFF : 1xxxxxxx 1xxxxxxx 0xxxxxxx

   125      * - 0x00200000 - 0x3FFFFFFF : 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx

   126      * - 0x40000000 - 0xFFFFFFFF : throw range exception

   127      *

   128      * 0x04 -> integer type code, followed by up to 4 bytes of data.

   129      *

   130      * Parsing integers on OSFlash for the AMF3 integer data format:

   131      * @link http://osflash.org/amf3/parsing_integers

   132      * @return int|float

   133      */

   134     public function readInteger()

   135     {

   136         $count        = 1;

   137         $intReference = $this->_stream->readByte();

   138         $result       = 0;

   139         while ((($intReference & 0x80) != 0) && $count < 4) {

   140             $result       <<= 7;

   141             $result        |= ($intReference & 0x7f);

   142             $intReference   = $this->_stream->readByte();

   143             $count++;

   144         }

   145         if ($count < 4) {

   146             $result <<= 7;

   147             $result  |= $intReference;

   148         } else {

   149             // Use all 8 bits from the 4th byte

   150             $result <<= 8;

   151             $result  |= $intReference;

   152 

   153             // Check if the integer should be negative

   154             if (($result & 0x10000000) != 0) {

   155                 //and extend the sign bit

   156                 $result |= ~0xFFFFFFF;

   157             }

   158         }

   159         return $result;

   160     }

   161 

   162     /**

   163      * Read and deserialize a string

   164      *

   165      * Strings can be sent as a reference to a previously

   166      * occurring String by using an index to the implicit string reference table.

   167      * Strings are encoding using UTF-8 - however the header may either

   168      * describe a string literal or a string reference.

   169      *

   170      * - string = 0x06 string-data

   171      * - string-data = integer-data [ modified-utf-8 ]

   172      * - modified-utf-8 = *OCTET

   173      *

   174      * @return String

   175      */

   176     public function readString()

   177     {

   178         $stringReference = $this->readInteger();

   179 

   180         //Check if this is a reference string

   181         if (($stringReference & 0x01) == 0) {

   182             // reference string

   183             $stringReference = $stringReference >> 1;

   184             if ($stringReference >= count($this->_referenceStrings)) {

   185                 require_once 'Zend/Amf/Exception.php';

   186                 throw new Zend_Amf_Exception('Undefined string reference: ' . $stringReference);

   187             }

   188             // reference string found

   189             return $this->_referenceStrings[$stringReference];

   190         }

   191 

   192         $length = $stringReference >> 1;

   193         if ($length) {

   194             $string = $this->_stream->readBytes($length);

   195             $this->_referenceStrings[] = $string;

   196         } else {

   197             $string = "";

   198         }

   199         return $string;

   200     }

   201 

   202     /**

   203      * Read and deserialize a date

   204      *

   205      * Data is the number of milliseconds elapsed since the epoch

   206      * of midnight, 1st Jan 1970 in the UTC time zone.

   207      * Local time zone information is not sent to flash.

   208      *

   209      * - date = 0x08 integer-data [ number-data ]

   210      *

   211      * @return Zend_Date

   212      */

   213     public function readDate()

   214     {

   215         $dateReference = $this->readInteger();

   216         if (($dateReference & 0x01) == 0) {

   217             $dateReference = $dateReference >> 1;

   218             if ($dateReference>=count($this->_referenceObjects)) {

   219                 require_once 'Zend/Amf/Exception.php';

   220                 throw new Zend_Amf_Exception('Undefined date reference: ' . $dateReference);

   221             }

   222             return $this->_referenceObjects[$dateReference];

   223         }

   224 

   225         $timestamp = floor($this->_stream->readDouble() / 1000);

   226 

   227         require_once 'Zend/Date.php';

   228         $dateTime  = new Zend_Date((int) $timestamp);

   229         $this->_referenceObjects[] = $dateTime;

   230         return $dateTime;

   231     }

   232 

   233     /**

   234      * Read amf array to PHP array

   235      *

   236      * - array = 0x09 integer-data ( [ 1OCTET *amf3-data ] | [OCTET *amf3-data 1] | [ OCTET *amf-data ] )

   237      *

   238      * @return array

   239      */

   240     public function readArray()

   241     {

   242         $arrayReference = $this->readInteger();

   243         if (($arrayReference & 0x01)==0){

   244             $arrayReference = $arrayReference >> 1;

   245             if ($arrayReference>=count($this->_referenceObjects)) {

   246                 require_once 'Zend/Amf/Exception.php';

   247                 throw new Zend_Amf_Exception('Unknow array reference: ' . $arrayReference);

   248             }

   249             return $this->_referenceObjects[$arrayReference];

   250         }

   251 

   252         // Create a holder for the array in the reference list

   253         $data = array();

   254         $this->_referenceObjects[] =& $data;

   255         $key = $this->readString();

   256 

   257         // Iterating for string based keys.

   258         while ($key != '') {

   259             $data[$key] = $this->readTypeMarker();

   260             $key = $this->readString();

   261         }

   262 

   263         $arrayReference = $arrayReference >>1;

   264 

   265         //We have a dense array

   266         for ($i=0; $i < $arrayReference; $i++) {

   267             $data[] = $this->readTypeMarker();

   268         }

   269 

   270         return $data;

   271     }

   272 

   273     /**

   274      * Read an object from the AMF stream and convert it into a PHP object

   275      *

   276      * @todo   Rather than using an array of traitsInfo create Zend_Amf_Value_TraitsInfo

   277      * @return object|array

   278      */

   279     public function readObject()

   280     {

   281         $traitsInfo   = $this->readInteger();

   282         $storedObject = ($traitsInfo & 0x01)==0;

   283         $traitsInfo   = $traitsInfo >> 1;

   284 

   285         // Check if the Object is in the stored Objects reference table

   286         if ($storedObject) {

   287             $ref = $traitsInfo;

   288             if (!isset($this->_referenceObjects[$ref])) {

   289                 require_once 'Zend/Amf/Exception.php';

   290                 throw new Zend_Amf_Exception('Unknown Object reference: ' . $ref);

   291             }

   292             $returnObject = $this->_referenceObjects[$ref];

   293         } else {

   294             // Check if the Object is in the stored Definitions reference table

   295             $storedClass = ($traitsInfo & 0x01) == 0;

   296             $traitsInfo  = $traitsInfo >> 1;

   297             if ($storedClass) {

   298                 $ref = $traitsInfo;

   299                 if (!isset($this->_referenceDefinitions[$ref])) {

   300                     require_once 'Zend/Amf/Exception.php';

   301                     throw new Zend_Amf_Exception('Unknows Definition reference: '. $ref);

   302                 }

   303                 // Populate the reference attributes

   304                 $className     = $this->_referenceDefinitions[$ref]['className'];

   305                 $encoding      = $this->_referenceDefinitions[$ref]['encoding'];

   306                 $propertyNames = $this->_referenceDefinitions[$ref]['propertyNames'];

   307             } else {

   308                 // The class was not in the reference tables. Start reading rawdata to build traits.

   309                 // Create a traits table. Zend_Amf_Value_TraitsInfo would be ideal

   310                 $className     = $this->readString();

   311                 $encoding      = $traitsInfo & 0x03;

   312                 $propertyNames = array();

   313                 $traitsInfo    = $traitsInfo >> 2;

   314             }

   315 

   316             // We now have the object traits defined in variables. Time to go to work:

   317             if (!$className) {

   318                 // No class name generic object

   319                 $returnObject = new stdClass();

   320             } else {

   321                 // Defined object

   322                 // Typed object lookup against registered classname maps

   323                 if ($loader = Zend_Amf_Parse_TypeLoader::loadType($className)) {

   324                     $returnObject = new $loader();

   325                 } else {

   326                     //user defined typed object

   327                     require_once 'Zend/Amf/Exception.php';

   328                     throw new Zend_Amf_Exception('Typed object not found: '. $className . ' ');

   329                 }

   330             }

   331 

   332             // Add the Object to the reference table

   333             $this->_referenceObjects[] = $returnObject;

   334 

   335             $properties = array(); // clear value

   336             // Check encoding types for additional processing.

   337             switch ($encoding) {

   338                 case (Zend_Amf_Constants::ET_EXTERNAL):

   339                     // Externalizable object such as {ArrayCollection} and {ObjectProxy}

   340                     if (!$storedClass) {

   341                         $this->_referenceDefinitions[] = array(

   342                             'className'     => $className,

   343                             'encoding'      => $encoding,

   344                             'propertyNames' => $propertyNames,

   345                         );

   346                     }

   347                     $returnObject->externalizedData = $this->readTypeMarker();

   348                     break;

   349                 case (Zend_Amf_Constants::ET_DYNAMIC):

   350                     // used for Name-value encoding

   351                     if (!$storedClass) {

   352                         $this->_referenceDefinitions[] = array(

   353                             'className'     => $className,

   354                             'encoding'      => $encoding,

   355                             'propertyNames' => $propertyNames,

   356                         );

   357                     }

   358                     // not a reference object read name value properties from byte stream

   359                     do {

   360                         $property = $this->readString();

   361                         if ($property != "") {

   362                             $propertyNames[]       = $property;

   363                             $properties[$property] = $this->readTypeMarker();

   364                         }

   365                     } while ($property !="");

   366                     break;

   367                 default:

   368                     // basic property list object.

   369                     if (!$storedClass) {

   370                         $count = $traitsInfo; // Number of properties in the list

   371                         for($i=0; $i< $count; $i++) {

   372                             $propertyNames[] = $this->readString();

   373                         }

   374                         // Add a reference to the class.

   375                         $this->_referenceDefinitions[] = array(

   376                             'className'     => $className,

   377                             'encoding'      => $encoding,

   378                             'propertyNames' => $propertyNames,

   379                         );

   380                     }

   381                     foreach ($propertyNames as $property) {

   382                         $properties[$property] = $this->readTypeMarker();

   383                     }

   384                     break;

   385             }

   386 

   387             // Add properties back to the return object.

   388             foreach($properties as $key=>$value) {

   389                 if($key) {

   390                     $returnObject->$key = $value;

   391                 }

   392             }

   393 

   394 

   395         }

   396 

   397        if ($returnObject instanceof Zend_Amf_Value_Messaging_ArrayCollection) {

   398             if (isset($returnObject->externalizedData)) {

   399                 $returnObject = $returnObject->externalizedData;

   400             } else {

   401                 $returnObject = get_object_vars($returnObject);

   402             }

   403        }

   404 

   405         return $returnObject;

   406     }

   407 

   408     /**

   409      * Convert XML to SimpleXml

   410      * If user wants DomDocument they can use dom_import_simplexml

   411      *

   412      * @return SimpleXml Object

   413      */

   414     public function readXmlString()

   415     {

   416         $xmlReference = $this->readInteger();

   417         $length = $xmlReference >> 1;

   418         $string = $this->_stream->readBytes($length);

   419         return simplexml_load_string($string);

   420     }

   421 }