static HRESULT do_register_dll_server(IRegistrar *pRegistrar, LPCOLESTR wszDll,
LPCOLESTR wszId, BOOL do_register,
const struct _ATL_REGMAP_ENTRY* pMapEntries)
{
WCHAR buf[MAX_PATH];
HRESULT hres;
const struct _ATL_REGMAP_ENTRY *pMapEntry;
static const WCHAR wszModule[] = {'M','O','D','U','L','E',0};
static const WCHAR wszRegistry[] = {'R','E','G','I','S','T','R','Y',0};
static const WCHAR wszCLSID_ATLRegistrar[] =
{'C','L','S','I','D','_','A','T','L','R','e','g','i','s','t','r','a','r',0};
if (!pRegistrar)
Registrar_create(NULL, &IID_IRegistrar, (void**)&pRegistrar);
IRegistrar_AddReplacement(pRegistrar, wszModule, wszDll);
for (pMapEntry = pMapEntries; pMapEntry && pMapEntry->szKey; pMapEntry++)
IRegistrar_AddReplacement(pRegistrar, pMapEntry->szKey, pMapEntry->szData);
StringFromGUID2(&CLSID_ATLRegistrar, buf, sizeof(buf)/sizeof(buf[0]));
IRegistrar_AddReplacement(pRegistrar, wszCLSID_ATLRegistrar, buf);
if(do_register)
hres = IRegistrar_ResourceRegisterSz(pRegistrar, wszDll, wszId, wszRegistry);
else
hres = IRegistrar_ResourceUnregisterSz(pRegistrar, wszDll, wszId, wszRegistry);
IRegistrar_Release(pRegistrar);
return hres;
}
static HRESULT do_register_dll_server(IRegistrar *pRegistrar, LPCOLESTR wszDll,
LPCOLESTR wszId, BOOL do_register,
const struct _ATL_REGMAP_ENTRY* pMapEntries)
{
IRegistrar *registrar;
HRESULT hres;
const struct _ATL_REGMAP_ENTRY *pMapEntry;
static const WCHAR wszModule[] = {'M','O','D','U','L','E',0};
static const WCHAR wszRegistry[] = {'R','E','G','I','S','T','R','Y',0};
if(pRegistrar) {
registrar = pRegistrar;
}else {
hres = AtlCreateRegistrar(®istrar);
if(FAILED(hres))
return hres;
}
IRegistrar_AddReplacement(registrar, wszModule, wszDll);
for (pMapEntry = pMapEntries; pMapEntry && pMapEntry->szKey; pMapEntry++)
IRegistrar_AddReplacement(registrar, pMapEntry->szKey, pMapEntry->szData);
if(do_register)
hres = IRegistrar_ResourceRegisterSz(registrar, wszDll, wszId, wszRegistry);
else
hres = IRegistrar_ResourceUnregisterSz(registrar, wszDll, wszId, wszRegistry);
if(registrar != pRegistrar)
IRegistrar_Release(registrar);
return hres;
}
/***********************************************************************
* cleanup_fake_dlls
*/
void cleanup_fake_dlls(void)
{
if (file_buffer) VirtualFree( file_buffer, 0, MEM_RELEASE );
file_buffer = NULL;
HeapFree( GetProcessHeap(), 0, handled_dlls );
handled_dlls = NULL;
handled_count = handled_total = 0;
if (registrar) IRegistrar_Release( registrar );
registrar = NULL;
}
/***********************************************************************
* AtlUpdateRegistryFromResourceD [atl100.@]
*/
HRESULT WINAPI AtlUpdateRegistryFromResourceD(HINSTANCE inst, LPCOLESTR res,
BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries, IRegistrar *pReg)
{
const struct _ATL_REGMAP_ENTRY *iter;
WCHAR module_name[MAX_PATH];
IRegistrar *registrar;
HRESULT hres;
static const WCHAR moduleW[] = {'M','O','D','U','L','E',0};
static const WCHAR registryW[] = {'R','E','G','I','S','T','R','Y',0};
if(!GetModuleFileNameW(inst, module_name, MAX_PATH)) {
FIXME("hinst %p: did not get module name\n", inst);
return E_FAIL;
}
TRACE("%p (%s), %s, %d, %p, %p\n", inst, debugstr_w(module_name),
debugstr_w(res), bRegister, pMapEntries, pReg);
if(pReg) {
registrar = pReg;
}else {
hres = AtlCreateRegistrar(®istrar);
if(FAILED(hres))
return hres;
}
IRegistrar_AddReplacement(registrar, moduleW, module_name);
for (iter = pMapEntries; iter && iter->szKey; iter++)
IRegistrar_AddReplacement(registrar, iter->szKey, iter->szData);
if(bRegister)
hres = IRegistrar_ResourceRegisterSz(registrar, module_name, res, registryW);
else
hres = IRegistrar_ResourceUnregisterSz(registrar, module_name, res, registryW);
if(registrar != pReg)
IRegistrar_Release(registrar);
return hres;
}
static HRESULT WINAPI RegistrarCF_CreateInstance(IClassFactory *iface, LPUNKNOWN pUnkOuter,
REFIID riid, void **ppv)
{
IRegistrar *registrar;
HRESULT hres;
TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
if(pUnkOuter) {
*ppv = NULL;
return CLASS_E_NOAGGREGATION;
}
hres = AtlCreateRegistrar(®istrar);
if(FAILED(hres))
return hres;
hres = IRegistrar_QueryInterface(registrar, riid, ppv);
IRegistrar_Release(registrar);
return hres;
}
static void test_registrar(void)
{
IRegistrar *registrar = NULL;
HRESULT hr;
INT count;
WCHAR *textW = NULL;
if (!GetProcAddress(GetModuleHandleA("atl.dll"), "AtlAxAttachControl"))
{
win_skip("Old versions of atl.dll don't support binary values\n");
return;
}
hr = CoCreateInstance(&CLSID_Registrar, NULL, CLSCTX_INPROC_SERVER, &IID_IRegistrar, (void**)®istrar);
if (FAILED(hr))
{
skip("creating IRegistrar failed, hr = 0x%08X\n", hr);
return;
}
count = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
textW = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
if (textW)
{
DWORD dword;
DWORD size;
LONG lret;
HKEY key;
BYTE bytes[4];
MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, count);
hr = IRegistrar_StringRegister(registrar, textW);
ok(SUCCEEDED(hr), "IRegistrar_StringRegister failed, hr = 0x%08X\n", hr);
lret = RegOpenKeyA(HKEY_CLASSES_ROOT, "eebf73c4-50fd-478f-bbcf-db212221227a", &key);
ok(lret == ERROR_SUCCESS, "error %d opening registry key\n", lret);
size = sizeof(dword);
lret = RegQueryValueExA(key, "dword_unquoted_hex", NULL, NULL, (BYTE*)&dword, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %d\n", lret);
ok(dword != 0xA, "unquoted hex is not supposed to be preserved\n");
size = sizeof(dword);
lret = RegQueryValueExA(key, "dword_quoted_hex", NULL, NULL, (BYTE*)&dword, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %d\n", lret);
ok(dword != 0xA, "quoted hex is not supposed to be preserved\n");
size = sizeof(dword);
lret = RegQueryValueExA(key, "dword_unquoted_dec", NULL, NULL, (BYTE*)&dword, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %d\n", lret);
ok(dword == 1, "unquoted dec is not supposed to be %d\n", dword);
size = sizeof(dword);
lret = RegQueryValueExA(key, "dword_quoted_dec", NULL, NULL, (BYTE*)&dword, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %d\n", lret);
ok(dword == 1, "quoted dec is not supposed to be %d\n", dword);
size = 4;
lret = RegQueryValueExA(key, "binary_quoted", NULL, NULL, bytes, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueA, failed, error %d\n", lret);
ok(bytes[0] == 0xde && bytes[1] == 0xad && bytes[2] == 0xbe && bytes[3] == 0xef,
"binary quoted value was not preserved (it's 0x%02X%02X%02X%02X)\n",
0xff & bytes[0], 0xff & bytes[1], 0xff & bytes[2], 0xff & bytes[3]);
size = 4;
lret = RegQueryValueExA(key, "binary_unquoted", NULL, NULL, bytes, &size);
ok(lret == ERROR_SUCCESS, "RegQueryValueA, failed, error %d\n", lret);
ok(bytes[0] == 0xde && bytes[1] == 0xad && bytes[2] == 0xbe && bytes[3] == 0xef,
"binary unquoted value was not preserved (it's 0x%02X%02X%02X%02X)\n",
0xff & bytes[0], 0xff & bytes[1], 0xff & bytes[2], 0xff & bytes[3]);
hr = IRegistrar_StringUnregister(registrar, textW);
ok(SUCCEEDED(hr), "IRegistrar_StringUnregister failed, hr = 0x%08X\n", hr);
RegCloseKey(key);
HeapFree(GetProcessHeap(), 0, textW);
}
else
skip("allocating memory failed\n");
IRegistrar_Release(registrar);
}
