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; }
/*************************************************************** * DMOUnregister (MSDMO.@) * * Unregister a DirectX Media Object. */ HRESULT WINAPI DMOUnregister(REFCLSID clsidDMO, REFGUID guidCategory) { HRESULT hres; WCHAR szguid[64]; HKEY hrkey = 0; HKEY hckey = 0; GUIDToString(szguid, clsidDMO); TRACE("%s %p\n", debugstr_w(szguid), guidCategory); hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &hrkey); if (ERROR_SUCCESS != hres) goto lend; hres = RegDeleteKeyW(hrkey, szguid); if (ERROR_SUCCESS != hres) goto lend; hres = RegOpenKeyExW(hrkey, szDMOCategories, 0, KEY_WRITE, &hckey); if (ERROR_SUCCESS != hres) goto lend; hres = RegDeleteKeyW(hckey, szguid); if (ERROR_SUCCESS != hres) goto lend; lend: if (hckey) RegCloseKey(hckey); if (hrkey) RegCloseKey(hrkey); return hres; }
STDAPI DllUnregisterServer(void) { DebugLog(L"Unregistering server"); TCHAR clsid[MAX_PATH]; StringFromGUID2(SHELLEXT_GUID, clsid, ARRAYSIZE(clsid)); Unregist_CLSID(clsid); RegDeleteKeyW(HKEY_CLASSES_ROOT, L"*\\ShellEx\\ContextMenuHandlers\\00TiXExt"); RegDeleteKeyW(HKEY_CLASSES_ROOT, L"Directory\\ShellEx\\ContextMenuHandlers\\00TiXExt"); HKEY hTmpKey; if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved", &hTmpKey) == ERROR_SUCCESS) { RegDeleteValueW(hTmpKey, clsid); RegCloseKey(hTmpKey); } if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\RyuaNerin", &hTmpKey) == ERROR_SUCCESS) { RegDeleteValueW(hTmpKey, L"TiX"); RegDeleteValueW(hTmpKey, L"TiX-Option"); RegCloseKey(hTmpKey); } return S_OK; }
static void test_SQLWritePrivateProfileString(void) { static const WCHAR odbc_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','O','D','B','C','.','I','N','I','\\','w','i','n','e','o','d','b','c',0}; static const WCHAR abcd_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','a','b','c','d','.','I','N','I','\\','w','i','n','e','o','d','b','c',0}; static const WCHAR abcdini_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','a','b','c','d','.','I','N','I',0 }; BOOL ret; LONG reg_ret; DWORD error_code; ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", ""); ok(!ret, "SQLWritePrivateProfileString passed\n"); SQLInstallerErrorW(1, &error_code, NULL, 0, NULL); ok(error_code == ODBC_ERROR_INVALID_STR, "SQLInstallerErrorW ret: %d\n", error_code); ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", NULL); ok(!ret, "SQLWritePrivateProfileString passed\n"); SQLInstallerErrorW(1, &error_code, NULL, 0, NULL); ok(error_code == ODBC_ERROR_INVALID_STR, "SQLInstallerErrorW ret: %d\n", error_code); ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", "odbc.ini"); ok(ret, "SQLWritePrivateProfileString failed\n"); if(ret) { HKEY hkey; reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, odbc_key, 0, KEY_READ, &hkey); ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n"); if(reg_ret == ERROR_SUCCESS) { reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, odbc_key); ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n"); RegCloseKey(hkey); } } ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", "abcd.ini"); ok(ret, "SQLWritePrivateProfileString failed\n"); if(ret) { HKEY hkey; reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, abcd_key, 0, KEY_READ, &hkey); ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n"); if(reg_ret == ERROR_SUCCESS) { reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcd_key); ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n"); RegCloseKey(hkey); } /* Cleanup key */ reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcdini_key); ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n"); } }
void Unregist_CLSID(LPWSTR clsid) { TCHAR subKey[MAX_PATH]; wsprintf(subKey, L"CLSID\\%s\\InprocServer32", clsid); RegDeleteKeyW(HKEY_CLASSES_ROOT, subKey); wsprintf(subKey, L"CLSID\\%s", clsid); RegDeleteKeyW(HKEY_CLASSES_ROOT, subKey); }
//------------------------------------------------------------------------------ // DllUnregisterServer //------------------------------------------------------------------------------ STDAPI DllUnregisterServer() { HKEY hKey = NULL; HRESULT hr = S_OK; LONG lResult = ERROR_SUCCESS; WCHAR szKey[MAX_PATH] = { 0 }; WCHAR szCLSID[OLEGUID_LEN_CCH] = { 0 }; // // Register the COM object in the registry // if (0 == StringFromGUID2(CLSID_SsysPrinterSvcProxy, szCLSID, ARRAYSIZE(szCLSID))) { hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); } if (S_OK == hr) { hr = StringCchPrintfW(szKey, ARRAYSIZE(szKey), L"%s\\InProcServer32", szCLSID); } if (S_OK == hr) { lResult = RegOpenKeyExW( HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_SET_VALUE, &hKey ); hr = HRESULT_FROM_WIN32(lResult); } if (S_OK == hr) { lResult = RegDeleteKeyW(hKey, szKey); hr = HRESULT_FROM_WIN32(lResult); } if (S_OK == hr) { lResult = RegDeleteKeyW(hKey, szCLSID); hr = HRESULT_FROM_WIN32(lResult); } RegCloseKey(hKey); hKey = NULL; return hr; }// DllUnregisterServer
static BOOL InputList_PrepareUserRegistry(VOID) { BOOL bResult = FALSE; HKEY hTempKey = NULL; HKEY hKey = NULL; if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Keyboard Layout", 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS) { RegDeleteKeyW(hKey, L"Preload"); RegDeleteKeyW(hKey, L"Substitutes"); RegCloseKey(hKey); } if (RegCreateKeyW(HKEY_CURRENT_USER, L"Keyboard Layout", &hKey) != ERROR_SUCCESS) { goto Cleanup; } if (RegCreateKeyW(hKey, L"Preload", &hTempKey) != ERROR_SUCCESS) { goto Cleanup; } RegCloseKey(hTempKey); if (RegCreateKeyW(hKey, L"Substitutes", &hTempKey) != ERROR_SUCCESS) { goto Cleanup; } RegCloseKey(hTempKey); bResult = TRUE; Cleanup: if (hTempKey != NULL) RegCloseKey(hTempKey); if (hKey != NULL) RegCloseKey(hKey); return bResult; }
static void s_RemoveRegistry(wchar_t *s) { HKEY key, result; wchar_t *subkey, *last; DWORD rc; SplitRegistryKey("remove-registry!", s, &key, &subkey, &last); /* open the key */ if (last == subkey) { rc = RegOpenKeyExW(key, L"", 0, KEY_ALL_ACCESS, &result); } else { *last = '\0'; /* Truncate subkey at backslash */ rc = RegOpenKeyExW(key, subkey, 0, KEY_ALL_ACCESS, &result); *last++ = '\\'; /* Restore backslash */ } if (rc == ERROR_SUCCESS) { /* delete the value */ rc = RegDeleteValueW(result, last); if (rc == ERROR_FILE_NOT_FOUND) /* value by given name not found; try deleting as key */ rc = RegDeleteKeyW(result, last); RegCloseKey(result); } if (rc != ERROR_SUCCESS) { char *s_utf8 = Swide_to_utf8(s); ptr s_scheme = Sstring_utf8(s_utf8, -1); free(s_utf8); S_error2("remove-registry!", "cannot remove ~a (~a)", s_scheme, rc == ERROR_FILE_NOT_FOUND ? Sstring("not found") : rc == ERROR_ACCESS_DENIED ? Sstring("insufficient permission or subkeys exist") : s_ErrorString(rc)); } }
LONG WINAPI RegDeleteKeyA( IN HKEY hKey, IN LPCSTR lpSubKey) { PWSTR lpSubKeyW = NULL; LONG rc; if (lpSubKey != NULL && strchr(lpSubKey, '\\') != NULL) return ERROR_INVALID_PARAMETER; if (lpSubKey) { lpSubKeyW = MultiByteToWideChar(lpSubKey); if (!lpSubKeyW) return ERROR_OUTOFMEMORY; } rc = RegDeleteKeyW(hKey, lpSubKeyW); if (lpSubKey) free(lpSubKeyW); return rc; }
/* * 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; }
VOID RemoveAppFromRegistry(INT Index) { PINSTALLED_INFO Info; WCHAR szFullName[MAX_PATH] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"; WCHAR szMsgText[MAX_STR_LEN], szMsgTitle[MAX_STR_LEN]; INT ItemIndex = SendMessage(hListView, LVM_GETNEXTITEM, -1, LVNI_FOCUSED); if (!IS_INSTALLED_ENUM(SelectedEnumType)) return; Info = (PINSTALLED_INFO) ListViewGetlParam(Index); if (!Info || !Info->hSubKey || (ItemIndex == -1)) return; if (!LoadStringW(hInst, IDS_APP_REG_REMOVE, szMsgText, sizeof(szMsgText) / sizeof(WCHAR)) || !LoadStringW(hInst, IDS_INFORMATION, szMsgTitle, sizeof(szMsgTitle) / sizeof(WCHAR))) return; if (MessageBoxW(hMainWnd, szMsgText, szMsgTitle, MB_YESNO | MB_ICONQUESTION) == IDYES) { wcsncat(szFullName, Info->szKeyName, MAX_PATH - wcslen(szFullName)); if (RegDeleteKeyW(Info->hRootKey, szFullName) == ERROR_SUCCESS) { (VOID) ListView_DeleteItem(hListView, ItemIndex); return; } if (!LoadStringW(hInst, IDS_UNABLE_TO_REMOVE, szMsgText, sizeof(szMsgText) / sizeof(WCHAR))) return; MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR); } }
KSDDKAPI HRESULT WINAPI DllUnregisterServer(void) { ULONG Index = 0; LPOLESTR pStr; HRESULT hr = S_OK; HKEY hClass; if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_SET_VALUE, &hClass) != ERROR_SUCCESS) return E_FAIL; do { hr = StringFromCLSID(*InterfaceTable[Index].riid, &pStr); if (FAILED(hr)) break; RegDeleteKeyW(hClass, pStr); CoTaskMemFree(pStr); Index++; }while(InterfaceTable[Index].lpfnCI != 0); RegCloseKey(hClass); return hr; }
/*********************************************************************** * 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; }
/********************************************************************** * COMCAT_ICatRegister_UnRegisterCategories */ static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterCategories( LPCATREGISTER iface, ULONG cCategories, CATID *rgcatid) { HKEY comcat_key; HRESULT res; TRACE("\n"); if (cCategories && rgcatid == NULL) return E_POINTER; /* Open the component categories key. */ res = open_classes_key(HKEY_CLASSES_ROOT, comcat_keyname, KEY_READ|KEY_WRITE, &comcat_key); if (res != ERROR_SUCCESS) return E_FAIL; for (; cCategories; --cCategories, ++rgcatid) { WCHAR keyname[CHARS_IN_GUID]; /* Delete the key for this category. */ if (!StringFromGUID2(rgcatid, keyname, CHARS_IN_GUID)) continue; RegDeleteKeyW(comcat_key, keyname); } RegCloseKey(comcat_key); return S_OK; }
/********************************************************************** * COMCAT_UnRegisterClassCategories */ static HRESULT COMCAT_UnRegisterClassCategories( REFCLSID rclsid, LPCWSTR type, ULONG cCategories, const CATID *rgcatid) { WCHAR keyname[68] = { 'C', 'L', 'S', 'I', 'D', '\\' }; HRESULT res; HKEY type_key; if (cCategories && rgcatid == NULL) return E_POINTER; /* Format the class category type key name. */ res = StringFromGUID2(rclsid, keyname + 6, 39); if (FAILED(res)) return res; keyname[44] = '\\'; lstrcpyW(keyname + 45, type); /* Open the class category type key. */ res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ | KEY_WRITE, &type_key); if (res != ERROR_SUCCESS) return E_FAIL; for (; cCategories; --cCategories, ++rgcatid) { /* Format the category key name. */ res = StringFromGUID2(rgcatid, keyname, 39); if (FAILED(res)) continue; /* Do the unregister. */ RegDeleteKeyW(type_key, keyname); } RegCloseKey(type_key); return S_OK; }
/********************************************************************** * COMCAT_ICatRegister_UnRegisterCategories */ static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterCategories( LPCATREGISTER iface, ULONG cCategories, CATID *rgcatid) { /* ICOM_THIS_MULTI(ComCatMgrImpl, regVtbl, iface); */ HKEY comcat_key; HRESULT res; TRACE("\n"); if (iface == NULL || (cCategories && rgcatid == NULL)) return E_POINTER; /* Open the component categories key. */ res = RegOpenKeyExW(HKEY_CLASSES_ROOT, comcat_keyname, 0, KEY_READ | KEY_WRITE, &comcat_key); if (res != ERROR_SUCCESS) return E_FAIL; for (; cCategories; --cCategories, ++rgcatid) { WCHAR keyname[39]; /* Delete the key for this category. */ if (!StringFromGUID2(rgcatid, keyname, 39)) continue; RegDeleteKeyW(comcat_key, keyname); } RegCloseKey(comcat_key); return S_OK; }
void WinRegistryKey::deleteKey() { Keys keys; subKeys(keys); close(); for (Keys::iterator it = keys.begin(); it != keys.end(); ++it) { std::string subKey(_subKey); subKey += "\\"; subKey += *it; WinRegistryKey subRegKey(_hRootKey, subKey); subRegKey.deleteKey(); } // NOTE: RegDeleteKeyEx is only available on Windows XP 64-bit SP3, Windows Vista or later. // We cannot call it directly as this would prevent the code running on Windows XP 32-bit. // Therefore, if we need to call RegDeleteKeyEx (_extraSam != 0) we need to check for // its existence in ADVAPI32.DLL and call it indirectly. #if defined(POCO_WIN32_UTF8) std::wstring usubKey; Poco::UnicodeConverter::toUTF16(_subKey, usubKey); typedef LONG (WINAPI *RegDeleteKeyExWFunc)(HKEY hKey, const wchar_t* lpSubKey, REGSAM samDesired, DWORD Reserved); if (_extraSam != 0) { AutoHandle advAPI32(LoadLibraryW(L"ADVAPI32.DLL")); if (advAPI32.handle()) { RegDeleteKeyExWFunc pRegDeleteKeyExW = reinterpret_cast<RegDeleteKeyExWFunc>(GetProcAddress(advAPI32.handle() , "RegDeleteKeyExW")); if (pRegDeleteKeyExW) { if ((*pRegDeleteKeyExW)(_hRootKey, usubKey.c_str(), _extraSam, 0) != ERROR_SUCCESS) throw NotFoundException(key()); return; } } } if (RegDeleteKeyW(_hRootKey, usubKey.c_str()) != ERROR_SUCCESS) throw NotFoundException(key()); #else typedef LONG (WINAPI *RegDeleteKeyExAFunc)(HKEY hKey, const char* lpSubKey, REGSAM samDesired, DWORD Reserved); if (_extraSam != 0) { AutoHandle advAPI32(LoadLibraryA("ADVAPI32.DLL")); if (advAPI32.handle()) { RegDeleteKeyExAFunc pRegDeleteKeyExA = reinterpret_cast<RegDeleteKeyExAFunc>(GetProcAddress(advAPI32.handle() , "RegDeleteKeyExA")); if (pRegDeleteKeyExA) { if ((*pRegDeleteKeyExA)(_hRootKey, _subKey.c_str(), _extraSam, 0) != ERROR_SUCCESS) throw NotFoundException(key()); return; } } } if (RegDeleteKey(_hRootKey, _subKey.c_str()) != ERROR_SUCCESS) throw NotFoundException(key()); #endif }
BOOL My_RegDeleteKeyW() { HKEY hKey=NULL; LPCWSTR lpSubKey=NULL; LONG returnVal_Real = NULL; LONG returnVal_Intercepted = NULL; DWORD error_Real = 0; DWORD error_Intercepted = 0; disableInterception(); returnVal_Real = RegDeleteKeyW (hKey,lpSubKey); error_Real = GetLastError(); enableInterception(); returnVal_Intercepted = RegDeleteKeyW (hKey,lpSubKey); error_Intercepted = GetLastError(); return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted)); }
bool Key::delete_sub_key_nt(const wchar_t* name) { LONG res = RegDeleteKeyW(h_key, name); if (res != ERROR_SUCCESS) { SetLastError(res); return false; } return true; }
void Key::remove() const { LONG lRtn = RegDeleteKeyW( m_hRootKey, m_wsPath.c_str() ); if (lRtn != ERROR_SUCCESS) { BP_THROW( "RegDeleteKeyW(" + wideToUtf8(m_wsPath) + ") returned: " + bp::conv::toString( lRtn ) ); } }
NS_IMETHODIMP nsWindowsRegKey::RemoveChild(const nsAString &name) { NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED); LONG rv = RegDeleteKeyW(mKey, PromiseFlatString(name).get()); return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE; }
//--------------------------------------------------------------------------- HRESULT DeleteRegistryKey(HKEY RootKey,const wchar_t * KeyName) { HKEY hkey; HRESULT hr; if( (hr = RegOpenKeyExW(RootKey,KeyName,0,KEY_ENUMERATE_SUB_KEYS | KEY_READ | KEY_WRITE,&hkey)) == ERROR_SUCCESS ){ DWORD SubKeyNameLen, SubKeyNameLen2; wchar_t * SubKeyName, * SubKeyName2; for(;;){ LONG a; SubKeyName = (wchar_t *) malloc(sizeof(wchar_t)); SubKeyName[0] = L'\0'; SubKeyNameLen = 1; for(;;){ SubKeyNameLen2 = SubKeyNameLen; a = RegEnumKeyExW(hkey,0,SubKeyName,&SubKeyNameLen2,NULL,NULL,NULL,NULL); if( a != ERROR_MORE_DATA ) break; SubKeyName2 = (wchar_t *) realloc(SubKeyName,sizeof(wchar_t) * (SubKeyNameLen << 1)); if( SubKeyName2 == NULL ) break; SubKeyName = SubKeyName2; SubKeyNameLen <<= 1; } if( a != ERROR_SUCCESS || a == ERROR_NO_MORE_ITEMS ){ free(SubKeyName); break; } hr = RegDeleteKeyW(hkey,SubKeyName); if( FAILED(hr) ){ SubKeyName2 = (wchar_t *) malloc((wcslen(KeyName) + 1 + wcslen(SubKeyName) + 1) * sizeof(wchar_t)); if( SubKeyName2 != NULL ){ wcscpy_s(SubKeyName2,~rsize_t(0),KeyName); wcscat_s(SubKeyName2,~rsize_t(0),L"\\"); wcscat_s(SubKeyName2,~rsize_t(0),SubKeyName); hr = DeleteRegistryKey(RootKey,SubKeyName2); free(SubKeyName2); } } free(SubKeyName); if( FAILED(hr) ) break; } RegCloseKey(hkey); if( SUCCEEDED(hr) ) hr = RegDeleteKeyW(RootKey,KeyName); } return hr; }
static LONG MyRegistry_DeleteKey_32(HKEY parentKey, LPCWSTR name) { #if k_Reg_WOW_Flag_32 != 0 if (func_RegDeleteKeyExW) return func_RegDeleteKeyExW(parentKey, name, k_Reg_WOW_Flag_32, 0); return E_FAIL; #else return RegDeleteKeyW(parentKey, name); #endif }
static HRESULT unregister_namespace_extensions(struct regsvr_namespace const *list) { WCHAR *pwszKey; for (; list->clsid; list++) { pwszKey = get_namespace_key(list); RegDeleteKeyW(HKEY_LOCAL_MACHINE, pwszKey); HeapFree(GetProcessHeap(), 0, pwszKey); } return S_OK; }
NS_IMETHODIMP nsWindowsRegKey::RemoveChild(const nsAString& aName) { if (NS_WARN_IF(!mKey)) { return NS_ERROR_NOT_INITIALIZED; } LONG rv = RegDeleteKeyW(mKey, PromiseFlatString(aName).get()); return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE; }
LONG Win32U_RegDeleteKey(HKEY keyName, // IN: LPCSTR subKey) // IN: { LONG ret; utf16_t *subKeyW = Unicode_GetAllocUTF16(subKey); ret = RegDeleteKeyW(keyName, subKeyW); free(subKeyW); return ret; }
/***************************************************************************** * UnregisterInprocServer() ***************************************************************************** */ HRESULT UnregisterInprocServer ( IN REFGUID ClassId ) { WCHAR ClsIdStr[MAX_PATH]; StringFromGUID2(ClassId, ClsIdStr, MAX_PATH); WCHAR KeyName[MAX_PATH]; wcscpy(KeyName, L"CLSID\\"); wcscat(KeyName, ClsIdStr); wcscat(KeyName, L"\\InprocServer32"); RegDeleteKeyW(HKEY_CLASSES_ROOT, KeyName); wcscpy(KeyName, L"CLSID\\"); wcscat(KeyName, ClsIdStr); RegDeleteKeyW(HKEY_CLASSES_ROOT, KeyName); return S_OK; }
/*********************************************************************** * WINTRUST_RemoveProviderFromReg * * Helper function for WintrustRemoveActionID * */ static void WINTRUST_RemoveProviderFromReg(WCHAR* GuidString, const WCHAR* FunctionType) { WCHAR ProvKey[MAX_PATH]; /* Create the needed key string */ ProvKey[0]='\0'; lstrcatW(ProvKey, Trust); lstrcatW(ProvKey, FunctionType); lstrcatW(ProvKey, GuidString); /* We don't care about success or failure */ RegDeleteKeyW(HKEY_LOCAL_MACHINE, ProvKey); }
static HRESULT unregister_dmo_from_category(const WCHAR *dmoW, const WCHAR *catW, HKEY categories) { HKEY catkey; LONG ret; ret = RegOpenKeyExW(categories, catW, 0, KEY_WRITE, &catkey); if (!ret) { ret = RegDeleteKeyW(catkey, dmoW); RegCloseKey(catkey); } return !ret ? S_OK : S_FALSE; }
static HRESULT UnregisterComponent(REFGUID clsid) { WCHAR szClsid[MAX_PATH]; WCHAR szRoot[MAX_PATH]; HKEY hkRoot; if (!StringFromGUID2(clsid, szClsid, _countof(szClsid))) return E_FAIL; HRESULT hr = StringCchPrintfW(szRoot, 0x104u, L"CLSID\\%s", szClsid); if (FAILED(hr)) return hr; if (RegOpenKeyExW(HKEY_CLASSES_ROOT, szRoot, 0, KEY_WRITE, &hkRoot) != 0) return E_FAIL; RegDeleteKeyW(hkRoot, L"InprocServer32"); RegCloseKey(hkRoot); RegDeleteKeyW(HKEY_CLASSES_ROOT, szRoot); return S_OK; }