static void test_MsiInstallProduct(void)
{
UINT r;
CHAR path[MAX_PATH];
LONG res;
HKEY hkey;
DWORD num, size, type;
r = MsiInstallProductA(msifile, NULL);
todo_wine
{
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
}
todo_wine
{
ok(delete_pf("msitest\\cabout\\new\\five.txt", TRUE), "File not installed\n");
ok(delete_pf("msitest\\cabout\\new", FALSE), "File not installed\n");
ok(delete_pf("msitest\\cabout\\four.txt", TRUE), "File not installed\n");
ok(delete_pf("msitest\\cabout", FALSE), "File not installed\n");
ok(delete_pf("msitest\\changed\\three.txt", TRUE), "File not installed\n");
ok(delete_pf("msitest\\changed", FALSE), "File not installed\n");
ok(delete_pf("msitest\\first\\two.txt", TRUE), "File not installed\n");
ok(delete_pf("msitest\\first", FALSE), "File not installed\n");
ok(delete_pf("msitest\\one.txt", TRUE), "File not installed\n");
ok(delete_pf("msitest", FALSE), "File not installed\n");
}
res = RegOpenKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\Wine\\msitest", &hkey);
todo_wine
{
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", res);
}
size = MAX_PATH;
type = REG_SZ;
res = RegQueryValueExA(hkey, "Name", NULL, &type, (LPBYTE)path, &size);
todo_wine
{
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", res);
ok(!lstrcmpA(path, "imaname"), "Expected imaname, got %s\n", path);
}
size = MAX_PATH;
type = REG_SZ;
res = RegQueryValueExA(hkey, "blah", NULL, &type, (LPBYTE)path, &size);
todo_wine
{
ok(res == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %ld\n", res);
}
size = sizeof(num);
type = REG_DWORD;
res = RegQueryValueExA(hkey, "number", NULL, &type, (LPBYTE)&num, &size);
todo_wine
{
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %ld\n", res);
ok(num == 314, "Expected 314, got %ld\n", num);
}
RegDeleteKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Wine\\msitest");
}
static void test_ExitCode(void)
{
static const char* AeDebug="Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug";
static const char* WineDbg="Software\\Wine\\WineDbg";
char test_exe[MAX_PATH];
DWORD ret;
HKEY hkey;
DWORD disposition;
reg_save_value auto_value;
reg_save_value debugger_value;
GetModuleFileNameA(GetModuleHandle(NULL), test_exe, sizeof(test_exe));
if (GetFileAttributes(test_exe) == INVALID_FILE_ATTRIBUTES)
strcat(test_exe, ".so");
if (GetFileAttributesA(test_exe) == INVALID_FILE_ATTRIBUTES)
{
ok(0, "could not find the test executable '%s'\n", test_exe);
return;
}
ret=RegCreateKeyExA(HKEY_LOCAL_MACHINE, AeDebug, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &disposition);
if (ret == ERROR_SUCCESS)
{
save_value(hkey, "auto", &auto_value);
save_value(hkey, "debugger", &debugger_value);
trace("HKLM\\%s\\debugger is set to '%s'\n", AeDebug, debugger_value.data);
}
else if (ret == ERROR_ACCESS_DENIED)
{
skip("not enough privileges to change the debugger\n");
return;
}
else if (ret != ERROR_FILE_NOT_FOUND)
{
ok(0, "could not open the AeDebug key: %d\n", ret);
return;
}
if (debugger_value.data && debugger_value.type == REG_SZ &&
strstr((char*)debugger_value.data, "winedbg --auto"))
{
HKEY hkeyWinedbg;
ret=RegCreateKeyA(HKEY_CURRENT_USER, WineDbg, &hkeyWinedbg);
if (ret == ERROR_SUCCESS)
{
static DWORD zero;
reg_save_value crash_dlg_value;
save_value(hkeyWinedbg, "ShowCrashDialog", &crash_dlg_value);
RegSetValueExA(hkeyWinedbg, "ShowCrashDialog", 0, REG_DWORD, (BYTE *)&zero, sizeof(DWORD));
crash_and_winedbg(hkey, test_exe);
restore_value(hkeyWinedbg, &crash_dlg_value);
RegCloseKey(hkeyWinedbg);
}
else
ok(0, "Couldn't access WineDbg Key - error %u\n", ret);
}
if (winetest_interactive)
/* Since the debugging process never sets the debug event, it isn't recognized
as a valid debugger and, after the debugger exits, Windows will show a dialog box
asking the user what to do */
crash_and_debug(hkey, test_exe, "dbg,none");
else
skip("\"none\" debugger test needs user interaction\n");
if (disposition == REG_CREATED_NEW_KEY)
win_skip("'dbg,event,order' test doesn't finish on Win9x/WinMe\n");
else
crash_and_debug(hkey, test_exe, "dbg,event,order");
crash_and_debug(hkey, test_exe, "dbg,attach,event,code2");
if (pDebugSetProcessKillOnExit)
crash_and_debug(hkey, test_exe, "dbg,attach,event,nokill");
else
win_skip("DebugSetProcessKillOnExit is not available\n");
if (pDebugActiveProcessStop)
crash_and_debug(hkey, test_exe, "dbg,attach,event,detach");
else
win_skip("DebugActiveProcessStop is not available\n");
if (disposition == REG_CREATED_NEW_KEY)
{
RegCloseKey(hkey);
RegDeleteKeyA(HKEY_LOCAL_MACHINE, AeDebug);
}
else
{
restore_value(hkey, &auto_value);
restore_value(hkey, &debugger_value);
RegCloseKey(hkey);
}
}
static void test_legacy_filter_registration(void)
{
IFilterMapper2 *pMapper2 = NULL;
IFilterMapper *pMapper = NULL;
HRESULT hr;
static const WCHAR wszFilterName[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', 0 };
static const CHAR szFilterName[] = "Testfilter";
static const WCHAR wszPinName[] = {'P', 'i', 'n', '1', 0 };
CLSID clsidFilter;
CHAR szRegKey[MAX_PATH];
static const CHAR szClsid[] = "CLSID";
WCHAR wszGuidstring[MAX_PATH];
CHAR szGuidstring[MAX_PATH];
LONG lRet;
HKEY hKey = NULL;
IEnumMoniker *pEnum = NULL;
BOOL found;
IEnumRegFilters *pRegEnum = NULL;
/* Test if legacy filter registration scheme works (filter is added to HKCR\Filter). IFilterMapper_RegisterFilter
* registers in this way. Filters so registered must then be accessible through both IFilterMapper_EnumMatchingFilters
* and IFilterMapper2_EnumMatchingFilters. */
hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
&IID_IFilterMapper2, (LPVOID*)&pMapper2);
ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr);
if (FAILED(hr)) goto out;
hr = IFilterMapper2_QueryInterface(pMapper2, &IID_IFilterMapper, (void **)&pMapper);
ok(hr == S_OK, "IFilterMapper2_QueryInterface failed with %x\n", hr);
if (FAILED(hr)) goto out;
/* Register a test filter. */
hr = CoCreateGuid(&clsidFilter);
ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr);
lRet = StringFromGUID2(&clsidFilter, wszGuidstring, MAX_PATH);
ok(lRet > 0, "StringFromGUID2 failed\n");
if (!lRet) goto out;
WideCharToMultiByte(CP_ACP, 0, wszGuidstring, -1, szGuidstring, MAX_PATH, 0, 0);
lstrcpyA(szRegKey, szClsid);
lstrcatA(szRegKey, "\\");
lstrcatA(szRegKey, szGuidstring);
/* Register---- functions need a filter class key to write pin and pin media type data to. Create a bogus
* class key for it. */
lRet = RegCreateKeyExA(HKEY_CLASSES_ROOT, szRegKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
if (lRet == ERROR_ACCESS_DENIED)
skip("Not authorized to register filters\n");
else
{
ok(lRet == ERROR_SUCCESS, "RegCreateKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
/* Set default value - this is interpreted as "friendly name" later. */
lRet = RegSetValueExA(hKey, NULL, 0, REG_SZ, (LPBYTE)szFilterName, lstrlenA(szFilterName) + 1);
ok(lRet == ERROR_SUCCESS, "RegSetValueExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
if (hKey) RegCloseKey(hKey);
hKey = NULL;
hr = IFilterMapper_RegisterFilter(pMapper, clsidFilter, wszFilterName, MERIT_UNLIKELY);
ok(hr == S_OK, "IFilterMapper_RegisterFilter failed with %x\n", hr);
hr = IFilterMapper_RegisterPin(pMapper, clsidFilter, wszPinName, TRUE, FALSE, FALSE, FALSE, GUID_NULL, NULL);
ok(hr == S_OK, "IFilterMapper_RegisterPin failed with %x\n", hr);
hr = IFilterMapper_RegisterPinType(pMapper, clsidFilter, wszPinName, GUID_NULL, GUID_NULL);
ok(hr == S_OK, "IFilterMapper_RegisterPinType failed with %x\n", hr);
hr = IFilterMapper2_EnumMatchingFilters(pMapper2, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE,
0, NULL, NULL, &GUID_NULL, FALSE, FALSE, 0, NULL, NULL, &GUID_NULL);
ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr);
if (SUCCEEDED(hr) && pEnum)
{
found = enum_find_filter(wszFilterName, pEnum);
ok(found, "IFilterMapper2_EnumMatchingFilters failed to return the test filter\n");
}
if (pEnum) IEnumMoniker_Release(pEnum);
pEnum = NULL;
found = FALSE;
hr = IFilterMapper_EnumMatchingFilters(pMapper, &pRegEnum, MERIT_UNLIKELY, TRUE, GUID_NULL, GUID_NULL,
FALSE, FALSE, GUID_NULL, GUID_NULL);
ok(hr == S_OK, "IFilterMapper_EnumMatchingFilters failed with %x\n", hr);
if (SUCCEEDED(hr) && pRegEnum)
{
ULONG cFetched;
REGFILTER *prgf;
while(!found && IEnumRegFilters_Next(pRegEnum, 1, &prgf, &cFetched) == S_OK)
{
CHAR val[512];
WideCharToMultiByte(CP_ACP, 0, prgf->Name, -1, val, sizeof(val), 0, 0);
if (!lstrcmpA(val, szFilterName)) found = TRUE;
CoTaskMemFree(prgf);
}
IEnumRegFilters_Release(pRegEnum);
}
ok(found, "IFilterMapper_EnumMatchingFilters failed to return the test filter\n");
hr = IFilterMapper_UnregisterFilter(pMapper, clsidFilter);
ok(hr == S_OK, "FilterMapper_UnregisterFilter failed with %x\n", hr);
lRet = RegOpenKeyExA(HKEY_CLASSES_ROOT, szClsid, 0, KEY_WRITE | DELETE, &hKey);
ok(lRet == ERROR_SUCCESS, "RegOpenKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
lRet = RegDeleteKeyA(hKey, szGuidstring);
ok(lRet == ERROR_SUCCESS, "RegDeleteKeyA failed with %x\n", HRESULT_FROM_WIN32(lRet));
}
if (hKey) RegCloseKey(hKey);
hKey = NULL;
out:
if (pMapper) IFilterMapper_Release(pMapper);
if (pMapper2) IFilterMapper2_Release(pMapper2);
}
/***********************************************************************
* VxDCall_VMM
*/
static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
{
switch ( LOWORD(service) )
{
case 0x0011: /* RegOpenKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegOpenKeyA( hkey, lpszSubKey, retkey );
}
case 0x0012: /* RegCreateKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegCreateKeyA( hkey, lpszSubKey, retkey );
}
case 0x0013: /* RegCloseKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RegCloseKey( hkey );
}
case 0x0014: /* RegDeleteKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
return RegDeleteKeyA( hkey, lpszSubKey );
}
case 0x0015: /* RegSetValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPCSTR lpszData = (LPCSTR)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
}
case 0x0016: /* RegDeleteValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR)stack32_pop( context );
return RegDeleteValueA( hkey, lpszValue );
}
case 0x0017: /* RegQueryValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
LPSTR lpszData = (LPSTR) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
}
case 0x0018: /* RegEnumKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iSubkey = (DWORD)stack32_pop( context );
LPSTR lpszName = (LPSTR)stack32_pop( context );
DWORD lpcchName = (DWORD)stack32_pop( context );
return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
}
case 0x0019: /* RegEnumValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iValue = (DWORD) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
lpReserved, lpdwType, lpbData, lpcbData );
}
case 0x001A: /* RegQueryValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueExA( hkey, lpszValue, lpReserved,
lpdwType, lpbData, lpcbData );
}
case 0x001B: /* RegSetValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
DWORD dwReserved = (DWORD) stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPBYTE lpbData = (LPBYTE)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueExA( hkey, lpszValue, dwReserved,
dwType, lpbData, cbData );
}
case 0x001C: /* RegFlushKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RtlNtStatusToDosError (NtFlushKey (hkey));
}
case 0x001D: /* RegQueryInfoKey */
{
/* NOTE: This VxDCall takes only a subset of the parameters that the
corresponding Win32 API call does. The implementation in Win95
ADVAPI32 sets all output parameters not mentioned here to zero. */
HKEY hkey = (HKEY) stack32_pop( context );
LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
return RegQueryInfoKeyA( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
NULL, NULL );
}
case 0x0021: /* RegLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
return RegLoadKeyA( hkey, lpszSubKey, lpszFile );
}
case 0x0022: /* RegUnLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s): stub (should call NtUnloadKey)\n",
(void *)hkey, lpszSubKey);
return ERROR_SUCCESS;
}
case 0x0023: /* RegSaveKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
return RegSaveKeyA( hkey, lpszFile, sa );
}
#if 0 /* Functions are not yet implemented in misc/registry.c */
case 0x0024: /* RegRemapPreDefKey */
case 0x0026: /* RegQueryMultipleValues */
#endif
case 0x0027: /* RegReplaceKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s, %s, %s): stub (should call NtReplaceKey)\n",
(void *)hkey, lpszSubKey, lpszNewFile, lpszOldFile);
return ERROR_SUCCESS;
}
case 0x0000: /* PageReserve */
{
LPVOID address;
LPVOID ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
page, npages, flags );
if ( page == PR_SYSTEM ) {
ERR("Can't reserve ring 1 memory\n");
return -1;
}
/* FIXME: This has to be handled separately for the separate
address-spaces we now have */
if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
/* FIXME: Handle flags in some way */
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
if ( ret == NULL )
return -1;
else
return (DWORD )ret;
}
case 0x0001: /* PageCommit */
{
LPVOID address;
LPVOID ret;
DWORD virt_perm;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG hpd = (ULONG) stack32_pop( context );
ULONG pagerdata = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
"%08lx, flags: %08lx partial stub\n",
page, npages, hpd, pagerdata, flags );
if ( flags & PC_USER )
if ( flags & PC_WRITEABLE )
virt_perm = PAGE_EXECUTE_READWRITE;
else
virt_perm = PAGE_EXECUTE_READ;
else
virt_perm = PAGE_NOACCESS;
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
return (DWORD )ret;
}
case 0x0002: /* PageDecommit */
{
LPVOID address;
BOOL ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
page, npages, flags );
address = (LPVOID )( page * psize );
ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
return ret;
}
case 0x000d: /* PageModifyPermissions */
{
DWORD pg_old_perm;
DWORD pg_new_perm;
DWORD virt_old_perm;
DWORD virt_new_perm;
MEMORY_BASIC_INFORMATION mbi;
LPVOID address;
DWORD psize = getpagesize();
ULONG page = stack32_pop ( context );
ULONG npages = stack32_pop ( context );
ULONG permand = stack32_pop ( context );
ULONG permor = stack32_pop ( context );
TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
page, npages, permand, permor );
address = (LPVOID )( page * psize );
VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
virt_old_perm = mbi.Protect;
switch ( virt_old_perm & mbi.Protect ) {
case PAGE_READONLY:
case PAGE_EXECUTE:
case PAGE_EXECUTE_READ:
pg_old_perm = PC_USER;
break;
case PAGE_READWRITE:
case PAGE_WRITECOPY:
case PAGE_EXECUTE_READWRITE:
case PAGE_EXECUTE_WRITECOPY:
pg_old_perm = PC_USER | PC_WRITEABLE;
break;
case PAGE_NOACCESS:
default:
pg_old_perm = 0;
break;
}
pg_new_perm = pg_old_perm;
pg_new_perm &= permand & ~PC_STATIC;
pg_new_perm |= permor & ~PC_STATIC;
virt_new_perm = ( virt_old_perm ) & ~0xff;
if ( pg_new_perm & PC_USER )
{
if ( pg_new_perm & PC_WRITEABLE )
virt_new_perm |= PAGE_EXECUTE_READWRITE;
else
virt_new_perm |= PAGE_EXECUTE_READ;
}
if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
ERR("Can't change page permissions for %08lx\n", (DWORD )address );
return 0xffffffff;
}
TRACE("Returning: %08lx\n", pg_old_perm );
return pg_old_perm;
}
case 0x000a: /* PageFree */
{
BOOL ret;
LPVOID hmem = (LPVOID) stack32_pop( context );
DWORD flags = (DWORD ) stack32_pop( context );
TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
(DWORD )hmem, flags );
ret = VirtualFree ( hmem, 0, MEM_RELEASE );
context->Eax = ret;
TRACE("Returning: %d\n", ret );
return 0;
}
case 0x001e: /* GetDemandPageInfo */
{
DWORD dinfo = (DWORD)stack32_pop( context );
DWORD flags = (DWORD)stack32_pop( context );
/* GetDemandPageInfo is supposed to fill out the struct at
* "dinfo" with various low-level memory management information.
* Apps are certainly not supposed to call this, although it's
* demoed and documented by Pietrek on pages 441-443 of "Windows
* 95 System Programming Secrets" if any program needs a real
* implementation of this.
*/
FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
return 0;
}
default:
if (LOWORD(service) < N_VMM_SERVICE)
FIXME( "Unimplemented service %s (%08lx)\n",
VMM_Service_Name[LOWORD(service)], service);
else
FIXME( "Unknown service %08lx\n", service);
break;
}
return 0xffffffff; /* FIXME */
}
static void test_add(void)
{
HKEY hkey, subkey;
LONG err;
DWORD r, dword, type, size;
char buffer[22];
run_reg_exe("reg add", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add /?", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE);
ok(err == ERROR_SUCCESS || err == ERROR_FILE_NOT_FOUND, "got %d\n", err);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey);
ok(err == ERROR_FILE_NOT_FOUND, "got %d\n", err);
run_reg_exe("reg add HKCU\\" KEY_BASE " /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey);
ok(err == ERROR_SUCCESS, "key creation failed, got %d\n", err);
/* Test empty type */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v emptyType /t \"\" /d WineTest /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
/* Test input key formats */
run_reg_exe("reg add \\HKCU\\" KEY_BASE "\\keytest0 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest0");
ok(err == ERROR_FILE_NOT_FOUND, "got exit code %d\n", r);
run_reg_exe("reg add \\\\HKCU\\" KEY_BASE "\\keytest1 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest1");
ok(err == ERROR_FILE_NOT_FOUND, "got exit code %d\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest2\\\\ /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %u\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest2");
ok(err == ERROR_FILE_NOT_FOUND || broken(err == ERROR_SUCCESS /* WinXP */),
"got exit code %d\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest3\\ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE "\\keytest3", 0, KEY_READ, &subkey);
ok(err == ERROR_SUCCESS, "key creation failed, got %d\n", err);
RegCloseKey(subkey);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest3");
ok(err == ERROR_SUCCESS, "got exit code %d\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE "\\keytest4 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE "\\keytest4", 0, KEY_READ, &subkey);
ok(err == ERROR_SUCCESS, "key creation failed, got %d\n", err);
RegCloseKey(subkey);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\keytest4");
ok(err == ERROR_SUCCESS, "got exit code %d\n", r);
/* REG_NONE */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v none0 /d deadbeef /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d\n", r);
verify_reg(hkey, "none0", REG_NONE, "d\0e\0a\0d\0b\0e\0e\0f\0\0", 18, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v none1 /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "none1", REG_NONE, "\0", 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_NONE /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_NONE, "\0", 2, 0);
/* REG_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /d WineTest /f", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_SZ, "WineTest", 9, 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test /d deadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test", REG_SZ, "deadbeef", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test1 /t REG_SZ /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /d WineTEST /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "", REG_SZ, "WineTEST", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test2 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test2", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test3 /f /d \"\"", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test3", REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_SZ, "", 1, 0);
/* REG_EXPAND_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v expand0 /t REG_EXpand_sz /d \"dead%PATH%beef\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "expand0", REG_EXPAND_SZ, "dead%PATH%beef", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v expand1 /t REG_EXpand_sz /d \"dead^%PATH^%beef\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "expand1", REG_EXPAND_SZ, "dead^%PATH^%beef", 17, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_EXPAND_SZ /v expand2 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "expand2", REG_EXPAND_SZ, "", 1, 0);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /t REG_EXPAND_SZ /d WineTEST /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "", REG_EXPAND_SZ, "WineTEST", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_EXPAND_SZ /v expand3 /f /d \"\"", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "expand3", REG_EXPAND_SZ, "", 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_EXPAND_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_EXPAND_SZ, "", 1, 0);
/* REG_BINARY */
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin0 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "bin0", REG_BINARY, buffer, 0, 0);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /t REG_BINARY /d deadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
dword = 0xefbeadde;
verify_reg(hkey, "", REG_BINARY, &dword, sizeof(DWORD), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin1 /f /d 0xDeAdBeEf", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin2 /f /d x01", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin3 /f /d 01x", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin4 /f /d DeAdBeEf0DD", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
/* Remaining nibble prefixed */
buffer[0] = 0x0d; buffer[1] = 0xea; buffer[2] = 0xdb;
buffer[3] = 0xee; buffer[4] = 0xf0; buffer[5] = 0xdd;
/* Remaining nibble suffixed on winXP */
buffer[6] = 0xde; buffer[7] = 0xad; buffer[8] = 0xbe;
buffer[9] = 0xef; buffer[10] = 0x0d; buffer[11] = 0xd0;
size = 6;
err = RegQueryValueExA(hkey, "bin4", NULL, &type, (void *) (buffer+12), &size);
ok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
ok(type == REG_BINARY, "got wrong type %u\n", type);
ok(size == 6, "got wrong size %u\n", size);
ok(memcmp(buffer, buffer+12, 6) == 0 ||
broken(memcmp(buffer+6, buffer+12, 6) == 0 /* WinXP */), "got wrong data\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin5 /d \"\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "bin5", REG_BINARY, buffer, 0, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v bin6 /t REG_BINARY /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_BINARY /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_BINARY, buffer, 0, 0);
/* REG_DWORD */
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /f /d 12345678", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
dword = 12345678;
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_DWORD, &dword, sizeof(dword), 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword0 /t REG_DWORD /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword1 /t REG_DWORD /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword2 /t REG_DWORD /d zzz /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword3 /t REG_DWORD /d deadbeef /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword4 /t REG_DWORD /d 123xyz /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword5 /t reg_dword /d 12345678 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 12345678;
verify_reg(hkey, "dword5", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword6 /t REG_DWORD /D 0123 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
size = sizeof(dword);
err = RegQueryValueExA(hkey, "dword6", NULL, &type, (LPBYTE)&dword, &size);
ok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
ok(type == REG_DWORD, "got wrong type %d, expected %d\n", type, REG_DWORD);
ok(size == sizeof(DWORD), "got wrong size %d, expected %d\n", size, (int)sizeof(DWORD));
ok(dword == 123 || broken(dword == 0123 /* WinXP */), "got wrong data %d, expected 123\n", dword);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword7 /t reg_dword /d 0xabcdefg /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword8 /t REG_dword /d 0xdeadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 0xdeadbeef;
verify_reg(hkey, "dword8", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /v dword9 /f /d -1", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /v dword10 /f /d -0x1", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword8 /t REG_dword /d 0x01ffffffff /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %d\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword12 /t REG_DWORD /d 0xffffffff /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = ~0u;
verify_reg(hkey, "dword12", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword13 /t REG_DWORD /d 00x123 /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword14 /t REG_DWORD /d 0X123 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 0x123;
verify_reg(hkey, "dword14", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword15 /t REG_DWORD /d 4294967296 /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
/* REG_DWORD_LITTLE_ENDIAN */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_LE /t REG_DWORD_LITTLE_ENDIAN /d 456 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 456;
verify_reg(hkey, "DWORD_LE", REG_DWORD_LITTLE_ENDIAN, &dword, sizeof(dword), 0);
/* REG_DWORD_BIG_ENDIAN */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE /t REG_DWORD_BIG_ENDIAN /d 456 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
dword = 456;
verify_reg(hkey, "DWORD_BE", REG_DWORD_BIG_ENDIAN, &dword, sizeof(dword), 0);
/* REG_DWORD_BIG_ENDIAN is broken in every version of windows. It behaves like
* an ordinary REG_DWORD - that is little endian. GG */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE2 /t REG_DWORD_BIG_ENDIAN /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_BE3 /t REG_DWORD_BIG_ENDIAN /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD_BIG_ENDIAN /f", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u\n", r);
/* REG_MULTI_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi0 /t REG_MULTI_SZ /d \"three\\0little\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
memcpy(buffer, "three\0little\0strings\0", 22);
verify_reg(hkey, "multi0", REG_MULTI_SZ, buffer, 22, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi1 /s \"#\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi1", REG_MULTI_SZ, buffer, 22, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi2 /d \"\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi2", REG_MULTI_SZ, &buffer[21], 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi3 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u\n", r);
verify_reg(hkey, "multi3", REG_MULTI_SZ, &buffer[21], 1, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi4 /s \"#\" /d \"threelittlestrings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi4", REG_MULTI_SZ, "threelittlestrings\0", 20, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi5 /s \"#randomgibberish\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi6 /s \"\\0\" /d \"three\\0little\\0strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi7 /s \"\" /d \"three#little#strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi8 /s \"#\" /d \"##\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi9 /s \"#\" /d \"two##strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi10 /s \"#\" /d \"#a\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi11 /s \"#\" /d \"a#\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
buffer[0]='a'; buffer[1]=0; buffer[2]=0;
verify_reg(hkey, "multi11", REG_MULTI_SZ, buffer, 3, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi12 /t REG_MULTI_SZ /f /d", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi13 /t REG_MULTI_SZ /f /s", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi14 /t REG_MULTI_SZ /d \"\\0a\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi15 /t REG_MULTI_SZ /d \"a\\0\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi15", REG_MULTI_SZ, buffer, 3, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /v multi16 /d \"two\\0\\0strings\" /f", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi17 /t REG_MULTI_SZ /s \"#\" /d \"#\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
buffer[0] = 0; buffer[1] = 0;
verify_reg(hkey, "multi17", REG_MULTI_SZ, buffer, 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi18 /t REG_MULTI_SZ /d \"\\0\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi18", REG_MULTI_SZ, buffer, 2, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi19 /t REG_MULTI_SZ /s \"#\" /d \"two\\0#strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi19", REG_MULTI_SZ, "two\\0\0strings\0", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi20 /t REG_MULTI_SZ /s \"#\" /d \"two#\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi20", REG_MULTI_SZ, "two\0\\0strings\0", 15, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi21 /t REG_MULTI_SZ /s \"#\" /d \"two\\0\\0strings\" /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, "multi21", REG_MULTI_SZ, "two\\0\\0strings\0", 16, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_MULTI_SZ /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r);
verify_reg(hkey, NULL, REG_MULTI_SZ, buffer, 1, 0);
RegCloseKey(hkey);
/* Test duplicate switches */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dup1 /t REG_DWORD /d 123 /f /t REG_SZ", &r);
ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dup2 /t REG_DWORD /d 123 /f /d 456", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
/* Test invalid switches */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid1 /a", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid2 /ae", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid3 /", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v invalid4 -", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE);
ok(err == ERROR_SUCCESS, "got %d\n", err);
}
static
DWORD
UmnSrvUpdateADUser(
PLW_EVENTLOG_CONNECTION pEventlog,
HANDLE hReg,
HKEY hUsers,
long long PreviousRun,
long long Now,
PLSA_SECURITY_OBJECT pUser
)
{
DWORD dwError = 0;
HKEY hKey = NULL;
USER_MONITOR_PASSWD old = { 0 };
DWORD dwNow = Now;
PSTR pEncodedUser = NULL;
dwError = LwURLEncodeString(
pUser->userInfo.pszUnixName,
&pEncodedUser);
BAIL_ON_UMN_ERROR(dwError);
dwError = RegOpenKeyExA(
hReg,
hUsers,
pEncodedUser,
0,
KEY_ALL_ACCESS,
&hKey);
if (dwError == LWREG_ERROR_NO_SUCH_KEY_OR_VALUE)
{
UMN_LOG_INFO("Adding user '%s' (uid %d)",
pUser->userInfo.pszUnixName, pUser->userInfo.uid);
dwError = RegCreateKeyExA(
hReg,
hUsers,
pEncodedUser,
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKey,
NULL);
BAIL_ON_UMN_ERROR(dwError);
dwError = UmnSrvWriteADUserValues(
hReg,
hKey,
pUser);
if (dwError == ERROR_NO_UNICODE_TRANSLATION)
{
UMN_LOG_ERROR("Ignoring user with URL encoding %s because one of their fields has no UCS-2 representation", pEncodedUser);
// Delete the key so it does not show up with blank values next
// time.
dwError = RegCloseKey(
hReg,
hKey);
BAIL_ON_UMN_ERROR(dwError);
hKey = NULL;
dwError = RegDeleteKeyA(
hReg,
hUsers,
pEncodedUser);
BAIL_ON_UMN_ERROR(dwError);
dwError = ERROR_NO_UNICODE_TRANSLATION;
BAIL_ON_UMN_ERROR(dwError);
}
BAIL_ON_UMN_ERROR(dwError);
dwError = UmnSrvWriteADUserEvent(
pEventlog,
PreviousRun,
NULL,
Now,
pUser);
BAIL_ON_UMN_ERROR(dwError);
}
else
{
BAIL_ON_UMN_ERROR(dwError);
dwError = UmnSrvReadUser(
"AD Users",
pEncodedUser,
&old);
BAIL_ON_UMN_ERROR(dwError);
if (strcmp((pUser->userInfo.pszPasswd ?
pUser->userInfo.pszPasswd : "x"),
old.pw_passwd) ||
pUser->userInfo.uid != old.pw_uid ||
pUser->userInfo.gid != old.pw_gid ||
!UmnSrvStringsEqual(pUser->userInfo.pszGecos, old.pw_gecos) ||
!UmnSrvStringsEqual(pUser->userInfo.pszHomedir, old.pw_dir) ||
!UmnSrvStringsEqual(pUser->userInfo.pszShell, old.pw_shell) ||
!UmnSrvStringsEqual(pUser->userInfo.pszDisplayName,
old.pDisplayName))
{
UMN_LOG_INFO("User '%s' (uid %d) changed",
pUser->userInfo.pszUnixName, pUser->userInfo.uid);
dwError = UmnSrvWriteADUserValues(
hReg,
hKey,
pUser);
BAIL_ON_UMN_ERROR(dwError);
dwError = UmnSrvWriteADUserEvent(
pEventlog,
PreviousRun,
&old,
Now,
pUser);
BAIL_ON_UMN_ERROR(dwError);
}
}
dwError = RegSetValueExA(
hReg,
hKey,
"LastUpdated",
0,
REG_DWORD,
(PBYTE)&dwNow,
sizeof(dwNow));
BAIL_ON_UMN_ERROR(dwError);
cleanup:
LW_SAFE_FREE_STRING(pEncodedUser);
UmnSrvFreeUserContents(&old);
if (hKey)
{
RegCloseKey(
hReg,
hKey);
}
return dwError;
error:
goto cleanup;
}
static void test_registerOIDFunction(void)
{
BOOL ret;
/* oddly, this succeeds under WinXP; the function name key is merely
* omitted. This may be a side effect of the registry code, I don't know.
* I don't check it because I doubt anyone would depend on it.
ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, NULL,
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
*/
/* On windows XP, GetLastError is incorrectly being set with an HRESULT,
* E_INVALIDARG
*/
ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "foo", NULL, bogusDll,
NULL);
ok(!ret && GetLastError() == E_INVALIDARG,
"Expected E_INVALIDARG: %d\n", GetLastError());
/* This has no effect, but "succeeds" on XP */
ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "foo",
"1.2.3.4.5.6.7.8.9.10", NULL, NULL);
ok(ret, "Expected pseudo-success, got %d\n", GetLastError());
SetLastError(0xdeadbeef);
ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
{
skip("Need admin rights\n");
return;
}
ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
ret = CryptUnregisterOIDFunction(X509_ASN_ENCODING, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10");
ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "bogus",
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
ret = CryptUnregisterOIDFunction(X509_ASN_ENCODING, "bogus",
"1.2.3.4.5.6.7.8.9.10");
ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
/* Unwanted Cryptography\OID\EncodingType 1\bogus\ will still be there */
ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 1\\bogus"),
"Could not delete bogus key\n");
/* Shouldn't have effect but registry keys are created */
ret = CryptRegisterOIDFunction(PKCS_7_ASN_ENCODING, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
ret = CryptUnregisterOIDFunction(PKCS_7_ASN_ENCODING, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10");
ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
/* Check with bogus encoding type. Registry keys are still created */
ret = CryptRegisterOIDFunction(0, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
ret = CryptUnregisterOIDFunction(0, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10");
ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
/* Unwanted Cryptography\OID\EncodingType 0\CryptDllEncodeObject\
* will still be there
*/
ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllEncodeObject"),
"Could not delete CryptDllEncodeObject key\n");
/* This is written with value 3 verbatim. Thus, the encoding type isn't
* (for now) treated as a mask. Registry keys are created.
*/
ret = CryptRegisterOIDFunction(3, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
ret = CryptUnregisterOIDFunction(3, "CryptDllEncodeObject",
"1.2.3.4.5.6.7.8.9.10");
ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
/* Unwanted Cryptography\OID\EncodingType 3\CryptDllEncodeObject
* will still be there.
*/
ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 3\\CryptDllEncodeObject"),
"Could not delete CryptDllEncodeObject key\n");
ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 3"),
"Could not delete 'EncodingType 3' key\n");
}
static void test_query(void)
{
DWORD r;
HKEY key, subkey;
LONG err;
const char hello[] = "Hello";
const char world[] = "World";
const char empty1[] = "Empty1";
const char empty2[] = "Empty2";
const DWORD dword1 = 0x123;
const DWORD dword2 = 0xabc;
run_reg_exe("reg query", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg query /?", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
/* Create a test key */
err = RegCreateKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL);
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
run_reg_exe("reg query HKCU\\" KEY_BASE " /ve", &r);
todo_wine ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
err = RegSetValueExA(key, "Test", 0, REG_SZ, (BYTE *)hello, sizeof(hello));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegSetValueExA(key, "Wine", 0, REG_DWORD, (BYTE *)&dword1, sizeof(dword1));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegSetValueExA(key, NULL, 0, REG_SZ, (BYTE *)empty1, sizeof(empty1));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
run_reg_exe("reg query HKCU\\" KEY_BASE, &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v Missing", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v Test", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v Wine", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /ve", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
/* Create a test subkey */
err = RegCreateKeyExA(key, "Subkey", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &subkey, NULL);
ok(err == ERROR_SUCCESS, "got %d\n", err);
err = RegSetValueExA(subkey, "Test", 0, REG_SZ, (BYTE *)world, sizeof(world));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegSetValueExA(subkey, "Wine", 0, REG_DWORD, (BYTE *)&dword2, sizeof(dword2));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegSetValueExA(subkey, NULL, 0, REG_SZ, (BYTE *)empty2, sizeof(empty2));
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegCloseKey(subkey);
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey /v Test", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey /v Wine", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey /ve", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
/* Test recursion */
run_reg_exe("reg query HKCU\\" KEY_BASE " /s", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v Test /s", &r);
ok(r == REG_EXIT_SUCCESS || r == REG_EXIT_FAILURE /* WinXP */,
"got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /v Wine /s", &r);
ok(r == REG_EXIT_SUCCESS || r == REG_EXIT_FAILURE /* WinXP */,
"got exit code %d, expected 0\n", r);
run_reg_exe("reg query HKCU\\" KEY_BASE " /ve /s", &r);
ok(r == REG_EXIT_SUCCESS || r == REG_EXIT_FAILURE /* WinXP */,
"got exit code %d, expected 0\n", r);
/* Clean-up, then query */
err = RegDeleteKeyA(key, "subkey");
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
err = RegCloseKey(key);
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
run_reg_exe("reg query HKCU\\" KEY_BASE "\\subkey", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE);
ok(err == ERROR_SUCCESS, "got %d, expected 0\n", err);
run_reg_exe("reg query HKCU\\" KEY_BASE, &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
}
static void test_add(void)
{
HKEY hkey;
LONG err;
DWORD r, dword, type, size;
run_reg_exe("reg add", &r);
ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE);
ok(err == ERROR_SUCCESS || err == ERROR_FILE_NOT_FOUND, "got %d\n", err);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey);
ok(err == ERROR_FILE_NOT_FOUND, "got %d\n", err);
run_reg_exe("reg add HKCU\\" KEY_BASE " /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
err = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey);
ok(err == ERROR_SUCCESS, "key creation failed, got %d\n", err);
/* REG_SZ */
run_reg_exe("reg add HKCU\\" KEY_BASE " /d WineTest /f", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_SZ, "WineTest", 9, 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test /d deadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test", REG_SZ, "deadbeef", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v test /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test", REG_SZ, "", 1, TODO_REG_SIZE);
run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /d WineTEST /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "", REG_SZ, "WineTEST", 9, 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test2 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test2", REG_SZ, "", 1, TODO_REG_SIZE);
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /v test3 /f /d \"\"", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
verify_reg(hkey, "test3", REG_SZ, "", 1, 0);
/* REG_DWORD */
run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_DWORD /f /d 12345678", &r);
ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */),
"got exit code %d, expected 0\n", r);
dword = 12345678;
if (r == REG_EXIT_SUCCESS)
verify_reg(hkey, "", REG_DWORD, &dword, sizeof(dword), 0);
else
win_skip("broken reg.exe detected\n");
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword1 /t REG_DWORD /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */),
"got exit code %d, expected 0\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword2 /t REG_DWORD /d zzz /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword3 /t REG_DWORD /d deadbeef /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword4 /t REG_DWORD /d 123xyz /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword5 /t reg_dword /d 12345678 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 12345678;
verify_reg(hkey, "dword5", REG_DWORD, &dword, sizeof(dword), 0);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword6 /t REG_DWORD /D 0123 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
size = sizeof(dword);
err = RegQueryValueExA(hkey, "dword6", NULL, &type, (LPBYTE)&dword, &size);
ok(err == ERROR_SUCCESS, "RegQueryValueEx failed: got %d\n", err);
ok(type == REG_DWORD, "got wrong type %d, expected %d\n", type, REG_DWORD);
ok(size == sizeof(DWORD), "got wrong size %d, expected %d\n", size, (int)sizeof(DWORD));
todo_wine ok(dword == 123 || broken(dword == 0123 /* WinXP */),
"got wrong data %d, expected %d\n", dword, 123);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword7 /t reg_dword /d 0xabcdefg /f", &r);
todo_wine ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r);
run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword8 /t REG_dword /d 0xdeadbeef /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 0xdeadbeef;
verify_reg(hkey, "dword8", REG_DWORD, &dword, sizeof(dword),
(sizeof(long) > sizeof(DWORD)) ? 0 : TODO_REG_DATA);
/* REG_DWORD_LITTLE_ENDIAN */
run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_LE /t REG_DWORD_LITTLE_ENDIAN /d 456 /f", &r);
ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r);
dword = 456;
verify_reg(hkey, "DWORD_LE", REG_DWORD_LITTLE_ENDIAN, &dword, sizeof(dword), 0);
RegCloseKey(hkey);
err = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE);
ok(err == ERROR_SUCCESS, "got %d\n", err);
}
static void setperusersecvalues_test(void)
{
PERUSERSECTIONA peruser;
HRESULT hr;
HKEY guid;
lstrcpyA(peruser.szDispName, "displayname");
lstrcpyA(peruser.szLocale, "locale");
lstrcpyA(peruser.szStub, "stub");
lstrcpyA(peruser.szVersion, "1,1,1,1");
lstrcpyA(peruser.szCompID, "compid");
peruser.dwIsInstalled = 1;
peruser.bRollback = FALSE;
/* try a NULL pPerUser */
if (0)
{
/* This crashes on systems with IE7 */
hr = pSetPerUserSecValues(NULL);
todo_wine
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!OPEN_GUID_KEY(), "Expected guid key to not exist\n");
}
/* at the very least, szGUID must be valid */
peruser.szGUID[0] = '\0';
hr = pSetPerUserSecValues(&peruser);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!OPEN_GUID_KEY(), "Expected guid key to not exist\n");
/* set initial values */
lstrcpyA(peruser.szGUID, "guid");
hr = pSetPerUserSecValues(&peruser);
if (hr == E_FAIL)
{
skip("SetPerUserSecValues is broken\n");
return;
}
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(OPEN_GUID_KEY(), "Expected guid key to exist\n");
ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n");
ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n");
ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n");
ok(check_reg_str(guid, "StubPath", "stub"), "Expected stub\n");
ok(check_reg_str(guid, "Version", "1,1,1,1"), "Expected 1,1,1,1\n");
ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n");
ok(!REG_VAL_EXISTS(guid, "OldDisplayName"), "Expected OldDisplayName to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldLocale"), "Expected OldLocale to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldStubPath"), "Expected OldStubPath to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldVersion"), "Expected OldVersion to not exist\n");
ok(!REG_VAL_EXISTS(guid, "RealStubPath"), "Expected RealStubPath to not exist\n");
/* raise the version, but bRollback is FALSE, so vals not saved */
lstrcpyA(peruser.szVersion, "2,1,1,1");
hr = pSetPerUserSecValues(&peruser);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n");
ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n");
ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n");
ok(check_reg_str(guid, "StubPath", "stub"), "Expected stub\n");
ok(check_reg_str(guid, "Version", "2,1,1,1"), "Expected 2,1,1,1\n");
ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n");
ok(!REG_VAL_EXISTS(guid, "OldDisplayName"), "Expected OldDisplayName to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldLocale"), "Expected OldLocale to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldStubPath"), "Expected OldStubPath to not exist\n");
ok(!REG_VAL_EXISTS(guid, "OldVersion"), "Expected OldVersion to not exist\n");
ok(!REG_VAL_EXISTS(guid, "RealStubPath"), "Expected RealStubPath to not exist\n");
/* raise the version again, bRollback is TRUE so vals are saved */
peruser.bRollback = TRUE;
lstrcpyA(peruser.szVersion, "3,1,1,1");
hr = pSetPerUserSecValues(&peruser);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n");
ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n");
ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n");
ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n");
ok(check_reg_str(guid, "Version", "3,1,1,1"), "Expected 3,1,1,1\n");
todo_wine
{
ok(check_reg_str(guid, "OldDisplayName", "displayname"), "Expected displayname\n");
ok(check_reg_str(guid, "OldLocale", "locale"), "Expected locale\n");
ok(check_reg_str(guid, "RealStubPath", "stub"), "Expected stub\n");
ok(check_reg_str(guid, "OldStubPath", "stub"), "Expected stub\n");
ok(check_reg_str(guid, "OldVersion", "2,1,1,1"), "Expected 2,1,1,1\n");
ok(check_reg_str(guid, "StubPath",
"rundll32.exe advpack.dll,UserInstStubWrapper guid"),
"Expected real stub\n");
}
RegDeleteKeyA(HKEY_LOCAL_MACHINE, GUID_KEY);
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer
//
/////////////////////////////////////////////////////////////////////////////
STDAPI DllUnregisterServer(void)
{
HKEY hRootKey = NULL;
HKEY hModuleKey = NULL;
HKEY hLTMKey = NULL;
HKEY hLTMModuleKey = NULL;
WCHAR* pwszCLSID = NULL;
ULONG cBufferSize = MAX_NAME_LEN;
GlobalModuleData* pModuleData = &g_pThisTestModule->m_gmd;
CHAR szGuid[MAX_NAME_LEN];
CHAR szBuffer[MAX_NAME_LEN];
CHAR szBuffer2[MAX_NAME_LEN];
//{...Guid...}
StringFromCLSID(*pModuleData->m_pguidModuleCLSID, &pwszCLSID);
WideCharToMultiByte(CP_ACP, 0, pwszCLSID, -1, szGuid, MAX_NAME_LEN, NULL, NULL);
// Step 1: Remove our CLSID as an OLE Server
//HKEY_CLASSES_ROOT\CLSID
if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_CLASSES_ROOT, "CLSID", 0, KEY_WRITE, &hRootKey))
{
//HKEY_CLASSES_ROOT\CLSID\{..Guid..}
if(ERROR_SUCCESS == RegOpenKeyExA(hRootKey, szGuid, 0, KEY_WRITE, &hModuleKey))
{
//HKEY_CLASSES_ROOT\CLSID\{..Guid..}\InprocServer32
RegDeleteKeyA(hModuleKey, "InprocServer32");
RegDeleteKeyA(hModuleKey, "ProgID");
}
RegDeleteKeyA(hRootKey, szGuid);
RegCloseKey(hRootKey);
}
//HKEY_CLASSES_ROOT\ProgID
WideCharToMultiByte(CP_ACP, 0, pModuleData->m_wszModuleName, -1, szBuffer2, MAX_NAME_LEN, NULL, NULL);
strcpy(szBuffer, "LTMTest.");
strcat(szBuffer, szBuffer2);
if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_CLASSES_ROOT, szBuffer, 0, KEY_WRITE, &hRootKey))
{
//HKEY_CLASSES_ROOT\ProgID\CLSID
RegDeleteKeyA(hRootKey, "CLSID");
RegDeleteKey(hRootKey, NULL);
}
// Step 2: Remove LTM-specific registery entries
//Obtain the Key for HKEY_LOCAL_MACHINE\"SOFTWARE\Microsoft\LTM\Test Modules"
if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\LTM\\Test Modules", 0, KEY_WRITE, &hLTMKey))
{
//Obtain the Key for "...\{Guid}
if(ERROR_SUCCESS == RegOpenKeyExA(hLTMKey, szGuid, 0, KEY_WRITE | KEY_READ, &hLTMModuleKey))
{
while(RegEnumKeyExA(hLTMModuleKey, 0, szBuffer, &cBufferSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
HKEY hLTMCase = NULL;
if(ERROR_SUCCESS == RegOpenKeyExA(hLTMModuleKey, szBuffer, 0, KEY_WRITE | KEY_READ, &hLTMCase))
{
cBufferSize = MAX_NAME_LEN;
while(RegEnumKeyExA(hLTMCase, 0, szBuffer2, &cBufferSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
RegDeleteKeyA(hLTMCase, szBuffer2);
cBufferSize = MAX_NAME_LEN;
}
RegCloseKey(hLTMCase); hLTMCase = NULL;
RegDeleteKeyA(hLTMModuleKey, szBuffer);
cBufferSize = MAX_NAME_LEN;
}
}
RegDeleteKeyA(hLTMKey, szGuid);
}
}
RegCloseKey(hLTMKey);
RegCloseKey(hLTMModuleKey);
RegCloseKey(hRootKey);
RegCloseKey(hModuleKey);
CoTaskMemFree(pwszCLSID);
return S_OK;
}
int DeleteRegistryKeys( ) {
LONG res = 0;
HKEY hRootkey = NULL;
DWORD dwValue = 3;
DWORD dwTypes = 7;
LPSTR dllpath = APP_DLL_PATH;
DWORD size = 0;
int ret = 0;
__try {
// Open the main service key
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_KEY_PATH, &hRootkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegOpenKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
ret = -1;
__leave;
}
printf("[+] Debug :: DeleteRegistrykeys :: root key %s opened successfully\n", ROOT_KEY_PATH);
// Delete the existing key
res = RegDeleteKeyA(hRootkey, APPS_KEY_NAME);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegDeleteKeyA failed with error :: %d :: %d\n", GetLastError(),res );
ret = -1;
__leave;
}
printf("[+] Debug :: DeleteRegistrykeys :: key %s\\%s deleted successfully\n", ROOT_KEY_PATH,APPS_KEY_NAME);
}
__finally {
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
}
__try {
// Open the main service key
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_CRASH_KEY_PATH_LOCAL_DUMPS, &hRootkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegOpenKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
ret = -1;
__leave;
}
printf("[+] Debug :: DeleteRegistrykeys :: root key %s opened successfully\n", ROOT_CRASH_KEY_PATH_LOCAL_DUMPS);
// Delete the existing key
res = RegDeleteKeyA(hRootkey, SVC_KEY_NAME);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegDeleteKeyA failed with error :: %d :: %d\n", GetLastError(),res );
ret = -1;
__leave;
}
printf("[+] Debug :: DeleteRegistrykeys :: key %s\\%s deleted successfully\n", ROOT_CRASH_KEY_PATH_LOCAL_DUMPS,SVC_KEY_NAME);
}
__finally {
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
}
return 0;
}
/* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
static LSTATUS mru_RegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
{
LONG ret;
DWORD dwMaxSubkeyLen, dwMaxValueLen;
DWORD dwMaxLen, dwSize;
CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
HKEY hSubKey = hKey;
if(lpszSubKey)
{
ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
if (ret) return ret;
}
/* Get highest length for keys, values */
ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
&dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
if (ret) goto cleanup;
dwMaxSubkeyLen++;
dwMaxValueLen++;
dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR))
{
/* Name too big: alloc a buffer for it */
if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR))))
{
ret = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
}
/* Recursively delete all the subkeys */
while (TRUE)
{
dwSize = dwMaxLen;
if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
NULL, NULL, NULL)) break;
ret = mru_RegDeleteTreeA(hSubKey, lpszName);
if (ret) goto cleanup;
}
if (lpszSubKey)
ret = RegDeleteKeyA(hKey, lpszSubKey);
else
while (TRUE)
{
dwSize = dwMaxLen;
if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
NULL, NULL, NULL, NULL)) break;
ret = RegDeleteValueA(hKey, lpszName);
if (ret) goto cleanup;
}
cleanup:
/* Free buffer if allocated */
if (lpszName != szNameBuf)
HeapFree( GetProcessHeap(), 0, lpszName);
if(lpszSubKey)
RegCloseKey(hSubKey);
return ret;
}
/******************************************************************************
* RegDeleteKey [SHELL.4]
*/
DWORD WINAPI RegDeleteKey16( HKEY hkey, LPCSTR name )
{
fix_win16_hkey( &hkey );
return RegDeleteKeyA( hkey, name );
}
static BOOL write_display_settings(HKEY parent_hkey, CGDirectDisplayID displayID)
{
BOOL ret = FALSE;
char display_key_name[19];
HKEY display_hkey;
CGDisplayModeRef display_mode;
DWORD val;
CFStringRef pixel_encoding;
size_t len;
WCHAR* buf = NULL;
snprintf(display_key_name, sizeof(display_key_name), "Display 0x%08x", CGDisplayUnitNumber(displayID));
/* @@ Wine registry key: HKLM\Software\Wine\Mac Driver\Initial Display Mode\Display 0xnnnnnnnn */
if (RegCreateKeyExA(parent_hkey, display_key_name, 0, NULL,
REG_OPTION_VOLATILE, KEY_WRITE, NULL, &display_hkey, NULL))
return FALSE;
display_mode = CGDisplayCopyDisplayMode(displayID);
if (!display_mode)
goto fail;
val = CGDisplayModeGetWidth(display_mode);
if (RegSetValueExA(display_hkey, "Width", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
val = CGDisplayModeGetHeight(display_mode);
if (RegSetValueExA(display_hkey, "Height", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
val = CGDisplayModeGetRefreshRate(display_mode) * 100;
if (RegSetValueExA(display_hkey, "RefreshRateTimes100", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
val = CGDisplayModeGetIOFlags(display_mode);
if (RegSetValueExA(display_hkey, "IOFlags", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
#if defined(MAC_OS_X_VERSION_10_8) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_8
if (CGDisplayModeGetPixelWidth != NULL && CGDisplayModeGetPixelHeight != NULL)
{
val = CGDisplayModeGetPixelWidth(display_mode);
if (RegSetValueExA(display_hkey, "PixelWidth", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
val = CGDisplayModeGetPixelHeight(display_mode);
if (RegSetValueExA(display_hkey, "PixelHeight", 0, REG_DWORD, (const BYTE*)&val, sizeof(val)))
goto fail;
}
#endif
pixel_encoding = CGDisplayModeCopyPixelEncoding(display_mode);
len = CFStringGetLength(pixel_encoding);
buf = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
CFStringGetCharacters(pixel_encoding, CFRangeMake(0, len), (UniChar*)buf);
buf[len] = 0;
CFRelease(pixel_encoding);
if (RegSetValueExW(display_hkey, pixelencodingW, 0, REG_SZ, (const BYTE*)buf, (len + 1) * sizeof(WCHAR)))
goto fail;
ret = TRUE;
fail:
HeapFree(GetProcessHeap(), 0, buf);
if (display_mode) CGDisplayModeRelease(display_mode);
RegCloseKey(display_hkey);
if (!ret)
RegDeleteKeyA(parent_hkey, display_key_name);
return ret;
}
