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