diff options
Diffstat (limited to 'sandbox/src/crosscall_server.h')
| -rw-r--r-- | sandbox/src/crosscall_server.h | 224 |
1 files changed, 0 insertions, 224 deletions
diff --git a/sandbox/src/crosscall_server.h b/sandbox/src/crosscall_server.h deleted file mode 100644 index 59445f6..0000000 --- a/sandbox/src/crosscall_server.h +++ /dev/null @@ -1,224 +0,0 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef SANDBOX_SRC_CROSSCALL_SERVER_H_ -#define SANDBOX_SRC_CROSSCALL_SERVER_H_ - -#include <string> -#include <vector> -#include "base/basictypes.h" -#include "base/callback.h" -#include "sandbox/src/crosscall_params.h" - -// This is the IPC server interface for CrossCall: The IPC for the Sandbox -// On the server, CrossCall needs two things: -// 1) threads: Or better said, someone to provide them, that is what the -// ThreadProvider interface is defined for. These thread(s) are -// the ones that will actually execute the IPC data retrieval. -// -// 2) a dispatcher: This interface represents the way to route and process -// an IPC call given the IPC tag. -// -// The other class included here CrossCallParamsEx is the server side version -// of the CrossCallParams class of /sandbox/crosscall_params.h The difference -// is that the sever version is paranoid about the correctness of the IPC -// message and will do all sorts of verifications. -// -// A general diagram of the interaction is as follows: -// -// ------------ -// | | -// ThreadProvider <--(1)Register--| IPC | -// | | Implemen | -// | | -tation | -// (2) | | OnMessage -// IPC fired --callback ------>| |--(3)---> Dispatcher -// | | -// ------------ -// -// The IPC implementation sits as a middleman between the handling of the -// specifics of scheduling a thread to service the IPC and the multiple -// entities that can potentially serve each particular IPC. -namespace sandbox { - -class InterceptionManager; - -// This function signature is required as the callback when an IPC call fires. -// context: a user-defined pointer that was set using ThreadProvider -// reason: 0 if the callback was fired because of a timeout. -// 1 if the callback was fired because of an event. -typedef void (__stdcall * CrossCallIPCCallback)(void* context, - unsigned char reason); - -// ThreadProvider models a thread factory. The idea is to decouple thread -// creation and lifetime from the inner guts of the IPC. The contract is -// simple: -// - the IPC implementation calls RegisterWait with a waitable object that -// becomes signaled when an IPC arrives and needs to be serviced. -// - when the waitable object becomes signaled, the thread provider conjures -// a thread that calls the callback (CrossCallIPCCallback) function -// - the callback function tries its best not to block and return quickly -// and should not assume that the next callback will use the same thread -// - when the callback returns the ThreadProvider owns again the thread -// and can destroy it or keep it around. -class ThreadProvider { - public: - // Registers a waitable object with the thread provider. - // client: A number to associate with all the RegisterWait calls, typically - // this is the address of the caller object. This parameter cannot - // be zero. - // waitable_object : a kernel object that can be waited on - // callback: a function pointer which is the function that will be called - // when the waitable object fires - // context: a user-provider pointer that is passed back to the callback - // when its called - virtual bool RegisterWait(const void* client, HANDLE waitable_object, - CrossCallIPCCallback callback, - void* context) = 0; - - // Removes all the registrations done with the same cookie parameter. - // This frees internal thread pool resources. - virtual bool UnRegisterWaits(void* cookie) = 0; - virtual ~ThreadProvider() {} -}; - -// Models the server-side of the original input parameters. -// Provides IPC buffer validation and it is capable of reading the parameters -// out of the IPC buffer. -class CrossCallParamsEx : public CrossCallParams { - public: - // Factory constructor. Pass an IPCbuffer (and buffer size) that contains a - // pending IPCcall. This constructor will: - // 1) validate the IPC buffer. returns NULL is the IPCbuffer is malformed. - // 2) make a copy of the IPCbuffer (parameter capture) - static CrossCallParamsEx* CreateFromBuffer(void* buffer_base, - uint32 buffer_size, - uint32* output_size); - - // Provides IPCinput parameter raw access: - // index : the parameter to read; 0 is the first parameter - // returns NULL if the parameter is non-existent. If it exists it also - // returns the size in *size - void* GetRawParameter(uint32 index, uint32* size, ArgType* type); - - // Gets a parameter that is four bytes in size. - // Returns false if the parameter does not exist or is not 32 bits wide. - bool GetParameter32(uint32 index, uint32* param); - - // Gets a parameter that is void pointer in size. - // Returns false if the parameter does not exist or is not void pointer sized. - bool GetParameterVoidPtr(uint32 index, void** param); - - // Gets a parameter that is a string. Returns false if the parameter does not - // exist. - bool GetParameterStr(uint32 index, std::wstring* string); - - // Gets a parameter that is an in/out buffer. Returns false is the parameter - // does not exist or if the size of the actual parameter is not equal to the - // expected size. - bool GetParameterPtr(uint32 index, uint32 expected_size, void** pointer); - - // Frees the memory associated with the IPC parameters. - static void operator delete(void* raw_memory) throw(); - - private: - // Only the factory method CreateFromBuffer can construct these objects. - CrossCallParamsEx(); - - ParamInfo param_info_[1]; - DISALLOW_COPY_AND_ASSIGN(CrossCallParamsEx); -}; - -// Simple helper function that sets the members of CrossCallReturn -// to the proper state to signal a basic error. -void SetCallError(ResultCode error, CrossCallReturn* call_return); - -// Sets the internal status of call_return to signify the that IPC call -// completed successfully. -void SetCallSuccess(CrossCallReturn* call_return); - -// Represents the client process that initiated the IPC which boils down to the -// process handle and the job object handle that contains the client process. -struct ClientInfo { - HANDLE process; - HANDLE job_object; - DWORD process_id; -}; - -// All IPC-related information to be passed to the IPC handler. -struct IPCInfo { - int ipc_tag; - const ClientInfo* client_info; - CrossCallReturn return_info; -}; - -// This structure identifies IPC signatures. -struct IPCParams { - int ipc_tag; - ArgType args[kMaxIpcParams]; - - bool Matches(IPCParams* other) const { - return !memcmp(this, other, sizeof(*other)); - } -}; - -// Models an entity that can process an IPC message or it can route to another -// one that could handle it. When an IPC arrives the IPC implementation will: -// 1) call OnMessageReady() with the tag of the pending IPC. If the dispatcher -// returns NULL it means that it cannot handle this IPC but if it returns -// non-null, it must be the pointer to a dispatcher that can handle it. -// 2) When the IPC finally obtains a valid Dispatcher the IPC -// implementation creates a CrossCallParamsEx from the raw IPC buffer. -// 3) It calls the returned callback, with the IPC info and arguments. -class Dispatcher { - public: - // Called from the IPC implementation to handle a specific IPC message. - typedef bool (Dispatcher::*CallbackGeneric)(); - typedef bool (Dispatcher::*Callback0)(IPCInfo* ipc); - typedef bool (Dispatcher::*Callback1)(IPCInfo* ipc, void* p1); - typedef bool (Dispatcher::*Callback2)(IPCInfo* ipc, void* p1, void* p2); - typedef bool (Dispatcher::*Callback3)(IPCInfo* ipc, void* p1, void* p2, - void* p3); - typedef bool (Dispatcher::*Callback4)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4); - typedef bool (Dispatcher::*Callback5)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4, void* p5); - typedef bool (Dispatcher::*Callback6)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4, void* p5, void* p6); - typedef bool (Dispatcher::*Callback7)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4, void* p5, void* p6, - void* p7); - typedef bool (Dispatcher::*Callback8)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4, void* p5, void* p6, - void* p7, void* p8); - typedef bool (Dispatcher::*Callback9)(IPCInfo* ipc, void* p1, void* p2, - void* p3, void* p4, void* p5, void* p6, - void* p7, void* p8, void* p9); - - // Called from the IPC implementation when an IPC message is ready override - // on a derived class to handle a set of IPC messages. Return NULL if your - // subclass does not handle the message or return the pointer to the subclass - // that can handle it. - virtual Dispatcher* OnMessageReady(IPCParams* ipc, CallbackGeneric* callback); - - // Called when a target proces is created, to setup the interceptions related - // with the given service (IPC). - virtual bool SetupService(InterceptionManager* manager, int service) = 0; - - virtual ~Dispatcher() {} - - protected: - // Structure that defines an IPC Call with all the parameters and the handler. - struct IPCCall { - IPCParams params; - CallbackGeneric callback; - }; - - // List of IPC Calls supported by the class. - std::vector<IPCCall> ipc_calls_; -}; - -} // namespace sandbox - -#endif // SANDBOX_SRC_CROSSCALL_SERVER_H_ |