Home | History | Annotate | Download | only in src 
      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   virtual ResultCode Init() OVERRIDE;
     49   virtual TargetPolicy* CreatePolicy() OVERRIDE;
     50   virtual ResultCode SpawnTarget(const wchar_t* exe_path,
     51                                  const wchar_t* command_line,
     52                                  TargetPolicy* policy,
     53                                  PROCESS_INFORMATION* target) OVERRIDE;
     54   virtual ResultCode WaitForAllTargets() OVERRIDE;
     55   virtual ResultCode AddTargetPeer(HANDLE peer_process) OVERRIDE;
     56   virtual ResultCode InstallAppContainer(const wchar_t* sid,
     57                                          const wchar_t* name) OVERRIDE;
     58   virtual 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   // Releases the Job and notifies the associated Policy object to its
     68   // resources as well.
     69   static void FreeResources(JobTracker* tracker);
     70 
     71   // The routine that the worker thread executes. It is in charge of
     72   // notifications and cleanup-related tasks.
     73   static DWORD WINAPI TargetEventsThread(PVOID param);
     74 
     75   // Removes a target peer from the process list if it expires.
     76   static VOID CALLBACK RemovePeer(PVOID parameter, BOOLEAN timeout);
     77 
     78   // The completion port used by the job objects to communicate events to
     79   // the worker thread.
     80   HANDLE job_port_;
     81 
     82   // Handle to a manual-reset event that is signaled when the total target
     83   // process count reaches zero.
     84   HANDLE no_targets_;
     85 
     86   // Handle to the worker thread that reacts to job notifications.
     87   HANDLE job_thread_;
     88 
     89   // Lock used to protect the list of targets from being modified by 2
     90   // threads at the same time.
     91   CRITICAL_SECTION lock_;
     92 
     93   // provides a pool of threads that are used to wait on the IPC calls.
     94   ThreadProvider* thread_pool_;
     95 
     96   // List of the trackers for closing and cleanup purposes.
     97   typedef std::list<JobTracker*> JobTrackerList;
     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   typedef std::map<DWORD, PeerTracker*> PeerTrackerMap;
    103   PeerTrackerMap peer_map_;
    104 
    105   // Provides a fast lookup to identify sandboxed processes that belong to a
    106   // job. Consult |jobless_process_handles_| for handles of pocess without job.
    107   std::set<DWORD> child_process_ids_;
    108 
    109   typedef std::map<uint32_t, std::pair<HANDLE, HANDLE>> TokenCacheMap;
    110   TokenCacheMap token_cache_;
    111 
    112   DISALLOW_COPY_AND_ASSIGN(BrokerServicesBase);
    113 };
    114 
    115 }  // namespace sandbox
    116 
    117 
    118 #endif  // SANDBOX_WIN_SRC_BROKER_SERVICES_H_
    119