public function processCall($payload)
{
$this->checkPermutationStrongName();
try {
$rpcRequest = RPC::decodeRequest($payload, Classes::classOf($this->delegate), $this);
$this->onAfterRequestDeserialized($rpcRequest);
return RPC::invokeAndEncodeResponse($this->delegate, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getFlags());
} catch (IncompatibleRemoteServiceException $ex) {
echo $ex;
/*log(
"An IncompatibleRemoteServiceException was thrown while processing this call.",
ex);
*/
return RPC::encodeResponseForFailure(null, $ex);
} catch (RpcTokenException $ex) {
//log("An RpcTokenException was thrown while processing this call.",
//tokenException);
return RPC::encodeResponseForFailure(null, $ex);
}
}
/** @return boolean */
public function objectCall(CustomObject $param)
{
if (Classes::classOf($param) != Classes::classOf('CustomObject')) {
return false;
}
return $param->number == 5;
}
private static function maybeDeobfuscate(ServerSerializationStreamReader $streamReader, $name)
{
if ($streamReader->hasFlags(AbstractSerializationStream::FLAG_ELIDE_TYPE_NAMES)) {
$serializationPolicy = $streamReader->getSerializationPolicy();
if (!serializationPolicy instanceof TypeNameObfuscator) {
throw new IncompatibleRemoteServiceException('RPC request was encoded with obfuscated type names, ' . 'but the SerializationPolicy in use does not implement ' . Classes::classOf(TypeNameObfuscator)->getName());
}
$maybe = $serializationPolicy->getClassNameForTypeId($name);
if (!is_null($maybe)) {
return $maybe;
}
} else {
if (($index = mb_strpos($name, '/')) !== false) {
return mb_substr($name, 0, $index);
}
}
return $name;
}
private function makeObject(Clazz $type, $value)
{
// no anonymous class, and no local class in php
$manualType = $type;
$customSerializer = null;
do {
$customSerializer = SerializabilityUtil::hasCustomFieldSerializer($manualType);
if ($customSerializer != null) {
break;
}
$manualType = $manualType->getSuperClass();
} while ($manualType != null);
$ins = null;
if ($customSerializer != null) {
$ins = $this->serializeWithCustomSerializer($customSerializer, $value, $type, $manualType);
} else {
$ins = new InstantiateCommand($type);
$this->identityMap->put($value, $ins);
}
if ($type != $manualType) {
if (!Classes::classOf('GWTSerializable')->isAssignableFrom($type) && !Classes::classOf('IsSerializable')->isAssignableFrom($type)) {
throw new SerializationException($type->getName() . ' is not a serializable type');
}
}
while ($type != $manualType) {
$serializableFields = $this->clientOracle->getOperableFields($type);
foreach ($serializableFields as $declField) {
assert($declField != null);
//echo '[' . $declField->getName() . ' = ' . $declField->getType() . ']<br />';
$accessor = Accessors::get($declField->getType());
$valueCommand = null;
$fieldValue = $accessor->get($value, $declField);
if (is_null($fieldValue)) {
$valueCommand = NullValueCommand::INSTANCE();
} else {
$fieldType = $declField->getType()->isPrimitive() ? $declField->getType() : ($declField->hasType() ? $declField->getType() : Classes::classOfValue($fieldValue));
$valueCommand = $this->makeValue($fieldType, $fieldValue);
}
//echo '{set ' . $declField->getDeclaringClass()->getName() . ' / ' . $declField->getName() . ' / ' . $valueCommand . '}';
$ins->set($declField->getDeclaringClass(), $declField->getName(), $valueCommand);
}
$type = $type->getSuperClass();
}
return $ins;
}
protected function deserialize($typeSignature)
{
$instance = null;
try {
$instanceClass = null;
if ($this->hasFlags(self::FLAG_ELIDE_TYPE_NAMES)) {
if ($this->getSerializationPolicy() instanceof TypeNameObfuscator) {
$obfuscator = $this->getSerializationPolicy();
$instanceClassName = $obfuscator->getClassNameForTypeId($typeSignature);
$instanceClass = Classes::classOf($instanceClassName);
} else {
throw new SerializationException('The GWT module was compiled with RPC type name elision enabled, but ' . Classes::classOf($this->getSerializationPolicy())->getFullName() . ' does not implement ' + Classes::classOf('TypeNameObfuscator')->getFullName());
}
} else {
$serializedInstRef = SerializabilityUtilEx::decodeSerializedInstanceReference($typeSignature);
$instanceClass = Classes::classOf($serializedInstRef->getName());
$this->validateTypeVersions($instanceClass, $serializedInstRef);
}
assert(!is_null($this->serializationPolicy));
$this->serializationPolicy->validateDeserialize($instanceClass);
$customSerializer = SerializabilityUtilEx::hasCustomFieldSerializer($instanceClass);
$index = $this->reserveDecodedObjectIndex();
//TODO to test
$transform = $this->getCustomSerializerTransform($customSerializer);
if (!is_null($transform)) {
$instance = $transform->invoke($this);
$this->rememberDecodedObject($index, $instance);
} else {
$instance = $this->instantiate($customSerializer, $instanceClass);
$this->rememberDecodedObject($index, $instance);
$replacement = $this->deserializeImpl($customSerializer, $instanceClass, $instance);
// It's possible that deserializing an object requires the original proxy
// object to be replaced.
if (instance !== $replacement) {
$this->rememberDecodedObject($index, $replacement);
$instance = $replacement;
}
}
return $instance;
} catch (Exception $e) {
throw new SerializationException($e);
}
}
private function findClass($token)
{
if (isset($this->classCache[$token])) {
return $this->classCache[$token];
}
$className = $this->clientOracle->getTypeName($token);
if ($className == null) {
$className = $token;
}
if (strstr($className, '[]') !== false) {
$firstIndex = -1;
$j = -1;
$dims = 0;
while (($j = strpos($className, '[')) !== false) {
if ($dims++ == 0) {
$firstIndex = $j;
}
}
$componentType = $this->findClass(substr($className, 0, $firstIndex));
assert($componentType != null);
$clazz = ArrayType::clazz($componentType, $dims);
} else {
$clazz = Classes::classOf($className);
}
$this->classCache[$token] = $clazz;
return $clazz;
}
public function __construct($exceptionClassName, $msg)
{
$this->exceptionClass = Classes::classOf($exceptionClassName);
$this->detailMessage = $msg;
}
public static function loadFromStream($filename, GenericList $classNotFoundExceptions)
{
if (is_null($filename)) {
throw new NullPointerException('InputStream');
}
$whitelistSer = new HashMap();
$whitelistDeser = new HashMap();
$typeIds = new HashMap();
$clientFields = new HashMap();
$br = new BufferedReader($filename);
$line = $br->readLine();
$lineNum = 1;
while (!is_null($line)) {
$line = trim($line);
if (mb_strlen($line) > 0) {
$components = explode(',', $line);
if ($components[0] === self::CLIENT_FIELDS_KEYWORD) {
/*
* Lines starting with '@ClientFields' list potentially serializable fields known to
* client code for classes that may be enhanced with additional fields on the server.
* If additional server fields are found, they will be serizalized separately from the
* normal RPC process and transmitted to the client as an opaque blob of data stored
* in a WeakMapping associated with the object instance.
*/
$binaryTypeName = trim($components[1]);
try {
$clazz = Classes::classOf($binaryTypeName);
$fieldNames = new HashSet();
for ($i = 2; $i < count($components); $i++) {
$fieldNames->add($components[$i]);
}
$clientFields->put($clazz, $fieldNames);
} catch (ClassNotFoundException $e) {
// Ignore the error, but add it to the list of errors if one was
// provided.
if (!is_null($classNotFoundExceptions)) {
$classNotFoundExceptions->add($e);
}
}
} else {
if (count($components) != 2 && count($components) != 7) {
throw new ParseException(self::FORMAT_ERROR_MESSAGE, $lineNum);
}
for ($i = 0; $i < count($components); $i++) {
$components[$i] = trim($components[$i]);
if (mb_strlen($components[$i]) == 0) {
throw new ParseException(self::FORMAT_ERROR_MESSAGE, $lineNum);
}
}
$binaryTypeName = trim($components[0]);
if (count($components) == 2) {
$fieldSer = $fieldDeser = true;
$instantSer = $instantDeser = Boolean::valueOf($components[1]);
$typeId = $binaryTypeName;
} else {
$idx = 1;
// TODO: Validate the instantiable string better
$fieldSer = Boolean::valueOf($components[$idx++]);
$instantSer = Boolean::valueOf($components[$idx++]);
$fieldDeser = Boolean::valueOf($components[$idx++]);
$instantDeser = Boolean::valueOf($components[$idx++]);
$typeId = $components[$idx++];
if (!$fieldSer && !$fieldDeser && TypeNameObfuscator::SERVICE_INTERFACE_ID != $typeId) {
throw new ParseException('Type ' . $binaryTypeName . ' is neither field serializable, field deserializable ' . 'nor the service interface : ', $lineNum);
}
}
try {
$clazz = Classes::classOf($binaryTypeName);
if ($fieldSer) {
$whitelistSer->put($clazz, $instantSer);
}
if ($fieldDeser) {
$whitelistDeser->put($clazz, $instantDeser);
}
$typeIds->put($clazz, $typeId);
} catch (ClassNotFoundException $e) {
// Ignore the error, but add it to the list of errors if one was
// provided.
if (!is_null($classNotFoundExceptions)) {
$classNotFoundExceptions->add($e);
}
}
}
}
$line = $br->readLine();
$lineNum++;
}
return new StandardSerializationPolicy($whitelistSer, $whitelistDeser, $typeIds, $clientFields);
}
private static function classOfArray($className)
{
// Java array style
if ($className[0] == ArrayType::SIGNATURE) {
if (self::exists($className)) {
return self::getClass($className);
} else {
$count = substr_count($className, '[');
$type = mb_substr($className, $count);
if ($type[0] == Object::SIGNATURE) {
$clazz = Classes::classOf(mb_substr($type, 1, mb_strlen($type) - 2));
} else {
$clazz = self::$SIGNATURES[$type[0]];
}
$reformed = $clazz->getName() . str_repeat('[]', $count);
$wanted = self::classOfArray($reformed);
self::registerClass($className, $wanted);
return $wanted;
}
} else {
$count = substr_count($className, '[');
$pos = strpos($className, '[');
$type = substr($className, 0, $pos);
$className = $type . str_repeat('[]', $count);
if (self::exists($className)) {
return self::getClass($className);
} else {
$compType = $type . str_repeat('[]', $count - 1);
$class = new ArrayClazz(Object::clazz(), Classes::classOf($compType), $count);
self::registerClass($class->getName(), $class);
return $class;
}
}
}
private function isInstantiable(Clazz $clazz)
{
if ($clazz->isPrimitive()) {
return true;
}
if ($clazz->isArray()) {
return $this->isInstantiable($clazz->getComponentType());
}
if (Classes::classOf('IsSerializable')->isAssignableFrom($clazz)) {
return true;
}
return Serializability::hasCustomFieldSerializer($clazz) != null;
}
protected function getObjectTypeSignature($instance, Clazz $instanceClass = null)
{
assert(!is_null($instance));
$clazz = self::getClassForSerialization($instance, $instanceClass);
if ($this->hasFlags(self::FLAG_ELIDE_TYPE_NAMES)) {
if ($this->serializationPolicy instanceof TypeNameObfuscator) {
return $this->serializationPolicy->getTypeIdForClass($clazz);
}
throw new SerializationException('The GWT module was compiled with RPC ' . 'type name elision enabled, but ' . Classes::classOf($this->serializationPolicy)->getFullName() . ' does not implement ' . Classes::classOf('TypeNameObfuscator')->getFullName());
} else {
return SerializabilityUtilEx::encodeSerializedInstanceReference($clazz, $this->serializationPolicy);
}
}
public static function loadCustomFieldSerializer(Clazz $customSerializerClass)
{
$customFieldSerializer = self::$CLASS_TO_SERIALIZER_INSTANCE->get($customSerializerClass);
if (is_null($customFieldSerializer)) {
if (Classes::classOf('CustomFieldSerializer')->isAssignableFrom($customSerializerClass)) {
$customFieldSerializer = $customSerializerClass->newInstance();
} else {
$customFieldSerializer = self::$NO_SUCH_SERIALIZER;
}
self::$CLASS_TO_SERIALIZER_INSTANCE->put($customSerializerClass, $customFieldSerializer);
}
if ($customFieldSerializer == self::$NO_SUCH_SERIALIZER) {
return null;
} else {
return $customFieldSerializer;
}
}
public function accept(RpcCommand $command)
{
if (!$command instanceof ValueCommand) {
throw new SerializationException(Classes::classOf($command)->getName());
}
$this->container->addValue($command);
}
public function instantiateInstance(SerializationStreamReader $streamReader)
{
throw new SerializationException('instantiateInstance is not supported by ' . Classes::classOf($this)->getFullName);
}
private function constructorFunctionArray(ArrayValueCommand $x)
{
$targetClass = ArrayType::clazz($x->getComponentType());
$functionName = $this->constructorFunctions->get($targetClass);
if (!is_null($functionName)) {
return $functionName;
}
$initValuesId = $this->clientOracle->getMethodIdByClassName('com.google.gwt.lang.Array', 'initValues', array('Ljava/lang/Class;', 'Lcom/google/gwt/core/client/JavaScriptObject;', 'I', 'Lcom/google/gwt/lang/Array;'));
assert(!is_null($initValuesId));
$classLitId = $this->clientOracle->getFieldIdByClassName('com.google.gwt.lang.ClassLiteralHolder', $this->getJavahSignatureName($x->getComponentType()) . '_classLit');
assert(!is_null($classLitId));
$functionName = $this->clientOracle->createUnusedIdent($classLitId);
$this->constructorFunctions->put($targetClass, $functionName);
$castableTypeData = $this->clientOracle->getCastableTypeData($targetClass);
if (is_null($castableTypeData)) {
$castableTypeData = $this->clientOracle->getCastableTypeData(Classes::classOf('Object[]'));
}
$queryId = $this->clientOracle->getQueryId($x->getComponentType());
if ($queryId == 0) {
$queryId = $this->clientOracle->getQueryId(Classes::classOf('Object'));
}
$ident = '_0';
// function foo(_0) {return initValues(classLid, castableTypeData, queryId, _0)}
$this->_function();
$this->push($functionName);
$this->lparen();
$this->push($ident);
$this->rparen();
$this->lbrace();
$this->_return();
$this->push($initValuesId);
$this->lparen();
$this->push($classLitId);
$this->comma();
$this->push($castableTypeData->toJs());
$this->comma();
$this->push(String::valueOf($queryId));
$this->comma();
$this->push($ident);
$this->rparen();
$this->rbrace();
$this->flush($x);
return $functionName;
}
public static function streamResponse2(ClientOracle $clientOracle, $payload, $payloadType, CommandSink $sink, $asThrow)
{
$command = null;
if ($asThrow) {
$command = new ThrowCommand();
assert($payload instanceof Exception);
$payload = new Throwable(get_class($payload), (string) $payload);
} else {
$command = new ReturnCommand();
}
$out = new CommandServerSerializationStreamWriter(new HasValuesCommandSink($command), $clientOracle);
if (empty($payloadType)) {
$out->writeObject($payload);
} else {
$clazz = Classes::classOf($payloadType);
$out->writeValue($clazz, $payload);
}
$sink->accept($command);
}
public function hashObject($x)
{
if ($x instanceof HasHashCode) {
return $x->hashCode();
} else {
if (Classes::classOf($x)->hasMethod('hashCode')) {
return $x->hashCode();
} else {
return spl_object_hash($x);
}
}
}
private static function getCustomFieldSerializer($qualifiedSerializerName)
{
try {
return Classes::classOf($qualifiedSerializerName);
} catch (ClassNotFoundException $e) {
return null;
}
}
public static function typeClass()
{
return Classes::classOf(self::TYPE);
}