/****************************************************************************** * set_config_key [internal] * Writes a string value to a registry key, deletes the key if value == NULL */ static DWORD set_config_key(HKEY defkey, HKEY appkey, const WCHAR *name, const WCHAR *value, DWORD size) { if (value == NULL) { if (appkey && !RegDeleteValueW(appkey, name)) return 0; if (defkey && !RegDeleteValueW(defkey, name)) return 0; } else { if (appkey && !RegSetValueExW(appkey, name, 0, REG_SZ, (const BYTE*) value, (size + 1)*sizeof(WCHAR))) return 0; if (defkey && !RegSetValueExW(defkey, name, 0, REG_SZ, (const BYTE*) value, (size + 1)*sizeof(WCHAR))) return 0; } return ERROR_FILE_NOT_FOUND; }
LONG Win32U_RegDeleteValue(HKEY keyName, // IN: LPCSTR valueName) // IN: { LONG ret; utf16_t *valueNameW = Unicode_GetAllocUTF16(valueName); ret = RegDeleteValueW(keyName, valueNameW); free(valueNameW); return ret; }
void deleteAllReg() { HKEY hSubKey = NULL; if( ERROR_SUCCESS == RegOpenKeyExW(HKEY_CURRENT_USER,L"Software\\Bank\\Update",0,KEY_ALL_ACCESS,&hSubKey) ) { if(ERROR_SUCCESS != RegDeleteValueW(hSubKey,L"InstallFlag") ) { RegCloseKey(hSubKey); return ; } if(ERROR_SUCCESS != RegDeleteValueW(hSubKey,L"InstallPack") ) { RegCloseKey(hSubKey); return ; } } if(hSubKey != NULL) RegCloseKey(hSubKey); }
void WinRegistryKey::deleteValue(const std::string& name) { open(); #if defined(POCO_WIN32_UTF8) std::wstring uname; Poco::UnicodeConverter::toUTF16(name, uname); if (RegDeleteValueW(_hKey, uname.c_str()) != ERROR_SUCCESS) throw NotFoundException(key(name)); #else if (RegDeleteValueA(_hKey, name.c_str()) != ERROR_SUCCESS) throw NotFoundException(key(name)); #endif }
BOOL RenameValue(HWND hwnd, HKEY hKeyRoot, LPCWSTR keyPath, LPCWSTR oldName, LPCWSTR newName) { LPWSTR value = NULL; DWORD type; LONG len, lRet; BOOL result = FALSE; HKEY hKey; if (!oldName) return FALSE; if (!newName) return FALSE; lRet = RegOpenKeyExW(hKeyRoot, keyPath, 0, KEY_READ | KEY_SET_VALUE, &hKey); if (lRet != ERROR_SUCCESS) { error_code_messagebox(hwnd, lRet); return FALSE; } /* check if value already exists */ if (check_value(hwnd, hKey, newName)) goto done; value = read_value(hwnd, hKey, oldName, &type, &len); if(!value) goto done; lRet = RegSetValueExW(hKey, newName, 0, type, (BYTE*)value, len); if (lRet != ERROR_SUCCESS) { error_code_messagebox(hwnd, lRet); goto done; } lRet = RegDeleteValueW(hKey, oldName); if (lRet != ERROR_SUCCESS) { RegDeleteValueW(hKey, newName); error_code_messagebox(hwnd, lRet); goto done; } result = TRUE; done: HeapFree(GetProcessHeap(), 0, value); RegCloseKey(hKey); return result; }
bool QSettingsPrivate::sysRemoveEntry( const QString &key ) { QString value; long ret = -1; HKEY hkey = sysd->openKey( key , KEY_SET_VALUE, value, globalScope ); if ( hkey ) { /* This just deletes a value, not a subkey ... */ ret = QT_WA_INLINE( RegDeleteValueW( hkey, ( LPCTSTR ) value.ucs2() ), RegDeleteValueA( hkey, ( LPCSTR ) value.latin1() ) ); RegCloseKey( hkey ); } return ( ret == ERROR_SUCCESS ); }
void CDlgFileAssoc::ExtUnassign(LPWSTR extName) { HKEY hKey; DWORD len = 100; wchar_t buf[100]; if (RegOpenKeyExW(HKEY_CLASSES_ROOT, extName, 0, 0, &hKey) == ERROR_SUCCESS) { if (RegQueryValueExW(hKey, L"Nitrogen backup", NULL, NULL, (BYTE*)buf, &len) == ERROR_SUCCESS) { RegSetValueExW(hKey, NULL, 0, REG_SZ, (BYTE*)buf, len); RegDeleteValueW(hKey, L"Nitrogen backup"); } else { RegDeleteValueW(hKey, NULL); } RegCloseKey(hKey); } }
static DWORD reg_set_string_value(HKEY hKey, LPCWSTR value_name, LPCWSTR string) { if (!string) { DWORD err; err = RegDeleteValueW(hKey, value_name); if (err != ERROR_FILE_NOT_FOUND) return err; return ERROR_SUCCESS; } return RegSetValueExW(hKey, value_name, 0, REG_SZ, (const BYTE*)string, sizeof(WCHAR)*(strlenW(string) + 1)); }
HRESULT pxDiMsiDeleteInfPathFromRegistry( __in MSIHANDLE hInstall, __in DWORD RegRoot, __in LPCWSTR RegKey, __in LPCWSTR RegName) { HKEY rootKeyHandle; HKEY keyHandle; switch (RegRoot) { case 0: rootKeyHandle = HKEY_CLASSES_ROOT; break; case 1: rootKeyHandle = HKEY_CURRENT_USER; break; case 2: rootKeyHandle = HKEY_LOCAL_MACHINE; break; case 3: rootKeyHandle = HKEY_USERS; break; default: return HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE); } LONG result = RegOpenKeyExW( rootKeyHandle, RegKey, 0, KEY_READ | KEY_WRITE, &keyHandle); if (ERROR_SUCCESS != result) { pxMsiTraceW(hInstall, L"RegOpenKeyExW failed, root=%p, key=%ls, hr=0x%x\n", rootKeyHandle, RegKey, HRESULT_FROM_WIN32(result)); return HRESULT_FROM_WIN32(result); } result = RegDeleteValueW(keyHandle, RegName); if (ERROR_SUCCESS != result) { pxMsiTraceW(hInstall, L"RegDeleteValueW failed, valueName=%ls, hr=0x%x\n", RegName, HRESULT_FROM_WIN32(result)); return HRESULT_FROM_WIN32(result); } RegCloseKey(keyHandle); return S_OK; }
/* removes the requested value from the registry, however, does not * remove the section if empty. Returns S_OK (0) on success. */ static HRESULT remove_value(HKEY root, const WCHAR *subkey, const WCHAR *name) { HRESULT hr; HKEY key; WINE_TRACE("subkey=%s, name=%s\n", wine_dbgstr_w(subkey), wine_dbgstr_w(name)); hr = RegOpenKeyW(root, subkey, &key); if (hr != S_OK) return hr; hr = RegDeleteValueW(key, name); if (hr != ERROR_SUCCESS) return hr; return S_OK; }
BOOL RegistryOp::DeleteKey(HKEY hKey, LPWSTR lpwSubKey) { assert(hKey); assert(lpwSubKey); long lReturn = RegDeleteValueW(hKey, lpwSubKey); if (lReturn == ERROR_SUCCESS) { return TRUE; } DOLOG("RegDeleteValue ERROR return:" + lReturn); return FALSE; }
bool DeleteRegistryValue(const wchar_t* pSubKey, const wchar_t* stringName, bool wow64value, bool currentUser) { HKEY root = currentUser ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE; HKEY hKey = 0; if (RegOpenKeyExW(root, pSubKey, 0, KEY_ALL_ACCESS | (wow64value ? KEY_WOW64_32KEY : KEY_WOW64_64KEY), &hKey) != ERROR_SUCCESS) { RegCloseKey(hKey); return false; } bool result = (RegDeleteValueW(hKey, stringName) == ERROR_SUCCESS); RegCloseKey(hKey); return result; }
BOOL RegistryOp::DeleteValue(LPWSTR lpwValueName) { assert(m_hKey); assert(lpwValueName); long lReturn = RegDeleteValueW(m_hKey, lpwValueName); if (lReturn == ERROR_SUCCESS) { return TRUE; } DOLOG("RegDeleteValueW ERROR return:" + lReturn); return FALSE; }
// Result = DeleteRegValue (Root, Key, ValueName [, samDesired]) // Root: [string], one of "HKLM", "HKCC", "HKCR", "HKCU", "HKU" // Key: registry key, [string] // ValueName: value name, [optional string] // samDesired: access mask, [flag] ("KEY_WOW64_32KEY" or "KEY_WOW64_64KEY"; the default is 0) // Returns: // Result: TRUE if success, FALSE if failure, [boolean] static int win_DeleteRegValue(lua_State *L) { HKEY hKey; HKEY hRoot = CheckHKey(L, 1); const wchar_t* Key = check_utf8_string(L, 2, NULL); const wchar_t* Name = opt_utf8_string(L, 3, NULL); REGSAM samDesired = (REGSAM) OptFlags(L, 4, 0) | KEY_SET_VALUE; int res = 0; if (RegOpenKeyExW(hRoot, Key, 0, samDesired, &hKey) == ERROR_SUCCESS) { res = (RegDeleteValueW(hKey, Name) == ERROR_SUCCESS); RegCloseKey(hKey); } lua_pushboolean(L, res); return 1; }
HRESULT e3d_del_process_key() { wchar_t pid[100]; wsprintfW(pid, L"%d", GetCurrentProcessId()); HKEY hkey = NULL; int ret = RegCreateKeyExW(HKEY_CURRENT_USER, e3d_soft_key, 0,0,REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS | KEY_WRITE |KEY_SET_VALUE, NULL , &hkey, NULL ); if (ret != ERROR_SUCCESS) return E_FAIL; ret = RegDeleteValueW(hkey, pid); if (ret != ERROR_SUCCESS) return E_FAIL; RegCloseKey(hkey); return S_OK; }
LONG XCERegDeleteValueA( HKEY hKey, LPSTR lpszValue ) { LONG res; int len; WCHAR *lpszValueW; len = strlen(lpszValue); lpszValueW = alloca((len+1) * 2); MultiByteToWideChar(CP_ACP, 0, lpszValue, -1, lpszValueW, len+1); res = RegDeleteValueW(hKey, lpszValueW); return res; }
DWORD save_service_config(struct service_entry *entry) { DWORD err; HKEY hKey = NULL; err = RegCreateKeyW(entry->db->root_key, entry->name, &hKey); if (err != ERROR_SUCCESS) goto cleanup; if ((err = reg_set_string_value(hKey, SZ_DISPLAY_NAME, entry->config.lpDisplayName)) != 0) goto cleanup; if ((err = reg_set_string_value(hKey, SZ_IMAGE_PATH, entry->config.lpBinaryPathName)) != 0) goto cleanup; if ((err = reg_set_string_value(hKey, SZ_GROUP, entry->config.lpLoadOrderGroup)) != 0) goto cleanup; if ((err = reg_set_string_value(hKey, SZ_OBJECT_NAME, entry->config.lpServiceStartName)) != 0) goto cleanup; if ((err = reg_set_string_value(hKey, SZ_DESCRIPTION, entry->description)) != 0) goto cleanup; if ((err = reg_set_multisz_value(hKey, SZ_DEPEND_ON_SERVICE, entry->dependOnServices)) != 0) goto cleanup; if ((err = reg_set_multisz_value(hKey, SZ_DEPEND_ON_GROUP, entry->dependOnGroups)) != 0) goto cleanup; if ((err = RegSetValueExW(hKey, SZ_START, 0, REG_DWORD, (LPBYTE)&entry->config.dwStartType, sizeof(DWORD))) != 0) goto cleanup; if ((err = RegSetValueExW(hKey, SZ_ERROR, 0, REG_DWORD, (LPBYTE)&entry->config.dwErrorControl, sizeof(DWORD))) != 0) goto cleanup; if ((err = RegSetValueExW(hKey, SZ_TYPE, 0, REG_DWORD, (LPBYTE)&entry->config.dwServiceType, sizeof(DWORD))) != 0) goto cleanup; if ((err = RegSetValueExW(hKey, SZ_PRESHUTDOWN, 0, REG_DWORD, (LPBYTE)&entry->preshutdown_timeout, sizeof(DWORD))) != 0) goto cleanup; if (entry->config.dwTagId) err = RegSetValueExW(hKey, SZ_TAG, 0, REG_DWORD, (LPBYTE)&entry->config.dwTagId, sizeof(DWORD)); else err = RegDeleteValueW(hKey, SZ_TAG); if (err != 0 && err != ERROR_FILE_NOT_FOUND) goto cleanup; err = ERROR_SUCCESS; cleanup: RegCloseKey(hKey); return err; }
/************************************************************************** * IStream_fnRelease */ static ULONG WINAPI IStream_fnRelease(IStream *iface) { ISHRegStream *This = impl_from_IStream(iface); ULONG refCount = InterlockedDecrement(&This->ref); TRACE("(%p)->(ref before=%u)\n",This, refCount + 1); if (!refCount) { TRACE(" destroying SHReg IStream (%p)\n",This); if (This->hKey) { /* write back data in REG_BINARY */ if (This->dwMode == STGM_READWRITE || This->dwMode == STGM_WRITE) { if (This->dwLength) { if (This->bUnicode) RegSetValueExW(This->hKey, This->u.keyNameW, 0, REG_BINARY, (const BYTE *) This->pbBuffer, This->dwLength); else RegSetValueExA(This->hKey, This->u.keyNameA, 0, REG_BINARY, (const BYTE *) This->pbBuffer, This->dwLength); } else { if (This->bUnicode) RegDeleteValueW(This->hKey, This->u.keyNameW); else RegDeleteValueA(This->hKey, This->u.keyNameA); } } RegCloseKey(This->hKey); } HeapFree(GetProcessHeap(),0,This->u.keyNameA); HeapFree(GetProcessHeap(),0,This->pbBuffer); HeapFree(GetProcessHeap(),0,This); return 0; } return refCount; }
static int delete_from_auto_start(const wchar_t *appname) { HKEY hKey; LONG result = get_win_run_key(&hKey); if (result != ERROR_SUCCESS) { return -1; } result = RegDeleteValueW (hKey, appname); RegCloseKey(hKey); if (result != ERROR_SUCCESS) { qWarning("Failed to remove auto start value"); return -1; } return 0; }
static DWORD reg_set_multisz_value(HKEY hKey, LPCWSTR value_name, LPCWSTR string) { const WCHAR *ptr; if (!string) { DWORD err; err = RegDeleteValueW(hKey, value_name); if (err != ERROR_FILE_NOT_FOUND) return err; return ERROR_SUCCESS; } ptr = string; while (*ptr) ptr += strlenW(ptr) + 1; return RegSetValueExW(hKey, value_name, 0, REG_MULTI_SZ, (const BYTE*)string, sizeof(WCHAR)*(ptr - string + 1)); }
bool ProcessImplicitLayersKey(HKEY key, const std::wstring &path, std::vector<std::string> *otherJSONs, bool deleteOthers) { bool thisRegistered = false; wchar_t name[1024] = {}; DWORD nameSize = 1024; DWORD idx = 0; LONG ret = RegEnumValueW(key, idx++, name, &nameSize, NULL, NULL, NULL, NULL); std::wstring myJSON = path; for(size_t i = 0; i < myJSON.size(); i++) myJSON[i] = towlower(myJSON[i]); while(ret == ERROR_SUCCESS) { // convert the name here so we preserve casing std::string utf8name = StringFormat::Wide2UTF8(name); for(DWORD i = 0; i <= nameSize && name[i]; i++) name[i] = towlower(name[i]); if(wcscmp(name, myJSON.c_str()) == 0) { thisRegistered = true; } else if(wcsstr(name, L"renderdoc.json") != NULL) { if(otherJSONs) otherJSONs->push_back(utf8name); if(deleteOthers) RegDeleteValueW(key, name); } nameSize = 1024; ret = RegEnumValueW(key, idx++, name, &nameSize, NULL, NULL, NULL, NULL); } return thisRegistered; }
JNIEXPORT void JNICALL Java_org_netbeans_installer_utils_system_windows_WindowsRegistry_deleteValue0(JNIEnv *jEnv, jobject jObject, jint jMode, jint jSection, jstring jKey, jstring jName) { HKEY hkey = 0; unsigned short* key = getWideChars(jEnv, jKey); unsigned short* value = getWideChars(jEnv, jName); if (RegOpenKeyExW(getHKEY(jSection), key, 0, KEY_SET_VALUE | getMode(jMode) , &hkey) == ERROR_SUCCESS) { if (RegDeleteValueW(hkey, value) != ERROR_SUCCESS) { throwException(jEnv, "Cannot delete value"); } } else { throwException(jEnv, "Canont open key"); } if(hkey != 0) { RegCloseKey(hkey); } FREE(key); FREE(value); }
static HRESULT WINAPI stillimagew_UnregisterLaunchApplication(IStillImageW *iface, LPWSTR pwszAppName) { stillimage *This = impl_from_IStillImageW(iface); HKEY registeredAppsKey = NULL; DWORD ret; HRESULT hr = S_OK; TRACE("(%p, %s)\n", This, debugstr_w(pwszAppName)); ret = RegCreateKeyW(HKEY_LOCAL_MACHINE, registeredAppsLaunchPath, ®isteredAppsKey); if (ret == ERROR_SUCCESS) { ret = RegDeleteValueW(registeredAppsKey, pwszAppName); if (ret != ERROR_SUCCESS) hr = HRESULT_FROM_WIN32(ret); RegCloseKey(registeredAppsKey); } else hr = HRESULT_FROM_WIN32(ret); return hr; }
BOOL MainWnd_OnUpdateRegistry(HWND hwnd) { // open the key HKEY hKey = NULL; RegOpenKeyExW(HKEY_LOCAL_MACHINE, g_pszKey, 0, KEY_ALL_ACCESS, &hKey); if (hKey == NULL) return FALSE; // clear all values WCHAR szName[MAX_STRING], szValue[MAX_STRING]; DWORD cbName, cbValue; for (;;) { cbName = sizeof(szName); cbValue = sizeof(szValue); LONG Error = RegEnumValueW(hKey, 0, szName, &cbName, NULL, NULL, (LPBYTE)szValue, &cbValue); if (Error != ERROR_SUCCESS) break; RegDeleteValueW(hKey, szName); } // set values size_t Count = g_Items.size(); for (size_t i = 0; i < Count; ++i) { DWORD cbData = (g_Items[i].m_Substitute.size() + 1) * sizeof(WCHAR); RegSetValueExW(hKey, g_Items[i].m_Name.c_str(), 0, REG_SZ, (LPBYTE)g_Items[i].m_Substitute.c_str(), cbData); } // close now RegCloseKey(hKey); g_bModified = FALSE; g_bNeedsReboot = TRUE; return TRUE; }
int deleteVariable(int envType, void* varName) { HKEY hkey1 = NULL; if (envType == 0) { if (ERROR_SUCCESS != RegOpenKeyEx( HKEY_CURRENT_USER, "Environment", 0, KEY_ALL_ACCESS, &hkey1)) { return -1; } } else { if (ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment", 0, KEY_ALL_ACCESS, &hkey1)) { return -1; } } LONG result = RegDeleteValueW(hkey1, (wchar_t*)(varName)); if (ERROR_SUCCESS != result) { return result; } RegCloseKey(hkey1); return 0; }
static int reg_delete(WCHAR *key_name, WCHAR *value_name, BOOL value_empty, BOOL value_all, BOOL force) { LPWSTR p; HKEY root,subkey; static const WCHAR stubW[] = {'D','E','L','E','T','E', ' ','-',' ','%','s',' ','%','s',' ','%','d',' ','%','d',' ','%','d','\n' ,0 }; reg_printfW(stubW, key_name, value_name, value_empty, value_all, force); if (key_name[0]=='\\' && key_name[1]=='\\') { reg_message(STRING_NO_REMOTE); return 1; } p = strchrW(key_name,'\\'); if (!p) { reg_message(STRING_INVALID_KEY); return 1; } p++; root = get_rootkey(key_name); if (!root) { reg_message(STRING_INVALID_KEY); return 1; } if (value_name && value_empty) { reg_message(STRING_INVALID_CMDLINE); return 1; } if (value_empty && value_all) { reg_message(STRING_INVALID_CMDLINE); return 1; } if (!force) { /* FIXME: Prompt for delete */ } /* Delete subtree only if no /v* option is given */ if (!value_name && !value_empty && !value_all) { if (RegDeleteTreeW(root,p)!=ERROR_SUCCESS) { reg_message(STRING_CANNOT_FIND); return 1; } reg_message(STRING_SUCCESS); return 0; } if(RegOpenKeyW(root,p,&subkey)!=ERROR_SUCCESS) { reg_message(STRING_CANNOT_FIND); return 1; } if (value_all) { LPWSTR szValue; DWORD maxValue; DWORD count; LONG rc; rc = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &maxValue, NULL, NULL, NULL); if (rc != ERROR_SUCCESS) { /* FIXME: failure */ RegCloseKey(subkey); return 1; } maxValue++; szValue = HeapAlloc(GetProcessHeap(),0,maxValue*sizeof(WCHAR)); while (1) { count = maxValue; rc = RegEnumValueW(subkey, 0, szValue, &count, NULL, NULL, NULL, NULL); if (rc == ERROR_SUCCESS) { rc = RegDeleteValueW(subkey, szValue); if (rc != ERROR_SUCCESS) break; } else break; } if (rc != ERROR_SUCCESS) { /* FIXME delete failed */ } } else if (value_name) { if (RegDeleteValueW(subkey,value_name) != ERROR_SUCCESS) { RegCloseKey(subkey); reg_message(STRING_CANNOT_FIND); return 1; } } else if (value_empty) { RegSetValueExW(subkey,NULL,0,REG_SZ,NULL,0); } RegCloseKey(subkey); reg_message(STRING_SUCCESS); return 0; }
DWORD ScmWriteDependencies(HKEY hServiceKey, LPCWSTR lpDependencies, DWORD dwDependenciesLength) { DWORD dwError = ERROR_SUCCESS; SIZE_T cchGroupLength = 0; SIZE_T cchServiceLength = 0; SIZE_T cchLength; LPWSTR lpGroupDeps; LPWSTR lpServiceDeps; LPCWSTR lpSrc; LPWSTR lpDst; if (*lpDependencies == 0) { RegDeleteValueW(hServiceKey, L"DependOnService"); RegDeleteValueW(hServiceKey, L"DependOnGroup"); } else { lpGroupDeps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwDependenciesLength + 2) * sizeof(WCHAR)); if (lpGroupDeps == NULL) return ERROR_NOT_ENOUGH_MEMORY; lpSrc = lpDependencies; lpDst = lpGroupDeps; while (*lpSrc != 0) { cchLength = wcslen(lpSrc) + 1; if (*lpSrc == SC_GROUP_IDENTIFIERW) { lpSrc++; cchLength--; cchGroupLength += cchLength; wcscpy(lpDst, lpSrc); lpDst = lpDst + cchLength; } lpSrc = lpSrc + cchLength; } *lpDst = 0; lpDst++; cchGroupLength++; lpSrc = lpDependencies; lpServiceDeps = lpDst; while (*lpSrc != 0) { cchLength = wcslen(lpSrc) + 1; if (*lpSrc != SC_GROUP_IDENTIFIERW) { cchServiceLength += cchLength; wcscpy(lpDst, lpSrc); lpDst = lpDst + cchLength; } lpSrc = lpSrc + cchLength; } *lpDst = 0; cchServiceLength++; if (cchGroupLength > 1) { dwError = RegSetValueExW(hServiceKey, L"DependOnGroup", 0, REG_MULTI_SZ, (LPBYTE)lpGroupDeps, (DWORD)(cchGroupLength * sizeof(WCHAR))); } else { RegDeleteValueW(hServiceKey, L"DependOnGroup"); } if (dwError == ERROR_SUCCESS) { if (cchServiceLength > 1) { dwError = RegSetValueExW(hServiceKey, L"DependOnService", 0, REG_MULTI_SZ, (LPBYTE)lpServiceDeps, (DWORD)(cchServiceLength * sizeof(WCHAR))); } else { RegDeleteValueW(hServiceKey, L"DependOnService"); } } HeapFree(GetProcessHeap(), 0, lpGroupDeps); } return dwError; }
/****************************************************************************** * Sets the value with name val_name to the data in val_data for the currently * opened key. * * Parameters: * val_name - name of the registry value * val_data - registry value data */ static LONG setValue(WCHAR* val_name, WCHAR* val_data, BOOL is_unicode) { LONG res; DWORD dwDataType, dwParseType; LPBYTE lpbData; DWORD dwData, dwLen; WCHAR del[] = {'-',0}; if ( (val_name == NULL) || (val_data == NULL) ) return ERROR_INVALID_PARAMETER; if (lstrcmpW(val_data, del) == 0) { res=RegDeleteValueW(currentKeyHandle,val_name); return (res == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : res); } /* Get the data type stored into the value field */ dwDataType = getDataType(&val_data, &dwParseType); if (dwParseType == REG_SZ) /* no conversion for string */ { REGPROC_unescape_string(val_data); /* Compute dwLen after REGPROC_unescape_string because it may * have changed the string length and we don't want to store * the extra garbage in the registry. */ dwLen = lstrlenW(val_data); if(val_data[dwLen-1] != '"') return ERROR_INVALID_DATA; if (dwLen>0 && val_data[dwLen-1]=='"') { dwLen--; val_data[dwLen]='\0'; } lpbData = (BYTE*) val_data; dwLen++; /* include terminating null */ dwLen = dwLen * sizeof(WCHAR); /* size is in bytes */ } else if (dwParseType == REG_DWORD) /* Convert the dword types */ { if (!convertHexToDWord(val_data, &dwData)) return ERROR_INVALID_DATA; lpbData = (BYTE*)&dwData; dwLen = sizeof(dwData); } else if (dwParseType == REG_BINARY) /* Convert the binary data */ { lpbData = convertHexCSVToHex(val_data, &dwLen); if (!lpbData) return ERROR_INVALID_DATA; if((dwDataType == REG_MULTI_SZ || dwDataType == REG_EXPAND_SZ) && !is_unicode) { LPBYTE tmp = lpbData; lpbData = (LPBYTE)GetWideStringN((char*)lpbData, dwLen, &dwLen); dwLen *= sizeof(WCHAR); HeapFree(GetProcessHeap(), 0, tmp); } } else /* unknown format */ { fprintf(stderr,"%s: ERROR, unknown data format\n", getAppName()); return ERROR_INVALID_DATA; } res = RegSetValueExW( currentKeyHandle, val_name, 0, /* Reserved */ dwDataType, lpbData, dwLen); if (dwParseType == REG_BINARY) HeapFree(GetProcessHeap(), 0, lpbData); return res; }
BOOLEAN ConCfgWriteUserSettings(IN PCONSOLE_STATE_INFO ConsoleInfo, IN BOOLEAN DefaultSettings) { HKEY hKey; DWORD Storage = 0; #define SetConsoleSetting(SettingName, SettingType, SettingSize, Setting, DefaultValue) \ do { \ if (DefaultSettings || (!DefaultSettings && (*(Setting) != (DefaultValue)))) \ { \ RegSetValueExW(hKey, (SettingName), 0, (SettingType), (PBYTE)(Setting), (SettingSize)); \ } \ else \ { \ RegDeleteValueW(hKey, (SettingName)); \ } \ } while (0) WCHAR szValueName[15]; UINT i; if (!ConCfgOpenUserSettings(DefaultSettings ? L"" : ConsoleInfo->ConsoleTitle, &hKey, KEY_WRITE, TRUE)) { return FALSE; } for (i = 0; i < ARRAYSIZE(ConsoleInfo->ColorTable); ++i) { /* * Write only the new value if we are saving the global settings * or we are saving settings for a particular console, which differs * from the default ones. */ swprintf(szValueName, L"ColorTable%02u", i); SetConsoleSetting(szValueName, REG_DWORD, sizeof(DWORD), &ConsoleInfo->ColorTable[i], s_Colors[i]); } SetConsoleSetting(L"FaceName", REG_SZ, (wcslen(ConsoleInfo->FaceName) + 1) * sizeof(WCHAR), ConsoleInfo->FaceName, UNICODE_NULL); // wcsnlen SetConsoleSetting(L"FontFamily", REG_DWORD, sizeof(DWORD), &ConsoleInfo->FontFamily, FF_DONTCARE); Storage = MAKELONG(ConsoleInfo->FontSize.X, ConsoleInfo->FontSize.Y); // Width, Height SetConsoleSetting(L"FontSize", REG_DWORD, sizeof(DWORD), &Storage, 0); SetConsoleSetting(L"FontWeight", REG_DWORD, sizeof(DWORD), &ConsoleInfo->FontWeight, FW_DONTCARE); SetConsoleSetting(L"HistoryBufferSize", REG_DWORD, sizeof(DWORD), &ConsoleInfo->HistoryBufferSize, 50); SetConsoleSetting(L"NumberOfHistoryBuffers", REG_DWORD, sizeof(DWORD), &ConsoleInfo->NumberOfHistoryBuffers, 4); Storage = ConsoleInfo->HistoryNoDup; SetConsoleSetting(L"HistoryNoDup", REG_DWORD, sizeof(DWORD), &Storage, FALSE); Storage = ConsoleInfo->QuickEdit; SetConsoleSetting(L"QuickEdit", REG_DWORD, sizeof(DWORD), &Storage, FALSE); Storage = ConsoleInfo->InsertMode; SetConsoleSetting(L"InsertMode", REG_DWORD, sizeof(DWORD), &Storage, TRUE); Storage = MAKELONG(ConsoleInfo->ScreenBufferSize.X, ConsoleInfo->ScreenBufferSize.Y); SetConsoleSetting(L"ScreenBufferSize", REG_DWORD, sizeof(DWORD), &Storage, MAKELONG(80, 300)); Storage = ConsoleInfo->FullScreen; SetConsoleSetting(L"FullScreen", REG_DWORD, sizeof(DWORD), &Storage, FALSE); if (ConsoleInfo->AutoPosition == FALSE) { Storage = MAKELONG(ConsoleInfo->WindowPosition.x, ConsoleInfo->WindowPosition.y); RegSetValueExW(hKey, L"WindowPosition", 0, REG_DWORD, (PBYTE)&Storage, sizeof(DWORD)); } else { RegDeleteValueW(hKey, L"WindowPosition"); } Storage = MAKELONG(ConsoleInfo->WindowSize.X, ConsoleInfo->WindowSize.Y); SetConsoleSetting(L"WindowSize", REG_DWORD, sizeof(DWORD), &Storage, MAKELONG(80, 25)); SetConsoleSetting(L"CursorSize", REG_DWORD, sizeof(DWORD), &ConsoleInfo->CursorSize, CSR_DEFAULT_CURSOR_SIZE); Storage = ConsoleInfo->ScreenAttributes; SetConsoleSetting(L"ScreenColors", REG_DWORD, sizeof(DWORD), &Storage, DEFAULT_SCREEN_ATTRIB); Storage = ConsoleInfo->PopupAttributes; SetConsoleSetting(L"PopupColors", REG_DWORD, sizeof(DWORD), &Storage, DEFAULT_POPUP_ATTRIB); RegCloseKey(hKey); return TRUE; }
static BOOL pendingRename() { static const WCHAR ValueName[] = {'P','e','n','d','i','n','g', 'F','i','l','e','R','e','n','a','m','e', 'O','p','e','r','a','t','i','o','n','s',0}; static const WCHAR SessionW[] = { 'S','y','s','t','e','m','\\', 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\', 'C','o','n','t','r','o','l','\\', 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0}; WCHAR *buffer=NULL; const WCHAR *src=NULL, *dst=NULL; DWORD dataLength=0; HKEY hSession=NULL; DWORD res; printf("Entered\n"); if ((res=RegOpenKeyExW(HKEY_LOCAL_MACHINE, SessionW, 0, KEY_ALL_ACCESS, &hSession)) !=ERROR_SUCCESS) { if (res==ERROR_FILE_NOT_FOUND) { printf("The key was not found - skipping\n"); res=TRUE; } else { printf("Couldn't open key, error %ld\n", res); res=FALSE; } goto end; } res=RegQueryValueExW(hSession, ValueName, NULL, NULL /* The value type does not really interest us, as it is not truely a REG_MULTI_SZ anyways */, NULL, &dataLength); if (res==ERROR_FILE_NOT_FOUND) { /* No value - nothing to do. Great! */ printf("Value not present - nothing to rename\n"); res=TRUE; goto end; } if (res!=ERROR_SUCCESS) { printf("Couldn't query value's length (%ld)\n", res); res=FALSE; goto end; } buffer=malloc(dataLength); if (buffer==NULL) { printf("Couldn't allocate %lu bytes for the value\n", dataLength); res=FALSE; goto end; } res=RegQueryValueExW(hSession, ValueName, NULL, NULL, (LPBYTE)buffer, &dataLength); if (res!=ERROR_SUCCESS) { printf("Couldn't query value after successfully querying before (%lu),\n" "please report to [email protected]\n", res); res=FALSE; goto end; } /* Make sure that the data is long enough and ends with two NULLs. This * simplifies the code later on. */ if (dataLength<2*sizeof(buffer[0]) || buffer[dataLength/sizeof(buffer[0])-1]!='\0' || buffer[dataLength/sizeof(buffer[0])-2]!='\0') { printf("Improper value format - doesn't end with NULL\n"); res=FALSE; goto end; } for(src=buffer; (src-buffer)*sizeof(src[0])<dataLength && *src!='\0'; src=dst+lstrlenW(dst)+1) { DWORD dwFlags=0; printf("processing next command\n"); dst=src+lstrlenW(src)+1; /* We need to skip the \??\ header */ if (src[0]=='\\' && src[1]=='?' && src[2]=='?' && src[3]=='\\') src+=4; if (dst[0]=='!') { dwFlags|=MOVEFILE_REPLACE_EXISTING; dst++; } if (dst[0]=='\\' && dst[1]=='?' && dst[2]=='?' && dst[3]=='\\') dst+=4; if (*dst!='\0') { /* Rename the file */ MoveFileExW(src, dst, dwFlags); } else { /* Delete the file or directory */ res = GetFileAttributesW (src); if (res != (DWORD)-1) { if ((res&FILE_ATTRIBUTE_DIRECTORY)==0) { /* It's a file */ DeleteFileW(src); } else { /* It's a directory */ RemoveDirectoryW(src); } } else { printf("couldn't get file attributes (%ld)\n", GetLastError()); } } } if ((res=RegDeleteValueW(hSession, ValueName))!=ERROR_SUCCESS) { printf("Error deleting the value (%lu)\n", GetLastError()); res=FALSE; } else res=TRUE; end: if (buffer!=NULL) free(buffer); if (hSession!=NULL) RegCloseKey(hSession); return res; }