Sweden-Number/dlls/atl/registrar.c

882 lines
27 KiB
C
Raw Normal View History

2005-03-14 11:51:27 +01:00
/*
* Copyright 2005 Jacek Caban
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
2005-03-14 11:51:27 +01:00
*/
#include <stdarg.h>
#define COBJMACROS
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "objbase.h"
#include "oaidl.h"
#define ATL_INITGUID
#include "atliface.h"
#include "atlbase.h"
2005-03-14 11:51:27 +01:00
#include "wine/debug.h"
#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(atl);
static LONG dll_count;
2005-03-14 11:51:27 +01:00
/**************************************************************
* ATLRegistrar implementation
*/
2006-12-14 15:46:31 +01:00
static const struct {
2005-03-14 11:51:27 +01:00
WCHAR name[22];
HKEY key;
} root_keys[] = {
{{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
HKEY_CLASSES_ROOT},
{{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
HKEY_CURRENT_USER},
{{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
HKEY_LOCAL_MACHINE},
{{'H','K','E','Y','_','U','S','E','R','S',0},
HKEY_USERS},
{{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
HKEY_PERFORMANCE_DATA},
{{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
HKEY_DYN_DATA},
{{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
HKEY_CURRENT_CONFIG},
{{'H','K','C','R',0}, HKEY_CLASSES_ROOT},
{{'H','K','C','U',0}, HKEY_CURRENT_USER},
{{'H','K','L','M',0}, HKEY_LOCAL_MACHINE},
{{'H','K','U',0}, HKEY_USERS},
{{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA},
{{'H','K','D','D',0}, HKEY_DYN_DATA},
{{'H','K','C','C',0}, HKEY_CURRENT_CONFIG}
};
typedef struct rep_list_str {
LPOLESTR key;
LPOLESTR item;
int key_len;
struct rep_list_str *next;
} rep_list;
typedef struct {
const IRegistrarVtbl *lpVtbl;
2005-07-11 15:21:17 +02:00
LONG ref;
2005-03-14 11:51:27 +01:00
rep_list *rep;
} Registrar;
typedef struct {
LPOLESTR str;
DWORD alloc;
DWORD len;
} strbuf;
static void strbuf_init(strbuf *buf)
{
buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
buf->alloc = 128;
buf->len = 0;
}
static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
{
if(len == -1)
len = lstrlenW(str);
if(buf->len+len+1 >= buf->alloc) {
buf->alloc = (buf->len+len)<<1;
buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
}
memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
buf->len += len;
buf->str[buf->len] = '\0';
}
static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
{
LPCOLESTR iter, iter2 = *str;
buf->len = 0;
buf->str[0] = '\0';
while(isspaceW(*iter2))
iter2++;
iter = iter2;
if(!*iter) {
*str = iter;
return S_OK;
}
2005-11-18 13:04:53 +01:00
if(*iter == '}' || *iter == '=') {
2005-03-14 11:51:27 +01:00
strbuf_write(iter++, buf, 1);
}else if(*iter == '\'') {
iter2 = ++iter;
iter = strchrW(iter, '\'');
if(!iter) {
WARN("Unexpected end of script\n");
*str = iter;
return DISP_E_EXCEPTION;
}
strbuf_write(iter2, buf, iter-iter2);
iter++;
}else {
while(*iter && !isspaceW(*iter))
iter++;
strbuf_write(iter2, buf, iter-iter2);
}
while(isspaceW(*iter))
iter++;
*str = iter;
return S_OK;
}
2007-04-02 23:50:14 +02:00
static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf)
2005-03-14 11:51:27 +01:00
{
LPCOLESTR iter, iter2 = data;
rep_list *rep_iter;
static const WCHAR wstr[] = {'%',0};
iter = strchrW(data, '%');
while(iter) {
strbuf_write(iter2, buf, iter-iter2);
iter2 = ++iter;
if(!*iter2)
return DISP_E_EXCEPTION;
iter = strchrW(iter2, '%');
if(!iter)
return DISP_E_EXCEPTION;
if(iter == iter2) {
strbuf_write(wstr, buf, 1);
}else {
for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
if(rep_iter->key_len == iter-iter2
&& !memicmpW(iter2, rep_iter->key, rep_iter->key_len))
2005-03-14 11:51:27 +01:00
break;
}
if(!rep_iter) {
WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2));
2005-03-14 11:51:27 +01:00
return DISP_E_EXCEPTION;
}
2005-03-14 11:51:27 +01:00
strbuf_write(rep_iter->item, buf, -1);
}
iter2 = ++iter;
iter = strchrW(iter, '%');
}
strbuf_write(iter2, buf, -1);
TRACE("%s\n", debugstr_w(buf->str));
return S_OK;
}
static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
{
LPCOLESTR iter = *pstr;
HRESULT hres;
LONG lres;
HKEY hkey = 0;
strbuf name;
2005-03-18 11:25:29 +01:00
enum {
NORMAL,
NO_REMOVE,
IS_VAL,
FORCE_REMOVE,
DO_DELETE
} key_type = NORMAL;
2005-03-14 11:51:27 +01:00
static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
static const WCHAR wstrval[] = {'v','a','l',0};
iter = *pstr;
hres = get_word(&iter, buf);
if(FAILED(hres))
return hres;
strbuf_init(&name);
while(buf->str[1] || buf->str[0] != '}') {
2005-03-18 11:25:29 +01:00
key_type = NORMAL;
if(!lstrcmpiW(buf->str, wstrNoRemove))
2005-03-18 11:25:29 +01:00
key_type = NO_REMOVE;
else if(!lstrcmpiW(buf->str, wstrForceRemove))
2005-03-18 11:25:29 +01:00
key_type = FORCE_REMOVE;
else if(!lstrcmpiW(buf->str, wstrval))
2005-03-18 11:25:29 +01:00
key_type = IS_VAL;
else if(!lstrcmpiW(buf->str, wstrDelete))
2005-03-18 11:25:29 +01:00
key_type = DO_DELETE;
if(key_type != NORMAL) {
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
}
TRACE("name = %s\n", debugstr_w(buf->str));
if(do_register) {
if(key_type == IS_VAL) {
hkey = parent_key;
strbuf_write(buf->str, &name, -1);
}else if(key_type == DO_DELETE) {
TRACE("Deleting %s\n", debugstr_w(buf->str));
2008-11-19 22:32:29 +01:00
RegDeleteTreeW(parent_key, buf->str);
2005-03-18 11:25:29 +01:00
}else {
if(key_type == FORCE_REMOVE)
RegDeleteTreeW(parent_key, buf->str);
2005-03-18 11:25:29 +01:00
lres = RegCreateKeyW(parent_key, buf->str, &hkey);
if(lres != ERROR_SUCCESS) {
WARN("Could not create(open) key: %08x\n", lres);
2005-03-18 11:25:29 +01:00
hres = HRESULT_FROM_WIN32(lres);
break;
}
}
}else if(key_type != IS_VAL && key_type != DO_DELETE) {
strbuf_write(buf->str, &name, -1);
lres = RegOpenKeyW(parent_key, buf->str, &hkey);
if(lres != ERROR_SUCCESS)
WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
2005-03-18 11:25:29 +01:00
}
if(key_type != DO_DELETE && *iter == '=') {
iter++;
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
if(buf->len != 1) {
WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
hres = DISP_E_EXCEPTION;
break;
}
2005-03-14 11:51:27 +01:00
if(do_register) {
2005-03-18 11:25:29 +01:00
switch(buf->str[0]) {
case 's':
hres = get_word(&iter, buf);
if(FAILED(hres))
2005-03-14 11:51:27 +01:00
break;
2005-03-18 11:25:29 +01:00
lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_SZ, (PBYTE)buf->str,
(lstrlenW(buf->str)+1)*sizeof(WCHAR));
2005-03-14 11:51:27 +01:00
if(lres != ERROR_SUCCESS) {
WARN("Could set value of key: %08x\n", lres);
2005-03-14 11:51:27 +01:00
hres = HRESULT_FROM_WIN32(lres);
break;
}
break;
2005-03-18 11:25:29 +01:00
case 'd': {
DWORD dw;
2010-11-24 10:09:05 +01:00
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
dw = atoiW(buf->str);
2005-03-18 11:25:29 +01:00
lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_DWORD,
(PBYTE)&dw, sizeof(dw));
if(lres != ERROR_SUCCESS) {
WARN("Could set value of key: %08x\n", lres);
2005-03-18 11:25:29 +01:00
hres = HRESULT_FROM_WIN32(lres);
2005-03-14 11:51:27 +01:00
break;
2005-03-18 11:25:29 +01:00
}
break;
2005-03-14 11:51:27 +01:00
}
case 'b': {
BYTE *bytes;
DWORD count;
DWORD i;
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
count = (lstrlenW(buf->str) + 1) / 2;
bytes = HeapAlloc(GetProcessHeap(), 0, count);
if(bytes == NULL) {
hres = E_OUTOFMEMORY;
break;
}
for(i = 0; i < count && buf->str[2*i]; i++) {
WCHAR digits[3];
if(!isxdigitW(buf->str[2*i]) || !isxdigitW(buf->str[2*i + 1])) {
hres = E_FAIL;
break;
}
digits[0] = buf->str[2*i];
digits[1] = buf->str[2*i + 1];
digits[2] = 0;
bytes[i] = (BYTE) strtoulW(digits, NULL, 16);
}
if(SUCCEEDED(hres)) {
lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_BINARY,
bytes, count);
if(lres != ERROR_SUCCESS) {
WARN("Could not set value of key: 0x%08x\n", lres);
hres = HRESULT_FROM_WIN32(lres);
}
}
HeapFree(GetProcessHeap(), 0, bytes);
break;
}
2005-03-18 11:25:29 +01:00
default:
WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
hres = DISP_E_EXCEPTION;
};
2005-03-14 11:51:27 +01:00
if(FAILED(hres))
break;
2005-03-18 11:25:29 +01:00
}else {
if(*iter == '-')
iter++;
hres = get_word(&iter, buf);
2005-03-14 11:51:27 +01:00
if(FAILED(hres))
break;
}
2005-03-18 11:25:29 +01:00
}else if(key_type == IS_VAL) {
WARN("value not set!\n");
hres = DISP_E_EXCEPTION;
break;
}
2005-11-18 13:04:53 +01:00
if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && isspaceW(iter[1])) {
2005-03-18 11:25:29 +01:00
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
hres = do_process_key(&iter, hkey, buf, do_register);
if(FAILED(hres))
break;
2005-03-14 11:51:27 +01:00
}
2005-03-18 11:25:29 +01:00
TRACE("%x %x\n", do_register, key_type);
if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
TRACE("Deleting %s\n", debugstr_w(name.str));
RegDeleteKeyW(parent_key, name.str);
}
if(hkey && key_type != IS_VAL)
RegCloseKey(hkey);
hkey = 0;
name.len = 0;
2005-03-14 11:51:27 +01:00
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
}
HeapFree(GetProcessHeap(), 0, name.str);
2005-03-18 11:25:29 +01:00
if(hkey && key_type != IS_VAL)
2005-03-14 11:51:27 +01:00
RegCloseKey(hkey);
*pstr = iter;
return hres;
}
static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
{
LPCOLESTR iter = data;
strbuf buf;
HRESULT hres = S_OK;
unsigned int i;
2005-03-14 11:51:27 +01:00
strbuf_init(&buf);
hres = get_word(&iter, &buf);
if(FAILED(hres))
return hres;
while(*iter) {
if(!buf.len) {
WARN("ward.len == 0, failed\n");
hres = DISP_E_EXCEPTION;
break;
}
for(i=0; i<sizeof(root_keys)/sizeof(root_keys[0]); i++) {
if(!lstrcmpiW(buf.str, root_keys[i].name))
2005-03-14 11:51:27 +01:00
break;
}
if(i == sizeof(root_keys)/sizeof(root_keys[0])) {
WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
hres = DISP_E_EXCEPTION;
break;
}
hres = get_word(&iter, &buf);
if(FAILED(hres))
break;
if(buf.str[1] || buf.str[0] != '{') {
WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
hres = DISP_E_EXCEPTION;
break;
}
hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
if(FAILED(hres)) {
WARN("Processing key failed: %08x\n", hres);
2005-03-14 11:51:27 +01:00
break;
}
hres = get_word(&iter, &buf);
if(FAILED(hres))
break;
}
HeapFree(GetProcessHeap(), 0, buf.str);
return hres;
}
static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
{
strbuf buf;
HRESULT hres;
TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
strbuf_init(&buf);
hres = do_preprocess(This, data, &buf);
if(FAILED(hres)) {
WARN("preprocessing failed!\n");
HeapFree(GetProcessHeap(), 0, buf.str);
return hres;
}
hres = do_process_root_key(buf.str, do_register);
if(FAILED(hres) && do_register)
do_process_root_key(buf.str, FALSE);
HeapFree(GetProcessHeap(), 0, buf.str);
return hres;
}
static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
2005-03-14 11:51:27 +01:00
{
HINSTANCE hins;
HRSRC src;
LPSTR regstra;
LPWSTR regstrw;
DWORD len, reslen;
HRESULT hres;
hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
if(hins) {
src = FindResourceW(hins, szID, szType);
2005-03-14 11:51:27 +01:00
if(src) {
2008-12-05 07:50:43 +01:00
regstra = LoadResource(hins, src);
2005-03-14 11:51:27 +01:00
reslen = SizeofResource(hins, src);
if(regstra) {
len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, len);
2005-03-14 11:51:27 +01:00
regstrw[len-1] = '\0';
hres = string_register(This, regstrw, do_register);
HeapFree(GetProcessHeap(), 0, regstrw);
}else {
WARN("could not load resource\n");
hres = HRESULT_FROM_WIN32(GetLastError());
}
}else {
WARN("Could not find source\n");
hres = HRESULT_FROM_WIN32(GetLastError());
}
FreeLibrary(hins);
}else {
WARN("Could not load resource file\n");
hres = HRESULT_FROM_WIN32(GetLastError());
}
return hres;
}
static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
{
HANDLE file;
DWORD filelen, len;
LPWSTR regstrw;
LPSTR regstra;
LRESULT lres;
HRESULT hres;
file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
if(file != INVALID_HANDLE_VALUE) {
filelen = GetFileSize(file, NULL);
regstra = HeapAlloc(GetProcessHeap(), 0, filelen);
lres = ReadFile(file, regstra, filelen, NULL, NULL);
if(lres == ERROR_SUCCESS) {
len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0)+1;
regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
regstrw[len-1] = '\0';
hres = string_register(This, regstrw, do_register);
HeapFree(GetProcessHeap(), 0, regstrw);
}else {
WARN("Failed to read faile\n");
hres = HRESULT_FROM_WIN32(lres);
}
HeapFree(GetProcessHeap(), 0, regstra);
CloseHandle(file);
}else {
WARN("Could not open file\n");
hres = HRESULT_FROM_WIN32(GetLastError());
}
return hres;
}
2005-03-14 11:51:27 +01:00
static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
{
TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
IRegistrar_AddRef(iface);
*ppvObject = iface;
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
{
Registrar *This = (Registrar*)iface;
ULONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ->%d\n", This, ref);
2005-03-14 11:51:27 +01:00
return ref;
}
static ULONG WINAPI Registrar_Release(IRegistrar *iface)
{
Registrar *This = (Registrar*)iface;
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ->%d\n", This, ref);
2005-03-14 11:51:27 +01:00
if(!ref) {
IRegistrar_ClearReplacements(iface);
HeapFree(GetProcessHeap(), 0, This);
InterlockedDecrement(&dll_count);
2005-03-14 11:51:27 +01:00
}
return ref;
}
static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
{
Registrar *This = (Registrar*)iface;
int len;
rep_list *new_rep;
TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
new_rep->key_len = lstrlenW(Key);
2010-06-28 11:44:40 +02:00
new_rep->key = HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR));
2005-03-14 11:51:27 +01:00
memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
len = lstrlenW(item)+1;
new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
memcpy(new_rep->item, item, len*sizeof(OLECHAR));
new_rep->next = This->rep;
This->rep = new_rep;
return S_OK;
}
static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
{
Registrar *This = (Registrar*)iface;
rep_list *iter, *iter2;
TRACE("(%p)\n", This);
if(!This->rep)
return S_OK;
iter = This->rep;
while(iter) {
iter2 = iter->next;
HeapFree(GetProcessHeap(), 0, iter->key);
HeapFree(GetProcessHeap(), 0, iter->item);
HeapFree(GetProcessHeap(), 0, iter);
iter = iter2;
}
This->rep = NULL;
return S_OK;
}
static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
LPCOLESTR szID, LPCOLESTR szType)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
return resource_register(This, resFileName, szID, szType, TRUE);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
LPCOLESTR szID, LPCOLESTR szType)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
return resource_register(This, resFileName, szID, szType, FALSE);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s)\n", This, debugstr_w(fileName));
return file_register(This, fileName, TRUE);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
{
Registrar *This = (Registrar*)iface;
FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
return file_register(This, fileName, FALSE);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI Registrar_StringRegister(IRegistrar* iface, LPCOLESTR data)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s)\n", This, debugstr_w(data));
return string_register(This, data, TRUE);
}
static HRESULT WINAPI Registrar_StringUnregister(IRegistrar* iface, LPCOLESTR data)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s)\n", This, debugstr_w(data));
return string_register(This, data, FALSE);
}
static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
UINT nID, LPCOLESTR szType)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, TRUE);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
UINT nID, LPCOLESTR szType)
{
Registrar *This = (Registrar*)iface;
TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, FALSE);
2005-03-14 11:51:27 +01:00
}
static const IRegistrarVtbl RegistrarVtbl = {
2005-03-14 11:51:27 +01:00
Registrar_QueryInterface,
Registrar_AddRef,
Registrar_Release,
Registrar_AddReplacement,
Registrar_ClearReplacements,
Registrar_ResourceRegisterSz,
Registrar_ResourceUnregisterSz,
Registrar_FileRegister,
Registrar_FileUnregister,
Registrar_StringRegister,
Registrar_StringUnregister,
Registrar_ResourceRegister,
Registrar_ResourceUnregister,
};
2007-04-02 23:50:14 +02:00
static HRESULT Registrar_create(const IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
2005-03-16 20:53:41 +01:00
{
Registrar *ret;
if(!IsEqualGUID(&IID_IUnknown, riid) && !IsEqualGUID(&IID_IRegistrar, riid))
return E_NOINTERFACE;
ret = HeapAlloc(GetProcessHeap(), 0, sizeof(Registrar));
ret->lpVtbl = &RegistrarVtbl;
ret->ref = 1;
ret->rep = NULL;
*ppvObject = ret;
InterlockedIncrement(&dll_count);
2005-03-16 20:53:41 +01:00
return S_OK;
}
2005-03-14 11:51:27 +01:00
/**************************************************************
* ClassFactory implementation
*/
static HRESULT WINAPI RegistrarCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppvObject)
{
TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2005-03-14 11:51:27 +01:00
*ppvObject = iface;
IClassFactory_AddRef( iface );
2005-03-14 11:51:27 +01:00
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI RegistrarCF_AddRef(IClassFactory *iface)
{
InterlockedIncrement(&dll_count);
2005-03-14 11:51:27 +01:00
return 2;
}
static ULONG WINAPI RegistrarCF_Release(IClassFactory *iface)
{
InterlockedDecrement(&dll_count);
2005-03-14 11:51:27 +01:00
return 1;
}
2005-03-16 20:53:41 +01:00
static HRESULT WINAPI RegistrarCF_CreateInstance(IClassFactory *iface, LPUNKNOWN pUnkOuter,
REFIID riid, void **ppvObject)
2005-03-14 11:51:27 +01:00
{
TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
2005-03-16 20:53:41 +01:00
return Registrar_create(pUnkOuter, riid, ppvObject);
2005-03-14 11:51:27 +01:00
}
static HRESULT WINAPI RegistrarCF_LockServer(IClassFactory *iface, BOOL lock)
{
TRACE("(%p)->(%x)\n", iface, lock);
if(lock)
InterlockedIncrement(&dll_count);
else
InterlockedDecrement(&dll_count);
2005-03-14 11:51:27 +01:00
return S_OK;
}
static const IClassFactoryVtbl IRegistrarCFVtbl = {
RegistrarCF_QueryInterface,
RegistrarCF_AddRef,
RegistrarCF_Release,
RegistrarCF_CreateInstance,
RegistrarCF_LockServer
};
static IClassFactory RegistrarCF = { &IRegistrarCFVtbl };
/**************************************************************
* DllGetClassObject (ATL.2)
2005-03-14 11:51:27 +01:00
*/
HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, LPVOID *ppvObject)
2005-03-14 11:51:27 +01:00
{
2006-10-05 11:11:03 +02:00
TRACE("(%s %s %p)\n", debugstr_guid(clsid), debugstr_guid(riid), ppvObject);
2005-03-14 11:51:27 +01:00
if(IsEqualGUID(&CLSID_Registrar, clsid))
return IClassFactory_QueryInterface( &RegistrarCF, riid, ppvObject );
2005-03-14 11:51:27 +01:00
FIXME("Not supported class %s\n", debugstr_guid(clsid));
return CLASS_E_CLASSNOTAVAILABLE;
}
2005-03-16 20:53:41 +01:00
extern HINSTANCE hInst;
static HRESULT do_register_dll_server(IRegistrar *pRegistrar, LPCOLESTR wszDll,
LPCOLESTR wszId, BOOL do_register,
const struct _ATL_REGMAP_ENTRY* pMapEntries)
2005-03-16 20:53:41 +01:00
{
IRegistrar *registrar;
2005-03-16 20:53:41 +01:00
HRESULT hres;
const struct _ATL_REGMAP_ENTRY *pMapEntry;
2005-03-16 20:53:41 +01:00
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
Registrar_create(NULL, &IID_IRegistrar, (void**)&registrar);
IRegistrar_AddReplacement(registrar, wszModule, wszDll);
2005-03-16 20:53:41 +01:00
for (pMapEntry = pMapEntries; pMapEntry && pMapEntry->szKey; pMapEntry++)
IRegistrar_AddReplacement(registrar, pMapEntry->szKey, pMapEntry->szData);
2005-03-16 20:53:41 +01:00
if(do_register)
hres = IRegistrar_ResourceRegisterSz(registrar, wszDll, wszId, wszRegistry);
2005-03-16 20:53:41 +01:00
else
hres = IRegistrar_ResourceUnregisterSz(registrar, wszDll, wszId, wszRegistry);
2005-03-16 20:53:41 +01:00
if(registrar != pRegistrar)
IRegistrar_Release(registrar);
2005-03-16 20:53:41 +01:00
return hres;
}
static HRESULT do_register_server(BOOL do_register)
{
static const WCHAR CLSID_RegistrarW[] =
{'C','L','S','I','D','_','R','e','g','i','s','t','r','a','r',0};
static const WCHAR atl_dllW[] = {'a','t','l','.','d','l','l',0};
WCHAR clsid_str[40];
const struct _ATL_REGMAP_ENTRY reg_map[] = {{CLSID_RegistrarW, clsid_str}, {NULL,NULL}};
StringFromGUID2(&CLSID_Registrar, clsid_str, sizeof(clsid_str)/sizeof(WCHAR));
return do_register_dll_server(NULL, atl_dllW, MAKEINTRESOURCEW(101), do_register, reg_map);
}
/***********************************************************************
* AtlModuleUpdateRegistryFromResourceD [ATL.@]
*
*/
HRESULT WINAPI AtlModuleUpdateRegistryFromResourceD(_ATL_MODULEW* pM, LPCOLESTR lpszRes,
BOOL bRegister, struct _ATL_REGMAP_ENTRY* pMapEntries, IRegistrar* pReg)
{
HINSTANCE lhInst = pM->m_hInst;
/* everything inside this function below this point
* should go into atl71.AtlUpdateRegistryFromResourceD
*/
WCHAR module_name[MAX_PATH];
if(!GetModuleFileNameW(lhInst, module_name, MAX_PATH)) {
FIXME("hinst %p: did not get module name\n",
lhInst);
return E_FAIL;
}
TRACE("%p (%s), %s, %d, %p, %p\n", hInst, debugstr_w(module_name),
debugstr_w(lpszRes), bRegister, pMapEntries, pReg);
return do_register_dll_server(pReg, module_name, lpszRes, bRegister, pMapEntries);
}
2005-03-16 20:53:41 +01:00
/***********************************************************************
* DllRegisterServer (ATL.@)
*/
HRESULT WINAPI DllRegisterServer(void)
2005-03-16 20:53:41 +01:00
{
TRACE("\n");
return do_register_server(TRUE);
}
/***********************************************************************
2010-11-13 03:56:30 +01:00
* DllUnRegisterServer (ATL.@)
2005-03-16 20:53:41 +01:00
*/
HRESULT WINAPI DllUnregisterServer(void)
2005-03-16 20:53:41 +01:00
{
TRACE("\n");
return do_register_server(FALSE);
}
/***********************************************************************
* DllCanUnloadNow (ATL.@)
*/
HRESULT WINAPI DllCanUnloadNow(void)
{
TRACE("dll_count = %u\n", dll_count);
return dll_count ? S_FALSE : S_OK;
}