The Tor Browser / file comparison
comparison: security/sandbox/win/src/sharedmem_ipc_server.h
security/sandbox/win/src/sharedmem_ipc_server.h
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:8bccb7f67fea |
|---|---|
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_ | |
| 6 #define SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_ | |
| 7 | |
| 8 #include <list> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/gtest_prod_util.h" | |
| 12 #include "sandbox/win/src/crosscall_params.h" | |
| 13 #include "sandbox/win/src/crosscall_server.h" | |
| 14 #include "sandbox/win/src/sharedmem_ipc_client.h" | |
| 15 | |
| 16 // IPC transport implementation that uses shared memory. | |
| 17 // This is the server side | |
| 18 // | |
| 19 // The server side has knowledge about the layout of the shared memory | |
| 20 // and the state transitions. Both are explained in sharedmem_ipc_client.h | |
| 21 // | |
| 22 // As opposed to SharedMemIPClient, the Server object should be one for the | |
| 23 // entire lifetime of the target process. The server is in charge of creating | |
| 24 // the events (ping, pong) both for the client and for the target that are used | |
| 25 // to signal the IPC and also in charge of setting the initial state of the | |
| 26 // channels. | |
| 27 // | |
| 28 // When an IPC is ready, the server relies on being called by on the | |
| 29 // ThreadPingEventReady callback. The IPC server then retrieves the buffer, | |
| 30 // marshals it into a CrossCallParam object and calls the Dispatcher, who is in | |
| 31 // charge of fulfilling the IPC request. | |
| 32 namespace sandbox { | |
| 33 | |
| 34 // the shared memory implementation of the IPC server. There should be one | |
| 35 // of these objects per target (IPC client) process | |
| 36 class SharedMemIPCServer { | |
| 37 public: | |
| 38 // Creates the IPC server. | |
| 39 // target_process: handle to the target process. It must be suspended. | |
| 40 // target_process_id: process id of the target process. | |
| 41 // target_job: the job object handle associated with the target process. | |
| 42 // thread_provider: a thread provider object. | |
| 43 // dispatcher: an object that can service IPC calls. | |
| 44 SharedMemIPCServer(HANDLE target_process, DWORD target_process_id, | |
| 45 HANDLE target_job, ThreadProvider* thread_provider, | |
| 46 Dispatcher* dispatcher); | |
| 47 | |
| 48 ~SharedMemIPCServer(); | |
| 49 | |
| 50 // Initializes the server structures, shared memory structures and | |
| 51 // creates the kernels events used to signal the IPC. | |
| 52 bool Init(void* shared_mem, uint32 shared_size, uint32 channel_size); | |
| 53 | |
| 54 private: | |
| 55 // Allow tests to be marked DISABLED_. Note that FLAKY_ and FAILS_ prefixes | |
| 56 // do not work with sandbox tests. | |
| 57 FRIEND_TEST_ALL_PREFIXES(IPCTest, SharedMemServerTests); | |
| 58 // When an event fires (IPC request). A thread from the ThreadProvider | |
| 59 // will call this function. The context parameter should be the same as | |
| 60 // provided when ThreadProvider::RegisterWait was called. | |
| 61 static void __stdcall ThreadPingEventReady(void* context, | |
| 62 unsigned char); | |
| 63 | |
| 64 // Makes the client and server events. This function is called once | |
| 65 // per channel. | |
| 66 bool MakeEvents(HANDLE* server_ping, HANDLE* server_pong, | |
| 67 HANDLE* client_ping, HANDLE* client_pong); | |
| 68 | |
| 69 // A copy this structure is maintained per channel. | |
| 70 // Note that a lot of the fields are just the same of what we have in the IPC | |
| 71 // object itself. It is better to have the copies since we can dispatch in the | |
| 72 // static method without worrying about converting back to a member function | |
| 73 // call or about threading issues. | |
| 74 struct ServerControl { | |
| 75 // This channel server ping event. | |
| 76 HANDLE ping_event; | |
| 77 // This channel server pong event. | |
| 78 HANDLE pong_event; | |
| 79 // The size of this channel. | |
| 80 uint32 channel_size; | |
| 81 // The pointer to the actual channel data. | |
| 82 char* channel_buffer; | |
| 83 // The pointer to the base of the shared memory. | |
| 84 char* shared_base; | |
| 85 // A pointer to this channel's client-side control structure this structure | |
| 86 // lives in the shared memory. | |
| 87 ChannelControl* channel; | |
| 88 // the IPC dispatcher associated with this channel. | |
| 89 Dispatcher* dispatcher; | |
| 90 // The target process information associated with this channel. | |
| 91 ClientInfo target_info; | |
| 92 }; | |
| 93 | |
| 94 // Looks for the appropriate handler for this IPC and invokes it. | |
| 95 static bool InvokeCallback(const ServerControl* service_context, | |
| 96 void* ipc_buffer, CrossCallReturn* call_result); | |
| 97 | |
| 98 // Points to the shared memory channel control which lives at | |
| 99 // the start of the shared section. | |
| 100 IPCControl* client_control_; | |
| 101 | |
| 102 // Keeps track of the server side objects that are used to answer an IPC. | |
| 103 typedef std::list<ServerControl*> ServerContexts; | |
| 104 ServerContexts server_contexts_; | |
| 105 | |
| 106 // The thread provider provides the threads that call back into this object | |
| 107 // when the IPC events fire. | |
| 108 ThreadProvider* thread_provider_; | |
| 109 | |
| 110 // The IPC object is associated with a target process. | |
| 111 HANDLE target_process_; | |
| 112 | |
| 113 // The target process id associated with the IPC object. | |
| 114 DWORD target_process_id_; | |
| 115 | |
| 116 // The target object is inside a job too. | |
| 117 HANDLE target_job_object_; | |
| 118 | |
| 119 // The dispatcher handles 'ready' IPC calls. | |
| 120 Dispatcher* call_dispatcher_; | |
| 121 | |
| 122 DISALLOW_COPY_AND_ASSIGN(SharedMemIPCServer); | |
| 123 }; | |
| 124 | |
| 125 } // namespace sandbox | |
| 126 | |
| 127 #endif // SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_ |
