void ConfigParser::ParseRegistry(CmdLineArgsParser &parser)
{
#ifdef _WIN32
HKEY hk;
bool includeUserHive = true;
if (NOERROR == RegOpenKeyExW(HKEY_LOCAL_MACHINE, JsUtil::ExternalApi::GetFeatureKeyName(), 0, KEY_READ, &hk))
{
DWORD dwValue;
DWORD dwSize = sizeof(dwValue);
ParseRegistryKey(hk, parser);
// HKLM can prevent user config from being read.
if (NOERROR == RegGetValueW(hk, nullptr, _u("AllowUserConfig"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize) && dwValue == 0)
{
includeUserHive = false;
}
RegCloseKey(hk);
}
if (includeUserHive && NOERROR == RegOpenKeyExW(HKEY_CURRENT_USER, JsUtil::ExternalApi::GetFeatureKeyName(), 0, KEY_READ, &hk))
{
ParseRegistryKey(hk, parser);
RegCloseKey(hk);
}
#endif // _WIN32
}
/*******************************************************************************
* GAMEUX_LoadRegistryString
*
* Helper function, loads string from registry value and allocates buffer for it
*/
static HRESULT GAMEUX_LoadRegistryString(HKEY hRootKey,
LPCWSTR lpRegistryKey,
LPCWSTR lpRegistryValue,
LPWSTR* lpValue)
{
HRESULT hr;
DWORD dwSize;
*lpValue = NULL;
hr = HRESULT_FROM_WIN32(RegGetValueW(hRootKey, lpRegistryKey, lpRegistryValue,
RRF_RT_REG_SZ, NULL, NULL, &dwSize));
if(SUCCEEDED(hr))
{
*lpValue = HeapAlloc(GetProcessHeap(), 0, dwSize);
if(!*lpValue)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
hr = HRESULT_FROM_WIN32(RegGetValueW(hRootKey, lpRegistryKey, lpRegistryValue,
RRF_RT_REG_SZ, NULL, *lpValue, &dwSize));
return hr;
}
/// <summary>
/// Checks whether application is registered for autostart
/// </summary>
/// <param name="pszAppName">Application name</param>
/// <returns></returns>
BOOL isProgramRegisteredForStartup(PCWSTR pszAppName)
{
HKEY hKey = NULL;
LONG lResult = 0;
BOOL fSuccess = TRUE;
DWORD dwRegType = REG_SZ;
wchar_t szPathToExe[MAX_PATH] = {};
DWORD dwSize = sizeof(szPathToExe);
lResult = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_READ, &hKey);
fSuccess = (lResult == 0);
if (fSuccess)
{
lResult = RegGetValueW(hKey, NULL, pszAppName, RRF_RT_REG_SZ, &dwRegType, szPathToExe, &dwSize);
fSuccess = (lResult == 0);
}
if (fSuccess)
{
fSuccess = (wcslen(szPathToExe) > 0) ? TRUE : FALSE;
}
if (hKey != NULL)
{
RegCloseKey(hKey);
hKey = NULL;
}
return fSuccess;
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpszCmdLine, int nCmdShow)
{
LPWSTR *pszArglist, szCommandLine;
int nArgs, nApp;
STARTUPINFOW si;
PROCESS_INFORMATION pi;
WCHAR szBuf[1024];
DWORD dwLen = sizeof(szBuf);
nApp = (IsUserAdmin() != 0);
RegGetValueW(HKEY_LOCAL_MACHINE, lpszKey[nApp][0], lpszKey[nApp][1], RRF_RT_REG_SZ, 0, szBuf, &dwLen);
pszArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
if(nArgs > 3) nArgs = 3;
pszArglist[0] = szBuf;
FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_FROM_STRING,
lpszAppSpec[nArgs-1][nApp],
0,
0,
(LPWSTR)&szCommandLine,
1024,
(void*)pszArglist
);
OutputDebugStringW(szCommandLine);
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
CreateProcessW(NULL, szCommandLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
LocalFree(szCommandLine);
LocalFree(pszArglist);
return IsUserAdmin();
}
static
DWORD
LwSmRegistryReadDword(
HANDLE hReg,
HKEY pRootKey,
PCWSTR pwszParentKey,
PCWSTR pwszValueName,
PDWORD pdwValue
)
{
DWORD dwError = 0;
DWORD dwSize = sizeof(*pdwValue) + 1;
DWORD dwType = 0;
dwError = RegGetValueW(
hReg,
pRootKey,
pwszParentKey,
pwszValueName,
RRF_RT_REG_DWORD,
&dwType,
(PBYTE) pdwValue,
&dwSize);
BAIL_ON_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
void InitIconOverlays(void)
{
HKEY hKey;
DWORD dwIndex, dwResult, dwSize;
WCHAR szName[MAX_PATH];
WCHAR szValue[100];
CLSID clsid;
IShellIconOverlayIdentifier * Overlay;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return;
if (RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &dwResult, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
Handlers = (IShellIconOverlayIdentifier **)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwResult * sizeof(IShellIconOverlayIdentifier*));
if (!Handlers)
{
RegCloseKey(hKey);
return;
}
dwIndex = 0;
CoInitialize(0);
do
{
dwSize = sizeof(szName) / sizeof(WCHAR);
dwResult = RegEnumKeyExW(hKey, dwIndex, szName, &dwSize, NULL, NULL, NULL, NULL);
if (dwResult == ERROR_NO_MORE_ITEMS)
break;
if (dwResult == ERROR_SUCCESS)
{
dwSize = sizeof(szValue) / sizeof(WCHAR);
if (RegGetValueW(hKey, szName, NULL, RRF_RT_REG_SZ, NULL, szValue, &dwSize) == ERROR_SUCCESS)
{
CLSIDFromString(szValue, &clsid);
dwResult = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID*)&Overlay);
if (dwResult == S_OK)
{
Handlers[NumIconOverlayHandlers] = Overlay;
NumIconOverlayHandlers++;
}
}
}
dwIndex++;
} while(1);
RegCloseKey(hKey);
}
void AddFSClassKeysToArray(PCUITEMID_CHILD pidl, HKEY* array, UINT* cKeys)
{
if (_ILIsValue(pidl))
{
FileStructW* pFileData = _ILGetFileStructW(pidl);
LPWSTR extension = PathFindExtension(pFileData->wszName);
if (extension)
{
AddClassKeyToArray(extension, array, cKeys);
WCHAR wszClass[MAX_PATH], wszClass2[MAX_PATH];
DWORD dwSize = sizeof(wszClass);
if (RegGetValueW(HKEY_CLASSES_ROOT, extension, NULL, RRF_RT_REG_SZ, NULL, wszClass, &dwSize) == ERROR_SUCCESS)
{
swprintf(wszClass2, L"%s//%s", extension, wszClass);
AddClassKeyToArray(wszClass, array, cKeys);
AddClassKeyToArray(wszClass2, array, cKeys);
}
swprintf(wszClass2, L"SystemFileAssociations//%s", extension);
AddClassKeyToArray(wszClass2, array, cKeys);
if (RegGetValueW(HKEY_CLASSES_ROOT, extension, L"PerceivedType ", RRF_RT_REG_SZ, NULL, wszClass, &dwSize) == ERROR_SUCCESS)
{
swprintf(wszClass2, L"SystemFileAssociations//%s", wszClass);
AddClassKeyToArray(wszClass2, array, cKeys);
}
}
AddClassKeyToArray(L"AllFilesystemObjects", array, cKeys);
AddClassKeyToArray(L"*", array, cKeys);
}
else if (_ILIsFolder(pidl))
{
AddClassKeyToArray(L"AllFilesystemObjects", array, cKeys);
AddClassKeyToArray(L"Directory", array, cKeys);
AddClassKeyToArray(L"Folder", array, cKeys);
}
else
{
ERR("Got non FS pidl\n");
}
}
/*******************************************************************************
* GAMEUX_getAppIdFromGDFPath
*
* Loads application identifier associated with given GDF binary.
* Routine reads identifier from registry, so will fail if game
* is not registered.
*
* Parameters:
* GDFBinaryPath [I] path to gdf binary
* lpApplicationId [O] place to store application id.
* must be at least 49 characters
* to store guid and termination 0
*/
static HRESULT GAMEUX_getAppIdFromGDFPath(
LPCWSTR GDFBinaryPath,
LPWSTR lpApplicationId)
{
static const WCHAR sApplicationId[] =
{'A','p','p','l','i','c','a','t','i','o','n','I','d',0};
HRESULT hr;
GAME_INSTALL_SCOPE installScope;
GUID instanceId;
LPWSTR lpRegistryPath = NULL;
HKEY hKey;
DWORD dwLength = 49*sizeof(WCHAR);/* place for GUID */
TRACE("(%s, %p)\n", debugstr_w(GDFBinaryPath), lpApplicationId);
if(!GDFBinaryPath)
return E_INVALIDARG;
installScope = GIS_CURRENT_USER;
hr = GAMEUX_FindGameInstanceId(GDFBinaryPath, installScope, &instanceId);
if(hr == S_FALSE)
{
installScope = GIS_ALL_USERS;
hr = GAMEUX_FindGameInstanceId(GDFBinaryPath, installScope, &instanceId);
}
if(hr == S_FALSE)
/* game not registered, so statistics cannot be used */
hr = E_FAIL;
if(SUCCEEDED(hr))
/* game is registered, let's read it's application id from registry */
hr = GAMEUX_buildGameRegistryPath(installScope, &instanceId, &lpRegistryPath);
if(SUCCEEDED(hr)) {
hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE,
lpRegistryPath, 0, KEY_READ | KEY_WOW64_64KEY, &hKey));
if(SUCCEEDED(hr)) {
hr = HRESULT_FROM_WIN32(RegGetValueW(hKey,
NULL, sApplicationId, RRF_RT_REG_SZ,
NULL, lpApplicationId, &dwLength));
RegCloseKey(hKey);
}
}
HeapFree(GetProcessHeap(), 0, lpRegistryPath);
TRACE("found app id: %s, return: %#x\n", debugstr_w(lpApplicationId), hr);
return hr;
}
static HRESULT get_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, VARIANT *value, VARIANT *retval )
{
HRESULT hr = S_OK;
BSTR str = NULL;
DWORD size;
LONG res;
TRACE("%p, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name));
if ((res = RegGetValueW( root, subkey, name, RRF_RT_REG_SZ, NULL, NULL, &size ))) goto done;
if (!(str = SysAllocStringLen( NULL, size / sizeof(WCHAR) - 1 )))
{
hr = E_OUTOFMEMORY;
goto done;
}
if (!(res = RegGetValueW( root, subkey, name, RRF_RT_REG_SZ, NULL, str, &size )))
set_variant( VT_BSTR, 0, str, value );
done:
set_variant( VT_UI4, res, NULL, retval );
if (res) SysFreeString( str );
return hr;
}
string GetReplayAppFilename()
{
HMODULE hModule = NULL;
GetModuleHandleEx(
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCTSTR)&dllLocator,
&hModule);
wchar_t curFile[512] = {0};
GetModuleFileNameW(hModule, curFile, 511);
string path = StringFormat::Wide2UTF8(wstring(curFile));
path = dirname(path);
string exe = path + "/renderdocui.exe";
FILE *f = FileIO::fopen(exe.c_str(), "rb");
if(f)
{
FileIO::fclose(f);
return exe;
}
// if renderdocui.exe doesn't live in the same dir, we must be in x86/
// so look one up the tree.
exe = path + "/../renderdocui.exe";
f = FileIO::fopen(exe.c_str(), "rb");
if(f)
{
FileIO::fclose(f);
return exe;
}
// if we didn't find the exe at all, we must not be in a standard
// distributed renderdoc package. On windows we can check in the registry
// to try and find the installed path.
DWORD type = 0;
DWORD dataSize = sizeof(curFile);
RDCEraseEl(curFile);
RegGetValueW(HKEY_CLASSES_ROOT, L"RenderDoc.RDCCapture.1\\DefaultIcon", NULL, RRF_RT_ANY,
&type, (void *)curFile, &dataSize);
if(type == REG_EXPAND_SZ || type == REG_SZ)
{
return StringFormat::Wide2UTF8(wstring(curFile));
}
return "";
}
static DWORD FspNpGetCredentialsKind(PWSTR RemoteName, PDWORD PCredentialsKind)
{
HKEY RegKey = 0;
DWORD NpResult, RegSize;
DWORD Credentials;
PWSTR ClassName, InstanceName;
ULONG ClassNameLen, InstanceNameLen;
WCHAR ClassNameBuf[sizeof(((FSP_FSCTL_VOLUME_PARAMS *)0)->Prefix) / sizeof(WCHAR)];
*PCredentialsKind = FSP_NP_CREDENTIALS_NONE;
if (!FspNpParseRemoteName(RemoteName,
&ClassName, &ClassNameLen, &InstanceName, &InstanceNameLen))
return WN_BAD_NETNAME;
if (ClassNameLen > sizeof ClassNameBuf / sizeof ClassNameBuf[0] - 1)
ClassNameLen = sizeof ClassNameBuf / sizeof ClassNameBuf[0] - 1;
memcpy(ClassNameBuf, ClassName, ClassNameLen * sizeof(WCHAR));
ClassNameBuf[ClassNameLen] = '\0';
NpResult = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"" LAUNCHER_REGKEY, 0, KEY_READ, &RegKey);
if (ERROR_SUCCESS != NpResult)
goto exit;
RegSize = sizeof Credentials;
Credentials = 0; /* default is NO credentials */
NpResult = RegGetValueW(RegKey, ClassNameBuf, L"Credentials", RRF_RT_REG_DWORD, 0,
&Credentials, &RegSize);
if (ERROR_SUCCESS != NpResult && ERROR_FILE_NOT_FOUND != NpResult)
goto exit;
switch (Credentials)
{
case FSP_NP_CREDENTIALS_NONE:
case FSP_NP_CREDENTIALS_PASSWORD:
case FSP_NP_CREDENTIALS_USERPASS:
*PCredentialsKind = Credentials;
break;
}
NpResult = ERROR_SUCCESS;
exit:
if (0 != RegKey)
RegCloseKey(RegKey);
return NpResult;
}
static
DWORD
LwSmRegistryReadString(
HANDLE hReg,
HKEY pRootKey,
PCWSTR pwszParentKey,
PCWSTR pwszValueName,
PWSTR* ppwszValue
)
{
DWORD dwError = 0;
WCHAR wszValue[MAX_VALUE_LENGTH];
DWORD dwSize = 0;
DWORD dwType = 0;
PWSTR pwszValue = NULL;
memset(wszValue, 0, sizeof(wszValue));
dwSize = sizeof(wszValue);
dwError = RegGetValueW(
hReg,
pRootKey,
pwszParentKey,
pwszValueName,
RRF_RT_REG_SZ,
&dwType,
wszValue,
&dwSize);
BAIL_ON_ERROR(dwError);
dwError = LwAllocateMemory(dwSize + sizeof(WCHAR), OUT_PPVOID(&pwszValue));
BAIL_ON_ERROR(dwError);
memcpy(pwszValue, wszValue, dwSize);
*ppwszValue = pwszValue;
cleanup:
return dwError;
error:
*ppwszValue = NULL;
goto cleanup;
}
static void load_settings(HTMLDocumentObj *doc)
{
nsIMarkupDocumentViewer *markup_document_viewer;
nsIContentViewer *content_viewer;
nsIDocShell *doc_shell;
HKEY settings_key;
DWORD val, size;
LONG res;
nsresult nsres;
static const WCHAR ie_keyW[] = {
'S','O','F','T','W','A','R','E','\\',
'M','i','c','r','o','s','o','f','t','\\',
'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',0};
static const WCHAR zoomW[] = {'Z','o','o','m',0};
static const WCHAR zoom_factorW[] = {'Z','o','o','m','F','a','c','t','o','r',0};
res = RegOpenKeyW(HKEY_CURRENT_USER, ie_keyW, &settings_key);
if(res != ERROR_SUCCESS)
return;
size = sizeof(val);
res = RegGetValueW(settings_key, zoomW, zoom_factorW, RRF_RT_REG_DWORD, NULL, &val, &size);
RegCloseKey(settings_key);
if(res != ERROR_SUCCESS)
return;
TRACE("Setting ZoomFactor to %u\n", val);
nsres = get_nsinterface((nsISupports*)doc->nscontainer->navigation, &IID_nsIDocShell, (void**)&doc_shell);
assert(nsres == NS_OK);
nsres = nsIDocShell_GetContentViewer(doc_shell, &content_viewer);
assert(nsres == NS_OK && content_viewer);
nsres = nsISupports_QueryInterface(content_viewer, &IID_nsIMarkupDocumentViewer, (void**)&markup_document_viewer);
nsISupports_Release(content_viewer);
assert(nsres == NS_OK);
nsres = nsIMarkupDocumentViewer_SetFullZoom(markup_document_viewer, (float)val/100000);
if(NS_FAILED(nsres))
ERR("SetFullZoom failed: %08x\n", nsres);
nsIDocShell_Release(doc_shell);
}
bool VisualStudioExists(const wchar_t *key)
{
HKEY hInst = nullptr;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, VSREG_KEY, 0, KEY_READ, &hInst) != ERROR_SUCCESS) {
/// Not Found Key
return false;
}
DWORD type = REG_SZ;
WCHAR buffer[4096];
DWORD dwSize = sizeof(buffer);
if (RegGetValueW(hInst, nullptr, key, RRF_RT_REG_SZ, &type,
buffer, &dwSize) != ERROR_SUCCESS) {
RegCloseKey(hInst);
return false;
}
RegCloseKey(hInst);
return true;
}
static INT
IsNamespaceExtensionHidden(const WCHAR *iid)
{
DWORD Result, dwResult;
dwResult = sizeof(DWORD);
if (RegGetValueW(HKEY_CURRENT_USER, /* FIXME use NewStartPanel when activated */
ClassicStartMenuW,
iid,
RRF_RT_DWORD,
NULL,
&Result,
&dwResult) != ERROR_SUCCESS)
{
return -1;
}
return Result;
}
BOOL Injector::checkStartingProcess(PCWSTR exeName)
{
HKEY hKey = NULL;
DWORD regType = REG_SZ;
wchar_t sizePath[MAX_PATH] = {};
DWORD len = sizeof(sizePath);
BOOL check = FALSE;
if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_READ, &hKey) == 0)
{
if (RegGetValueW(hKey, NULL, exeName, RRF_RT_REG_SZ, ®Type, sizePath, &len) == ERROR_SUCCESS)
check = TRUE;
else
check = FALSE;
}
if (hKey != NULL)
RegCloseKey(hKey);
return (check);
}
BOOL
CNetConnectionPropertyUi::GetDeviceInstanceID(
OUT LPOLESTR *DeviceInstanceID)
{
LPOLESTR pStr, pResult;
HKEY hKey;
DWORD dwInstanceID;
WCHAR szKeyName[2*MAX_PATH];
WCHAR szInstanceID[2*MAX_PATH];
if (StringFromCLSID(pProperties->guidId, &pStr) != ERROR_SUCCESS)
{
// failed to convert guid to string
return FALSE;
}
StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", pStr);
CoTaskMemFree(pStr);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
// failed to open key
return FALSE;
}
dwInstanceID = sizeof(szInstanceID);
if (RegGetValueW(hKey, NULL, L"PnpInstanceId", RRF_RT_REG_SZ, NULL, (PVOID)szInstanceID, &dwInstanceID) == ERROR_SUCCESS)
{
szInstanceID[MAX_PATH-1] = L'\0';
pResult = (LPOLESTR)CoTaskMemAlloc((wcslen(szInstanceID) + 1) * sizeof(WCHAR));
if (pResult != 0)
{
wcscpy(pResult, szInstanceID);
*DeviceInstanceID = pResult;
RegCloseKey(hKey);
return TRUE;
}
}
RegCloseKey(hKey);
return FALSE;
}
static UINT
LoadPropSheetHandlers(LPCWSTR pwszPath, PROPSHEETHEADERW *pHeader, UINT cMaxPages, HPSXA *phpsxa, IDataObject *pDataObj)
{
WCHAR wszBuf[MAX_PATH];
UINT cPages = 0, i = 0;
LPWSTR pwszFilename = PathFindFileNameW(pwszPath);
BOOL bDir = PathIsDirectoryW(pwszPath);
if (bDir)
{
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Folder", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Directory", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
else
{
/* Load property sheet handlers from ext key */
LPWSTR pwszExt = PathFindExtensionW(pwszFilename);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, pwszExt, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
/* Load property sheet handlers from prog id key */
DWORD cbBuf = sizeof(wszBuf);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &cbBuf) == ERROR_SUCCESS)
{
TRACE("EnumPropSheetExt wszBuf %s, pwszExt %s\n", debugstr_w(wszBuf), debugstr_w(pwszExt));
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszBuf, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
/* Add property sheet handlers from "*" key */
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"*", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
return cPages;
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
g_hInst = hModule;
if (m_menuImage == NULL)
m_menuImage = LoadImageW(g_hInst, MAKEINTRESOURCEW(IDB_ICON), IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS);
if (m_exePath[0] == 0)
{
HKEY hKey;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\RyuaNerin", NULL, KEY_READ, &hKey) == NO_ERROR)
{
DWORD len = sizeof(m_exePath);
RegGetValueW(hKey, NULL, L"TiX", REG_SZ, NULL, reinterpret_cast<LPBYTE>(&m_exePath), &len);
DWORD type = REG_DWORD;
len = sizeof(m_option);
RegQueryValueExW(hKey, L"TiX-Option", NULL, &type, (LPBYTE)&m_option, &len);
DebugLog(L"Get ExePath [%d] %s", len, m_exePath);
DebugLog(L"Get Option [%d]", m_option);
RegCloseKey(hKey);
}
}
DisableThreadLibraryCalls(hModule);
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
static void load_settings(HTMLDocumentObj *doc)
{
HKEY settings_key;
DWORD val, size;
LONG res;
static const WCHAR ie_keyW[] = {
'S','O','F','T','W','A','R','E','\\',
'M','i','c','r','o','s','o','f','t','\\',
'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',0};
static const WCHAR zoomW[] = {'Z','o','o','m',0};
static const WCHAR zoom_factorW[] = {'Z','o','o','m','F','a','c','t','o','r',0};
res = RegOpenKeyW(HKEY_CURRENT_USER, ie_keyW, &settings_key);
if(res != ERROR_SUCCESS)
return;
size = sizeof(val);
res = RegGetValueW(settings_key, zoomW, zoom_factorW, RRF_RT_REG_DWORD, NULL, &val, &size);
RegCloseKey(settings_key);
if(res == ERROR_SUCCESS)
set_viewer_zoom(doc->nscontainer, (float)val/100000);
}
bool registryGetAutostart() {
HKEY hkey = NULL;
if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, subkey_run, 0, NULL, 0,
KEY_READ, NULL, &hkey, NULL) != ERROR_SUCCESS) {
std::cout << "Error: couldn't create registry key handle" << std::endl;
return false;
}
wchar_t registry_exe_path[MAX_PATH] = {};
DWORD size = sizeof(registry_exe_path);
if (RegGetValueW(hkey, NULL, TEXT("ffxiv-camhack"), RRF_RT_REG_SZ,
NULL, registry_exe_path, &size) != ERROR_SUCCESS) {
//std::cout << "Error: couldn't get key value" << std::endl;
RegCloseKey(hkey);
return false;
}
RegCloseKey(hkey);
//TODO: function returning exe path
wchar_t exe_path[MAX_PATH];
DWORD path_len = GetModuleFileNameW(NULL, exe_path, MAX_PATH - 1);
if (path_len == 0) {
std::cout << "Error: couldn't get file path" << std::endl;
RegCloseKey(hkey);
return false;
}
exe_path[path_len] = 0;
return (wcscmp(registry_exe_path, exe_path) == 0);
}
static BOOL get_default_enable_shell( const WCHAR *name )
{
static const WCHAR desktop_keyW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
'E','x','p','l','o','r','e','r','\\',
'D','e','s','k','t','o','p','s',0};
static const WCHAR enable_shellW[] = {'E','n','a','b','l','e','S','h','e','l','l',0};
static const WCHAR shellW[] = {'s','h','e','l','l',0};
HKEY hkey;
BOOL found = FALSE;
BOOL result;
DWORD size = sizeof(result);
/* @@ Wine registry key: HKCU\Software\Wine\Explorer\Desktops */
if (!RegOpenKeyW( HKEY_CURRENT_USER, desktop_keyW, &hkey ))
{
if (!RegGetValueW( hkey, name, enable_shellW, RRF_RT_REG_DWORD, NULL, &result, &size ))
found = TRUE;
RegCloseKey( hkey );
}
/* Default off, except for the magic desktop name "shell" */
if (!found)
result = (lstrcmpiW( name, shellW ) == 0);
return result;
}
void ConfigParser::ParseRegistryKey(HKEY hk, CmdLineArgsParser &parser)
{
#ifdef _WIN32
DWORD dwSize;
DWORD dwValue;
#if ENABLE_DEBUG_CONFIG_OPTIONS
char16 regBuffer[MaxRegSize];
dwSize = sizeof(regBuffer);
if (NOERROR == RegGetValueW(hk, nullptr, _u("JScript9"), RRF_RT_REG_SZ, nullptr, (LPBYTE)regBuffer, &dwSize))
{
LPWSTR regValue = regBuffer, nextValue = nullptr;
regValue = wcstok_s(regBuffer, _u(" "), &nextValue);
while (regValue != nullptr)
{
int err = 0;
if ((err = parser.Parse(regValue)) != 0)
{
break;
}
regValue = wcstok_s(nullptr, _u(" "), &nextValue);
}
}
#endif
// MemSpect - This setting controls whether MemSpect instrumentation is enabled.
// The value is treated as a bit field with the following bits:
// 0x01 - Track Arena memory
// 0x02 - Track Recycler memory
// 0x04 - Track Page allocations
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == ::RegGetValueW(hk, nullptr, _u("MemSpect"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
if (dwValue & 0x01)
{
ArenaMemoryTracking::Activate();
}
if (dwValue & 0x02)
{
RecyclerMemoryTracking::Activate();
}
if (dwValue & 0x04)
{
PageTracking::Activate();
}
}
// JScriptJIT - This setting controls the JIT/interpretation of Jscript code.
// The legal values are as follows:
// 1- Force JIT code to be generated for everything.
// 2- Force interpretation without profiling (turn off JIT)
// 3- Default
// 4- Interpreter, simple JIT, and full JIT run a predetermined number of times. Requires >= 3 calls to functions.
// 5- Interpreter, simple JIT, and full JIT run a predetermined number of times. Requires >= 4 calls to functions.
// 6- Force interpretation with profiling
//
// This reg key is present in released builds. The QA team's tests use these switches to
// get reliable JIT coverage in servicing runs done by IE/Windows. Because this reg key is
// released, the number of possible values is limited to reduce surface area.
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == RegGetValueW(hk, nullptr, _u("JScriptJIT"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
Js::ConfigFlagsTable &configFlags = Js::Configuration::Global.flags;
switch (dwValue)
{
case 1:
configFlags.Enable(Js::ForceNativeFlag);
configFlags.ForceNative = true;
break;
case 6:
configFlags.Enable(Js::ForceDynamicProfileFlag);
configFlags.ForceDynamicProfile = true;
// fall through
case 2:
configFlags.Enable(Js::NoNativeFlag);
configFlags.NoNative = true;
break;
case 3:
break;
case 4:
configFlags.Enable(Js::AutoProfilingInterpreter0LimitFlag);
configFlags.Enable(Js::ProfilingInterpreter0LimitFlag);
configFlags.Enable(Js::AutoProfilingInterpreter1LimitFlag);
configFlags.Enable(Js::SimpleJitLimitFlag);
configFlags.Enable(Js::ProfilingInterpreter1LimitFlag);
configFlags.Enable(Js::EnforceExecutionModeLimitsFlag);
configFlags.AutoProfilingInterpreter0Limit = 0;
configFlags.AutoProfilingInterpreter1Limit = 0;
if (
#if ENABLE_DEBUG_CONFIG_OPTIONS
configFlags.NewSimpleJit
#else
DEFAULT_CONFIG_NewSimpleJit
#endif
)
{
configFlags.ProfilingInterpreter0Limit = 0;
configFlags.SimpleJitLimit = 0;
configFlags.ProfilingInterpreter1Limit = 2;
}
else
{
configFlags.ProfilingInterpreter0Limit = 1;
configFlags.SimpleJitLimit = 1;
configFlags.ProfilingInterpreter1Limit = 0;
}
configFlags.EnforceExecutionModeLimits = true;
break;
case 5:
configFlags.Enable(Js::AutoProfilingInterpreter0LimitFlag);
configFlags.Enable(Js::ProfilingInterpreter0LimitFlag);
configFlags.Enable(Js::AutoProfilingInterpreter1LimitFlag);
configFlags.Enable(Js::SimpleJitLimitFlag);
configFlags.Enable(Js::ProfilingInterpreter1LimitFlag);
configFlags.Enable(Js::EnforceExecutionModeLimitsFlag);
configFlags.AutoProfilingInterpreter0Limit = 0;
configFlags.ProfilingInterpreter0Limit = 0;
configFlags.AutoProfilingInterpreter1Limit = 1;
if (
#if ENABLE_DEBUG_CONFIG_OPTIONS
configFlags.NewSimpleJit
#else
DEFAULT_CONFIG_NewSimpleJit
#endif
)
{
configFlags.SimpleJitLimit = 0;
configFlags.ProfilingInterpreter1Limit = 2;
}
else
{
configFlags.SimpleJitLimit = 2;
configFlags.ProfilingInterpreter1Limit = 0;
}
configFlags.EnforceExecutionModeLimits = true;
break;
}
}
// EnumerationCompat
// This setting allows disabling a couple of changes to enumeration:
// - A change that causes deleted property indexes to be reused for new properties, thereby changing the order in which
// properties are enumerated
// - A change that creates a true snapshot of the type just before enumeration, and enumerating only those properties. A
// property that was deleted before enumeration and is added back during enumeration will not be enumerated.
// Values:
// 0 - Default
// 1 - Compatibility mode for enumeration order (disable changes described above)
// This FCK does not apply to WWAs. WWAs should use the RC compat mode to disable these changes.
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == RegGetValueW(hk, nullptr, _u("EnumerationCompat"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
if(dwValue == 1)
{
Js::Configuration::Global.flags.EnumerationCompat = true;
}
}
#ifdef ENABLE_PROJECTION
// FailFastIfDisconnectedDelegate
// This setting allows enabling fail fast if the delegate invoked is disconnected
// 0 - Default return the error RPC_E_DISCONNECTED if disconnected delegate is invoked
// 1 - Fail fast if disconnected delegate
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == RegGetValueW(hk, nullptr, _u("FailFastIfDisconnectedDelegate"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
if(dwValue == 1)
{
Js::Configuration::Global.flags.FailFastIfDisconnectedDelegate = true;
}
}
#endif
// ES6 feature control
// This setting allows enabling\disabling es6 features
// 0 - Enable ES6 flag - Also default behavior
// 1 - Disable ES6 flag
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == RegGetValueW(hk, nullptr, _u("DisableES6"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
Js::ConfigFlagsTable &configFlags = Js::Configuration::Global.flags;
if (dwValue == 1)
{
configFlags.Enable(Js::ES6Flag);
configFlags.SetAsBoolean(Js::ES6Flag, false);
}
}
// Asmjs feature control
// This setting allows enabling\disabling asmjs compilation
// 0 - Disable Asmjs phase - Also default behavior
// 1 - Enable Asmjs phase
dwValue = 0;
dwSize = sizeof(dwValue);
if (NOERROR == RegGetValueW(hk, nullptr, _u("EnableAsmjs"), RRF_RT_DWORD, nullptr, (LPBYTE)&dwValue, &dwSize))
{
if (dwValue == 1)
{
Js::Configuration::Global.flags.Asmjs = true;
}
}
#endif // _WIN32
}
BOOL CDrivesFolderEnum::CreateMyCompEnumList(DWORD dwFlags)
{
BOOL bRet = TRUE;
static const WCHAR MyComputer_NameSpaceW[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\Namespace";
TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
/* enumerate the folders */
if (dwFlags & SHCONTF_FOLDERS)
{
WCHAR wszDriveName[] = {'A', ':', '\\', '\0'};
DWORD dwDrivemap = GetLogicalDrives();
HKEY hKey;
UINT i;
while (bRet && wszDriveName[0] <= 'Z')
{
if(dwDrivemap & 0x00000001L)
bRet = AddToEnumList(_ILCreateDrive(wszDriveName));
wszDriveName[0]++;
dwDrivemap = dwDrivemap >> 1;
}
TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n", this);
for (i = 0; i < 2; i++)
{
if (bRet && ERROR_SUCCESS == RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
MyComputer_NameSpaceW, 0, KEY_READ, &hKey))
{
WCHAR wszBuf[50];
DWORD dwSize, j = 0;
LONG ErrorCode;
LPITEMIDLIST pidl;
while (bRet)
{
dwSize = sizeof(wszBuf) / sizeof(wszBuf[0]);
ErrorCode = RegEnumKeyExW(hKey, j, wszBuf, &dwSize, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == ErrorCode)
{
if (wszBuf[0] != L'{')
{
dwSize = sizeof(wszBuf);
RegGetValueW(hKey, wszBuf, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &dwSize);
}
/* FIXME: shell extensions - the type should be PT_SHELLEXT (tested) */
pidl = _ILCreateGuidFromStrW(wszBuf);
if (pidl != NULL)
bRet = AddToEnumList(pidl);
else
ERR("Invalid MyComputer namespace extesion: %s\n", wszBuf);
j++;
}
else if (ERROR_NO_MORE_ITEMS == ErrorCode)
break;
else
bRet = FALSE;
}
RegCloseKey(hKey);
}
}
}
INT_PTR
CALLBACK
DriveExtraDlg(
HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
STARTUPINFOW si;
PROCESS_INFORMATION pi;
WCHAR szPath[MAX_PATH + 10];
WCHAR szArg[MAX_PATH];
WCHAR * szDrive;
LPPROPSHEETPAGEW ppsp;
DWORD dwSize;
FORMAT_DRIVE_CONTEXT Context;
switch (uMsg)
{
case WM_INITDIALOG:
ppsp = (LPPROPSHEETPAGEW)lParam;
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)ppsp->lParam);
return TRUE;
case WM_COMMAND:
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );
szDrive = (WCHAR*)GetWindowLongPtr(hwndDlg, DWLP_USER);
switch(LOWORD(wParam))
{
case 14000:
if (InitializeFmifsLibrary(&Context))
{
Context.Drive = szDrive[0];
DialogBoxParamW(shell32_hInstance, L"CHKDSK_DLG", hwndDlg, ChkDskDlg, (LPARAM)&Context);
FreeLibrary(Context.hLibrary);
}
break;
case 14001:
dwSize = sizeof(szPath);
if (RegGetValueW(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\DefragPath",
NULL,
RRF_RT_REG_EXPAND_SZ,
NULL,
(PVOID)szPath,
&dwSize) == S_OK)
{
swprintf(szArg, szPath, szDrive[0]);
if (!GetSystemDirectoryW(szPath, MAX_PATH))
break;
szDrive = PathAddBackslashW(szPath);
if (!szDrive)
break;
wcscat(szDrive, L"mmc.exe");
if (CreateProcessW(szPath, szArg, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
break;
case 14002:
dwSize = sizeof(szPath);
if (RegGetValueW(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\BackupPath",
NULL,
RRF_RT_REG_EXPAND_SZ,
NULL,
(PVOID)szPath,
&dwSize) == S_OK)
{
if (CreateProcessW(szPath, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
}
break;
}
return FALSE;
}
HRESULT create_monodata(REFIID riid, LPVOID *ppObj )
{
static const WCHAR wszAssembly[] = {'A','s','s','e','m','b','l','y',0};
static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0};
static const WCHAR wszClass[] = {'C','l','a','s','s',0};
static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0};
static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
static const WCHAR wszDLL[] = {'.','d','l','l',0};
WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1];
MonoDomain *domain;
MonoAssembly *assembly;
ICLRRuntimeInfo *info = NULL;
RuntimeHost *host;
HRESULT hr;
HKEY key, subkey;
LONG res;
int offset = 0;
DWORD numKeys, keyLength;
WCHAR codebase[MAX_PATH + 8];
WCHAR classname[350], subkeyName[256];
WCHAR filename[MAX_PATH];
DWORD dwBufLen = 350;
lstrcpyW(path, wszCLSIDSlash);
StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
lstrcatW(path, wszInprocServer32);
TRACE("Registry key: %s\n", debugstr_w(path));
res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
if (res == ERROR_FILE_NOT_FOUND)
return CLASS_E_CLASSNOTAVAILABLE;
res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
if(res != ERROR_SUCCESS)
{
WARN("Class value cannot be found.\n");
hr = CLASS_E_CLASSNOTAVAILABLE;
goto cleanup;
}
TRACE("classname (%s)\n", debugstr_w(classname));
dwBufLen = MAX_PATH + 8;
res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
if(res == ERROR_SUCCESS)
{
/* Strip file:/// */
if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0)
offset = strlenW(wszFileSlash);
strcpyW(filename, codebase + offset);
}
else
{
WCHAR assemblyname[MAX_PATH + 8];
hr = CLASS_E_CLASSNOTAVAILABLE;
WARN("CodeBase value cannot be found, trying Assembly.\n");
/* get the last subkey of InprocServer32 */
res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0);
if (res != ERROR_SUCCESS || numKeys == 0)
goto cleanup;
numKeys--;
keyLength = sizeof(subkeyName) / sizeof(WCHAR);
res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0);
if (res != ERROR_SUCCESS)
goto cleanup;
res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey);
if (res != ERROR_SUCCESS)
goto cleanup;
dwBufLen = MAX_PATH + 8;
res = RegGetValueW(subkey, NULL, wszAssembly, RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
RegCloseKey(subkey);
if (res != ERROR_SUCCESS)
goto cleanup;
hr = get_file_from_strongname(assemblyname, filename, MAX_PATH);
if (!SUCCEEDED(hr))
{
/*
* The registry doesn't have a CodeBase entry and it's not in the GAC.
*
* Use the Assembly Key to retrieve the filename.
* Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null
*/
WCHAR *ns;
WARN("Attempt to load from the application directory.\n");
GetModuleFileNameW(NULL, filename, MAX_PATH);
ns = strrchrW(filename, '\\');
*(ns+1) = '\0';
ns = strchrW(assemblyname, ',');
*(ns) = '\0';
strcatW(filename, assemblyname);
*(ns) = '.';
strcatW(filename, wszDLL);
}
}
TRACE("filename (%s)\n", debugstr_w(filename));
*ppObj = NULL;
hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info);
if (SUCCEEDED(hr))
{
hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
if (SUCCEEDED(hr))
hr = RuntimeHost_GetDefaultDomain(host, &domain);
if (SUCCEEDED(hr))
{
MonoImage *image;
MonoClass *klass;
MonoObject *result;
IUnknown *unk = NULL;
char *filenameA, *ns;
char *classA;
hr = CLASS_E_CLASSNOTAVAILABLE;
mono_thread_attach(domain);
filenameA = WtoA(filename);
assembly = mono_domain_assembly_open(domain, filenameA);
HeapFree(GetProcessHeap(), 0, filenameA);
if (!assembly)
{
ERR("Cannot open assembly %s\n", filenameA);
goto cleanup;
}
image = mono_assembly_get_image(assembly);
if (!image)
{
ERR("Couldn't get assembly image\n");
goto cleanup;
}
classA = WtoA(classname);
ns = strrchr(classA, '.');
*ns = '\0';
klass = mono_class_from_name(image, classA, ns+1);
HeapFree(GetProcessHeap(), 0, classA);
if (!klass)
{
ERR("Couldn't get class from image\n");
goto cleanup;
}
/*
* Use the default constructor for the .NET class.
*/
result = mono_object_new(domain, klass);
mono_runtime_object_init(result);
hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
if (SUCCEEDED(hr))
{
hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
IUnknown_Release(unk);
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
}
else
hr = CLASS_E_CLASSNOTAVAILABLE;
cleanup:
if(info)
ICLRRuntimeInfo_Release(info);
RegCloseKey(key);
return hr;
}
BOOL HCR_GetClassNameW(REFIID riid, LPWSTR szDest, DWORD len)
{
HKEY hkey;
BOOL ret = FALSE;
DWORD buflen = len;
#ifdef __REACTOS__
WCHAR szName[100];
LPOLESTR pStr;
#endif
szDest[0] = 0;
#ifdef __REACTOS__
if (StringFromCLSID(riid, &pStr) == S_OK)
{
DWORD dwLen = buflen * sizeof(WCHAR);
swprintf(szName, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\%s", pStr);
if (!RegGetValueW(HKEY_CURRENT_USER, szName, NULL, RRF_RT_REG_SZ, NULL, (PVOID)szDest, &dwLen))
{
ret = TRUE;
}
CoTaskMemFree(pStr);
}
if (!ret && HCR_RegOpenClassIDKey(riid, &hkey))
#else
if (HCR_RegOpenClassIDKey(riid, &hkey))
#endif
{
static const WCHAR wszLocalizedString[] =
{ 'L','o','c','a','l','i','z','e','d','S','t','r','i','n','g', 0 };
if (!RegLoadMUIStringW(hkey, wszLocalizedString, szDest, len, NULL, 0, NULL) ||
!RegQueryValueExW(hkey, swEmpty, 0, NULL, (LPBYTE)szDest, &len))
{
ret = TRUE;
}
RegCloseKey(hkey);
}
if (!ret || !szDest[0])
{
if(IsEqualIID(riid, &CLSID_ShellDesktop))
{
if (LoadStringW(shell32_hInstance, IDS_DESKTOP, szDest, buflen))
ret = TRUE;
}
else if (IsEqualIID(riid, &CLSID_MyComputer))
{
if(LoadStringW(shell32_hInstance, IDS_MYCOMPUTER, szDest, buflen))
ret = TRUE;
}
#ifdef __REACTOS__
else if (IsEqualIID(riid, &CLSID_MyDocuments))
{
if(LoadStringW(shell32_hInstance, IDS_PERSONAL, szDest, buflen))
ret = TRUE;
}
else if (IsEqualIID(riid, &CLSID_RecycleBin))
{
if(LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_FOLDER_NAME, szDest, buflen))
ret = TRUE;
}
else if (IsEqualIID(riid, &CLSID_ControlPanel))
{
if(LoadStringW(shell32_hInstance, IDS_CONTROLPANEL, szDest, buflen))
ret = TRUE;
}
else if (IsEqualIID(riid, &CLSID_AdminFolderShortcut))
{
if(LoadStringW(shell32_hInstance, IDS_ADMINISTRATIVETOOLS, szDest, buflen))
ret = TRUE;
}
#endif
}
TRACE("-- %s\n", debugstr_w(szDest));
return ret;
}
static void test_setvalue_on_wow64(IPropertyStore *store)
{
PROPVARIANT pv;
HRESULT hr;
LONG ret;
WCHAR *guidW;
HKEY root, props, devkey;
DWORD type, regval, size;
static const PROPERTYKEY PKEY_Bogus = {
{0x1da5d803, 0xd492, 0x4edd, {0x8c, 0x23, 0xe0, 0xc0, 0xff, 0xee, 0x7f, 0x00}}, 0x7f
};
static const WCHAR bogusW[] = {'{','1','D','A','5','D','8','0','3','-','D','4','9','2','-','4','E','D','D','-','8','C','2','3','-','E','0','C','0','F','F','E','E','7','F','0','0','}',',','1','2','7',0};
PropVariantInit(&pv);
pv.vt = VT_EMPTY;
hr = IPropertyStore_GetValue(store, &PKEY_AudioEndpoint_GUID, &pv);
ok(hr == S_OK, "Failed to get Endpoint GUID: %08x\n", hr);
guidW = pv.u.pwszVal;
pv.vt = VT_UI4;
pv.u.ulVal = 0xAB;
hr = IPropertyStore_SetValue(store, &PKEY_Bogus, &pv);
ok(hr == S_OK || hr == E_ACCESSDENIED, "SetValue failed: %08x\n", hr);
if (hr != S_OK)
{
win_skip("Missing permission to write to registry\n");
return;
}
pv.u.ulVal = 0x00;
hr = IPropertyStore_GetValue(store, &PKEY_Bogus, &pv);
ok(hr == S_OK, "GetValue failed: %08x\n", hr);
ok(pv.u.ulVal == 0xAB, "Got wrong value: 0x%x\n", pv.u.ulVal);
/* should find the key in 64-bit view */
ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, software_renderW, 0, KEY_READ|KEY_WOW64_64KEY, &root);
ok(ret == ERROR_SUCCESS, "Couldn't open mmdevices Render key: %u\n", ret);
ret = RegOpenKeyExW(root, guidW, 0, KEY_READ|KEY_WOW64_64KEY, &devkey);
ok(ret == ERROR_SUCCESS, "Couldn't open mmdevice guid key: %u\n", ret);
ret = RegOpenKeyExW(devkey, propertiesW, 0, KEY_READ|KEY_WOW64_64KEY, &props);
ok(ret == ERROR_SUCCESS, "Couldn't open mmdevice property key: %u\n", ret);
/* Note: the registry key exists even without calling IPropStore::Commit */
size = sizeof(regval);
ret = RegGetValueW(props, NULL, bogusW, RRF_RT_DWORD, &type, ®val, &size);
ok(ret == ERROR_SUCCESS, "Couldn't get bogus propertykey value: %u\n", ret);
ok(type == REG_DWORD, "Got wrong value type: %u\n", type);
ok(regval == 0xAB, "Got wrong value: 0x%x\n", regval);
RegCloseKey(props);
RegCloseKey(devkey);
RegCloseKey(root);
CoTaskMemFree(guidW);
/* should NOT find the key in 32-bit view */
ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, software_renderW, 0, KEY_READ, &root);
ok(ret == ERROR_FILE_NOT_FOUND, "Wrong error when opening mmdevices Render key: %u\n", ret);
}
static HRESULT MMDevice_GetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, PROPVARIANT *pv)
{
WCHAR buffer[80];
const GUID *id = &key->fmtid;
DWORD type, size;
HRESULT hr = S_OK;
HKEY regkey;
LONG ret;
hr = MMDevPropStore_OpenPropKey(devguid, flow, ®key);
if (FAILED(hr))
return hr;
wsprintfW( buffer, propkey_formatW, id->Data1, id->Data2, id->Data3,
id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7], key->pid );
ret = RegGetValueW(regkey, NULL, buffer, RRF_RT_ANY, &type, NULL, &size);
if (ret != ERROR_SUCCESS)
{
WARN("Reading %s returned %d\n", debugstr_w(buffer), ret);
RegCloseKey(regkey);
PropVariantClear(pv);
return S_OK;
}
switch (type)
{
case REG_SZ:
{
pv->vt = VT_LPWSTR;
pv->u.pwszVal = CoTaskMemAlloc(size);
if (!pv->u.pwszVal)
hr = E_OUTOFMEMORY;
else
RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_SZ, NULL, (BYTE*)pv->u.pwszVal, &size);
break;
}
case REG_DWORD:
{
pv->vt = VT_UI4;
RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_DWORD, NULL, (BYTE*)&pv->u.ulVal, &size);
break;
}
case REG_BINARY:
{
pv->vt = VT_BLOB;
pv->u.blob.cbSize = size;
pv->u.blob.pBlobData = CoTaskMemAlloc(size);
if (!pv->u.blob.pBlobData)
hr = E_OUTOFMEMORY;
else
RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_BINARY, NULL, (BYTE*)pv->u.blob.pBlobData, &size);
break;
}
default:
ERR("Unknown/unhandled type: %u\n", type);
PropVariantClear(pv);
break;
}
RegCloseKey(regkey);
return hr;
}
static INT_PTR CALLBACK SysConfProc(HWND hDlgWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HKEY hKey;
WCHAR buffer[MAX_LOAD_STRING];
DWORD bufSize;
WCHAR wszReg[] = { 'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\','O','L','E','\\','\0' };
WCHAR wszEnableDCOM[] = { 'E','n','a','b','l','e','D','C','O','M','\0' };
WCHAR wszEnableRemote[] = { 'E','n','a','b','l','e',
'R','e','m','o','t','e','C','o','n','n','e','c','t','\0' };
WCHAR wszYes[] = { 'Y', '\0' };
WCHAR wszNo[] = { 'N', '\0' };
switch(uMsg)
{
case WM_INITDIALOG:
if(RegOpenKeyW(HKEY_LOCAL_MACHINE, wszReg, &hKey) != ERROR_SUCCESS)
RegCreateKeyW(HKEY_LOCAL_MACHINE, wszReg, &hKey);
bufSize = sizeof(buffer);
if(RegGetValueW(hKey, NULL, wszEnableDCOM, RRF_RT_REG_SZ,
NULL, buffer, &bufSize) != ERROR_SUCCESS)
{
bufSize = sizeof(wszYes);
RegSetValueExW(hKey, wszEnableDCOM, 0, REG_SZ, (BYTE*)wszYes, bufSize);
}
CheckDlgButton(hDlgWnd, IDC_ENABLEDCOM,
buffer[0]=='Y' ? BST_CHECKED : BST_UNCHECKED);
bufSize = sizeof(buffer);
if(RegGetValueW(hKey, NULL, wszEnableRemote, RRF_RT_REG_SZ,
NULL, buffer, &bufSize) != ERROR_SUCCESS)
{
bufSize = sizeof(wszYes);
RegSetValueExW(hKey, wszEnableRemote, 0, REG_SZ, (BYTE*)wszYes, bufSize);
}
CheckDlgButton(hDlgWnd, IDC_ENABLEREMOTE,
buffer[0]=='Y' ? BST_CHECKED : BST_UNCHECKED);
RegCloseKey(hKey);
return TRUE;
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDOK:
bufSize = sizeof(wszYes);
RegOpenKeyW(HKEY_LOCAL_MACHINE, wszReg, &hKey);
RegSetValueExW(hKey, wszEnableDCOM, 0, REG_SZ,
IsDlgButtonChecked(hDlgWnd, IDC_ENABLEDCOM) == BST_CHECKED ?
(BYTE*)wszYes : (BYTE*)wszNo, bufSize);
RegSetValueExW(hKey, wszEnableRemote, 0, REG_SZ,
IsDlgButtonChecked(hDlgWnd, IDC_ENABLEREMOTE) == BST_CHECKED ?
(BYTE*)wszYes : (BYTE*)wszNo, bufSize);
RegCloseKey(hKey);
EndDialog(hDlgWnd, IDOK);
return TRUE;
case IDCANCEL:
EndDialog(hDlgWnd, IDCANCEL);
return TRUE;
}
}
return FALSE;
}