static HKEY GetKeyA(LPCSTR appname, BOOL * closekey, BOOL fCreate)
{
HKEY key = 0;
char achName[MAX_PATH];
HRESULT hr;
#if !MMPROFILECACHE
*closekey = TRUE;
#else
UINT n;
ATOM atm;
*closekey = FALSE;
//
// See if we have already used this key
//
atm = FindAtomA(appname);
if (atm != 0) {
// Atom exists... search the table for it.
for (n=0; n<keyscached; ++n) {
if (akeyatoms[n] == atm) {
DPF2(("Found existing key for %s\n", appname));
return ahkey[n];
}
}
}
DPF2(("No key found for %s", appname));
#endif
hr = StringCchCopyA(achName, MAX_PATH, KEYNAMEA);
if (FAILED(hr))
OutputError(hr, IDS_SAFE_COPY);
if ((!fCreate && RegOpenKeyA(ROOTKEY, achName, &key) == ERROR_SUCCESS)
|| (fCreate && RegCreateKeyA(ROOTKEY, achName, &key) == ERROR_SUCCESS)) {
#if MMPROFILECACHE
if ((keyscached < KEYSCACHED)
&& (atm = AddAtomA(appname))) {
// Add this key to the cache array
akeyatoms[keyscached] = atm;
ahkey[keyscached] = key;
DPF1(("Adding key %s to cache array in position %d\n", appname, keyscached));
++keyscached;
} else {
DPF2(("Not adding key %s to cache array\n", appname));
*closekey = TRUE;
}
#endif
}
return(key);
}
static HKEY GetKeyA(LPCSTR appname, BOOL * closekey, BOOL fCreate)
{
HKEY key = 0;
char achName[MAX_PATH];
#if !MMPROFILECACHE
*closekey = TRUE;
#else
UINT n;
ATOM atm;
*closekey = FALSE;
//
// See if we have already used this key
//
atm = FindAtomA(appname);
if (atm != 0) {
// Atom exists... search the table for it.
for (n=0; n<keyscached; ++n) {
if (akeyatoms[n] == atm) {
DPF2(("Found existing key for %s\n", appname));
return ahkey[n];
}
}
}
DPF2(("No key found for %s", appname));
#endif
lstrcpyA(achName, KEYNAMEA);
// Use registry under "CURRENT_USER\Software\Microsoft\Windiff\"
//lstrcatA(achName, appname);
if ((!fCreate && RegOpenKeyA(ROOTKEY, achName, &key) == ERROR_SUCCESS)
|| (fCreate && RegCreateKeyA(ROOTKEY, achName, &key) == ERROR_SUCCESS)) {
#if MMPROFILECACHE
if ((keyscached < KEYSCACHED)
&& (atm = AddAtomA(appname))) {
// Add this key to the cache array
akeyatoms[keyscached] = atm;
ahkey[keyscached] = key;
DPF1(("Adding key %s to cache array in position %d\n", appname, keyscached));
++keyscached;
} else {
DPF2(("Not adding key %s to cache array\n", appname));
*closekey = TRUE;
}
#endif
}
return(key);
}
int Credentials_Save(Memory_U creds, char *pszUser)
{
HKEY hKey;
int iRet = 0;
char szKey[MAX_PATH];
sprintf (szKey, "SOFTWARE\\FakeSkype\\%s", pszUser);
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey) == ERROR_SUCCESS)
{
iRet = RegSetValueExA(hKey, "Credentials", 0, REG_BINARY, creds.Memory, creds.MsZ) == ERROR_SUCCESS;
RegCloseKey(hKey);
}
return iRet;
}
static void test_debug_heap( const char *argv0, DWORD flags )
{
char keyname[MAX_PATH];
char buffer[MAX_PATH];
PROCESS_INFORMATION info;
STARTUPINFOA startup;
BOOL ret;
DWORD err;
HKEY hkey;
const char *basename;
if ((basename = strrchr( argv0, '\\' ))) basename++;
else basename = argv0;
sprintf( keyname, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
basename );
if (!strcmp( keyname + strlen(keyname) - 3, ".so" )) keyname[strlen(keyname) - 3] = 0;
err = RegCreateKeyA( HKEY_LOCAL_MACHINE, keyname, &hkey );
if (err == ERROR_ACCESS_DENIED)
{
skip("Not authorized to change the image file execution options\n");
return;
}
ok( !err, "failed to create '%s' error %u\n", keyname, err );
if (err) return;
if (flags == 0xdeadbeef) /* magic value for unsetting it */
RegDeleteValueA( hkey, "GlobalFlag" );
else
RegSetValueExA( hkey, "GlobalFlag", 0, REG_DWORD, (BYTE *)&flags, sizeof(flags) );
memset( &startup, 0, sizeof(startup) );
startup.cb = sizeof(startup);
sprintf( buffer, "%s heap.c 0x%x", argv0, flags );
ret = CreateProcessA( NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info );
ok( ret, "failed to create child process error %u\n", GetLastError() );
if (ret)
{
winetest_wait_child_process( info.hProcess );
CloseHandle( info.hThread );
CloseHandle( info.hProcess );
}
RegDeleteValueA( hkey, "GlobalFlag" );
RegCloseKey( hkey );
RegDeleteKeyA( HKEY_LOCAL_MACHINE, keyname );
}
static HRESULT reg_open_folder(const WCHAR *path, HKEY *hfolder)
{
HKEY hroot;
DWORD ret;
ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, root, &hroot);
if (ret) return HRESULT_FROM_WIN32(ret);
while (*path == '\\') path++;
ret = RegOpenKeyExW(hroot, path, 0, KEY_ALL_ACCESS, hfolder);
if (ret == ERROR_FILE_NOT_FOUND)
ret = ERROR_PATH_NOT_FOUND;
RegCloseKey(hroot);
return HRESULT_FROM_WIN32(ret);
}
static void add_dos_device( const char *udi, const char *device,
const char *mount_point, const char *type )
{
struct dos_drive *drive;
/* first check if it already exists */
LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
{
if (!strcmp( udi, drive->udi )) goto found;
}
if (!(drive = HeapAlloc( GetProcessHeap(), 0, sizeof(*drive) ))) return;
if (!(drive->udi = HeapAlloc( GetProcessHeap(), 0, strlen(udi)+1 )))
{
HeapFree( GetProcessHeap(), 0, drive );
return;
}
strcpy( drive->udi, udi );
list_add_tail( &drives_list, &drive->entry );
found:
drive->drive = add_drive( device, type );
if (drive->drive != -1)
{
HKEY hkey;
set_mount_point( drive, mount_point );
WINE_TRACE( "added device %c: udi %s for %s on %s type %s\n",
'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
wine_dbgstr_a(mount_point), wine_dbgstr_a(type) );
/* hack: force the drive type in the registry */
if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hkey ))
{
char name[3] = "a:";
name[0] += drive->drive;
if (!type || strcmp( type, "cdrom" )) type = "floppy"; /* FIXME: default to floppy */
RegSetValueExA( hkey, name, 0, REG_SZ, (const BYTE *)type, strlen(type) + 1 );
RegCloseKey( hkey );
}
send_notify( drive->drive, DBT_DEVICEARRIVAL );
}
}
template<> bool read_registry_pref(const std::string& pref_key, std::string& value) {
HKEY hKey = 0;
CHAR data[512];
DWORD cbData = sizeof(data);
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, heroes2RegistrySubKey, &hKey) != ERROR_SUCCESS) {
return false;
}
if (RegQueryValueExA(hKey, pref_key.c_str(), 0, NULL, (LPBYTE)data, &cbData) != ERROR_SUCCESS) {
return false;
}
std::string sdata(data);
value = sdata;
return true;
}
void InitNodeId(Skype_Inst *pInst)
{
DWORD BufSz = sizeof(pInst->NodeID);
HKEY hKey;
if (QueryRegValue(HKEY_LOCAL_MACHINE,
"SOFTWARE\\FakeSkype\\NodeId",
(LPBYTE)&pInst->NodeID, &BufSz)) return;
*(int64_t *)&pInst->NodeID = BytesRandomI64();
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\FakeSkype", &hKey) == ERROR_SUCCESS)
{
RegSetValueExA(hKey, "NodeId", 0, REG_BINARY, (LPBYTE)&pInst->NodeID, sizeof(pInst->NodeID));
RegCloseKey(hKey);
}
//FIXED NODEID
//memcpy_s(NodeID, NODEID_SZ, "\x49\x63\xff\xee\xe0\x5c\x9d\xf8", NODEID_SZ);
//memcpy_s(NodeID, NODEID_SZ, "\x97\xca\xb1\x72\x06\xf6\x72\xb4", NODEID_SZ);
}
static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
{
HKEY hkey;
DWORD res;
if(!init) {
RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
return TRUE;
}
res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
if(res != ERROR_SUCCESS)
return FALSE;
if(def_value)
res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
RegCloseKey(hkey);
return res == ERROR_SUCCESS;
}
VOID CreateDepthSuccessKey(CHAR *KeyPath,CHAR *KeyName)
{
HKEY regKey;
LONG result;
result =RegOpenKeyExA(HKEY_LOCAL_MACHINE,
KeyPath,
0,
KEY_ALL_ACCESS,
®Key);
if (SUCCEEDED(result))
{
HKEY subKey;
if (SUCCEEDED(RegCreateKeyA(regKey,KeyName, &subKey)))
{
RegCloseKey(subKey);
}
RegCloseKey(regKey);
}
}
/**************************************************************************
* WNetCachePassword [MPR.@] Saves password in cache
*
* NOTES
* Only the parameter count is verified
*
* ---- everything below this line might be wrong (js) -----
* RETURNS
* Success: WN_SUCCESS
* Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BADVALUE, WN_NET_ERROR,
* WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
*/
DWORD WINAPI WNetCachePassword(
LPSTR pbResource, /* [in] Name of workgroup, computer, or resource */
WORD cbResource, /* [in] Size of name */
LPSTR pbPassword, /* [in] Buffer containing password */
WORD cbPassword, /* [in] Size of password */
BYTE nType, /* [in] Type of password to cache */
WORD x)
{
HKEY hkey;
DWORD r;
LPSTR valname;
WARN( "(%p(%s), %d, %p(%s), %d, %d, 0x%08x): totally insecure\n",
pbResource, debugstr_a(pbResource), cbResource,
pbPassword, debugstr_a(pbPassword), cbPassword,
nType, x );
/* @@ Wine registry key: HKCU\Software\Wine\Wine\Mpr */
r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
if( r )
return WN_ACCESS_DENIED;
valname = MPR_GetValueName( pbResource, cbResource, nType );
if( valname )
{
r = RegSetValueExA( hkey, valname, 0, REG_BINARY,
(LPBYTE)pbPassword, cbPassword );
if( r )
r = WN_CANCEL;
else
r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname );
}
else
r = WN_OUT_OF_MEMORY;
RegCloseKey( hkey );
return r;
}
/***********************************************************************
* MSACM_ReadCache
*/
static BOOL MSACM_ReadCache(PWINE_ACMDRIVERID padid)
{
LPSTR key = MSACM_GetRegistryKey(padid);
HKEY hKey;
DWORD type, size;
if (!key) return FALSE;
padid->aFormatTag = NULL;
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, key, &hKey))
goto errCleanUp;
size = sizeof(padid->cFormatTags);
if (RegQueryValueExA(hKey, "cFormatTags", 0, &type, (void*)&padid->cFormatTags, &size))
goto errCleanUp;
size = sizeof(padid->cFilterTags);
if (RegQueryValueExA(hKey, "cFilterTags", 0, &type, (void*)&padid->cFilterTags, &size))
goto errCleanUp;
size = sizeof(padid->fdwSupport);
if (RegQueryValueExA(hKey, "fdwSupport", 0, &type, (void*)&padid->fdwSupport, &size))
goto errCleanUp;
if (padid->cFormatTags > 0) {
size = padid->cFormatTags * sizeof(padid->aFormatTag[0]);
padid->aFormatTag = HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, size);
if (!padid->aFormatTag) goto errCleanUp;
if (RegQueryValueExA(hKey, "aFormatTagCache", 0, &type, (void*)padid->aFormatTag, &size))
goto errCleanUp;
}
HeapFree(MSACM_hHeap, 0, key);
return TRUE;
errCleanUp:
HeapFree(MSACM_hHeap, 0, key);
HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
padid->aFormatTag = NULL;
RegCloseKey(hKey);
return FALSE;
}
static HRESULT reg_delete_folder(const WCHAR *path, const WCHAR *name)
{
HKEY hroot, hfolder;
DWORD ret;
ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, root, &hroot);
if (ret) return HRESULT_FROM_WIN32(ret);
while (*path == '\\') path++;
ret = RegOpenKeyExW(hroot, path, 0, DELETE, &hfolder);
RegCloseKey(hroot);
while (*name == '\\') name++;
if (ret == ERROR_SUCCESS)
{
ret = RegDeleteKeyW(hfolder, name);
RegCloseKey(hfolder);
}
return HRESULT_FROM_WIN32(ret);
}
/*****************************************************************
* WNetGetCachedPassword [MPR.@] Retrieves password from cache
*
* NOTES
* the stub seems to be wrong:
* arg1: ptr 0x40xxxxxx -> (no string)
* arg2: len 36
* arg3: ptr 0x40xxxxxx -> (no string)
* arg4: ptr 0x40xxxxxx -> 0xc8
* arg5: type? 4
*
* ---- everything below this line might be wrong (js) -----
* RETURNS
* Success: WN_SUCCESS
* Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BAD_VALUE,
* WN_NET_ERROR, WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
*/
DWORD WINAPI WNetGetCachedPassword(
LPSTR pbResource, /* [in] Name of workgroup, computer, or resource */
WORD cbResource, /* [in] Size of name */
LPSTR pbPassword, /* [out] Buffer to receive password */
LPWORD pcbPassword, /* [out] Receives size of password */
BYTE nType) /* [in] Type of password to retrieve */
{
HKEY hkey;
DWORD r, type = 0, sz;
LPSTR valname;
WARN( "(%p(%s), %d, %p, %p, %d): totally insecure\n",
pbResource, debugstr_a(pbResource), cbResource,
pbPassword, pcbPassword, nType );
memset( pbPassword, 0, *pcbPassword);
/* @@ Wine registry key: HKCU\Software\Wine\Wine\Mpr */
r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
if( r )
return WN_ACCESS_DENIED;
valname = MPR_GetValueName( pbResource, cbResource, nType );
if( valname )
{
sz = *pcbPassword;
r = RegQueryValueExA( hkey, valname, 0, &type, (LPBYTE)pbPassword, &sz );
*pcbPassword = sz;
if( r )
r = WN_CANCEL;
else
r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname );
}
else
r = WN_OUT_OF_MEMORY;
return r;
}
static HKEY create_test_entries(void)
{
HKEY hKey;
DWORD ret;
DWORD nExpectedLen1, nExpectedLen2;
SetEnvironmentVariableA("LONGSYSTEMVAR", sEnvvar1);
SetEnvironmentVariableA("FOO", sEnvvar2);
ret = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY, &hKey);
ok( ERROR_SUCCESS == ret, "RegCreateKeyA failed, ret=%u\n", ret);
if (hKey)
{
ok(!RegSetValueExA(hKey,"Test1",0,REG_EXPAND_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
ok(!RegSetValueExA(hKey,"Test2",0,REG_SZ, (LPBYTE) sTestpath1, strlen(sTestpath1)+1), "RegSetValueExA failed\n");
ok(!RegSetValueExA(hKey,"Test3",0,REG_EXPAND_SZ, (LPBYTE) sTestpath2, strlen(sTestpath2)+1), "RegSetValueExA failed\n");
}
nExpLen1 = ExpandEnvironmentStringsA(sTestpath1, sExpTestpath1, sizeof(sExpTestpath1));
nExpLen2 = ExpandEnvironmentStringsA(sTestpath2, sExpTestpath2, sizeof(sExpTestpath2));
nExpectedLen1 = strlen(sTestpath1) - strlen("%LONGSYSTEMVAR%") + strlen(sEnvvar1) + 1;
nExpectedLen2 = strlen(sTestpath2) - strlen("%FOO%") + strlen(sEnvvar2) + 1;
/* ExpandEnvironmentStringsA on NT4 returns 2x the correct result */
trace("sExplen1 = (%d)\n", nExpLen1);
if (nExpectedLen1 != nExpLen1)
trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath1, nExpectedLen1 );
trace("sExplen2 = (%d)\n", nExpLen2);
if (nExpectedLen2 != nExpLen2)
trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath2, nExpectedLen2 );
/* Make sure we carry on with correct values */
nExpLen1 = nExpectedLen1;
nExpLen2 = nExpectedLen2;
return hKey;
}
static unsigned dbg_load_internal_vars(void)
{
HKEY hkey;
DWORD type = REG_DWORD;
DWORD val;
DWORD count = sizeof(val);
int i;
struct dbg_internal_var* div = dbg_internal_vars;
/* initializes internal vars table */
#define INTERNAL_VAR(_var,_val,_ref,_tid) \
div->val = _val; div->name = #_var; div->pval = _ref; \
div->typeid = _tid; div++;
#include "intvar.h"
#undef INTERNAL_VAR
/* @@ Wine registry key: HKCU\Software\Wine\WineDbg */
if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
{
WINE_ERR("Cannot create WineDbg key in registry\n");
return FALSE;
}
for (i = 0; i < DBG_IV_LAST; i++)
{
if (!dbg_internal_vars[i].pval)
{
if (!RegQueryValueEx(hkey, dbg_internal_vars[i].name, 0,
&type, (LPBYTE)&val, &count))
dbg_internal_vars[i].val = val;
dbg_internal_vars[i].pval = &dbg_internal_vars[i].val;
}
}
RegCloseKey(hkey);
/* set up the debug variables for the CPU context */
dbg_context_vars = be_cpu->init_registers(&dbg_context);
return TRUE;
}
static unsigned dbg_save_internal_vars(void)
{
HKEY hkey;
int i;
/* @@ Wine registry key: HKCU\Software\Wine\WineDbg */
if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
{
WINE_ERR("Cannot create WineDbg key in registry\n");
return FALSE;
}
for (i = 0; i < DBG_IV_LAST; i++)
{
/* FIXME: type should be infered from basic type -if any- of intvar */
if (dbg_internal_vars[i].pval == &dbg_internal_vars[i].val)
RegSetValueEx(hkey, dbg_internal_vars[i].name, 0,
REG_DWORD, (const void*)dbg_internal_vars[i].pval,
sizeof(*dbg_internal_vars[i].pval));
}
RegCloseKey(hkey);
return TRUE;
}
/* good2() reverses the bodies in the if statement */
static void good2()
{
if(GLOBAL_CONST_FIVE==5)
{
{
char * keyName = "TEST\\TestKey";
HKEY hKey;
/* FIX: Call RegCreateKeyA() with HKEY_CURRENT_USER */
if (RegCreateKeyA(
HKEY_CURRENT_USER,
keyName,
&hKey) != ERROR_SUCCESS)
{
printLine("Registry key could not be created");
}
else
{
printLine("Registry key created successfully");
RegCloseKey(hKey);
}
}
}
}
static HRESULT reg_create_folder(const WCHAR *path, HKEY *hfolder)
{
HKEY hroot;
DWORD ret, disposition;
ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, root, &hroot);
if (ret) return HRESULT_FROM_WIN32(ret);
while (*path == '\\') path++;
ret = RegCreateKeyExW(hroot, path, 0, NULL, 0, KEY_ALL_ACCESS, NULL, hfolder, &disposition);
if (ret == ERROR_FILE_NOT_FOUND)
ret = ERROR_PATH_NOT_FOUND;
if (ret == ERROR_SUCCESS && disposition == REG_OPENED_EXISTING_KEY)
{
RegCloseKey(*hfolder);
ret = ERROR_ALREADY_EXISTS;
}
RegCloseKey(hroot);
return HRESULT_FROM_WIN32(ret);
}
void CWE272_Least_Privilege_Violation__w32_char_RegCreateKey_13_bad()
{
if(GLOBAL_CONST_FIVE==5)
{
{
char * keyName = "TEST\\TestKey";
HKEY hKey;
/* FLAW: Call RegCreateKeyA() with HKEY_LOCAL_MACHINE violating the least privilege principal */
if (RegCreateKeyA(
HKEY_LOCAL_MACHINE,
keyName,
&hKey) != ERROR_SUCCESS)
{
printLine("Registry key could not be created");
}
else
{
printLine("Registry key created successfully");
RegCloseKey(hKey);
}
}
}
}
Memory_U Credentials_Load(char *pszUser)
{
Memory_U creds={0};
HKEY hKey;
char szKey[MAX_PATH];
sprintf (szKey, "SOFTWARE\\FakeSkype\\%s", pszUser);
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey) == ERROR_SUCCESS)
{
if (RegQueryValueExA(hKey, "Credentials", NULL, NULL, NULL, (LPDWORD)&creds.MsZ) == ERROR_SUCCESS &&
creds.MsZ)
{
if (!(creds.Memory = malloc(creds.MsZ)))
creds.MsZ = 0;
if (creds.Memory && RegQueryValueExA(hKey, "Credentials", NULL, NULL, creds.Memory, (LPDWORD)&creds.MsZ) != ERROR_SUCCESS)
{
free(creds.Memory);
ZeroMemory(&creds, sizeof(creds));
}
}
RegCloseKey(hKey);
}
return creds;
}
static void test_getstring_no_extra(void)
{
LONG ret;
HKEY hkey;
HRESULT hr;
static const CHAR dotWinetest[] = {
'.','w','i','n','e','t','e','s','t',0
};
static const CHAR winetestfile[] = {
'w','i','n','e','t','e','s','t', 'f','i','l','e',0
};
static const CHAR winetestfileAction[] = {
'w','i','n','e','t','e','s','t','f','i','l','e',
'\\','s','h','e','l','l',
'\\','f','o','o',
'\\','c','o','m','m','a','n','d',0
};
static const CHAR action[] = {
'n','o','t','e','p','a','d','.','e','x','e',0
};
CHAR buf[MAX_PATH];
DWORD len = MAX_PATH;
if (!pAssocQueryStringA)
{
win_skip("AssocQueryStringA() is missing\n");
return;
}
buf[0] = '\0';
ret = RegCreateKeyA(HKEY_CLASSES_ROOT, dotWinetest, &hkey);
if (ret != ERROR_SUCCESS) {
skip("failed to create dotWinetest key\n");
return;
}
ret = RegSetValueA(hkey, NULL, REG_SZ, winetestfile, lstrlenA(winetestfile));
RegCloseKey(hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to set dotWinetest key\n");
goto cleanup;
}
ret = RegCreateKeyA(HKEY_CLASSES_ROOT, winetestfileAction, &hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to create winetestfileAction key\n");
goto cleanup;
}
ret = RegSetValueA(hkey, NULL, REG_SZ, action, lstrlenA(action));
RegCloseKey(hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to set winetestfileAction key\n");
goto cleanup;
}
hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, NULL, buf, &len);
ok(hr == S_OK ||
hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP and W2K3 */
"Unexpected result : %08x\n", hr);
hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, "foo", buf, &len);
expect_hr(S_OK, hr);
ok(strstr(buf, action) != NULL,
"got '%s' (Expected result to include 'notepad.exe')\n", buf);
cleanup:
SHDeleteKeyA(HKEY_CLASSES_ROOT, dotWinetest);
SHDeleteKeyA(HKEY_CLASSES_ROOT, winetestfile);
}
static void test_registerOIDInfo(void)
{
static const WCHAR winetestW[] = { 'w','i','n','e','t','e','s','t',0 };
static char test_oid[] = "1.2.3.4.5.6.7.8.9.10";
CRYPT_OID_INFO info1;
const CRYPT_OID_INFO *info2;
HKEY key;
DWORD ret, size, type, value;
char buf[256];
SetLastError(0xdeadbeef);
ret = CryptUnregisterOIDInfo(NULL);
ok(!ret, "should fail\n");
ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError());
memset(&info1, 0, sizeof(info1));
SetLastError(0xdeadbeef);
ret = CryptUnregisterOIDInfo(&info1);
ok(!ret, "should fail\n");
ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError());
info1.cbSize = sizeof(info1);
SetLastError(0xdeadbeef);
ret = CryptUnregisterOIDInfo(&info1);
ok(!ret, "should fail\n");
ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError());
info1.pszOID = test_oid;
SetLastError(0xdeadbeef);
ret = CryptUnregisterOIDInfo(&info1);
ok(!ret, "should fail\n");
ok(GetLastError() == ERROR_FILE_NOT_FOUND, "got %u\n", GetLastError());
info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0);
ok(!info2, "should fail\n");
SetLastError(0xdeadbeef);
/* While it succeeds, the next call does not write anything to the
* registry on Windows because dwGroupId == 0.
*/
ret = CryptRegisterOIDInfo(&info1, 0);
ok(ret, "got %u\n", GetLastError());
ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key);
ok(ret == ERROR_FILE_NOT_FOUND, "got %u\n", ret);
info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0);
ok(!info2, "should fail\n");
info1.pwszName = winetestW;
info1.dwGroupId = CRYPT_HASH_ALG_OID_GROUP_ID;
SetLastError(0xdeadbeef);
ret = CryptRegisterOIDInfo(&info1, CRYPT_INSTALL_OID_INFO_BEFORE_FLAG);
if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
{
skip("Need admin rights\n");
return;
}
ok(ret, "got %u\n", GetLastError());
/* It looks like crypt32 reads the OID info from registry only on load,
* and CryptFindOIDInfo will find the registered OID on next run
*/
info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0);
ok(!info2, "should fail\n");
ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key);
ok(!ret, "got %u\n", ret);
memset(buf, 0, sizeof(buf));
size = sizeof(buf);
ret = RegQueryValueExA(key, "Name", NULL, &type, (BYTE *)buf, &size);
ok(!ret, "got %u\n", ret);
ok(type == REG_SZ, "got %u\n", type);
ok(!strcmp(buf, "winetest"), "got %s\n", buf);
value = 0xdeadbeef;
size = sizeof(value);
ret = RegQueryValueExA(key, "Flags", NULL, &type, (BYTE *)&value, &size);
ok(!ret, "got %u\n", ret);
ok(type == REG_DWORD, "got %u\n", type);
ok(value == 1, "got %u\n", value);
RegCloseKey(key);
CryptUnregisterOIDInfo(&info1);
ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key);
ok(ret == ERROR_FILE_NOT_FOUND, "got %u\n", ret);
}
void cache_system_info()
{
HKEY xhkey=0,hkey;
memset(PF,0,sizeof(PF));
/* choose sensible defaults ...
* FIXME: perhaps overrideable with precompiler flags?
*/
cachedsi.u.s.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
cachedsi.dwPageSize = getpagesize();
/* FIXME: the two entries below should be computed somehow... */
cachedsi.lpMinimumApplicationAddress = (void *)0x00010000;
cachedsi.lpMaximumApplicationAddress = (void *)0x7FFFFFFF;
cachedsi.dwActiveProcessorMask = 1;
cachedsi.dwNumberOfProcessors = 1;
cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
cachedsi.dwAllocationGranularity = 0x10000;
cachedsi.wProcessorLevel = 5; /* 586 */
cachedsi.wProcessorRevision = 0;
cache = TRUE; /* even if there is no more info, we now have a cacheentry */
/* Hmm, reasonable processor feature defaults? */
/* Create these registry keys for all systems
* FPU entry is often empty on Windows, so we don't care either */
if ( (RegCreateKeyA(HKEY_LOCAL_MACHINE,"HARDWARE\\DESCRIPTION\\System\\FloatingPointProcessor",&hkey)!=ERROR_SUCCESS)
|| (RegCreateKeyA(HKEY_LOCAL_MACHINE,"HARDWARE\\DESCRIPTION\\System\\CentralProcessor",&hkey)!=ERROR_SUCCESS) )
{
WARN("Unable to write FPU/CPU info to registry\n");
}
#ifdef linux
{
char buf[20];
char line[200];
FILE *f = fopen ("/proc/cpuinfo", "r");
if (!f)
return;
xhkey = 0;
while (fgets(line,200,f)!=NULL) {
char *s,*value;
/* NOTE: the ':' is the only character we can rely on */
if (!(value = strchr(line,':')))
continue;
/* terminate the valuename */
*value++ = '\0';
/* skip any leading spaces */
while (*value==' ') value++;
if ((s=strchr(value,'\n')))
*s='\0';
if (!strncasecmp (line, "cpu MHz", strlen ("cpu MHz")))
{
float f;
if (sscanf (value, "%f", &f))
{
DWORD iVal = (DWORD)f;
RegSetValueExA (xhkey, "~MHz", 0, REG_DWORD,
(BYTE *)&iVal, 4);
}
continue;
}
/* 2.1 method */
if (!strncasecmp(line, "cpu family",strlen("cpu family"))) {
if (isdigit (value[0])) {
switch (value[0] - '0') {
case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
cachedsi.wProcessorLevel= 3;
break;
case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
cachedsi.wProcessorLevel= 4;
break;
case 5:
case 6: /* PPro/2/3 has same info as P1 */
cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
cachedsi.wProcessorLevel= 5;
break;
case 1: /* two-figure levels */
if (value[1] == '5')
{
cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
cachedsi.wProcessorLevel= 5;
break;
}
/* fall through */
default:
FIXME("unknown cpu family '%s', please report ! (-> setting to 386)\n", value);
break;
}
}
/* set the CPU type of the current processor */
sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
if (xhkey)
RegSetValueExA(xhkey,"Identifier",0,REG_SZ,(BYTE *)buf,
strlen(buf));
continue;
}
/* old 2.0 method */
if (!strncasecmp(line, "cpu",strlen("cpu"))) {
if ( isdigit (value[0]) && value[1] == '8' &&
value[2] == '6' && value[3] == 0
) {
switch (value[0] - '0') {
case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
cachedsi.wProcessorLevel= 3;
break;
case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
cachedsi.wProcessorLevel= 4;
break;
case 5:
case 6: /* PPro/2/3 has same info as P1 */
cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
cachedsi.wProcessorLevel= 5;
break;
default:
FIXME("unknown Linux 2.0 cpu family '%s', please report ! (-> setting to 386)\n", value);
break;
}
}
/* set the CPU type of the current processor
* FIXME: someone reported P4 as being set to
* " Intel(R) Pentium(R) 4 CPU 1500MHz"
* Do we need to do the same ?
* */
sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
if (xhkey)
RegSetValueExA(xhkey,"Identifier",0,REG_SZ,(BYTE *)buf,
strlen(buf));
continue;
}
if (!strncasecmp(line,"fdiv_bug",strlen("fdiv_bug"))) {
if (!strncasecmp(value,"yes",3))
PF[PF_FLOATING_POINT_PRECISION_ERRATA] = TRUE;
continue;
}
if (!strncasecmp(line,"fpu",strlen("fpu"))) {
if (!strncasecmp(value,"no",2))
PF[PF_FLOATING_POINT_EMULATED] = TRUE;
continue;
}
if (!strncasecmp(line,"processor",strlen("processor"))) {
/* processor number counts up... */
unsigned int x;
if (sscanf(value,"%d",&x))
if (x+1>cachedsi.dwNumberOfProcessors)
cachedsi.dwNumberOfProcessors=x+1;
/* Create a new processor subkey on a multiprocessor
* system
*/
sprintf(buf,"%d",x);
if (xhkey)
RegCloseKey(xhkey);
RegCreateKeyA(hkey,buf,&xhkey);
}
if (!strncasecmp(line,"stepping",strlen("stepping"))) {
int x;
if (sscanf(value,"%d",&x))
cachedsi.wProcessorRevision = x;
}
if ( !strncasecmp(line,"flags",strlen("flags")) ||
!strncasecmp(line,"features",strlen("features"))
) {
if (strstr(value,"cx8"))
PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
if (strstr(value,"mmx"))
PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
if (strstr(value,"tsc"))
PF[PF_RDTSC_INSTRUCTION_AVAILABLE] = TRUE;
if (strstr(value,"3dnow"))
PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE;
if (strstr(value,"sse"))
PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE;
if (strstr(value,"sse2"))
PF[PF_XMMI64_INSTRUCTIONS_AVAILABLE] = TRUE;
if (strstr(value,"sse3"))
PF[PF_SSE3_INSTRUCTIONS_AVAILABLE] = TRUE;
}
}
fclose (f);
}
#elif defined(__APPLE__)
{
int iVal, i;
size_t ValSize;
char sVal[256];
long long lVal;
ValSize = sizeof (int);
if (sysctlbyname ("hw.optional.mmx", &iVal, &ValSize, NULL, 0) == 0)
PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = iVal;
ValSize = sizeof (int);
if (sysctlbyname ("hw.optional.sse", &iVal, &ValSize, NULL, 0) == 0)
PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = iVal;
ValSize = sizeof (int);
if (sysctlbyname ("hw.optional.sse2", &iVal, &ValSize, NULL, 0) == 0)
PF[PF_XMMI64_INSTRUCTIONS_AVAILABLE] = iVal;
ValSize = sizeof (int);
if (sysctlbyname ("hw.optional.sse3", &iVal, &ValSize, NULL, 0) == 0)
PF[PF_SSE3_INSTRUCTIONS_AVAILABLE] = iVal;
ValSize = sizeof (int);
if (sysctlbyname ("hw.optional.floatingpoint", &iVal, &ValSize, NULL,
0) == 0)
PF[PF_FLOATING_POINT_EMULATED] = !iVal;
ValSize = sizeof (sVal);
if (sysctlbyname ("machdep.cpu.features", &sVal, &ValSize, NULL, 0) == 0)
{
if (strstr (sVal, "TSC") != NULL)
PF[PF_RDTSC_INSTRUCTION_AVAILABLE] = TRUE;
if (strstr (sVal, "PAE") != NULL)
PF[PF_PAE_ENABLED] = TRUE;
if (strstr (sVal, "CX8") != NULL)
PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
if (strstr (sVal, "CX16") != NULL)
PF[PF_COMPARE_EXCHANGE128] = TRUE;
}
ValSize = sizeof (int);
if (sysctlbyname ("hw.ncpu", &iVal, &ValSize, NULL, 0) == 0)
cachedsi.dwNumberOfProcessors = iVal;
for (i = 0; i < cachedsi.dwNumberOfProcessors; i++)
{
HKEY ProcKey;
int Family = 0, Model = 0, Stepping = 0;
sprintf (sVal, "%d", i);
RegCreateKeyA (hkey, sVal, &ProcKey);
ValSize = sizeof (sVal);
if (sysctlbyname ("machdep.cpu.vendor", &sVal, &ValSize, NULL, 0) == 0)
RegSetValueExA (ProcKey, "VendorIdentifier", 0, REG_SZ, (BYTE*)sVal,
strlen (sVal));
ValSize = sizeof (sVal);
if (sysctlbyname ("machdep.cpu.brand_string", &sVal, &ValSize, NULL,
0) == 0)
RegSetValueExA (ProcKey, "ProcessorNameString", 0, REG_SZ,
(BYTE*)sVal, strlen (sVal));
ValSize = sizeof (int);
sysctlbyname ("machdep.cpu.family", &Family, &ValSize, NULL, 0);
ValSize = sizeof (int);
sysctlbyname ("machdep.cpu.model", &Model, &ValSize, NULL, 0);
ValSize = sizeof (int);
sysctlbyname ("machdep.cpu.stepping", &Stepping, &ValSize, NULL, 0);
sprintf (sVal, "x86 Family %d Model %d Stepping %d",
Family, Model, Stepping);
RegSetValueExA (ProcKey, "Identifier", 0, REG_SZ, (BYTE*)sVal,
strlen (sVal));
cachedsi.wProcessorRevision = Model << 8 | Stepping;
ValSize = sizeof (lVal);
if (sysctlbyname ("hw.cpufrequency", &lVal, &ValSize, NULL, 0) == 0)
{
iVal = (int)(lVal / 1000000);
RegSetValueExA (ProcKey, "~MHz", 0, REG_DWORD, (BYTE *)&iVal, 4);
}
RegCloseKey (ProcKey);
cachedsi.dwActiveProcessorMask |= 1 << i;
}
cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
cachedsi.wProcessorLevel = 5;
}
#else
FIXME("not yet supported on this system !!\n");
/* Fill in some stuff by default on an x86 */
#ifdef __i386__
PF[PF_FLOATING_POINT_EMULATED] = FALSE;
PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
PF[PF_RDTSC_INSTRUCTION_AVAILABLE] = TRUE;
#endif
RegCreateKeyA(hkey,"0",&xhkey);
RegSetValueExA(xhkey,"Identifier",0,REG_SZ,"CPU 386",strlen("CPU 386"));
#endif /* !linux */
if (xhkey)
RegCloseKey(xhkey);
if (hkey)
RegCloseKey(hkey);
TRACE("<- CPU arch %d, res'd %d, pagesize %ld, minappaddr %p, maxappaddr %p, act.cpumask %08lx, "
"numcpus %ld, CPU type %ld, allocgran. %ld, CPU level %d, CPU rev 0x%hx\n",
cachedsi.u.s.wProcessorArchitecture, cachedsi.u.s.wReserved, cachedsi.dwPageSize,
cachedsi.lpMinimumApplicationAddress, cachedsi.lpMaximumApplicationAddress,
cachedsi.dwActiveProcessorMask, cachedsi.dwNumberOfProcessors, cachedsi.dwProcessorType,
cachedsi.dwAllocationGranularity, cachedsi.wProcessorLevel, cachedsi.wProcessorRevision);
}
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_CreateMRUListLazyW(void)
{
static const WCHAR mrutestW[] = {'M','R','U','T','e','s','t',0};
MRUINFOW infoW;
void *named;
HKEY hKey;
HANDLE hMru;
if (!pCreateMRUListLazyW)
{
win_skip("CreateMRUListLazyW entry point not found\n");
return;
}
/* check that it's not exported by name */
named = GetProcAddress(hComctl32, "CreateMRUListLazyW");
ok(named == NULL, "got %p\n", named);
ok(!RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEYA, &hKey),
"Couldn't create test key \"%s\"\n", REG_TEST_KEYA);
infoW.cbSize = sizeof(infoW);
infoW.uMax = 1;
infoW.fFlags = 0;
infoW.lpszSubKey = mrutestW;
infoW.hKey = hKey;
infoW.lpfnCompare = NULL;
hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
ok(hMru != NULL, "got %p\n", hMru);
pFreeMRUList(hMru);
/* smaller size */
infoW.cbSize = sizeof(infoW) - 1;
infoW.uMax = 1;
infoW.fFlags = 0;
infoW.lpszSubKey = mrutestW;
infoW.hKey = hKey;
infoW.lpfnCompare = NULL;
hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
ok(hMru != NULL, "got %p\n", hMru);
pFreeMRUList(hMru);
/* increased size */
infoW.cbSize = sizeof(infoW) + 1;
infoW.uMax = 1;
infoW.fFlags = 0;
infoW.lpszSubKey = mrutestW;
infoW.hKey = hKey;
infoW.lpfnCompare = NULL;
hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
ok(hMru != NULL, "got %p\n", hMru);
pFreeMRUList(hMru);
/* zero size */
infoW.cbSize = 0;
infoW.uMax = 1;
infoW.fFlags = 0;
infoW.lpszSubKey = mrutestW;
infoW.hKey = hKey;
infoW.lpfnCompare = NULL;
hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
ok(hMru != NULL, "got %p\n", hMru);
pFreeMRUList(hMru);
/* NULL hKey */
infoW.cbSize = sizeof(infoW);
infoW.uMax = 1;
infoW.fFlags = 0;
infoW.lpszSubKey = mrutestW;
infoW.hKey = NULL;
infoW.lpfnCompare = NULL;
hMru = pCreateMRUListLazyW(&infoW, 0, 0, 0);
ok(hMru == NULL, "got %p\n", hMru);
RegCloseKey(hKey);
}
/***********************************************************************
* 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 */
}
// RegistryInitialization()
int RegistryKeysInitialization( ) {
LONG res = 0;
INT ret = -1;
HKEY hRootkey = NULL;
HKEY hkey = NULL;
DWORD dwValue = 3;
DWORD dwTypes = 7;
LPSTR dllpath = APP_DLL_PATH;
LPSTR dumpfolder = DUMP_FOLDER;
DWORD dwDumpType = DUMP_TYPE;
DWORD size = 0;
// TODO :: disable registry SYSWOW redirection
__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);
__leave;
}
//printf("[+] Debug :: initRegistrykeys :: root key %s opened successfully\n", ROOT_KEY_PATH);
res = RegCreateKeyA(hRootkey,APPS_KEY_NAME,&hkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegCreateKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
// TODO :: if the key is already created.
__leave;
}
//printf("[+] Debug :: initRegistrykeys :: key %s\\%s created successfully\n",ROOT_KEY_PATH,APPS_KEY_NAME);
// Set keys values (CategoryCount - CategoryMessageFile - EventMessageFile - )
res = RegSetKeyValueA(hkey,NULL,"CategoryCount",REG_DWORD,&dwValue,sizeof(DWORD));
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
size = strnlen(dllpath, MAX_PATH) +1;
res = RegSetKeyValueA(hkey,NULL,"CategoryMessageFile",REG_EXPAND_SZ,dllpath,size);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
res = RegSetKeyValueA(hkey,NULL,"EventMessageFile",REG_EXPAND_SZ,dllpath,size);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res);
__leave;
}
res = RegSetKeyValueA(hkey,NULL,"ParameterMessageFile",REG_EXPAND_SZ,dllpath,size);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
res = RegSetKeyValueA(hkey,NULL,"TypesSupported",REG_DWORD,&dwTypes,sizeof(DWORD));
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
//ret = 0;
}
__finally {
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
if (hkey != NULL) {
RegCloseKey(hkey);
hkey = NULL;
}
}
// Crash report configuration registry key.
__try {
ret = -1;
// Open the main service key
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_CRASH_KEY_PATH_LOCAL_DUMPS, &hRootkey);
if (res != ERROR_SUCCESS) {
if (res == ERROR_FILE_NOT_FOUND) { // if the LocalDumps key is not created, then create it.
//
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_CRASH_KEY_PATH, &hRootkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegOpenKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
__leave;
}
res = RegCreateKeyA(hRootkey,"LocalDumps",&hkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegCreateKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
__leave;
}
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
if (hkey != NULL) {
RegCloseKey(hkey);
hkey = NULL;
}
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_CRASH_KEY_PATH_LOCAL_DUMPS, &hRootkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegistryKeysInitialization :: RegOpenKeyA() failed with error :: %d :: %d\n", GetLastError( ), res);
__leave;
}
}
else {
printf("[-] Error :: RegOpenKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
__leave;
}
}
res = RegCreateKeyA(hRootkey,SVC_KEY_NAME,&hkey);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegCreateKeyA failed with error :: %d :: %d\n", GetLastError( ), res);
__leave;
}
// Set dump folder
size = strnlen(dumpfolder, MAX_PATH) +1;
res = RegSetKeyValueA(hkey,NULL,"DumpFolder",REG_EXPAND_SZ,DUMP_FOLDER,size);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
res = RegSetKeyValueA(hkey,NULL,"DumpType",REG_DWORD,&dwDumpType,sizeof(DWORD));
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegSetKeyValueA failed with error :: %d :: %d\n", GetLastError(),res );
__leave;
}
printf("[+] Debug :: Armadito-av registry keys created successfully\n");
ret = 0;
}
__finally {
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
if (hkey != NULL) {
RegCloseKey(hkey);
hkey = NULL;
}
}
// Driver Registry keys for crash dumps (verification only)
/*
__try {
ret = -1;
// Open the main service key
res = RegOpenKeyA(HKEY_LOCAL_MACHINE, ROOT_DRIVER_CRASH_KEY_PATH, &hRootkey);
if (res != ERROR_SUCCESS) {
__leave;
}
// TODO...
ret = 0;
}
__finally {
if (hRootkey != NULL) {
RegCloseKey(hRootkey);
hRootkey = NULL;
}
if (hkey != NULL) {
RegCloseKey(hkey);
hkey = NULL;
}
}
*/
return ret;
}
static void test_registry(void)
{
static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0};
static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0};
static const WCHAR regszW[] = {'r','e','g','s','z',0};
static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0};
static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0};
static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0};
static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0};
static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
static const WCHAR fooW[] = {'f','o','o',0};
static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0};
static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0};
WCHAR pathW[MAX_PATH];
DWORD dwvalue, type;
VARIANT value, v;
IWshShell3 *sh3;
VARTYPE vartype;
LONG bound;
HRESULT hr;
BSTR name;
HKEY root;
LONG ret;
UINT dim;
hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IWshShell3, (void**)&sh3);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* RegRead() */
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, NULL, &value);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
name = SysAllocString(brokenW);
hr = IWshShell3_RegRead(sh3, name, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
name = SysAllocString(broken2W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9);
ok(ret == 0, "got %d\n", ret);
dwvalue = 10;
ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
dwvalue = 11;
ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
/* REG_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_SZ with embedded NULL */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regsz2W);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_DWORD */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regdwordW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value));
ok(V_I4(&value) == 10, "got %d\n", V_I4(&value));
SysFreeString(name);
/* REG_BINARY */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regbinaryW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 3, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v));
ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v));
VariantClear(&v);
VariantClear(&value);
SysFreeString(name);
/* REG_MULTI_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regmultiszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
SysFreeString(name);
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 1, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
VariantClear(&value);
name = SysAllocString(regsz1W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
VariantClear(&value);
SysFreeString(name);
delete_key(root);
/* RegWrite() */
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
hr = IWshShell3_RegWrite(sh3, name, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
VariantInit(&value);
hr = IWshShell3_RegWrite(sh3, name, &value, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShell3_RegWrite(sh3, name, &value, &value);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
/* type is optional */
V_VT(&v) = VT_ERROR;
V_ERROR(&v) = DISP_E_PARAMNOTFOUND;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* default type is REG_SZ */
V_VT(&value) = VT_I4;
V_I4(&value) = 12;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_BSTR;
V_BSTR(&value) = SysAllocString(regszW);
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
V_VT(&v) = VT_I2;
V_I2(&v) = 1;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
VariantClear(&value);
SysFreeString(name);
delete_key(root);
IWshShell3_Release(sh3);
}
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer
//
/////////////////////////////////////////////////////////////////////////////
STDAPI DllRegisterServer(void)
{
HRESULT hr = E_FAIL;
HKEY hLTMKey = NULL;
HKEY hLTMModuleKey = NULL;
HKEY hRootKey = NULL;
HKEY hModuleKey = NULL;
HKEY hInprocServerKey = NULL;
HKEY hProgIDKey = NULL;
WCHAR* pwszCLSID = NULL;
GlobalModuleData* pModuleData = &g_pThisTestModule->m_gmd;
CHAR szModuleFileName[MAX_NAME_LEN];
CHAR szProgID[MAX_NAME_LEN];
CHAR szModuleName[MAX_NAME_LEN];
CHAR szGuid[MAX_NAME_LEN];
//Unregister First
DllUnregisterServer();
//{...Guid...}
StringFromCLSID(*pModuleData->m_pguidModuleCLSID, &pwszCLSID);
WideCharToMultiByte(CP_ACP, 0, pwszCLSID, -1, szGuid, MAX_NAME_LEN, NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, pModuleData->m_wszModuleName, -1, szModuleName, MAX_NAME_LEN, NULL, NULL);
strcpy(szProgID, "LTMTest.");
strcat(szProgID, szModuleName);
// Step 1: Register our CLSID as an OLE Server
//HKEY_CLASSES_ROOT\CLSID
if(ERROR_SUCCESS == RegCreateKeyA(HKEY_CLASSES_ROOT, "CLSID", &hRootKey))
{
//HKEY_CLASSES_ROOT\CLSID\{..Guid..}
if(ERROR_SUCCESS == RegCreateKeyA(hRootKey, szGuid, &hModuleKey))
{
//{Guid}\Value=ModuleName
RegSetValueEx(hModuleKey, NULL, 0, REG_SZ, (BYTE*)szModuleName, ((DWORD)strlen(szModuleName)) * sizeof(CHAR));
//HKEY_CLASSES_ROOT\CLSID\{..Guid..}\InprocServer32
if(ERROR_SUCCESS == RegCreateKeyA(hModuleKey, "InprocServer32", &hInprocServerKey))
{
//InprocServer32\<>\FileName.dll
GetModuleFileNameA(g_hInstance, szModuleFileName, MAX_NAME_LEN);
RegSetValueExA(hInprocServerKey, NULL, 0, REG_SZ, (BYTE*)szModuleFileName, ((DWORD)strlen(szModuleFileName)) * sizeof(CHAR));
//InprocServer32\ThreadingModel\Both
RegSetValueExA(hInprocServerKey, "ThreadingModel", 0, REG_SZ, (BYTE*)"Both", ((DWORD)strlen("Both")) * sizeof(CHAR));
RegCloseKey(hInprocServerKey);
hr = S_OK;
}
//HKEY_CLASSES_ROOT\CLSID\{..Guid..}\ProgID
if(ERROR_SUCCESS == RegCreateKeyA(hModuleKey, "ProgID", &hProgIDKey))
{
RegSetValueExA(hProgIDKey, NULL, 0, REG_SZ, (BYTE*)szProgID, ((DWORD)strlen(szProgID)) * sizeof(CHAR));
RegCloseKey(hProgIDKey);
}
RegCloseKey(hModuleKey);
}
RegCloseKey(hRootKey);
}
//HKEY_CLASSES_ROOT\ProgID
if(ERROR_SUCCESS == RegCreateKeyA(HKEY_CLASSES_ROOT, szProgID, &hRootKey))
{
//HKEY_CLASSES_ROOT\ProgID\CLSID
if(ERROR_SUCCESS == RegCreateKeyA(hRootKey, "CLSID", &hModuleKey))
{
//ProgID\CLSID\{Guid}
RegSetValueExA(hModuleKey, NULL, 0, REG_SZ, (BYTE*)szGuid, ((DWORD)strlen(szGuid)) * sizeof(CHAR));
RegCloseKey(hModuleKey);
hr = S_OK;
}
RegCloseKey(hRootKey);
}
//Step 2: Register our test in the LTM Test Location
//So LTM is aware of a new test module is available for running...
//Obtain the Key for HKEY_LOCAL_MACHINE\"SOFTWARE\Microsoft\LTM\Test Modules"
if(ERROR_SUCCESS == RegCreateKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\LTM\\Test Modules", &hLTMKey))
{
//Obtain the Key for "...\{Guid}
if(ERROR_SUCCESS == RegCreateKeyA(hLTMKey, szGuid, &hLTMModuleKey))
{
//ModuleName
RegSetValueExA(hLTMModuleKey, NULL, 0, REG_SZ, (BYTE*)szModuleName, ((DWORD)strlen(szModuleName)) * sizeof(CHAR));
}
}
RegCloseKey(hLTMKey);
RegCloseKey(hLTMModuleKey);
CoTaskMemFree(pwszCLSID);
return hr;
}
