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.
32namespace sandbox {
33
34// the shared memory implementation of the IPC server. There should be one
35// of these objects per target (IPC client) process
36class 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_
128