/** * Returns an {@link RPCRequest} that is built by decoding the contents of an * encoded RPC request and optionally validating that type can handle the * request. If the type parameter is not <code>null</code>, the * implementation checks that the type is assignable to the * {@link RemoteService} interface requested in the encoded request string. * * <p> * If the serializationPolicyProvider parameter is not <code>null</code>, * it is asked for a {@link SerializationPolicy} to use to restrict the set of * types that can be decoded from the request. If this parameter is * <code>null</code>, then only subtypes of * {@link com.google.gwt.user.client.rpc.IsSerializable IsSerializable} or * types which have custom field serializers can be decoded. * </p> * * <p> * Invoking this method with <code>null</code> for the type parameter, * <code>decodeRequest(encodedRequest, null)</code>, is equivalent to * calling <code>decodeRequest(encodedRequest)</code>. * </p> * @param String $encodedRequest a string that encodes the {@link RemoteService} * interface, the service method, and the arguments to pass to the * service method * @param MappedClassLoader $mappedClassLoader * @param SerializationPolicyProvider $serializationPolicyProvider if not <code>null</code>, the * implementation asks this provider for a * {@link SerializationPolicy} which will be used to restrict the set * of types that can be decoded from this request * @return RPCRequest an {@link RPCRequest} instance * @throws NullPointerException if the encodedRequest is <code>null</code> * @throws IllegalArgumentException if the encodedRequest is an empty string * @throws IncompatibleRemoteServiceException if any of the following * conditions apply: * <ul> * <li>if the types in the encoded request cannot be deserialized</li> * <li>if the {@link ClassLoader} acquired from * <code>Thread.currentThread().getClassLoader()</code> * cannot load the service interface or any of the types specified * in the encodedRequest</li> * <li>the requested interface is not assignable to * {@link RemoteService}</li> * <li>the service method requested in the encodedRequest is not a * member of the requested service interface</li> * <li>the type parameter is not <code>null</code> and is not * assignable to the requested {@link RemoteService} interface * </ul> */ public static function decodeRequest($encodedRequest, MappedClassLoader $mappedClassLoader, SerializationPolicyProvider $serializationPolicyProvider) { $logger = LoggerManager::getLogger('gwtphp.rpc.RPC'); if ($encodedRequest === null) { throw new NullPointerException("encodedRequest cannot be null"); } if (strlen($encodedRequest) == 0) { throw new IllegalArgumentException("encodedRequest cannot be empty"); } try { /*ServerSerializationStreamReader*/ $streamReader = new ServerSerializationStreamReader($mappedClassLoader, $serializationPolicyProvider); //classLoader, serializationPolicyProvider); $streamReader->prepareToRead($encodedRequest); // Read the name of the RemoteService interface /*String*/ $serviceIntfName = $streamReader->readString(); $logger->info("serviceIntfName: " . $serviceIntfName); // TODO: wybrac metode sprawdzenia czy posiadamy obiekt ktory moze implementowac wybrany // do uruchomienia interface //if ($type != null) { // if (!implementsInterface(type, serviceIntfName)) { // // The service does not implement the requested interface // throw new IncompatibleRemoteServiceException( // "Blocked attempt to access interface '" + serviceIntfName // + "', which is not implemented by '" + printTypeName(type) // + "'; this is either misconfiguration or a hack attempt"); // } //} $serializationPolicy = $streamReader->getSerializationPolicy(); //$gwtService = $classLoader->getMapManager()->getGWTServiceMap($serviceIntfName); /*MappedClass*/ $serviceIntf = null; try { $serviceIntf = RPC::getClassFromSerializedName($serviceIntfName, $mappedClassLoader); // if (!RemoteService.class.isAssignableFrom(serviceIntf)) { // // The requested interface is not a RemoteService interface // throw new IncompatibleRemoteServiceException( // "Blocked attempt to access interface '" // + printTypeName(serviceIntf) // + "', which doesn't extend RemoteService; this is either misconfiguration or a hack attempt"); // } } catch (ClassNotFoundException $e) { class_exists('IncompatibleRemoteServiceException') || (require GWTPHP_DIR . '/../com/google/gwt/user/client/rpc/IncompatibleRemoteServiceException.class.php'); throw new IncompatibleRemoteServiceException("Could not locate requested interface '" + $serviceIntfName + "' in default classloader", $e); } $serviceMethodName = $streamReader->readString(); $logger->debug("serviceMethodName: " . $serviceMethodName); $paramCount = $streamReader->readInt(); $logger->debug("paramCount: " . $paramCount); /*MappedClass[]*/ $parameterTypes = array(); for ($i = 0; $i < $paramCount; ++$i) { $paramClassName = $streamReader->readString(); //$parameterTypes[$i] = $paramClassName; try { $parameterTypes[$i] = RPC::getClassFromSerializedName($paramClassName, $mappedClassLoader); } catch (ClassNotFoundException $e) { class_exists('IncompatibleRemoteServiceException') || (require GWTPHP_DIR . '/../com/google/gwt/user/client/rpc/IncompatibleRemoteServiceException.class.php'); throw new IncompatibleRemoteServiceException("Parameter " + $i + " of is of an unknown type '" + $paramClassName + "'", $e); } } $logger->info(print_r($parameterTypes, true)); $mappedMethod = RPC::findInterfaceMethod($serviceIntf, $serviceMethodName, $parameterTypes, true); if ($mappedMethod == null) { class_exists('IncompatibleRemoteServiceException') || (require GWTPHP_DIR . '/../com/google/gwt/user/client/rpc/IncompatibleRemoteServiceException.class.php'); throw new IncompatibleRemoteServiceException(RPC::formatMethodNotFoundErrorMessage($serviceIntf, $serviceMethodName, $parameterTypes)); } /*Object[]*/ $parameterValues = array(); for ($i = 0; $i < $paramCount; ++$i) { $parameterValues[$i] = $streamReader->deserializeValue($parameterTypes[$i]); } $logger->info(print_r($parameterValues, true)); //$gwtService->getServiceMethodMap(0)->getMethod(); // //$rpcResolver-> //$method = $rpcResolver->getRPCServiceMethod($serviceIntfName,$serviceMethodName); //$rpcRequest = new RPCRequest($method, $parameterValues, $serializationPolicy); //$rpcRequest->setClass($service); // $rpcRequest = $rpcResolver->getRPCRequest($serviceIntfName,$serviceMethodName,$parameterTypes); // $rpcRequest->setParameters($parameterValues); // $rpcRequest->setSerializationPolicy($serializationPolicy); return new RPCRequest($mappedMethod, $parameterValues, $serializationPolicy, $mappedClassLoader); } catch (SerializationException $ex) { class_exists('IncompatibleRemoteServiceException') || (require GWTPHP_DIR . '/../com/google/gwt/user/client/rpc/IncompatibleRemoteServiceException.class.php'); throw new IncompatibleRemoteServiceException($ex->getMessage(), $ex); } }
public static function decodeRequest($encodedRequest, Clazz $type = null, SerializationPolicyProvider $serializationPolicyPolicyProvider = null) { if (is_null($encodedRequest)) { throw new NullPointerException('encodedRequest cannot be null'); } if (empty($encodedRequest)) { throw new IllegalArgumentException('encodedRequest cannot be empty'); } try { $streamReader = new ServerSerializationStreamReader($serializationPolicyPolicyProvider); $streamReader->prepareToRead($encodedRequest); $rpcToken = null; if ($streamReader->hasFlags(AbstractSerializationStream::FLAG_RPC_TOKEN_INCLUDED)) { // Read the RPC token $rpcToken = $streamReader->deserializeValue(Classes::classOf(RpcToken)); } // Read the name of the RemoteService interface $serviceIntfName = self::maybeDeobfuscate($streamReader, $streamReader->readString()); //TODO: implements model or is class /*if (!is_null($type)) { if (!self::implementsInterface($type, $serviceIntfName)) { $printedType = self::printTypeName($type); throw new IncompatibleRemoteServiceException( "Blocked attempt to access interface '$serviceIntfName', " . "which is not implemented by '$printedType'; " . "this is either misconfiguration or a hack attempt" ); } }*/ $serializationPolicy = $streamReader->getSerializationPolicy(); try { $serviceIntf = self::getClassFromSerializedName($serviceIntfName); if (!Classes::classOf(RemoteService)->isAssignableFrom($serviceIntf)) { // The requested interface is not a RemoteService interface $printedType = $this->printTypeName($serviceIntf); throw new IncompatibleRemoteServiceException("Blocked attempt to access interface '{$printedType}', " . "which doesn't extend RemoteService; this is either misconfiguration or a hack attempt"); } } catch (ClassNotFoundException $e) { throw new IncompatibleRemoteServiceException("Could not locate requested interface '{$serviceIntfName}' : {$e}"); } $serviceMethodName = $streamReader->readString(); $paramCount = $streamReader->readInt(); if ($paramCount > $streamReader->getNumberOfTokens()) { throw new IncompatibleRemoteServiceException('Invalid number of parameters'); } $parameterTypes = array(); for ($i = 0; $i < $paramCount; $i++) { $paramClassName = self::maybeDeobfuscate($streamReader, $streamReader->readString()); try { $parameterTypes[] = self::getClassFromSerializedName($paramClassName); } catch (ClassNotFoundException $e) { throw new IncompatibleRemoteServiceException("Paramter {$i} is unknown type '{$paramClassName}' : {$e}"); } } try { $method = $serviceIntf->getMethod($serviceMethodName); $parameterValues = array(); for ($i = 0; $i < $paramCount; $i++) { $parameterValues[] = $streamReader->deserializeValue($parameterTypes[$i]); } return new RPCRequest($method, $parameterValues, $serializationPolicy, $streamReader->getFlags(), $rpcToken); } catch (NoSuchMethodException $e) { throw new IncompatibleRemoteServiceException(self::formatMethodNotFoundErrorMessage($serviceIntf, $serviceMethodName, $parameterTypes)); } } catch (SerizalizationException $ex) { throw new IncompatibleRemoteServiceException($ex->getMessage() . ' : ' . $ex); } }