/******************************************************************************
* 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;
}