2 * Copyright 2005 Jacek Caban
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(atl
);
40 static LONG dll_count
;
42 /**************************************************************
43 * ATLRegistrar implementation
50 {{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
52 {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
54 {{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
56 {{'H','K','E','Y','_','U','S','E','R','S',0},
58 {{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
59 HKEY_PERFORMANCE_DATA
},
60 {{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
62 {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
64 {{'H','K','C','R',0}, HKEY_CLASSES_ROOT
},
65 {{'H','K','C','U',0}, HKEY_CURRENT_USER
},
66 {{'H','K','L','M',0}, HKEY_LOCAL_MACHINE
},
67 {{'H','K','U',0}, HKEY_USERS
},
68 {{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA
},
69 {{'H','K','D','D',0}, HKEY_DYN_DATA
},
70 {{'H','K','C','C',0}, HKEY_CURRENT_CONFIG
}
73 typedef struct rep_list_str
{
77 struct rep_list_str
*next
;
81 const IRegistrarVtbl
*lpVtbl
;
92 static void strbuf_init(strbuf
*buf
)
94 buf
->str
= HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR
));
99 static void strbuf_write(LPCOLESTR str
, strbuf
*buf
, int len
)
103 if(buf
->len
+len
+1 >= buf
->alloc
) {
104 buf
->alloc
= (buf
->len
+len
)<<1;
105 buf
->str
= HeapReAlloc(GetProcessHeap(), 0, buf
->str
, buf
->alloc
*sizeof(WCHAR
));
107 memcpy(buf
->str
+buf
->len
, str
, len
*sizeof(OLECHAR
));
109 buf
->str
[buf
->len
] = '\0';
112 static HRESULT
get_word(LPCOLESTR
*str
, strbuf
*buf
)
114 LPCOLESTR iter
, iter2
= *str
;
119 while(isspaceW(*iter2
))
127 if(*iter
== '}' || *iter
== '=') {
128 strbuf_write(iter
++, buf
, 1);
129 }else if(*iter
== '\'') {
131 iter
= strchrW(iter
, '\'');
133 WARN("Unexpected end of script\n");
135 return DISP_E_EXCEPTION
;
137 strbuf_write(iter2
, buf
, iter
-iter2
);
140 while(*iter
&& !isspaceW(*iter
))
142 strbuf_write(iter2
, buf
, iter
-iter2
);
145 while(isspaceW(*iter
))
151 static HRESULT
do_preprocess(const Registrar
*This
, LPCOLESTR data
, strbuf
*buf
)
153 LPCOLESTR iter
, iter2
= data
;
155 static const WCHAR wstr
[] = {'%',0};
157 iter
= strchrW(data
, '%');
159 strbuf_write(iter2
, buf
, iter
-iter2
);
163 return DISP_E_EXCEPTION
;
164 iter
= strchrW(iter2
, '%');
166 return DISP_E_EXCEPTION
;
169 strbuf_write(wstr
, buf
, 1);
171 for(rep_iter
= This
->rep
; rep_iter
; rep_iter
= rep_iter
->next
) {
172 if(rep_iter
->key_len
== iter
-iter2
173 && !memicmpW(iter2
, rep_iter
->key
, rep_iter
->key_len
))
177 WARN("Could not find replacement: %s\n", debugstr_wn(iter2
, iter
-iter2
));
178 return DISP_E_EXCEPTION
;
181 strbuf_write(rep_iter
->item
, buf
, -1);
185 iter
= strchrW(iter
, '%');
188 strbuf_write(iter2
, buf
, -1);
189 TRACE("%s\n", debugstr_w(buf
->str
));
194 static HRESULT
do_process_key(LPCOLESTR
*pstr
, HKEY parent_key
, strbuf
*buf
, BOOL do_register
)
196 LPCOLESTR iter
= *pstr
;
210 static const WCHAR wstrNoRemove
[] = {'N','o','R','e','m','o','v','e',0};
211 static const WCHAR wstrForceRemove
[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
212 static const WCHAR wstrDelete
[] = {'D','e','l','e','t','e',0};
213 static const WCHAR wstrval
[] = {'v','a','l',0};
216 hres
= get_word(&iter
, buf
);
221 while(buf
->str
[1] || buf
->str
[0] != '}') {
223 if(!lstrcmpiW(buf
->str
, wstrNoRemove
))
224 key_type
= NO_REMOVE
;
225 else if(!lstrcmpiW(buf
->str
, wstrForceRemove
))
226 key_type
= FORCE_REMOVE
;
227 else if(!lstrcmpiW(buf
->str
, wstrval
))
229 else if(!lstrcmpiW(buf
->str
, wstrDelete
))
230 key_type
= DO_DELETE
;
232 if(key_type
!= NORMAL
) {
233 hres
= get_word(&iter
, buf
);
237 TRACE("name = %s\n", debugstr_w(buf
->str
));
240 if(key_type
== IS_VAL
) {
242 strbuf_write(buf
->str
, &name
, -1);
243 }else if(key_type
== DO_DELETE
) {
244 TRACE("Deleting %s\n", debugstr_w(buf
->str
));
245 RegDeleteTreeW(parent_key
, buf
->str
);
247 if(key_type
== FORCE_REMOVE
)
248 RegDeleteTreeW(parent_key
, buf
->str
);
249 lres
= RegCreateKeyW(parent_key
, buf
->str
, &hkey
);
250 if(lres
!= ERROR_SUCCESS
) {
251 WARN("Could not create(open) key: %08x\n", lres
);
252 hres
= HRESULT_FROM_WIN32(lres
);
256 }else if(key_type
!= IS_VAL
&& key_type
!= DO_DELETE
) {
257 strbuf_write(buf
->str
, &name
, -1);
258 lres
= RegOpenKeyW(parent_key
, buf
->str
, &hkey
);
259 if(lres
!= ERROR_SUCCESS
)
260 WARN("Could not open key %s: %08x\n", debugstr_w(name
.str
), lres
);
263 if(key_type
!= DO_DELETE
&& *iter
== '=') {
265 hres
= get_word(&iter
, buf
);
269 WARN("Wrong registry type: %s\n", debugstr_w(buf
->str
));
270 hres
= DISP_E_EXCEPTION
;
274 switch(buf
->str
[0]) {
276 hres
= get_word(&iter
, buf
);
279 lres
= RegSetValueExW(hkey
, name
.len
? name
.str
: NULL
, 0, REG_SZ
, (PBYTE
)buf
->str
,
280 (lstrlenW(buf
->str
)+1)*sizeof(WCHAR
));
281 if(lres
!= ERROR_SUCCESS
) {
282 WARN("Could set value of key: %08x\n", lres
);
283 hres
= HRESULT_FROM_WIN32(lres
);
290 if(*iter
== '0' && iter
[1] == 'x') {
292 dw
= strtolW(iter
, &end
, 16);
294 dw
= strtolW(iter
, &end
, 10);
297 lres
= RegSetValueExW(hkey
, name
.len
? name
.str
: NULL
, 0, REG_DWORD
,
298 (PBYTE
)&dw
, sizeof(dw
));
299 if(lres
!= ERROR_SUCCESS
) {
300 WARN("Could set value of key: %08x\n", lres
);
301 hres
= HRESULT_FROM_WIN32(lres
);
307 WARN("Wrong resource type: %s\n", debugstr_w(buf
->str
));
308 hres
= DISP_E_EXCEPTION
;
315 hres
= get_word(&iter
, buf
);
319 }else if(key_type
== IS_VAL
) {
320 WARN("value not set!\n");
321 hres
= DISP_E_EXCEPTION
;
325 if(key_type
!= IS_VAL
&& key_type
!= DO_DELETE
&& *iter
== '{' && isspaceW(iter
[1])) {
326 hres
= get_word(&iter
, buf
);
329 hres
= do_process_key(&iter
, hkey
, buf
, do_register
);
334 TRACE("%x %x\n", do_register
, key_type
);
335 if(!do_register
&& (key_type
== NORMAL
|| key_type
== FORCE_REMOVE
)) {
336 TRACE("Deleting %s\n", debugstr_w(name
.str
));
337 RegDeleteKeyW(parent_key
, name
.str
);
340 if(hkey
&& key_type
!= IS_VAL
)
345 hres
= get_word(&iter
, buf
);
350 HeapFree(GetProcessHeap(), 0, name
.str
);
351 if(hkey
&& key_type
!= IS_VAL
)
357 static HRESULT
do_process_root_key(LPCOLESTR data
, BOOL do_register
)
359 LPCOLESTR iter
= data
;
365 hres
= get_word(&iter
, &buf
);
371 WARN("ward.len == 0, failed\n");
372 hres
= DISP_E_EXCEPTION
;
375 for(i
=0; i
<sizeof(root_keys
)/sizeof(root_keys
[0]); i
++) {
376 if(!lstrcmpiW(buf
.str
, root_keys
[i
].name
))
379 if(i
== sizeof(root_keys
)/sizeof(root_keys
[0])) {
380 WARN("Wrong root key name: %s\n", debugstr_w(buf
.str
));
381 hres
= DISP_E_EXCEPTION
;
384 hres
= get_word(&iter
, &buf
);
387 if(buf
.str
[1] || buf
.str
[0] != '{') {
388 WARN("Failed, expected '{', got %s\n", debugstr_w(buf
.str
));
389 hres
= DISP_E_EXCEPTION
;
392 hres
= do_process_key(&iter
, root_keys
[i
].key
, &buf
, do_register
);
394 WARN("Processing key failed: %08x\n", hres
);
397 hres
= get_word(&iter
, &buf
);
401 HeapFree(GetProcessHeap(), 0, buf
.str
);
405 static HRESULT
string_register(Registrar
*This
, LPCOLESTR data
, BOOL do_register
)
410 TRACE("(%p %s %x)\n", This
, debugstr_w(data
), do_register
);
413 hres
= do_preprocess(This
, data
, &buf
);
415 WARN("preprocessing failed!\n");
416 HeapFree(GetProcessHeap(), 0, buf
.str
);
420 hres
= do_process_root_key(buf
.str
, do_register
);
421 if(FAILED(hres
) && do_register
)
422 do_process_root_key(buf
.str
, FALSE
);
424 HeapFree(GetProcessHeap(), 0, buf
.str
);
428 static HRESULT
resource_register(Registrar
*This
, LPCOLESTR resFileName
,
429 LPCOLESTR szID
, LPCOLESTR szType
, BOOL do_register
)
438 hins
= LoadLibraryExW(resFileName
, NULL
, LOAD_LIBRARY_AS_DATAFILE
);
440 src
= FindResourceW(hins
, szID
, szType
);
442 regstra
= LoadResource(hins
, src
);
443 reslen
= SizeofResource(hins
, src
);
445 len
= MultiByteToWideChar(CP_ACP
, 0, regstra
, reslen
, NULL
, 0)+1;
446 regstrw
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, len
*sizeof(WCHAR
));
447 MultiByteToWideChar(CP_ACP
, 0, regstra
, reslen
, regstrw
, len
);
448 regstrw
[len
-1] = '\0';
450 hres
= string_register(This
, regstrw
, do_register
);
452 HeapFree(GetProcessHeap(), 0, regstrw
);
454 WARN("could not load resource\n");
455 hres
= HRESULT_FROM_WIN32(GetLastError());
458 WARN("Could not find source\n");
459 hres
= HRESULT_FROM_WIN32(GetLastError());
463 WARN("Could not load resource file\n");
464 hres
= HRESULT_FROM_WIN32(GetLastError());
470 static HRESULT
file_register(Registrar
*This
, LPCOLESTR fileName
, BOOL do_register
)
479 file
= CreateFileW(fileName
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_READONLY
, NULL
);
480 if(file
!= INVALID_HANDLE_VALUE
) {
481 filelen
= GetFileSize(file
, NULL
);
482 regstra
= HeapAlloc(GetProcessHeap(), 0, filelen
);
483 lres
= ReadFile(file
, regstra
, filelen
, NULL
, NULL
);
484 if(lres
== ERROR_SUCCESS
) {
485 len
= MultiByteToWideChar(CP_ACP
, 0, regstra
, filelen
, NULL
, 0)+1;
486 regstrw
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, len
*sizeof(WCHAR
));
487 MultiByteToWideChar(CP_ACP
, 0, regstra
, filelen
, regstrw
, len
);
488 regstrw
[len
-1] = '\0';
490 hres
= string_register(This
, regstrw
, do_register
);
492 HeapFree(GetProcessHeap(), 0, regstrw
);
494 WARN("Failed to read faile\n");
495 hres
= HRESULT_FROM_WIN32(lres
);
497 HeapFree(GetProcessHeap(), 0, regstra
);
500 WARN("Could not open file\n");
501 hres
= HRESULT_FROM_WIN32(GetLastError());
507 static HRESULT WINAPI
Registrar_QueryInterface(IRegistrar
*iface
, REFIID riid
, void **ppvObject
)
509 TRACE("(%p)->(%s %p\n", iface
, debugstr_guid(riid
), ppvObject
);
511 if(IsEqualGUID(&IID_IUnknown
, riid
) || IsEqualGUID(&IID_IRegistrar
, riid
)) {
512 IRegistrar_AddRef(iface
);
516 return E_NOINTERFACE
;
519 static ULONG WINAPI
Registrar_AddRef(IRegistrar
*iface
)
521 Registrar
*This
= (Registrar
*)iface
;
522 ULONG ref
= InterlockedIncrement(&This
->ref
);
523 TRACE("(%p) ->%d\n", This
, ref
);
527 static ULONG WINAPI
Registrar_Release(IRegistrar
*iface
)
529 Registrar
*This
= (Registrar
*)iface
;
530 ULONG ref
= InterlockedDecrement(&This
->ref
);
532 TRACE("(%p) ->%d\n", This
, ref
);
534 IRegistrar_ClearReplacements(iface
);
535 HeapFree(GetProcessHeap(), 0, This
);
536 InterlockedDecrement(&dll_count
);
541 static HRESULT WINAPI
Registrar_AddReplacement(IRegistrar
*iface
, LPCOLESTR Key
, LPCOLESTR item
)
543 Registrar
*This
= (Registrar
*)iface
;
547 TRACE("(%p)->(%s %s)\n", This
, debugstr_w(Key
), debugstr_w(item
));
549 new_rep
= HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list
));
551 new_rep
->key_len
= lstrlenW(Key
);
552 new_rep
->key
= HeapAlloc(GetProcessHeap(), 0, (new_rep
->key_len
+ 1) * sizeof(OLECHAR
));
553 memcpy(new_rep
->key
, Key
, (new_rep
->key_len
+1)*sizeof(OLECHAR
));
555 len
= lstrlenW(item
)+1;
556 new_rep
->item
= HeapAlloc(GetProcessHeap(), 0, len
*sizeof(OLECHAR
));
557 memcpy(new_rep
->item
, item
, len
*sizeof(OLECHAR
));
559 new_rep
->next
= This
->rep
;
565 static HRESULT WINAPI
Registrar_ClearReplacements(IRegistrar
*iface
)
567 Registrar
*This
= (Registrar
*)iface
;
568 rep_list
*iter
, *iter2
;
570 TRACE("(%p)\n", This
);
578 HeapFree(GetProcessHeap(), 0, iter
->key
);
579 HeapFree(GetProcessHeap(), 0, iter
->item
);
580 HeapFree(GetProcessHeap(), 0, iter
);
588 static HRESULT WINAPI
Registrar_ResourceRegisterSz(IRegistrar
* iface
, LPCOLESTR resFileName
,
589 LPCOLESTR szID
, LPCOLESTR szType
)
591 Registrar
*This
= (Registrar
*)iface
;
592 TRACE("(%p)->(%s %s %s)\n", This
, debugstr_w(resFileName
), debugstr_w(szID
), debugstr_w(szType
));
593 return resource_register(This
, resFileName
, szID
, szType
, TRUE
);
596 static HRESULT WINAPI
Registrar_ResourceUnregisterSz(IRegistrar
* iface
, LPCOLESTR resFileName
,
597 LPCOLESTR szID
, LPCOLESTR szType
)
599 Registrar
*This
= (Registrar
*)iface
;
600 TRACE("(%p)->(%s %s %s)\n", This
, debugstr_w(resFileName
), debugstr_w(szID
), debugstr_w(szType
));
601 return resource_register(This
, resFileName
, szID
, szType
, FALSE
);
604 static HRESULT WINAPI
Registrar_FileRegister(IRegistrar
* iface
, LPCOLESTR fileName
)
606 Registrar
*This
= (Registrar
*)iface
;
607 TRACE("(%p)->(%s)\n", This
, debugstr_w(fileName
));
608 return file_register(This
, fileName
, TRUE
);
611 static HRESULT WINAPI
Registrar_FileUnregister(IRegistrar
* iface
, LPCOLESTR fileName
)
613 Registrar
*This
= (Registrar
*)iface
;
614 FIXME("(%p)->(%s)\n", This
, debugstr_w(fileName
));
615 return file_register(This
, fileName
, FALSE
);
618 static HRESULT WINAPI
Registrar_StringRegister(IRegistrar
* iface
, LPCOLESTR data
)
620 Registrar
*This
= (Registrar
*)iface
;
621 TRACE("(%p)->(%s)\n", This
, debugstr_w(data
));
622 return string_register(This
, data
, TRUE
);
625 static HRESULT WINAPI
Registrar_StringUnregister(IRegistrar
* iface
, LPCOLESTR data
)
627 Registrar
*This
= (Registrar
*)iface
;
628 TRACE("(%p)->(%s)\n", This
, debugstr_w(data
));
629 return string_register(This
, data
, FALSE
);
632 static HRESULT WINAPI
Registrar_ResourceRegister(IRegistrar
* iface
, LPCOLESTR resFileName
,
633 UINT nID
, LPCOLESTR szType
)
635 Registrar
*This
= (Registrar
*)iface
;
636 TRACE("(%p)->(%s %d %s)\n", iface
, debugstr_w(resFileName
), nID
, debugstr_w(szType
));
637 return resource_register(This
, resFileName
, MAKEINTRESOURCEW(nID
), szType
, TRUE
);
640 static HRESULT WINAPI
Registrar_ResourceUnregister(IRegistrar
* iface
, LPCOLESTR resFileName
,
641 UINT nID
, LPCOLESTR szType
)
643 Registrar
*This
= (Registrar
*)iface
;
644 TRACE("(%p)->(%s %d %s)\n", This
, debugstr_w(resFileName
), nID
, debugstr_w(szType
));
645 return resource_register(This
, resFileName
, MAKEINTRESOURCEW(nID
), szType
, FALSE
);
648 static const IRegistrarVtbl RegistrarVtbl
= {
649 Registrar_QueryInterface
,
652 Registrar_AddReplacement
,
653 Registrar_ClearReplacements
,
654 Registrar_ResourceRegisterSz
,
655 Registrar_ResourceUnregisterSz
,
656 Registrar_FileRegister
,
657 Registrar_FileUnregister
,
658 Registrar_StringRegister
,
659 Registrar_StringUnregister
,
660 Registrar_ResourceRegister
,
661 Registrar_ResourceUnregister
,
664 static HRESULT
Registrar_create(const IUnknown
*pUnkOuter
, REFIID riid
, void **ppvObject
)
668 if(!IsEqualGUID(&IID_IUnknown
, riid
) && !IsEqualGUID(&IID_IRegistrar
, riid
))
669 return E_NOINTERFACE
;
671 ret
= HeapAlloc(GetProcessHeap(), 0, sizeof(Registrar
));
672 ret
->lpVtbl
= &RegistrarVtbl
;
677 InterlockedIncrement(&dll_count
);
682 /**************************************************************
683 * ClassFactory implementation
686 static HRESULT WINAPI
RegistrarCF_QueryInterface(IClassFactory
*iface
, REFIID riid
, void **ppvObject
)
688 TRACE("(%p)->(%s %p)\n", iface
, debugstr_guid(riid
), ppvObject
);
690 if(IsEqualGUID(&IID_IUnknown
, riid
) || IsEqualGUID(&IID_IClassFactory
, riid
)) {
692 IClassFactory_AddRef( iface
);
696 return E_NOINTERFACE
;
699 static ULONG WINAPI
RegistrarCF_AddRef(IClassFactory
*iface
)
701 InterlockedIncrement(&dll_count
);
705 static ULONG WINAPI
RegistrarCF_Release(IClassFactory
*iface
)
707 InterlockedDecrement(&dll_count
);
711 static HRESULT WINAPI
RegistrarCF_CreateInstance(IClassFactory
*iface
, LPUNKNOWN pUnkOuter
,
712 REFIID riid
, void **ppvObject
)
714 TRACE("(%p)->(%s %p)\n", iface
, debugstr_guid(riid
), ppvObject
);
715 return Registrar_create(pUnkOuter
, riid
, ppvObject
);
718 static HRESULT WINAPI
RegistrarCF_LockServer(IClassFactory
*iface
, BOOL lock
)
720 TRACE("(%p)->(%x)\n", iface
, lock
);
723 InterlockedIncrement(&dll_count
);
725 InterlockedDecrement(&dll_count
);
730 static const IClassFactoryVtbl IRegistrarCFVtbl
= {
731 RegistrarCF_QueryInterface
,
734 RegistrarCF_CreateInstance
,
735 RegistrarCF_LockServer
738 static IClassFactory RegistrarCF
= { &IRegistrarCFVtbl
};
740 /**************************************************************
741 * DllGetClassObject (ATL.2)
743 HRESULT WINAPI
DllGetClassObject(REFCLSID clsid
, REFIID riid
, LPVOID
*ppvObject
)
745 TRACE("(%s %s %p)\n", debugstr_guid(clsid
), debugstr_guid(riid
), ppvObject
);
747 if(IsEqualGUID(&CLSID_Registrar
, clsid
))
748 return IClassFactory_QueryInterface( &RegistrarCF
, riid
, ppvObject
);
750 FIXME("Not supported class %s\n", debugstr_guid(clsid
));
751 return CLASS_E_CLASSNOTAVAILABLE
;
754 extern HINSTANCE hInst
;
756 static HRESULT
do_register_dll_server(IRegistrar
*pRegistrar
, LPCOLESTR wszDll
,
757 LPCOLESTR wszId
, BOOL do_register
,
758 const struct _ATL_REGMAP_ENTRY
* pMapEntries
)
760 IRegistrar
*registrar
;
762 const struct _ATL_REGMAP_ENTRY
*pMapEntry
;
764 static const WCHAR wszModule
[] = {'M','O','D','U','L','E',0};
765 static const WCHAR wszRegistry
[] = {'R','E','G','I','S','T','R','Y',0};
768 registrar
= pRegistrar
;
770 Registrar_create(NULL
, &IID_IRegistrar
, (void**)®istrar
);
772 IRegistrar_AddReplacement(registrar
, wszModule
, wszDll
);
774 for (pMapEntry
= pMapEntries
; pMapEntry
&& pMapEntry
->szKey
; pMapEntry
++)
775 IRegistrar_AddReplacement(registrar
, pMapEntry
->szKey
, pMapEntry
->szData
);
778 hres
= IRegistrar_ResourceRegisterSz(registrar
, wszDll
, wszId
, wszRegistry
);
780 hres
= IRegistrar_ResourceUnregisterSz(registrar
, wszDll
, wszId
, wszRegistry
);
782 if(registrar
!= pRegistrar
)
783 IRegistrar_Release(registrar
);
787 static HRESULT
do_register_server(BOOL do_register
)
789 static const WCHAR CLSID_RegistrarW
[] =
790 {'C','L','S','I','D','_','R','e','g','i','s','t','r','a','r',0};
791 static const WCHAR atl_dllW
[] = {'a','t','l','.','d','l','l',0};
794 const struct _ATL_REGMAP_ENTRY reg_map
[] = {{CLSID_RegistrarW
, clsid_str
}, {NULL
,NULL
}};
796 StringFromGUID2(&CLSID_Registrar
, clsid_str
, sizeof(clsid_str
)/sizeof(WCHAR
));
797 return do_register_dll_server(NULL
, atl_dllW
, MAKEINTRESOURCEW(101), do_register
, reg_map
);
800 /***********************************************************************
801 * AtlModuleUpdateRegistryFromResourceD [ATL.@]
804 HRESULT WINAPI
AtlModuleUpdateRegistryFromResourceD(_ATL_MODULEW
* pM
, LPCOLESTR lpszRes
,
805 BOOL bRegister
, struct _ATL_REGMAP_ENTRY
* pMapEntries
, IRegistrar
* pReg
)
807 HINSTANCE lhInst
= pM
->m_hInst
;
808 /* everything inside this function below this point
809 * should go into atl71.AtlUpdateRegistryFromResourceD
811 WCHAR module_name
[MAX_PATH
];
813 if(!GetModuleFileNameW(lhInst
, module_name
, MAX_PATH
)) {
814 FIXME("hinst %p: did not get module name\n",
819 TRACE("%p (%s), %s, %d, %p, %p\n", hInst
, debugstr_w(module_name
),
820 debugstr_w(lpszRes
), bRegister
, pMapEntries
, pReg
);
822 return do_register_dll_server(pReg
, module_name
, lpszRes
, bRegister
, pMapEntries
);
825 /***********************************************************************
826 * DllRegisterServer (ATL.@)
828 HRESULT WINAPI
DllRegisterServer(void)
831 return do_register_server(TRUE
);
834 /***********************************************************************
835 * DllRegisterServer (ATL.@)
837 HRESULT WINAPI
DllUnregisterServer(void)
840 return do_register_server(FALSE
);
843 /***********************************************************************
844 * DllCanUnloadNow (ATL.@)
846 HRESULT WINAPI
DllCanUnloadNow(void)
848 TRACE("dll_count = %u\n", dll_count
);
849 return dll_count
? S_FALSE
: S_OK
;