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