sandbox/src/handle_table.h

   1 // Copyright (c) 2011 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_HANDLE_TABLE_H_
   6 #define SANDBOX_SRC_HANDLE_TABLE_H_
   7 #pragma once
   8
   9 #include <windows.h>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/string16.h"
  14 #include "sandbox/src/nt_internals.h"
  15
  16 namespace sandbox {
  17
  18 // HandleTable retrieves the global handle table and provides helper classes
  19 // for iterating through the table and retrieving handle info.
  20 class HandleTable {
  21  public:
  22   static const char16* HandleTable::kTypeProcess;
  23   static const char16* HandleTable::kTypeThread;
  24   static const char16* HandleTable::kTypeFile;
  25   static const char16* HandleTable::kTypeDirectory;
  26   static const char16* HandleTable::kTypeKey;
  27   static const char16* HandleTable::kTypeWindowStation;
  28   static const char16* HandleTable::kTypeDesktop;
  29   static const char16* HandleTable::kTypeService;
  30   static const char16* HandleTable::kTypeMutex;
  31   static const char16* HandleTable::kTypeSemaphore;
  32   static const char16* HandleTable::kTypeEvent;
  33   static const char16* HandleTable::kTypeTimer;
  34   static const char16* HandleTable::kTypeNamedPipe;
  35   static const char16* HandleTable::kTypeJobObject;
  36   static const char16* HandleTable::kTypeFileMap;
  37   static const char16* HandleTable::kTypeAlpcPort;
  38
  39   class Iterator;
  40
  41   // Used by the iterator to provide simple caching accessors to handle data.
  42   class HandleEntry {
  43    public:
  44     bool operator==(const HandleEntry& rhs) const {
  45       return handle_entry_ == rhs.handle_entry_;
  46     }
  47
  48     bool operator!=(const HandleEntry& rhs) const {
  49       return handle_entry_ != rhs.handle_entry_;
  50     }
  51
  52     const SYSTEM_HANDLE_INFORMATION* handle_entry() const {
  53       return handle_entry_;
  54     }
  55
  56     const OBJECT_TYPE_INFORMATION* TypeInfo();
  57
  58     const string16& Name();
  59
  60     const string16& Type();
  61
  62     bool IsType(const string16& type_string);
  63
  64    private:
  65     friend class Iterator;
  66     friend class HandleTable;
  67
  68     enum UpdateType {
  69       UPDATE_INFO_ONLY,
  70       UPDATE_INFO_AND_NAME,
  71       UPDATE_INFO_AND_TYPE_NAME,
  72     };
  73
  74     explicit HandleEntry(const SYSTEM_HANDLE_INFORMATION* handle_info_entry);
  75
  76     bool needs_info_update() { return handle_entry_ != last_entry_; }
  77
  78     void UpdateInfo(UpdateType flag);
  79
  80     OBJECT_TYPE_INFORMATION* type_info_internal() {
  81       return reinterpret_cast<OBJECT_TYPE_INFORMATION*>(
  82           &(type_info_buffer_[0]));
  83     }
  84
  85     const SYSTEM_HANDLE_INFORMATION* handle_entry_;
  86     const SYSTEM_HANDLE_INFORMATION* last_entry_;
  87     std::vector<BYTE> type_info_buffer_;
  88     string16 handle_name_;
  89     string16 type_name_;
  90
  91     DISALLOW_COPY_AND_ASSIGN(HandleEntry);
  92   };
  93
  94   class Iterator {
  95    public:
  96     Iterator(const HandleTable& table, const SYSTEM_HANDLE_INFORMATION* start,
  97              const SYSTEM_HANDLE_INFORMATION* stop);
  98
  99     Iterator(const Iterator& it);
 100
 101     Iterator& operator++() {
 102       if (++(current_.handle_entry_) == end_)
 103         current_.handle_entry_ = table_.end();
 104       return *this;
 105     }
 106
 107     bool operator==(const Iterator& rhs) const {
 108       return current_ == rhs.current_;
 109     }
 110
 111     bool operator!=(const Iterator& rhs) const {
 112       return current_ != rhs.current_;
 113     }
 114
 115     HandleEntry& operator*() { return current_; }
 116
 117     operator const SYSTEM_HANDLE_INFORMATION*() {
 118       return current_.handle_entry_;
 119     }
 120
 121     HandleEntry* operator->() { return &current_; }
 122
 123    private:
 124     const HandleTable& table_;
 125     HandleEntry current_;
 126     const SYSTEM_HANDLE_INFORMATION* end_;
 127   };
 128
 129   HandleTable();
 130
 131   Iterator begin() const {
 132     return Iterator(*this, handle_info()->Information,
 133         &handle_info()->Information[handle_info()->NumberOfHandles]);
 134   }
 135
 136   const SYSTEM_HANDLE_INFORMATION_EX* handle_info() const {
 137     return reinterpret_cast<const SYSTEM_HANDLE_INFORMATION_EX*>(
 138         &(handle_info_buffer_[0]));
 139   }
 140
 141   // Returns an iterator to the handles for only the supplied process ID.
 142   Iterator HandlesForProcess(ULONG process_id) const;
 143   const SYSTEM_HANDLE_INFORMATION* end() const {
 144     return &handle_info()->Information[handle_info()->NumberOfHandles];
 145   }
 146
 147  private:
 148   SYSTEM_HANDLE_INFORMATION_EX* handle_info_internal() {
 149     return reinterpret_cast<SYSTEM_HANDLE_INFORMATION_EX*>(
 150         &(handle_info_buffer_[0]));
 151   }
 152
 153   std::vector<BYTE> handle_info_buffer_;
 154
 155   DISALLOW_COPY_AND_ASSIGN(HandleTable);
 156 };
 157
 158 }  // namespace sandbox
 159
 160 #endif  // SANDBOX_SRC_HANDLE_TABLE_H_