| // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // All Rights Reserved. |
| |
| #include "base/registry.h" |
| |
| #include <assert.h> |
| #include <shlwapi.h> |
| #include <windows.h> |
| |
| #pragma comment(lib, "shlwapi.lib") // for SHDeleteKey |
| |
| // local types (see the same declarations in the header file) |
| #define tchar TCHAR |
| #define CTP const tchar* |
| #define tstr std::basic_string<tchar> |
| |
| // |
| // RegistryValueIterator |
| // |
| |
| RegistryValueIterator::RegistryValueIterator(HKEY root_key, |
| LPCTSTR folder_key) { |
| LONG result = RegOpenKeyEx(root_key, folder_key, 0, KEY_READ, &key_); |
| if (result != ERROR_SUCCESS) { |
| key_ = NULL; |
| } else { |
| DWORD count = 0; |
| result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL, &count, |
| NULL, NULL, NULL, NULL); |
| |
| if (result != ERROR_SUCCESS) { |
| ::RegCloseKey(key_); |
| key_ = NULL; |
| } else { |
| index_ = count - 1; |
| } |
| } |
| |
| Read(); |
| } |
| |
| RegistryValueIterator::~RegistryValueIterator() { |
| if (key_) |
| ::RegCloseKey(key_); |
| } |
| |
| bool RegistryValueIterator::Valid() const { |
| // true while the iterator is valid |
| return key_ != NULL && index_ >= 0; |
| } |
| |
| void RegistryValueIterator::operator++() { |
| // advance to the next entry in the folder |
| --index_; |
| Read(); |
| } |
| |
| bool RegistryValueIterator::Read() { |
| if (Valid()) { |
| DWORD ncount = sizeof(name_)/sizeof(*name_); |
| value_size_ = sizeof(value_); |
| LRESULT r = ::RegEnumValue(key_, index_, name_, &ncount, NULL, &type_, |
| reinterpret_cast<BYTE*>(value_), &value_size_); |
| if (ERROR_SUCCESS == r) |
| return true; |
| } |
| |
| name_[0] = '\0'; |
| value_[0] = '\0'; |
| value_size_ = 0; |
| return false; |
| } |
| |
| DWORD RegistryValueIterator::ValueCount() const { |
| |
| DWORD count = 0; |
| HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL, |
| &count, NULL, NULL, NULL, NULL); |
| |
| if (result != ERROR_SUCCESS) |
| return 0; |
| |
| return count; |
| } |
| |
| // |
| // RegistryKeyIterator |
| // |
| |
| RegistryKeyIterator::RegistryKeyIterator(HKEY root_key, |
| LPCTSTR folder_key) { |
| LONG result = RegOpenKeyEx(root_key, folder_key, 0, KEY_READ, &key_); |
| if (result != ERROR_SUCCESS) { |
| key_ = NULL; |
| } else { |
| DWORD count = 0; |
| HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL, |
| NULL, NULL, NULL, NULL, NULL); |
| |
| if (result != ERROR_SUCCESS) { |
| ::RegCloseKey(key_); |
| key_ = NULL; |
| } else { |
| index_ = count - 1; |
| } |
| } |
| |
| Read(); |
| } |
| |
| RegistryKeyIterator::~RegistryKeyIterator() { |
| if (key_) |
| ::RegCloseKey(key_); |
| } |
| |
| bool RegistryKeyIterator::Valid() const { |
| // true while the iterator is valid |
| return key_ != NULL && index_ >= 0; |
| } |
| |
| void RegistryKeyIterator::operator++() { |
| // advance to the next entry in the folder |
| --index_; |
| Read(); |
| } |
| |
| bool RegistryKeyIterator::Read() { |
| if (Valid()) { |
| DWORD ncount = sizeof(name_)/sizeof(*name_); |
| FILETIME written; |
| LRESULT r = ::RegEnumKeyEx(key_, index_, name_, &ncount, NULL, NULL, |
| NULL, &written); |
| if (ERROR_SUCCESS == r) |
| return true; |
| } |
| |
| name_[0] = '\0'; |
| return false; |
| } |
| |
| DWORD RegistryKeyIterator::SubkeyCount() const { |
| |
| DWORD count = 0; |
| HRESULT result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL, |
| NULL, NULL, NULL, NULL, NULL); |
| |
| if (result != ERROR_SUCCESS) |
| return 0; |
| |
| return count; |
| } |
| |
| // |
| // RegKey |
| // |
| |
| RegKey::RegKey(HKEY rootkey, const tchar* subkey, REGSAM access) |
| : key_(NULL), watch_event_(0) { |
| if (rootkey) { |
| if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK)) |
| this->Create(rootkey, subkey, access); |
| else |
| this->Open(rootkey, subkey, access); |
| } else { |
| assert(!subkey); |
| } |
| } |
| |
| void RegKey::Close() { |
| StopWatching(); |
| if (key_) { |
| ::RegCloseKey(key_); |
| key_ = NULL; |
| } |
| } |
| |
| bool RegKey::Create(HKEY rootkey, const tchar* subkey, REGSAM access) { |
| DWORD disposition_value; |
| return CreateWithDisposition(rootkey, subkey, &disposition_value, access); |
| } |
| |
| bool RegKey::CreateWithDisposition(HKEY rootkey, const tchar* subkey, |
| DWORD* disposition, REGSAM access) { |
| assert(rootkey && subkey && access && disposition); |
| this->Close(); |
| |
| LONG const result = RegCreateKeyEx(rootkey, |
| subkey, |
| 0, |
| NULL, |
| REG_OPTION_NON_VOLATILE, |
| access, |
| NULL, |
| &key_, |
| disposition ); |
| if (result != ERROR_SUCCESS) { |
| key_ = NULL; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool RegKey::Open(HKEY rootkey, const tchar* subkey, REGSAM access) { |
| assert(rootkey && subkey && access); |
| this->Close(); |
| |
| LONG const result = RegOpenKeyEx(rootkey, subkey, 0, |
| access, &key_ ); |
| if (result != ERROR_SUCCESS) { |
| key_ = NULL; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool RegKey::CreateKey(const tchar* name, REGSAM access) { |
| assert(name && access); |
| |
| HKEY subkey = NULL; |
| LONG const result = RegCreateKeyEx(key_, name, 0, NULL, |
| REG_OPTION_NON_VOLATILE, |
| access, NULL, &subkey, NULL); |
| this->Close(); |
| |
| key_ = subkey; |
| return (result == ERROR_SUCCESS); |
| } |
| |
| bool RegKey::OpenKey(const tchar* name, REGSAM access) { |
| assert(name && access); |
| |
| HKEY subkey = NULL; |
| LONG const result = RegOpenKeyEx(key_, name, 0, access, &subkey); |
| |
| this->Close(); |
| |
| key_ = subkey; |
| return (result == ERROR_SUCCESS); |
| } |
| |
| DWORD RegKey::ValueCount() { |
| DWORD count = 0; |
| HRESULT const result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, |
| NULL, &count, NULL, NULL, NULL, NULL); |
| return (result != ERROR_SUCCESS) ? 0 : count; |
| } |
| |
| bool RegKey::ReadName(int index, tstr* name) { |
| tchar buf[256]; |
| DWORD bufsize = sizeof(buf)/sizeof(*buf); |
| LRESULT r = ::RegEnumValue(key_, index, buf, &bufsize, NULL, NULL, |
| NULL, NULL); |
| if (r != ERROR_SUCCESS) |
| return false; |
| if (name) |
| *name = buf; |
| return true; |
| } |
| |
| bool RegKey::ValueExists(const tchar* name) { |
| if (!key_) return false; |
| const HRESULT result = RegQueryValueEx(key_, name, 0, NULL, NULL, NULL); |
| return (result == ERROR_SUCCESS); |
| } |
| |
| bool RegKey::ReadValue(const tchar* name, void* data, |
| DWORD* dsize, DWORD* dtype) { |
| if (!key_) return false; |
| HRESULT const result = RegQueryValueEx(key_, name, 0, dtype, |
| reinterpret_cast<LPBYTE>(data), |
| dsize); |
| return (result == ERROR_SUCCESS); |
| } |
| |
| bool RegKey::ReadValue(const tchar* name, tstr * value) { |
| assert(value); |
| static const size_t kMaxStringLength = 1024; // This is after expansion. |
| // Use the one of the other forms of ReadValue if 1024 is too small for you. |
| TCHAR raw_value[kMaxStringLength]; |
| DWORD type = REG_SZ, size = sizeof(raw_value); |
| if (this->ReadValue(name, raw_value, &size, &type)) { |
| if (type == REG_SZ) { |
| *value = raw_value; |
| } else if (type == REG_EXPAND_SZ) { |
| TCHAR expanded[kMaxStringLength]; |
| size = ExpandEnvironmentStrings(raw_value, expanded, kMaxStringLength); |
| // Success: returns the number of TCHARs copied |
| // Fail: buffer too small, returns the size required |
| // Fail: other, returns 0 |
| if (size == 0 || size > kMaxStringLength) |
| return false; |
| *value = expanded; |
| } else { |
| // Not a string. Oops. |
| return false; |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool RegKey::ReadValueDW(const tchar* name, DWORD * value) { |
| assert(value); |
| DWORD type = REG_DWORD, size = sizeof(DWORD), result = 0; |
| if (this->ReadValue(name, &result, &size, &type) |
| && (type == REG_DWORD || type == REG_BINARY) |
| && size == sizeof(DWORD)) { |
| *value = result; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool RegKey::WriteValue(const tchar* name, |
| const void * data, |
| DWORD dsize, |
| DWORD dtype) { |
| assert(data); |
| if (!key_) return false; |
| HRESULT const result = RegSetValueEx( |
| key_, |
| name, |
| 0, |
| dtype, |
| reinterpret_cast<LPBYTE>(const_cast<void*>(data)), |
| dsize); |
| return (result == ERROR_SUCCESS); |
| } |
| |
| bool RegKey::WriteValue(const tchar * name, const tchar * value) { |
| return this->WriteValue(name, value, |
| static_cast<DWORD>(sizeof(*value) * (_tcslen(value) + 1)), REG_SZ); |
| } |
| |
| bool RegKey::WriteValue(const tchar * name, DWORD value) { |
| return this->WriteValue(name, &value, |
| static_cast<DWORD>(sizeof(value)), REG_DWORD); |
| } |
| |
| bool RegKey::DeleteKey(const tchar * name) { |
| if (!key_) return false; |
| return (ERROR_SUCCESS == SHDeleteKey(key_, name)); |
| } |
| |
| |
| bool RegKey::DeleteValue(const tchar * value_name) { |
| assert(value_name); |
| HRESULT const result = RegDeleteValue(key_, value_name); |
| return (result == ERROR_SUCCESS); |
| } |
| |
| bool RegKey::StartWatching() { |
| if (!watch_event_) |
| watch_event_ = CreateEvent(NULL, TRUE, FALSE, NULL); |
| |
| DWORD filter = REG_NOTIFY_CHANGE_NAME | |
| REG_NOTIFY_CHANGE_ATTRIBUTES | |
| REG_NOTIFY_CHANGE_LAST_SET | |
| REG_NOTIFY_CHANGE_SECURITY; |
| |
| // Watch the registry key for a change of value. |
| HRESULT result = RegNotifyChangeKeyValue(key_, TRUE, filter, |
| watch_event_, TRUE); |
| if (SUCCEEDED(result)) { |
| return true; |
| } else { |
| CloseHandle(watch_event_); |
| watch_event_ = 0; |
| return false; |
| } |
| } |
| |
| bool RegKey::StopWatching() { |
| if (watch_event_) { |
| CloseHandle(watch_event_); |
| watch_event_ = 0; |
| return true; |
| } |
| return false; |
| } |
| |
| bool RegKey::HasChanged() { |
| if (watch_event_) { |
| if (WaitForSingleObject(watch_event_, 0) == WAIT_OBJECT_0) { |
| StartWatching(); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Register a COM object with the most usual properties. |
| bool RegisterCOMServer(const tchar* guid, |
| const tchar* name, |
| const tchar* path) { |
| RegKey key(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_WRITE); |
| key.CreateKey(guid, KEY_WRITE); |
| key.WriteValue(NULL, name); |
| key.CreateKey(_T("InprocServer32"), KEY_WRITE); |
| key.WriteValue(NULL, path); |
| key.WriteValue(_T("ThreadingModel"), _T("Apartment")); |
| return true; |
| } |
| |
| bool RegisterCOMServer(const tchar* guid, const tchar* name, HINSTANCE module) { |
| tchar module_path[MAX_PATH]; |
| ::GetModuleFileName(module, module_path, MAX_PATH); |
| _tcslwr_s(module_path, MAX_PATH); |
| return RegisterCOMServer(guid, name, module_path); |
| } |
| |
| bool UnregisterCOMServer(const tchar* guid) { |
| RegKey key(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_WRITE); |
| key.DeleteKey(guid); |
| return true; |
| } |