src/sandbox/win/src/broker_services.h

   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_WIN_SRC_BROKER_SERVICES_H_
   6 #define SANDBOX_WIN_SRC_BROKER_SERVICES_H_
   7
   8 #include <list>
   9 #include <map>
  10 #include <set>
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/win/scoped_handle.h"
  14 #include "sandbox/win/src/crosscall_server.h"
  15 #include "sandbox/win/src/job.h"
  16 #include "sandbox/win/src/sandbox.h"
  17 #include "sandbox/win/src/sharedmem_ipc_server.h"
  18 #include "sandbox/win/src/win2k_threadpool.h"
  19 #include "sandbox/win/src/win_utils.h"
  20
  21 namespace {
  22
  23 struct JobTracker;
  24 struct PeerTracker;
  25
  26 }  // namespace
  27
  28 namespace sandbox {
  29
  30 class PolicyBase;
  31
  32 // BrokerServicesBase ---------------------------------------------------------
  33 // Broker implementation version 0
  34 //
  35 // This is an implementation of the interface BrokerServices and
  36 // of the associated TargetProcess interface. In this implementation
  37 // TargetProcess is a friend of BrokerServices where the later manages a
  38 // collection of the former.
  39 class BrokerServicesBase : public BrokerServices,
  40                            public SingletonBase<BrokerServicesBase>  {
  41  public:
  42   BrokerServicesBase();
  43
  44   ~BrokerServicesBase();
  45
  46   // BrokerServices interface.
  47   virtual ResultCode Init() OVERRIDE;
  48   virtual TargetPolicy* CreatePolicy() OVERRIDE;
  49   virtual ResultCode SpawnTarget(const wchar_t* exe_path,
  50                                  const wchar_t* command_line,
  51                                  TargetPolicy* policy,
  52                                  PROCESS_INFORMATION* target) OVERRIDE;
  53   virtual ResultCode WaitForAllTargets() OVERRIDE;
  54   virtual ResultCode AddTargetPeer(HANDLE peer_process) OVERRIDE;
  55   virtual ResultCode InstallAppContainer(const wchar_t* sid,
  56                                          const wchar_t* name) OVERRIDE;
  57   virtual ResultCode UninstallAppContainer(const wchar_t* sid) OVERRIDE;
  58
  59   // Checks if the supplied process ID matches one of the broker's active
  60   // target processes
  61   // Returns:
  62   //   true if there is an active target process for this ID, otherwise false.
  63   bool IsActiveTarget(DWORD process_id);
  64
  65  private:
  66   // Releases the Job and notifies the associated Policy object to its
  67   // resources as well.
  68   static void FreeResources(JobTracker* tracker);
  69
  70   // The routine that the worker thread executes. It is in charge of
  71   // notifications and cleanup-related tasks.
  72   static DWORD WINAPI TargetEventsThread(PVOID param);
  73
  74   // Removes a target peer from the process list if it expires.
  75   static VOID CALLBACK RemovePeer(PVOID parameter, BOOLEAN timeout);
  76
  77   // The completion port used by the job objects to communicate events to
  78   // the worker thread.
  79   HANDLE job_port_;
  80
  81   // Handle to a manual-reset event that is signaled when the total target
  82   // process count reaches zero.
  83   HANDLE no_targets_;
  84
  85   // Handle to the worker thread that reacts to job notifications.
  86   HANDLE job_thread_;
  87
  88   // Lock used to protect the list of targets from being modified by 2
  89   // threads at the same time.
  90   CRITICAL_SECTION lock_;
  91
  92   // provides a pool of threads that are used to wait on the IPC calls.
  93   ThreadProvider* thread_pool_;
  94
  95   // List of the trackers for closing and cleanup purposes.
  96   typedef std::list<JobTracker*> JobTrackerList;
  97   JobTrackerList tracker_list_;
  98
  99   // Maps peer process IDs to the saved handle and wait event.
 100   // Prevents peer callbacks from accessing the broker after destruction.
 101   typedef std::map<DWORD, PeerTracker*> PeerTrackerMap;
 102   PeerTrackerMap peer_map_;
 103
 104   // Provides a fast lookup to identify sandboxed processes that belong to a
 105   // job. Consult |jobless_process_handles_| for handles of pocess without job.
 106   std::set<DWORD> child_process_ids_;
 107
 108   DISALLOW_COPY_AND_ASSIGN(BrokerServicesBase);
 109 };
 110
 111 }  // namespace sandbox
 112
 113
 114 #endif  // SANDBOX_WIN_SRC_BROKER_SERVICES_H_