BOOL CRegKey::DeleteKey(HKEY hKey,LPCWSTR szKey) { if (!IsUnicodeSystem()) return DeleteKey(hKey,W2A(szKey)); HKEY hSubKey; FILETIME ft; DWORD cb; WCHAR szSubKey[200]; if (RegOpenKeyExW(hKey,szKey,0, KEY_ENUMERATE_SUB_KEYS|KEY_SET_VALUE,&hSubKey)!=ERROR_SUCCESS) return TRUE; DebugOpenHandle(dhtRegKey,hSubKey,szKey); for(;;) { cb=400; if (RegEnumKeyExW(hSubKey,0,szSubKey,&cb,NULL, NULL,NULL,&ft)==ERROR_NO_MORE_ITEMS) break; DeleteKey(hSubKey,szSubKey); } RegCloseKey(hSubKey); DebugCloseHandle(dhtRegKey,hSubKey,szKey); RegDeleteKeyW(hKey,szKey); return TRUE; }
/*********************************************************************** * recursive_delete_key */ static LONG recursive_delete_key(HKEY key) { LONG res; WCHAR subkey_name[MAX_PATH]; DWORD cName; HKEY subkey; for (;;) { cName = sizeof(subkey_name) / sizeof(WCHAR); res = RegEnumKeyExW(key, 0, subkey_name, &cName, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) { res = ERROR_SUCCESS; /* presumably we're done enumerating */ break; } res = RegOpenKeyExW(key, subkey_name, 0, KEY_READ | KEY_WRITE, &subkey); if (res == ERROR_FILE_NOT_FOUND) continue; if (res != ERROR_SUCCESS) break; res = recursive_delete_key(subkey); RegCloseKey(subkey); if (res != ERROR_SUCCESS) break; } if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0); return res; }
static inline void addPluginPathsFromRegistry(HKEY rootKey, HashSet<String>& paths) { HKEY key; HRESULT result = RegOpenKeyExW(rootKey, L"Software\\MozillaPlugins", 0, KEY_ENUMERATE_SUB_KEYS, &key); if (result != ERROR_SUCCESS) return; wchar_t name[128]; FILETIME lastModified; // Enumerate subkeys for (int i = 0;; i++) { DWORD nameLen = _countof(name); result = RegEnumKeyExW(key, i, name, &nameLen, 0, 0, 0, &lastModified); if (result != ERROR_SUCCESS) break; WCHAR pathStr[_MAX_PATH]; DWORD pathStrSize = sizeof(pathStr); DWORD type; result = SHGetValue(key, name, TEXT("Path"), &type, (LPBYTE)pathStr, &pathStrSize); if (result != ERROR_SUCCESS || type != REG_SZ) continue; paths.add(String(pathStr, pathStrSize / sizeof(WCHAR) - 1)); } RegCloseKey(key); }
static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Next( LPENUMGUID iface, ULONG celt, GUID *rgelt, ULONG *pceltFetched) { CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface; ULONG fetched = 0; TRACE("\n"); if (rgelt == NULL) return E_POINTER; if (This->key) while (fetched < celt) { LSTATUS res; HRESULT hr; WCHAR catid[39]; DWORD cName = 39; res = RegEnumKeyExW(This->key, This->next_index, catid, &cName, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break; ++(This->next_index); hr = CLSIDFromString(catid, rgelt); if (FAILED(hr)) continue; ++fetched; ++rgelt; } if (pceltFetched) *pceltFetched = fetched; return fetched == celt ? S_OK : S_FALSE; }
BOOL WINAPI CertEnumSystemStore(DWORD dwFlags, void *pvSystemStoreLocationPara, void *pvArg, PFN_CERT_ENUM_SYSTEM_STORE pfnEnum) { BOOL ret = FALSE; LONG rc; HKEY key; TRACE("(%08x, %p, %p, %p)\n", dwFlags, pvSystemStoreLocationPara, pvArg, pfnEnum); rc = CRYPT_OpenParentStore(dwFlags, pvArg, &key); if (!rc) { DWORD index = 0; CERT_SYSTEM_STORE_INFO info = { sizeof(info) }; ret = TRUE; do { WCHAR name[MAX_PATH]; DWORD size = sizeof(name) / sizeof(name[0]); rc = RegEnumKeyExW(key, index++, name, &size, NULL, NULL, NULL, NULL); if (!rc) ret = pfnEnum(name, dwFlags, &info, NULL, pvArg); } while (ret && !rc); if (ret && rc != ERROR_NO_MORE_ITEMS) SetLastError(rc); } else SetLastError(rc); return ret; }
// RegEnumKeyEx // returns ERROR_NO_MORE_ITEMS or ERROR_SUCCESS // if maxNameSize == 0, then we will compute it for you. Use it between calls on the same key for performance inline LONG RegEnumKeyExX(HKEY hKey, DWORD dwIndex, std::wstring& outName, DWORD& maxNameSize) { FILETIME temp; LONG ret; std::vector<wchar_t> buf; DWORD size; outName.clear(); // get maximum subkey name length. if(!maxNameSize) { if(ERROR_SUCCESS != (ret = RegQueryInfoKeyW(hKey, 0, 0, 0, 0, &maxNameSize, 0, 0, 0, 0, 0, 0))) { return ret; } maxNameSize += 2;// for safety } buf.resize(maxNameSize); // make the call size = static_cast<DWORD>(buf.size()); ret = RegEnumKeyExW(hKey, dwIndex, buf.data(), &size, 0, 0, 0, &temp); if(ret == ERROR_SUCCESS) { outName = buf.data(); } return ret; }
/* * Delete a key and all its subkeys */ HRESULT DeleteEntireSubKey(HKEY hkey, LPWSTR strSubKey) { WCHAR buffer[MAX_KEY_LEN]; DWORD dw = MAX_KEY_LEN; FILETIME ft; HKEY hk; LONG ret = RegOpenKeyExW(hkey, strSubKey, 0, MAXIMUM_ALLOWED, &hk); if (ERROR_SUCCESS == ret) { /* Keep on enumerating the first key and deleting that */ for( ; ; ) { dw = MAX_KEY_LEN; ret = RegEnumKeyExW(hk, 0, buffer, &dw, NULL, NULL, NULL, &ft); if (ERROR_SUCCESS == ret) DeleteEntireSubKey(hk, buffer); else break; } RegCloseKey(hk); RegDeleteKeyW(hkey, strSubKey); } return NOERROR; }
QStringList QSettingsPrivate::sysSubkeyList( const QString &key ) const { QString value; QStringList list; HKEY hkey = sysd->openKey( key + "\\", KEY_ENUMERATE_SUB_KEYS, value, globalScope ); if ( hkey ) { int idx = 0; unsigned long count = 255; QByteArray ba( ( count + 1 ) * sizeof( TCHAR ) ); FILETIME time; while ( QT_WA_INLINE( RegEnumKeyExW( hkey, idx, ( LPTSTR ) ba.data(), &count, NULL, NULL, NULL, &time ), RegEnumKeyExA( hkey, idx, ( LPSTR ) ba.data(), &count, NULL, NULL, NULL, &time ) ) == ERROR_SUCCESS ) { list.append ( QT_WA_INLINE( QString::fromUcs2( ( unsigned short * ) ba.data() ), QString::fromLatin1( ( LPCSTR ) ba.data() ) ) ); idx++; count = 255; /* !! */ } RegCloseKey( hkey ); } return list; }
static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key) { MMDevPropStore *This = impl_from_IPropertyStore(iface); WCHAR buffer[50]; DWORD len = sizeof(buffer)/sizeof(*buffer); HRESULT hr; HKEY propkey; TRACE("(%p)->(%u,%p)\n", iface, prop, key); if (!key) return E_POINTER; hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey); if (FAILED(hr)) return hr; if (RegEnumKeyExW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS || len <= 40) { WARN("GetAt %u failed\n", prop); return E_INVALIDARG; } RegCloseKey(propkey); buffer[39] = 0; CLSIDFromString(buffer, &key->fmtid); key->pid = atoiW(&buffer[40]); return S_OK; }
static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *nprops) { MMDevPropStore *This = impl_from_IPropertyStore(iface); WCHAR buffer[50]; DWORD i = 0; HKEY propkey; HRESULT hr; TRACE("(%p)->(%p)\n", iface, nprops); if (!nprops) return E_POINTER; hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey); if (FAILED(hr)) return hr; *nprops = 0; do { DWORD len = sizeof(buffer)/sizeof(*buffer); if (RegEnumKeyExW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) break; i++; } while (0); RegCloseKey(propkey); TRACE("Returning %i\n", i); *nprops = i; return S_OK; }
Key Key::subKey( int nIdx ) const { HKEY hKey; LONG lRtn = RegOpenKeyExW( m_hRootKey, m_wsPath.c_str(), 0, KEY_READ, &hKey ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegOpenKeyExW(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } // TODO: could use RegQueryInfo to get required buf size. const int knBufSize = 1000; wchar_t szSubKeyName[knBufSize]; DWORD dwBufSize = knBufSize; lRtn = RegEnumKeyExW( hKey, nIdx, szSubKeyName, &dwBufSize, NULL, NULL, NULL, NULL ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegEnumKeyEx(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } string sSubKeyFullPath = fullPath() + "\\" + wideToUtf8( szSubKeyName ); return Key( sSubKeyFullPath ); }
void InitIconOverlays(void) { HKEY hKey; DWORD dwIndex, dwResult, dwSize; WCHAR szName[MAX_PATH]; WCHAR szValue[100]; CLSID clsid; IShellIconOverlayIdentifier * Overlay; if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers", 0, KEY_READ, &hKey) != ERROR_SUCCESS) return; if (RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &dwResult, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) { RegCloseKey(hKey); return; } Handlers = (IShellIconOverlayIdentifier **)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwResult * sizeof(IShellIconOverlayIdentifier*)); if (!Handlers) { RegCloseKey(hKey); return; } dwIndex = 0; CoInitialize(0); do { dwSize = sizeof(szName) / sizeof(WCHAR); dwResult = RegEnumKeyExW(hKey, dwIndex, szName, &dwSize, NULL, NULL, NULL, NULL); if (dwResult == ERROR_NO_MORE_ITEMS) break; if (dwResult == ERROR_SUCCESS) { dwSize = sizeof(szValue) / sizeof(WCHAR); if (RegGetValueW(hKey, szName, NULL, RRF_RT_REG_SZ, NULL, szValue, &dwSize) == ERROR_SUCCESS) { CLSIDFromString(szValue, &clsid); dwResult = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID*)&Overlay); if (dwResult == S_OK) { Handlers[NumIconOverlayHandlers] = Overlay; NumIconOverlayHandlers++; } } } dwIndex++; } while(1); RegCloseKey(hKey); }
static HRESULT load_devices_from_reg(void) { DWORD i = 0; HKEY root, cur; LONG ret; DWORD curflow; ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, software_mmdevapi, 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &root, NULL); if (ret == ERROR_SUCCESS) ret = RegCreateKeyExW(root, reg_capture, 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_capture, NULL); if (ret == ERROR_SUCCESS) ret = RegCreateKeyExW(root, reg_render, 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_render, NULL); RegCloseKey(root); cur = key_capture; curflow = eCapture; if (ret != ERROR_SUCCESS) { RegCloseKey(key_capture); key_render = key_capture = NULL; WARN("Couldn't create key: %u\n", ret); return E_FAIL; } do { WCHAR guidvalue[39]; GUID guid; DWORD len; PROPVARIANT pv = { VT_EMPTY }; len = sizeof(guidvalue)/sizeof(guidvalue[0]); ret = RegEnumKeyExW(cur, i++, guidvalue, &len, NULL, NULL, NULL, NULL); if (ret == ERROR_NO_MORE_ITEMS) { if (cur == key_capture) { cur = key_render; curflow = eRender; i = 0; continue; } break; } if (ret != ERROR_SUCCESS) continue; if (SUCCEEDED(CLSIDFromString(guidvalue, &guid)) && SUCCEEDED(MMDevice_GetPropValue(&guid, curflow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv)) && pv.vt == VT_LPWSTR) { DWORD size_bytes = (strlenW(pv.u.pwszVal) + 1) * sizeof(WCHAR); WCHAR *name = HeapAlloc(GetProcessHeap(), 0, size_bytes); memcpy(name, pv.u.pwszVal, size_bytes); MMDevice_Create(name, &guid, curflow, DEVICE_STATE_NOTPRESENT, FALSE); CoTaskMemFree(pv.u.pwszVal); } } while (1); return S_OK; }
/*********************************************************************** * MSACM_RegisterAllDrivers() */ void MSACM_RegisterAllDrivers(void) { static const WCHAR msacm32[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'}; static const WCHAR msacmW[] = {'M','S','A','C','M','.'}; static const WCHAR drv32[] = {'d','r','i','v','e','r','s','3','2','\0'}; static const WCHAR sys[] = {'s','y','s','t','e','m','.','i','n','i','\0'}; static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\', 'M','i','c','r','o','s','o','f','t','\\', 'W','i','n','d','o','w','s',' ','N','T','\\', 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', 'D','r','i','v','e','r','s','3','2','\0'}; DWORD i, cnt, bufLen, lRet, type; WCHAR buf[2048], valname[64], *name, *s; FILETIME lastWrite; HKEY hKey; /* FIXME: What if the user edits system.ini while the program is running? * Does Windows handle that? */ if (MSACM_pFirstACMDriverID) return; lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey); if (lRet == ERROR_SUCCESS) { RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); for (i = 0; i < cnt; i++) { bufLen = sizeof(buf) / sizeof(buf[0]); lRet = RegEnumKeyExW(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite); if (lRet != ERROR_SUCCESS) continue; if (strncmpiW(buf, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue; if (!(name = strchrW(buf, '='))) continue; *name = 0; MSACM_RegisterDriver(buf, name + 1, 0); } i = 0; cnt = sizeof(valname) / sizeof(*valname); bufLen = sizeof(buf); while(RegEnumValueW(hKey, i, valname, &cnt, 0, &type, (BYTE*)buf, &bufLen) == ERROR_SUCCESS){ if(!strncmpiW(valname, msacmW, sizeof(msacmW) / sizeof(*msacmW))) MSACM_RegisterDriver(valname, buf, 0); ++i; } RegCloseKey( hKey ); } if (GetPrivateProfileSectionW(drv32, buf, sizeof(buf)/sizeof(buf[0]), sys)) { for(s = buf; *s; s += strlenW(s) + 1) { if (strncmpiW(s, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue; if (!(name = strchrW(s, '='))) continue; *name = 0; MSACM_RegisterDriver(s, name + 1, 0); *name = '='; } } MSACM_ReorderDriversByPriority(); MSACM_RegisterDriver(msacm32, msacm32, 0); }
/********************************************************************** * COMCAT_IsClassOfCategories */ static HRESULT COMCAT_IsClassOfCategories( HKEY key, struct class_categories const* categories) { const WCHAR *impl_strings, *req_strings; HKEY subkey; HRESULT res; DWORD index; LPCWSTR string; impl_strings = (WCHAR*)((BYTE*)categories + categories->impl_offset); req_strings = (WCHAR*)((BYTE*)categories + categories->req_offset); /* Check that every given category is implemented by class. */ if (*impl_strings) { res = open_classes_key(key, impl_keyname, KEY_READ, &subkey); if (res != ERROR_SUCCESS) return S_FALSE; for (string = impl_strings; *string; string += CHARS_IN_GUID) { HKEY catkey; #ifdef __REACTOS__ res = open_classes_key(subkey, string, READ_CONTROL, &catkey); #else res = open_classes_key(subkey, string, 0, &catkey); #endif if (res != ERROR_SUCCESS) { RegCloseKey(subkey); return S_FALSE; } RegCloseKey(catkey); } RegCloseKey(subkey); } /* Check that all categories required by class are given. */ res = open_classes_key(key, req_keyname, KEY_READ, &subkey); if (res == ERROR_SUCCESS) { for (index = 0; ; ++index) { WCHAR keyname[CHARS_IN_GUID]; DWORD size = CHARS_IN_GUID; res = RegEnumKeyExW(subkey, index, keyname, &size, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break; if (size != CHARS_IN_GUID-1) continue; /* bogus catid in registry */ for (string = req_strings; *string; string += CHARS_IN_GUID) if (!strcmpiW(string, keyname)) break; if (!*string) { RegCloseKey(subkey); return S_FALSE; } } RegCloseKey(subkey); } return S_OK; }
static BOOL CreateMyCompEnumList(IEnumIDListImpl *list, DWORD dwFlags) { BOOL ret = TRUE; TRACE("(%p)->(flags=0x%08x)\n", list, dwFlags); /* enumerate the folders */ if (dwFlags & SHCONTF_FOLDERS) { WCHAR wszDriveName[] = {'A', ':', '\\', '\0'}; DWORD dwDrivemap = get_drive_map(); HKEY hkey; UINT i; while (ret && wszDriveName[0]<='Z') { if(dwDrivemap & 0x00000001L) ret = AddToEnumList(list, _ILCreateDrive(wszDriveName)); wszDriveName[0]++; dwDrivemap = dwDrivemap >> 1; } TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n",list); for (i=0; i<2; i++) { if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, MyComputer_NameSpaceW, 0, KEY_READ, &hkey)) { WCHAR iid[50]; int i=0; while (ret) { DWORD size; LONG r; size = sizeof(iid) / sizeof(iid[0]); r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL); if (ERROR_SUCCESS == r) { /* FIXME: shell extensions, shouldn't the type be * PT_SHELLEXT? */ ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid)); i++; } else if (ERROR_NO_MORE_ITEMS == r) break; else ret = FALSE; } RegCloseKey(hkey); } } }
static VOID LoadUsernameHint(HWND hDlg, INT iCur) { WCHAR szValue[MAXVALUE+1000]; WCHAR szName[MAX_KEY_NAME]; WCHAR szKeyName[] = L"Software\\Microsoft\\Terminal Server Client\\Servers"; PWCHAR lpAddress; HKEY hKey; HKEY hSubKey; LONG lRet = ERROR_SUCCESS; INT iIndex = 0; DWORD dwSize = MAX_KEY_NAME; SendDlgItemMessageW(hDlg, IDC_SERVERCOMBO, CB_GETLBTEXT, (WPARAM)iCur, (LPARAM)szValue); /* remove possible port number */ lpAddress = wcstok(szValue, L":"); if (lpAddress == NULL) return; if (RegOpenKeyExW(HKEY_CURRENT_USER, szKeyName, 0, KEY_READ, &hKey) == ERROR_SUCCESS) { while (lRet == ERROR_SUCCESS) { dwSize = MAX_KEY_NAME; lRet = RegEnumKeyExW(hKey, iIndex, szName, &dwSize, NULL, NULL, NULL, NULL); if(lRet == ERROR_SUCCESS && wcscmp(szName, lpAddress) == 0) { if(RegOpenKeyExW(hKey, szName, 0, KEY_READ, &hSubKey) != ERROR_SUCCESS) break; dwSize = MAXVALUE * sizeof(WCHAR); if(RegQueryValueExW(hKey, L"UsernameHint", 0, NULL, (LPBYTE)szValue, &dwSize) == ERROR_SUCCESS) { SetDlgItemTextW(hDlg, IDC_NAMEEDIT, szValue); } RegCloseKey(hSubKey); break; } iIndex++; } RegCloseKey(hKey); } }
/********************************************************************** * COMCAT_IsClassOfCategories */ static HRESULT COMCAT_IsClassOfCategories( HKEY key, struct class_categories const* categories) { static const WCHAR impl_keyname[] = { 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'e', 'd', ' ', 'C', 'a', 't', 'e', 'g', 'o', 'r', 'i', 'e', 's', 0 }; static const WCHAR req_keyname[] = { 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd', ' ', 'C', 'a', 't', 'e', 'g', 'o', 'r', 'i', 'e', 's', 0 }; HKEY subkey; HRESULT res; DWORD index; LPCWSTR string; /* Check that every given category is implemented by class. */ res = RegOpenKeyExW(key, impl_keyname, 0, KEY_READ, &subkey); if (res != ERROR_SUCCESS) return S_FALSE; for (string = categories->impl_strings; *string; string += 39) { HKEY catkey; res = RegOpenKeyExW(subkey, string, 0, 0, &catkey); if (res != ERROR_SUCCESS) { RegCloseKey(subkey); return S_FALSE; } RegCloseKey(catkey); } RegCloseKey(subkey); /* Check that all categories required by class are given. */ res = RegOpenKeyExW(key, req_keyname, 0, KEY_READ, &subkey); if (res == ERROR_SUCCESS) { for (index = 0; ; ++index) { WCHAR keyname[39]; DWORD size = 39; res = RegEnumKeyExW(subkey, index, keyname, &size, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break; if (size != 38) continue; /* bogus catid in registry */ for (string = categories->req_strings; *string; string += 39) if (!strcmpiW(string, keyname)) break; if (!*string) { RegCloseKey(subkey); return S_FALSE; } } RegCloseKey(subkey); } return S_OK; }
BOOL InitNotifications(VOID) { HKEY hNotifyKey = NULL; LONG lError; DWORD dwIndex; WCHAR szKeyName[80]; DWORD dwKeyName; TRACE("InitNotifications()\n"); InitializeListHead(&NotificationDllListHead); lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Notify", 0, KEY_READ | KEY_ENUMERATE_SUB_KEYS, &hNotifyKey); if (lError != ERROR_SUCCESS) { TRACE("RegOpenKeyExW()\n"); return TRUE; } dwIndex = 0; for(;;) { dwKeyName = 80 * sizeof(WCHAR); lError = RegEnumKeyExW(hNotifyKey, dwIndex, szKeyName, &dwKeyName, NULL, NULL, NULL, NULL); if (lError != ERROR_SUCCESS) break; TRACE("Notification DLL: %S\n", szKeyName); LoadNotificationDll(hNotifyKey, szKeyName); dwIndex++; } RegCloseKey(hNotifyKey); TRACE("InitNotifications() done\n"); return TRUE; }
static BOOL CreateDesktopEnumList(IEnumIDListImpl *list, DWORD dwFlags) { BOOL ret = TRUE; WCHAR szPath[MAX_PATH]; TRACE("(%p)->(flags=0x%08x)\n", list, dwFlags); /* enumerate the root folders */ if (dwFlags & SHCONTF_FOLDERS) { HKEY hkey; UINT i; /* create the pidl for This item */ ret = AddToEnumList(list, _ILCreateMyComputer()); for (i=0; i<2; i++) { if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, Desktop_NameSpaceW, 0, KEY_READ, &hkey)) { WCHAR iid[50]; int i=0; while (ret) { DWORD size; LONG r; size = sizeof (iid) / sizeof (iid[0]); r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL); if (ERROR_SUCCESS == r) { ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid)); i++; } else if (ERROR_NO_MORE_ITEMS == r) break; else ret = FALSE; } RegCloseKey(hkey); } } } /* enumerate the elements in %windir%\desktop */ SHGetSpecialFolderPathW(0, szPath, CSIDL_DESKTOPDIRECTORY, FALSE); ret = ret && CreateFolderEnumList(list, szPath, dwFlags); return ret; }
/*********************************************************************** * build_zonemap_from_reg [internal] * * Enumerate the Zones in the Registry and return the Zones in a DWORD-array * The number of the Zones is returned in data[0] */ static LPDWORD build_zonemap_from_reg(void) { WCHAR name[32]; HKEY hkey; LPDWORD data = NULL; DWORD allocated = 6; /* space for the zonecount and Zone "0" up to Zone "4" */ DWORD used = 0; DWORD res; DWORD len; res = RegOpenKeyW(HKEY_CURRENT_USER, wszZonesKey, &hkey); if (res) return NULL; data = heap_alloc(allocated * sizeof(DWORD)); if (!data) goto cleanup; while (!res) { name[0] = '\0'; len = sizeof(name) / sizeof(name[0]); res = RegEnumKeyExW(hkey, used, name, &len, NULL, NULL, NULL, NULL); if (!res) { used++; if (used == allocated) { LPDWORD new_data; allocated *= 2; new_data = heap_realloc_zero(data, allocated * sizeof(DWORD)); if (!new_data) goto cleanup; data = new_data; } data[used] = atoiW(name); } } if (used) { RegCloseKey(hkey); data[0] = used; return data; } cleanup: /* something failed */ RegCloseKey(hkey); heap_free(data); return NULL; }
LONG Win32U_RegEnumKeyEx(HKEY keyName, // IN: DWORD index, // IN: LPSTR key, // OUT: buffer LPDWORD keySize, // IN/OUT: LPDWORD reserved, // IN: reserved LPSTR className, // IN/OUT: LPDWORD classNameSize, // IN/OUT: PFILETIME lastWriteTime) // OUT: { LONG ret; // Receiving buffer for key. utf16_t keyW[REG_MAX_KEY_LEN] = { 0 }; DWORD keySizeW = ARRAYSIZE(keyW); // Receiving buffer for className. utf16_t classNameW[REG_MAX_KEY_LEN] = { 0 }; DWORD classNameSizeW = ARRAYSIZE(classNameW); ret = RegEnumKeyExW(keyName, index, keyW, &keySizeW, reserved, className == NULL ? NULL : classNameW, classNameSize == NULL ? NULL : &classNameSizeW, lastWriteTime); if (ret == ERROR_SUCCESS) { /* * Convert key name back to UTF-8 * * If the call returns FALSE, the buffer is not big enough and * *keySize has the necessary size (excluding the terminating NUL). * In this case we fake ERROR_MORE_DATA. */ if (!Win32UCodeSetUtf16leToUtf8(keyW, keySizeW * 2, key, keySize)) { ret = ERROR_MORE_DATA; } /* Convert class name back to UTF-8 */ if (className) { if (!Win32UCodeSetUtf16leToUtf8(classNameW, classNameSizeW * 2, className, classNameSize)) { ret = ERROR_MORE_DATA; } } } return ret; }
bool WinRegKey::EnumKey(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName) { LONG lRes; // enum the keys lRes = RegEnumKeyExW(m_hKey, index, pValueName, pcchValueName, NULL, NULL, NULL, NULL); if (ERROR_SUCCESS != lRes) { DISPATCHER_LOG_OPERATION(SetLastError(lRes)); TRACE_WINREG_ERROR("EnumKey with index=%d: RegEnumKeyExW()==0x%x\n", index, GetLastError()); return false; } return true; } // bool WinRegKey::EnumKey(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName)
JNIEXPORT jobjectArray JNICALL Java_org_netbeans_installer_utils_system_windows_WindowsRegistry_getSubkeyNames0(JNIEnv *jEnv, jobject jObject, jint jMode, jint jSection, jstring jKey) { HKEY hkey = 0; unsigned short* key = getWideChars(jEnv, jKey); DWORD number = 0; int err = 0; int index = 0 ; unsigned short* buffer = (unsigned short*) MALLOC(sizeof(char) * MAX_LEN_VALUE_NAME); jobjectArray result = NULL; if (RegOpenKeyExW(getHKEY(jSection), key, 0, KEY_READ | getMode(jMode), &hkey) == ERROR_SUCCESS) { if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, &number, NULL, NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { jclass stringClazz = (*jEnv)->FindClass(jEnv, "java/lang/String"); result = (*jEnv)->NewObjectArray(jEnv, number, stringClazz, NULL); do { DWORD size = MAX_LEN_VALUE_NAME; buffer[0] = 0; err = RegEnumKeyExW(hkey, index, buffer, &size, NULL, NULL, NULL, NULL); if (err == ERROR_SUCCESS) { (*jEnv)->SetObjectArrayElement(jEnv, result, index, getStringW(jEnv, buffer)); } else { if (err != ERROR_NO_MORE_ITEMS) { throwException(jEnv, "Cannot get key names"); } } index++; } while (err == ERROR_SUCCESS); } else { throwException(jEnv, "Cannot read key data"); } } else { throwException(jEnv, "Cannot open key"); } if (hkey != 0) { RegCloseKey(hkey); } FREE(key); FREE(buffer); return result; }
BOOL IsInstalledApplication(LPWSTR lpRegName, BOOL IsUserKey) { DWORD dwSize = MAX_PATH, dwType; WCHAR szName[MAX_PATH]; WCHAR szDisplayName[MAX_PATH]; HKEY hKey, hSubKey; INT ItemIndex = 0; if (RegOpenKeyW(IsUserKey ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall", &hKey) != ERROR_SUCCESS) { return FALSE; } while (RegEnumKeyExW(hKey, ItemIndex, szName, &dwSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { if (RegOpenKeyW(hKey, szName, &hSubKey) == ERROR_SUCCESS) { dwType = REG_SZ; dwSize = MAX_PATH; if (RegQueryValueExW(hSubKey, L"DisplayName", NULL, &dwType, (LPBYTE)szDisplayName, &dwSize) == ERROR_SUCCESS) { if (wcscmp(szDisplayName, lpRegName) == 0) { RegCloseKey(hSubKey); RegCloseKey(hKey); return TRUE; } } } RegCloseKey(hSubKey); dwSize = MAX_PATH; ItemIndex++; } RegCloseKey(hKey); return FALSE; }
void PuttySessions::loadRegSessions() { QStringList sessions; HKEY key; DWORD i, keyname_length; TCHAR keyname[256]; if (RegOpenKeyEx(HKEY_CURRENT_USER, PuttySessions::REG_POS, 0, KEY_ENUMERATE_SUB_KEYS, &key) == ERROR_SUCCESS) { keyname_length = sizeof(keyname)/sizeof(TCHAR); for (i=0; RegEnumKeyExW(key, i, keyname, &keyname_length, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; ++i) { this->append(unmungeString(keyname)); keyname_length = sizeof(keyname)/sizeof(TCHAR); } RegCloseKey(key); } }
/*************************************************************** * DMOUnregister (MSDMO.@) * * Unregister a DirectX Media Object. */ HRESULT WINAPI DMOUnregister(REFCLSID dmo, REFGUID category) { HKEY rootkey = 0, categorieskey = 0; WCHAR dmoW[64], catW[64]; HRESULT hr = S_FALSE; LONG ret; TRACE("%s %s\n", debugstr_guid(dmo), debugstr_guid(category)); ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &rootkey); if (ret) return S_FALSE; GUIDToString(dmoW, dmo); RegDeleteKeyW(rootkey, dmoW); /* open 'Categories' */ ret = RegOpenKeyExW(rootkey, szDMOCategories, 0, KEY_WRITE|KEY_ENUMERATE_SUB_KEYS, &categorieskey); RegCloseKey(rootkey); if (ret) { hr = HRESULT_FROM_WIN32(ret); goto lend; } /* remove from all categories */ if (IsEqualGUID(category, &GUID_NULL)) { DWORD index = 0, len = sizeof(catW)/sizeof(WCHAR); while (!RegEnumKeyExW(categorieskey, index++, catW, &len, NULL, NULL, NULL, NULL)) hr = unregister_dmo_from_category(dmoW, catW, categorieskey); } else { GUIDToString(catW, category); hr = unregister_dmo_from_category(dmoW, catW, categorieskey); } lend: if (categorieskey) RegCloseKey(categorieskey); return hr; }
static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Next( LPENUMCATEGORYINFO iface, ULONG celt, CATEGORYINFO *rgelt, ULONG *pceltFetched) { IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface; ULONG fetched = 0; TRACE("\n"); if (rgelt == NULL) return E_POINTER; if (This->key) while (fetched < celt) { LSTATUS res; HRESULT hr; WCHAR catid[39]; DWORD cName = 39; HKEY subkey; res = RegEnumKeyExW(This->key, This->next_index, catid, &cName, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break; ++(This->next_index); hr = CLSIDFromString(catid, &rgelt->catid); if (FAILED(hr)) continue; res = RegOpenKeyExW(This->key, catid, 0, KEY_READ, &subkey); if (res != ERROR_SUCCESS) continue; hr = COMCAT_GetCategoryDesc(subkey, This->lcid, rgelt->szDescription, 128); RegCloseKey(subkey); if (FAILED(hr)) continue; rgelt->lcid = This->lcid; ++fetched; ++rgelt; } if (pceltFetched) *pceltFetched = fetched; return fetched == celt ? S_OK : S_FALSE; }
static inline void addAdobeAcrobatPluginDirectory(Vector<String>& directories) { HKEY key; HRESULT result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Adobe\\Acrobat Reader"), 0, KEY_READ, &key); if (result != ERROR_SUCCESS) return; WCHAR name[128]; FILETIME lastModified; Vector<int> latestAcrobatVersion; String latestAcrobatVersionString; // Enumerate subkeys for (int i = 0;; i++) { DWORD nameLen = sizeof(name) / sizeof(WCHAR); result = RegEnumKeyExW(key, i, name, &nameLen, 0, 0, 0, &lastModified); if (result != ERROR_SUCCESS) break; Vector<int> acrobatVersion = parseVersionString(String(name, nameLen)); if (compareVersions(acrobatVersion, latestAcrobatVersion)) { latestAcrobatVersion = acrobatVersion; latestAcrobatVersionString = String(name, nameLen); } } if (!latestAcrobatVersionString.isNull()) { DWORD type; WCHAR acrobatInstallPathStr[_MAX_PATH]; DWORD acrobatInstallPathSize = sizeof(acrobatInstallPathStr); String acrobatPluginKeyPath = "Software\\Adobe\\Acrobat Reader\\" + latestAcrobatVersionString + "\\InstallPath"; result = SHGetValue(HKEY_LOCAL_MACHINE, acrobatPluginKeyPath.charactersWithNullTermination(), 0, &type, (LPBYTE)acrobatInstallPathStr, &acrobatInstallPathSize); if (result == ERROR_SUCCESS) { String acrobatPluginDirectory = String(acrobatInstallPathStr, acrobatInstallPathSize / sizeof(WCHAR) - 1) + "\\browser"; directories.append(acrobatPluginDirectory); } } RegCloseKey(key); }
static BOOL InitializeFileTypesListCtrl(HWND hwndDlg) { HWND hDlgCtrl; DWORD dwIndex = 0; WCHAR szName[50]; WCHAR szFile[100]; DWORD dwName; LVITEMW lvItem; INT iItem = 0; hDlgCtrl = GetDlgItem(hwndDlg, 14000); InitializeFileTypesListCtrlColumns(hDlgCtrl); szFile[0] = 0; if (!LoadStringW(shell32_hInstance, IDS_SHV_COLUMN1, szFile, sizeof(szFile) / sizeof(WCHAR))) { /* default to english */ wcscpy(szFile, L"File"); } szFile[(sizeof(szFile)/sizeof(WCHAR))-1] = 0; dwName = sizeof(szName) / sizeof(WCHAR); while(RegEnumKeyExW(HKEY_CLASSES_ROOT, dwIndex++, szName, &dwName, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { InsertFileType(hDlgCtrl, szName, &iItem, szFile); dwName = sizeof(szName) / sizeof(WCHAR); } /* sort list */ ListView_SortItems(hDlgCtrl, ListViewCompareProc, NULL); /* select first item */ ZeroMemory(&lvItem, sizeof(LVITEMW)); lvItem.mask = LVIF_STATE; lvItem.stateMask = (UINT) - 1; lvItem.state = LVIS_FOCUSED | LVIS_SELECTED; lvItem.iItem = 0; (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&lvItem); return TRUE; }