505 lines
17 KiB
PHP
505 lines
17 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Amf
|
|
* @subpackage Parse_Amf3
|
|
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id: Serializer.php 16971 2009-07-22 18:05:45Z mikaelkael $
|
|
*/
|
|
|
|
/** Zend_Amf_Parse_Serializer */
|
|
require_once 'Zend/Amf/Parse/Serializer.php';
|
|
|
|
/** Zend_Amf_Parse_TypeLoader */
|
|
require_once 'Zend/Amf/Parse/TypeLoader.php';
|
|
|
|
/**
|
|
* Detect PHP object type and convert it to a corresponding AMF3 object type
|
|
*
|
|
* @package Zend_Amf
|
|
* @subpackage Parse_Amf3
|
|
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
class Zend_Amf_Parse_Amf3_Serializer extends Zend_Amf_Parse_Serializer
|
|
{
|
|
/**
|
|
* An array of reference objects per amf body
|
|
* @var array
|
|
*/
|
|
protected $_referenceObjects = array();
|
|
|
|
/**
|
|
* An array of reference strings per amf body
|
|
* @var array
|
|
*/
|
|
protected $_referenceStrings = array();
|
|
|
|
/**
|
|
* An array of reference class definitions, indexed by classname
|
|
* @var array
|
|
*/
|
|
protected $_referenceDefinitions = array();
|
|
|
|
/**
|
|
* Serialize PHP types to AMF3 and write to stream
|
|
*
|
|
* Checks to see if the type was declared and then either
|
|
* auto negotiates the type or use the user defined markerType to
|
|
* serialize the data from php back to AMF3
|
|
*
|
|
* @param mixed $content
|
|
* @param int $markerType
|
|
* @return void
|
|
*/
|
|
public function writeTypeMarker($data, $markerType=null)
|
|
{
|
|
if (null !== $markerType) {
|
|
// Write the Type Marker to denote the following action script data type
|
|
$this->_stream->writeByte($markerType);
|
|
|
|
switch ($markerType) {
|
|
case Zend_Amf_Constants::AMF3_NULL:
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_BOOLEAN_FALSE:
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_BOOLEAN_TRUE:
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_INTEGER:
|
|
$this->writeInteger($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_NUMBER:
|
|
$this->_stream->writeDouble($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_STRING:
|
|
$this->writeString($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_DATE:
|
|
$this->writeDate($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_ARRAY:
|
|
$this->writeArray($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_OBJECT:
|
|
$this->writeObject($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_BYTEARRAY:
|
|
$this->writeByteArray($data);
|
|
break;
|
|
case Zend_Amf_Constants::AMF3_XMLSTRING;
|
|
$this->writeXml($data);
|
|
break;
|
|
default:
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Unknown Type Marker: ' . $markerType);
|
|
}
|
|
} else {
|
|
// Detect Type Marker
|
|
if(is_resource($data)) {
|
|
$data = Zend_Amf_Parse_TypeLoader::handleResource($data);
|
|
}
|
|
switch (true) {
|
|
case (null === $data):
|
|
$markerType = Zend_Amf_Constants::AMF3_NULL;
|
|
break;
|
|
case (is_bool($data)):
|
|
if ($data){
|
|
$markerType = Zend_Amf_Constants::AMF3_BOOLEAN_TRUE;
|
|
} else {
|
|
$markerType = Zend_Amf_Constants::AMF3_BOOLEAN_FALSE;
|
|
}
|
|
break;
|
|
case (is_int($data)):
|
|
if (($data > 0xFFFFFFF) || ($data < -268435456)) {
|
|
$markerType = Zend_Amf_Constants::AMF3_NUMBER;
|
|
} else {
|
|
$markerType = Zend_Amf_Constants::AMF3_INTEGER;
|
|
}
|
|
break;
|
|
case (is_float($data)):
|
|
$markerType = Zend_Amf_Constants::AMF3_NUMBER;
|
|
break;
|
|
case (is_string($data)):
|
|
$markerType = Zend_Amf_Constants::AMF3_STRING;
|
|
break;
|
|
case (is_array($data)):
|
|
$markerType = Zend_Amf_Constants::AMF3_ARRAY;
|
|
break;
|
|
case (is_object($data)):
|
|
// Handle object types.
|
|
if (($data instanceof DateTime) || ($data instanceof Zend_Date)) {
|
|
$markerType = Zend_Amf_Constants::AMF3_DATE;
|
|
} else if ($data instanceof Zend_Amf_Value_ByteArray) {
|
|
$markerType = Zend_Amf_Constants::AMF3_BYTEARRAY;
|
|
} else if (($data instanceof DOMDocument) || ($data instanceof SimpleXMLElement)) {
|
|
$markerType = Zend_Amf_Constants::AMF3_XMLSTRING;
|
|
} else {
|
|
$markerType = Zend_Amf_Constants::AMF3_OBJECT;
|
|
}
|
|
break;
|
|
default:
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Unsupported data type: ' . gettype($data));
|
|
}
|
|
$this->writeTypeMarker($data, $markerType);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write an AMF3 integer
|
|
*
|
|
* @param int|float $data
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeInteger($int)
|
|
{
|
|
if (($int & 0xffffff80) == 0) {
|
|
$this->_stream->writeByte($int & 0x7f);
|
|
return $this;
|
|
}
|
|
|
|
if (($int & 0xffffc000) == 0 ) {
|
|
$this->_stream->writeByte(($int >> 7 ) | 0x80);
|
|
$this->_stream->writeByte($int & 0x7f);
|
|
return $this;
|
|
}
|
|
|
|
if (($int & 0xffe00000) == 0) {
|
|
$this->_stream->writeByte(($int >> 14 ) | 0x80);
|
|
$this->_stream->writeByte(($int >> 7 ) | 0x80);
|
|
$this->_stream->writeByte($int & 0x7f);
|
|
return $this;
|
|
}
|
|
|
|
$this->_stream->writeByte(($int >> 22 ) | 0x80);
|
|
$this->_stream->writeByte(($int >> 15 ) | 0x80);
|
|
$this->_stream->writeByte(($int >> 8 ) | 0x80);
|
|
$this->_stream->writeByte($int & 0xff);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Send string to output stream, without trying to reference it.
|
|
* The string is prepended with strlen($string) << 1 | 0x01
|
|
*
|
|
* @param string $string
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
protected function writeBinaryString($string){
|
|
$ref = strlen($string) << 1 | 0x01;
|
|
$this->writeInteger($ref);
|
|
$this->_stream->writeBytes($string);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Send string to output stream
|
|
*
|
|
* @param string $string
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeString($string)
|
|
{
|
|
$len = strlen($string);
|
|
if(!$len){
|
|
$this->writeInteger(0x01);
|
|
return $this;
|
|
}
|
|
|
|
$ref = array_search($string, $this->_referenceStrings, true);
|
|
if($ref === false){
|
|
$this->_referenceStrings[] = $string;
|
|
$this->writeBinaryString($string);
|
|
} else {
|
|
$ref <<= 1;
|
|
$this->writeInteger($ref);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Send ByteArray to output stream
|
|
*
|
|
* @param string|Zend_Amf_Value_ByteArray $data
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeByteArray($data){
|
|
if($this->writeObjectReference($data)){
|
|
return $this;
|
|
}
|
|
|
|
if(is_string($data)) {
|
|
//nothing to do
|
|
} else if ($data instanceof Zend_Amf_Value_ByteArray) {
|
|
$data = $data->getData();
|
|
} else {
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Invalid ByteArray specified; must be a string or Zend_Amf_Value_ByteArray');
|
|
}
|
|
|
|
$this->writeBinaryString($data);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Send xml to output stream
|
|
*
|
|
* @param DOMDocument|SimpleXMLElement $xml
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeXml($xml)
|
|
{
|
|
if($this->writeObjectReference($xml)){
|
|
return $this;
|
|
}
|
|
|
|
if(is_string($xml)) {
|
|
//nothing to do
|
|
} else if ($xml instanceof DOMDocument) {
|
|
$xml = $xml->saveXml();
|
|
} else if ($xml instanceof SimpleXMLElement) {
|
|
$xml = $xml->asXML();
|
|
} else {
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Invalid xml specified; must be a DOMDocument or SimpleXMLElement');
|
|
}
|
|
|
|
$this->writeBinaryString($xml);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Convert DateTime/Zend_Date to AMF date
|
|
*
|
|
* @param DateTime|Zend_Date $date
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeDate($date)
|
|
{
|
|
if($this->writeObjectReference($date)){
|
|
return $this;
|
|
}
|
|
|
|
if ($date instanceof DateTime) {
|
|
$dateString = $date->format('U') * 1000;
|
|
} elseif ($date instanceof Zend_Date) {
|
|
$dateString = $date->toString('U') * 1000;
|
|
} else {
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Invalid date specified; must be a string DateTime or Zend_Date object');
|
|
}
|
|
|
|
$this->writeInteger(0x01);
|
|
// write time to stream minus milliseconds
|
|
$this->_stream->writeDouble($dateString);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Write a PHP array back to the amf output stream
|
|
*
|
|
* @param array $array
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeArray(array $array)
|
|
{
|
|
if($this->writeObjectReference($array)){
|
|
return $this;
|
|
}
|
|
|
|
// have to seperate mixed from numberic keys.
|
|
$numeric = array();
|
|
$string = array();
|
|
foreach ($array as $key => $value) {
|
|
if (is_int($key)) {
|
|
$numeric[] = $value;
|
|
} else {
|
|
$string[$key] = $value;
|
|
}
|
|
}
|
|
|
|
// write the preamble id of the array
|
|
$length = count($numeric);
|
|
$id = ($length << 1) | 0x01;
|
|
$this->writeInteger($id);
|
|
|
|
//Write the mixed type array to the output stream
|
|
foreach($string as $key => $value) {
|
|
$this->writeString($key)
|
|
->writeTypeMarker($value);
|
|
}
|
|
$this->writeString('');
|
|
|
|
// Write the numeric array to ouput stream
|
|
foreach($numeric as $value) {
|
|
$this->writeTypeMarker($value);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Check if the given object is in the reference table, write the reference if it exists,
|
|
* otherwise add the object to the reference table
|
|
*
|
|
* @param mixed $object object to check for reference
|
|
* @return Boolean true, if the reference was written, false otherwise
|
|
*/
|
|
protected function writeObjectReference($object){
|
|
$ref = array_search($object, $this->_referenceObjects,true);
|
|
//quickly handle object references
|
|
if($ref !== false){
|
|
$ref <<= 1;
|
|
$this->writeInteger($ref);
|
|
return true;
|
|
}
|
|
$this->_referenceObjects[] = $object;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Write object to ouput stream
|
|
*
|
|
* @param mixed $data
|
|
* @return Zend_Amf_Parse_Amf3_Serializer
|
|
*/
|
|
public function writeObject($object)
|
|
{
|
|
if($this->writeObjectReference($object)){
|
|
return $this;
|
|
}
|
|
|
|
$className = '';
|
|
|
|
//Check to see if the object is a typed object and we need to change
|
|
switch (true) {
|
|
// the return class mapped name back to actionscript class name.
|
|
case ($className = Zend_Amf_Parse_TypeLoader::getMappedClassName(get_class($object))):
|
|
break;
|
|
|
|
// Check to see if the user has defined an explicit Action Script type.
|
|
case isset($object->_explicitType):
|
|
$className = $object->_explicitType;
|
|
break;
|
|
|
|
// Check if user has defined a method for accessing the Action Script type
|
|
case method_exists($object, 'getASClassName'):
|
|
$className = $object->getASClassName();
|
|
break;
|
|
|
|
// No return class name is set make it a generic object
|
|
case ($object instanceof stdClass):
|
|
$className = '';
|
|
break;
|
|
|
|
// By default, use object's class name
|
|
default:
|
|
$className = get_class($object);
|
|
break;
|
|
}
|
|
|
|
$writeTraits = true;
|
|
|
|
//check to see, if we have a corresponding definition
|
|
if(array_key_exists($className, $this->_referenceDefinitions)){
|
|
$traitsInfo = $this->_referenceDefinitions[$className]['id'];
|
|
$encoding = $this->_referenceDefinitions[$className]['encoding'];
|
|
$propertyNames = $this->_referenceDefinitions[$className]['propertyNames'];
|
|
|
|
$traitsInfo = ($traitsInfo << 2) | 0x01;
|
|
|
|
$writeTraits = false;
|
|
} else {
|
|
$propertyNames = array();
|
|
|
|
if($className == ''){
|
|
//if there is no className, we interpret the class as dynamic without any sealed members
|
|
$encoding = Zend_Amf_Constants::ET_DYNAMIC;
|
|
} else {
|
|
$encoding = Zend_Amf_Constants::ET_PROPLIST;
|
|
|
|
foreach($object as $key => $value) {
|
|
if( $key[0] != "_") {
|
|
$propertyNames[] = $key;
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->_referenceDefinitions[$className] = array(
|
|
'id' => count($this->_referenceDefinitions),
|
|
'encoding' => $encoding,
|
|
'propertyNames' => $propertyNames,
|
|
);
|
|
|
|
$traitsInfo = Zend_Amf_Constants::AMF3_OBJECT_ENCODING;
|
|
$traitsInfo |= $encoding << 2;
|
|
$traitsInfo |= (count($propertyNames) << 4);
|
|
}
|
|
|
|
$this->writeInteger($traitsInfo);
|
|
|
|
if($writeTraits){
|
|
$this->writeString($className);
|
|
foreach ($propertyNames as $value) {
|
|
$this->writeString($value);
|
|
}
|
|
}
|
|
|
|
try {
|
|
switch($encoding) {
|
|
case Zend_Amf_Constants::ET_PROPLIST:
|
|
//Write the sealed values to the output stream.
|
|
foreach ($propertyNames as $key) {
|
|
$this->writeTypeMarker($object->$key);
|
|
}
|
|
break;
|
|
case Zend_Amf_Constants::ET_DYNAMIC:
|
|
//Write the sealed values to the output stream.
|
|
foreach ($propertyNames as $key) {
|
|
$this->writeTypeMarker($object->$key);
|
|
}
|
|
|
|
//Write remaining properties
|
|
foreach($object as $key => $value){
|
|
if(!in_array($key,$propertyNames) && $key[0] != "_"){
|
|
$this->writeString($key);
|
|
$this->writeTypeMarker($value);
|
|
}
|
|
}
|
|
|
|
//Write an empty string to end the dynamic part
|
|
$this->writeString('');
|
|
break;
|
|
case Zend_Amf_Constants::ET_EXTERNAL:
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('External Object Encoding not implemented');
|
|
break;
|
|
default:
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Unknown Object Encoding type: ' . $encoding);
|
|
}
|
|
} catch (Exception $e) {
|
|
require_once 'Zend/Amf/Exception.php';
|
|
throw new Zend_Amf_Exception('Unable to writeObject output: ' . $e->getMessage());
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
}
|