The Tor Browser / file comparison

comparison: ipc/chromium/src/base/registry.cc

ipc/chromium/src/base/registry.cc

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:aa3de53980a1
1 // Copyright (c) 2006-2008 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 // All Rights Reserved.
5
6 #include "base/registry.h"
7
8 #include <assert.h>
9 #include <shlwapi.h>
10 #include <windows.h>
11
12 #pragma comment(lib, "shlwapi.lib") // for SHDeleteKey
13
14 // local types (see the same declarations in the header file)
15 #define tchar TCHAR
16 #define CTP const tchar*
17 #define tstr std::basic_string<tchar>
18
19 //
20 // RegistryValueIterator
21 //
22
23 RegistryValueIterator::RegistryValueIterator(HKEY root_key,
24 LPCTSTR folder_key) {
25 LONG result = RegOpenKeyEx(root_key, folder_key, 0, KEY_READ, &key_);
26 if (result != ERROR_SUCCESS) {
27 key_ = NULL;
28 } else {
29 DWORD count = 0;
30 result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL, &count,
31 NULL, NULL, NULL, NULL);
32
33 if (result != ERROR_SUCCESS) {
34 ::RegCloseKey(key_);
35 key_ = NULL;
36 } else {
37 index_ = count - 1;
38 }
39 }
40
41 Read();
42 }
43
44 RegistryValueIterator::~RegistryValueIterator() {
45 if (key_)
46 ::RegCloseKey(key_);
47 }
48
49 bool RegistryValueIterator::Valid() const {
50 // true while the iterator is valid
51 return key_ != NULL && index_ >= 0;
52 }
53
54 void RegistryValueIterator::operator ++ () {
55 // advance to the next entry in the folder
56 --index_;
57 Read();
58 }
59
60 bool RegistryValueIterator::Read() {
61 if (Valid()) {
62 DWORD ncount = sizeof(name_)/sizeof(*name_);
63 value_size_ = sizeof(value_);
64 LRESULT r = ::RegEnumValue(key_, index_, name_, &ncount, NULL, &type_,
65 reinterpret_cast<BYTE*>(value_), &value_size_);
66 if (ERROR_SUCCESS == r)
67 return true;
68 }
69
70 name_[0] = '\0';
71 value_[0] = '\0';
72 value_size_ = 0;
73 return false;
74 }
75
76 DWORD RegistryValueIterator::ValueCount() const {
77
78 DWORD count = 0;
79 HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL,
80 &count, NULL, NULL, NULL, NULL);
81
82 if (result != ERROR_SUCCESS)
83 return 0;
84
85 return count;
86 }
87
88 //
89 // RegistryKeyIterator
90 //
91
92 RegistryKeyIterator::RegistryKeyIterator(HKEY root_key,
93 LPCTSTR folder_key) {
94 LONG result = RegOpenKeyEx(root_key, folder_key, 0, KEY_READ, &key_);
95 if (result != ERROR_SUCCESS) {
96 key_ = NULL;
97 } else {
98 DWORD count = 0;
99 HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL,
100 NULL, NULL, NULL, NULL, NULL);
101
102 if (result != ERROR_SUCCESS) {
103 ::RegCloseKey(key_);
104 key_ = NULL;
105 } else {
106 index_ = count - 1;
107 }
108 }
109
110 Read();
111 }
112
113 RegistryKeyIterator::~RegistryKeyIterator() {
114 if (key_)
115 ::RegCloseKey(key_);
116 }
117
118 bool RegistryKeyIterator::Valid() const {
119 // true while the iterator is valid
120 return key_ != NULL && index_ >= 0;
121 }
122
123 void RegistryKeyIterator::operator ++ () {
124 // advance to the next entry in the folder
125 --index_;
126 Read();
127 }
128
129 bool RegistryKeyIterator::Read() {
130 if (Valid()) {
131 DWORD ncount = sizeof(name_)/sizeof(*name_);
132 FILETIME written;
133 LRESULT r = ::RegEnumKeyEx(key_, index_, name_, &ncount, NULL, NULL,
134 NULL, &written);
135 if (ERROR_SUCCESS == r)
136 return true;
137 }
138
139 name_[0] = '\0';
140 return false;
141 }
142
143 DWORD RegistryKeyIterator::SubkeyCount() const {
144
145 DWORD count = 0;
146 HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL,
147 NULL, NULL, NULL, NULL, NULL);
148
149 if (result != ERROR_SUCCESS)
150 return 0;
151
152 return count;
153 }
154
155 //
156 // RegKey
157 //
158
159 RegKey::RegKey(HKEY rootkey, const tchar* subkey, REGSAM access)
160 : key_(NULL), watch_event_(0) {
161 if (rootkey) {
162 if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK))
163 this->Create(rootkey, subkey, access);
164 else
165 this->Open(rootkey, subkey, access);
166 }
167 else assert(!subkey);
168 }
169
170 void RegKey::Close() {
171 StopWatching();
172 if (key_) {
173 ::RegCloseKey(key_);
174 key_ = NULL;
175 }
176 }
177
178 bool RegKey::Create(HKEY rootkey, const tchar* subkey, REGSAM access) {
179 DWORD disposition_value;
180 return CreateWithDisposition(rootkey, subkey, &disposition_value, access);
181 }
182
183 bool RegKey::CreateWithDisposition(HKEY rootkey, const tchar* subkey,
184 DWORD* disposition, REGSAM access) {
185 assert(rootkey && subkey && access && disposition);
186 this->Close();
187
188 LONG const result = RegCreateKeyEx(rootkey,
189 subkey,
190 0,
191 NULL,
192 REG_OPTION_NON_VOLATILE,
193 access,
194 NULL,
195 &key_,
196 disposition );
197 if (result != ERROR_SUCCESS) {
198 key_ = NULL;
199 return false;
200 }
201 else return true;
202 }
203
204 bool RegKey::Open(HKEY rootkey, const tchar* subkey, REGSAM access) {
205 assert(rootkey && subkey && access);
206 this->Close();
207
208 LONG const result = RegOpenKeyEx(rootkey, subkey, 0,
209 access, &key_ );
210 if (result != ERROR_SUCCESS) {
211 key_ = NULL;
212 return false;
213 }
214 else return true;
215 }
216
217 bool RegKey::CreateKey(const tchar* name, REGSAM access) {
218 assert(name && access);
219
220 HKEY subkey = NULL;
221 LONG const result = RegCreateKeyEx(key_, name, 0, NULL,
222 REG_OPTION_NON_VOLATILE,
223 access, NULL, &subkey, NULL);
224 this->Close();
225
226 key_ = subkey;
227 return (result == ERROR_SUCCESS);
228 }
229
230 bool RegKey::OpenKey(const tchar* name, REGSAM access) {
231 assert(name && access);
232
233 HKEY subkey = NULL;
234 LONG const result = RegOpenKeyEx(key_, name, 0, access, &subkey);
235
236 this->Close();
237
238 key_ = subkey;
239 return (result == ERROR_SUCCESS);
240 }
241
242 DWORD RegKey::ValueCount() {
243 DWORD count = 0;
244 HRESULT const result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL,
245 NULL, &count, NULL, NULL, NULL, NULL);
246 return (result != ERROR_SUCCESS) ? 0 : count;
247 }
248
249 bool RegKey::ReadName(int index, tstr* name) {
250 tchar buf[256];
251 DWORD bufsize = sizeof(buf)/sizeof(*buf);
252 LRESULT r = ::RegEnumValue(key_, index, buf, &bufsize, NULL, NULL,
253 NULL, NULL);
254 if (r != ERROR_SUCCESS)
255 return false;
256 if (name)
257 *name = buf;
258 return true;
259 }
260
261 bool RegKey::ValueExists(const tchar* name) {
262 if (!key_) return false;
263 const HRESULT result = RegQueryValueEx(key_, name, 0, NULL, NULL, NULL);
264 return (result == ERROR_SUCCESS);
265 }
266
267 bool RegKey::ReadValue(const tchar* name, void* data,
268 DWORD* dsize, DWORD* dtype) {
269 if (!key_) return false;
270 HRESULT const result = RegQueryValueEx(key_, name, 0, dtype,
271 reinterpret_cast<LPBYTE>(data),
272 dsize);
273 return (result == ERROR_SUCCESS);
274 }
275
276 bool RegKey::ReadValue(const tchar* name, tstr * value) {
277 assert(value);
278 static const size_t kMaxStringLength = 1024; // This is after expansion.
279 // Use the one of the other forms of ReadValue if 1024 is too small for you.
280 TCHAR raw_value[kMaxStringLength];
281 DWORD type = REG_SZ, size = sizeof(raw_value);
282 if (this->ReadValue(name, raw_value, &size, &type)) {
283 if (type == REG_SZ) {
284 *value = raw_value;
285 } else if (type == REG_EXPAND_SZ) {
286 TCHAR expanded[kMaxStringLength];
287 size = ExpandEnvironmentStrings(raw_value, expanded, kMaxStringLength);
288 // Success: returns the number of TCHARs copied
289 // Fail: buffer too small, returns the size required
290 // Fail: other, returns 0
291 if (size == 0 || size > kMaxStringLength)
292 return false;
293 *value = expanded;
294 } else {
295 // Not a string. Oops.
296 return false;
297 }
298 return true;
299 }
300 else return false;
301 }
302
303 bool RegKey::ReadValueDW(const tchar* name, DWORD * value) {
304 assert(value);
305 DWORD type = REG_DWORD, size = sizeof(DWORD), result = 0;
306 if (this->ReadValue(name, &result, &size, &type)
307 && (type == REG_DWORD || type == REG_BINARY)
308 && size == sizeof(DWORD)) {
309 *value = result;
310 return true;
311 }
312 else return false;
313 }
314
315 bool RegKey::WriteValue(const tchar* name,
316 const void * data,
317 DWORD dsize,
318 DWORD dtype) {
319 assert(data);
320 if (!key_) return false;
321 HRESULT const result = RegSetValueEx(
322 key_,
323 name,
324 0,
325 dtype,
326 reinterpret_cast<LPBYTE>(const_cast<void*>(data)),
327 dsize);
328 return (result == ERROR_SUCCESS);
329 }
330
331 bool RegKey::WriteValue(const tchar * name, const tchar * value) {
332 return this->WriteValue(name, value,
333 static_cast<DWORD>(sizeof(*value) * (_tcslen(value) + 1)), REG_SZ);
334 }
335
336 bool RegKey::WriteValue(const tchar * name, DWORD value) {
337 return this->WriteValue(name, &value,
338 static_cast<DWORD>(sizeof(value)), REG_DWORD);
339 }
340
341 bool RegKey::DeleteKey(const tchar * name) {
342 if (!key_) return false;
343 return (ERROR_SUCCESS == SHDeleteKey(key_, name));
344 }
345
346
347 bool RegKey::DeleteValue(const tchar * value_name) {
348 assert(value_name);
349 HRESULT const result = RegDeleteValue(key_, value_name);
350 return (result == ERROR_SUCCESS);
351 }
352
353 bool RegKey::StartWatching() {
354 if (!watch_event_)
355 watch_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
356
357 DWORD filter = REG_NOTIFY_CHANGE_NAME |
358 REG_NOTIFY_CHANGE_ATTRIBUTES |
359 REG_NOTIFY_CHANGE_LAST_SET |
360 REG_NOTIFY_CHANGE_SECURITY;
361
362 // Watch the registry key for a change of value.
363 HRESULT result = RegNotifyChangeKeyValue(key_, TRUE, filter,
364 watch_event_, TRUE);
365 if (SUCCEEDED(result)) {
366 return true;
367 } else {
368 CloseHandle(watch_event_);
369 watch_event_ = 0;
370 return false;
371 }
372 }
373
374 bool RegKey::StopWatching() {
375 if (watch_event_) {
376 CloseHandle(watch_event_);
377 watch_event_ = 0;
378 return true;
379 }
380 return false;
381 }
382
383 bool RegKey::HasChanged() {
384 if (watch_event_) {
385 if (WaitForSingleObject(watch_event_, 0) == WAIT_OBJECT_0) {
386 StartWatching();
387 return true;
388 }
389 }
390 return false;
391 }
392
393 // Register a COM object with the most usual properties.
394 bool RegisterCOMServer(const tchar* guid,
395 const tchar* name,
396 const tchar* path) {
397 RegKey key(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_WRITE);
398 key.CreateKey(guid, KEY_WRITE);
399 key.WriteValue(NULL, name);
400 key.CreateKey(_T("InprocServer32"), KEY_WRITE);
401 key.WriteValue(NULL, path);
402 key.WriteValue(_T("ThreadingModel"), _T("Apartment"));
403 return true;
404 }
405
406 bool RegisterCOMServer(const tchar* guid, const tchar* name, HINSTANCE module) {
407 tchar module_path[MAX_PATH];
408 ::GetModuleFileName(module, module_path, MAX_PATH);
409 _tcslwr_s(module_path, MAX_PATH);
410 return RegisterCOMServer(guid, name, module_path);
411 }
412
413 bool UnregisterCOMServer(const tchar* guid) {
414 RegKey key(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_WRITE);
415 key.DeleteKey(guid);
416 return true;
417 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial