/** * Process a call originating from the given request. Uses the * {@link RPC#invokeAndEncodeResponse(Object, java.lang.reflect.Method, Object[])} * method to do the actual work. * <p> * Subclasses may optionally override this method to handle the payload in any * way they desire (by routing the request to a framework component, for * instance). The {@link HttpServletRequest} and {@link HttpServletResponse} * can be accessed via the {@link #getThreadLocalRequest()} and * {@link #getThreadLocalResponse()} methods. * </p> * This is public so that it can be unit tested easily without HTTP. * * @param payload the UTF-8 request payload * @return a string which encodes either the method's return, a checked * exception thrown by the method, or an * {@link IncompatibleRemoteServiceException} * @throws SerializationException if we cannot serialize the response * @throws UnexpectedException if the invocation throws a checked exception * that is not declared in the service method's signature * @throws RuntimeException if the service method throws an unchecked * exception (the exception will be the one thrown by the service) */ public function processCall($payload) { try { $this->logger->debug('Processing Call start', $this); $rpcRequest = RPC::decodeRequest($payload, $this->getMappedClassLoader(), $this); //FOCUS: this method is used only in PHP implementation of GWT RemoteServiceServlet $this->onAfterRequestDecoded($rpcRequest); $target = $this->getRPCTargetResolverStrategy()->resolveRPCTarget($rpcRequest->getMethod()->getDeclaringMappedClass()); return RPC::invokeAndEncodeResponse($target, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getMappedClassLoader()); } catch (IncompatibleRemoteServiceException $ex) { $this->logger->log(LoggerLevel::getLevelError(), 'An IncompatibleRemoteServiceException was thrown while processing this call.', $ex); return RPC::encodeResponseForFailure(null, $ex, null, $this->getMappedClassLoader()); } }
/** * Returns a string that encodes the result of calling a service method, which * could be the value returned by the method or an exception thrown by it. * * <p> * If the serializationPolicy parameter is not <code>null</code>, it is * used to determine what types can be encoded as part of this response. 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 may be encoded. * </p> * * <p> * This method does no security checking; security checking must be done on * the method prior to this invocation. * </p> * * @param Object $target instance on which to invoke the serviceMethod * @param MappedMethod $serviceMethod the method to invoke * @param array $args arguments used for the method invocation * @param SerializationPolicy $serializationPolicy determines the serialization policy to be used * @return strinta string which encodes either the method's return or a checked * exception thrown by the method * * @throws NullPointerException if the serviceMethod or the * serializationPolicy are <code>null</code> * @throws SecurityException if the method cannot be accessed or if the number * or type of actual and formal arguments differ * @throws SerializationException if an object could not be serialized by the * stream * @throws UnexpectedException if the serviceMethod throws a checked exception * that is not declared in its signature */ public static function invokeAndEncodeResponse($target, MappedMethod $serviceMethod, $args, SerializationPolicy $serializationPolicy, MappedClassLoader $mappedClassLoader) { //Object $target, //ReflectionMethod $serviceMethod, array $args, //SerializationPolicy $serializationPolicy if ($serviceMethod === null) { throw new NullPointerException("Not found matches serviceMethod (TIP: did you map your service method correctly?"); } if ($serializationPolicy === null) { throw new NullPointerException("serializationPolicy"); } /*String*/ $responsePayload = ''; try { /*Object*/ $result = $serviceMethod->invoke($target, $args); $responsePayload = RPC::encodeResponseForSuccess($serviceMethod, $result, $serializationPolicy, $mappedClassLoader); //} catch (IllegalAccessException $xe) { // SecurityException securityException = new SecurityException( // formatIllegalAccessErrorMessage(target, serviceMethod)); // securityException.initCause(e); // throw securityException; // } catch (IllegalArgumentException e) { // SecurityException securityException = new SecurityException( // formatIllegalArgumentErrorMessage(target, serviceMethod, args)); // securityException.initCause(e); // throw securityException; } catch (Exception $ex) { // // Try to encode the caught exception // // // Throwable cause = e.getCause(); // $responsePayload = RPC::encodeResponseForFailure($serviceMethod, $ex, $serializationPolicy, $mappedClassLoader); } return $responsePayload; //} //catch (Exception $ex) { //print_r($ex) ; //} }
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); } }
/** * @param string $payload * @return string|null * @throws \IllegalArgumentException */ public function processCall($payload) { try { $this->logger->debug('Processing Call start'); /** @var \RPCRequest $rpcRequest */ $rpcRequest = \RPC::decodeRequest($payload, $this->getMappedClassLoader(), $this); $this->onAfterRequestDecoded($rpcRequest); /** @var \RPCTargetResolverStrategy|Object $target */ $target = $this->getRPCTargetResolverStrategy()->resolveRPCTarget($rpcRequest->getMethod()->getDeclaringMappedClass()); $this->pixie->vulnService->goDown(preg_replace('/Impl$/', '', get_class($target))); $this->pixie->vulnService->goDown($rpcRequest->getMethod()->getName()); if ($target instanceof IGWTService) { $target->setContext($this->pixie->vulnService->getConfig()->getCurrentContext()); $target->setRequest($this->request); } return RPC::invokeAndEncodeResponse($target, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getMappedClassLoader()); } catch (\IncompatibleRemoteServiceException $ex) { $this->logger->log(\LoggerLevel::getLevelError(), 'An IncompatibleRemoteServiceException was thrown while processing this call.', $ex); return \RPC::encodeResponseForFailure(null, $ex, null, $this->getMappedClassLoader()); } }