atl: Make some data const.
[wine] / dlls / atl / registrar.c
1 /*
2  * Copyright 2005 Jacek Caban
3  *
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.
8  *
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.
13  *
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
17  */
18
19
20 #include <stdarg.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "winreg.h"
28 #include "objbase.h"
29 #include "oaidl.h"
30 #include "shlwapi.h"
31
32 #define ATL_INITGUID
33 #include "atliface.h"
34 #include "atlbase.h"
35
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(atl);
40
41 static LONG dll_count;
42
43 /**************************************************************
44  * ATLRegistrar implementation
45  */
46
47 static const struct {
48     WCHAR name[22];
49     HKEY  key;
50 } root_keys[] = {
51     {{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
52                     HKEY_CLASSES_ROOT},
53     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
54                     HKEY_CURRENT_USER},
55     {{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
56                     HKEY_LOCAL_MACHINE},
57     {{'H','K','E','Y','_','U','S','E','R','S',0},
58                     HKEY_USERS},
59     {{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
60                     HKEY_PERFORMANCE_DATA},
61     {{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
62                     HKEY_DYN_DATA},
63     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
64                     HKEY_CURRENT_CONFIG},
65     {{'H','K','C','R',0}, HKEY_CLASSES_ROOT},
66     {{'H','K','C','U',0}, HKEY_CURRENT_USER},
67     {{'H','K','L','M',0}, HKEY_LOCAL_MACHINE},
68     {{'H','K','U',0},     HKEY_USERS},
69     {{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA},
70     {{'H','K','D','D',0}, HKEY_DYN_DATA},
71     {{'H','K','C','C',0}, HKEY_CURRENT_CONFIG}
72 };
73
74 typedef struct rep_list_str {
75     LPOLESTR key;
76     LPOLESTR item;
77     int key_len;
78     struct rep_list_str *next;
79 } rep_list;
80
81 typedef struct {
82     const IRegistrarVtbl *lpVtbl;
83     LONG ref;
84     rep_list *rep;
85 } Registrar;
86
87 typedef struct {
88     LPOLESTR str;
89     DWORD alloc;
90     DWORD len;
91 } strbuf;
92
93 static void strbuf_init(strbuf *buf)
94 {
95     buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
96     buf->alloc = 128;
97     buf->len = 0;
98 }
99
100 static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
101 {
102     if(len == -1)
103         len = lstrlenW(str);
104     if(buf->len+len+1 >= buf->alloc) {
105         buf->alloc = (buf->len+len)<<1;
106         buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
107     }
108     memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
109     buf->len += len;
110     buf->str[buf->len] = '\0';
111 }
112
113 static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
114 {
115     LPCOLESTR iter, iter2 = *str;
116
117     buf->len = 0;
118     buf->str[0] = '\0';
119
120     while(isspaceW(*iter2))
121         iter2++;
122     iter = iter2;
123     if(!*iter) {
124         *str = iter;
125         return S_OK;
126     }
127
128     if(*iter == '}' || *iter == '=') {
129         strbuf_write(iter++, buf, 1);
130     }else if(*iter == '\'') {
131         iter2 = ++iter;
132         iter = strchrW(iter, '\'');
133         if(!iter) {
134             WARN("Unexpected end of script\n");
135             *str = iter;
136             return DISP_E_EXCEPTION;
137         }
138         strbuf_write(iter2, buf, iter-iter2);
139         iter++;
140     }else {
141         while(*iter && !isspaceW(*iter))
142             iter++;
143         strbuf_write(iter2, buf, iter-iter2);
144     }
145
146     while(isspaceW(*iter))
147         iter++;
148     *str = iter;
149     return S_OK;
150 }
151
152 static HRESULT do_preprocess(Registrar *This, LPCOLESTR data, strbuf *buf)
153 {
154     LPCOLESTR iter, iter2 = data;
155     rep_list *rep_iter;
156     static const WCHAR wstr[] = {'%',0};
157
158     iter = strchrW(data, '%');
159     while(iter) {
160         strbuf_write(iter2, buf, iter-iter2);
161
162         iter2 = ++iter;
163         if(!*iter2)
164             return DISP_E_EXCEPTION;
165         iter = strchrW(iter2, '%');
166         if(!iter)
167             return DISP_E_EXCEPTION;
168
169         if(iter == iter2) {
170             strbuf_write(wstr, buf, 1);
171         }else {
172             for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
173                 if(rep_iter->key_len == iter-iter2
174                         && !memicmpW(iter2, rep_iter->key, rep_iter->key_len))
175                     break;
176             }
177             if(!rep_iter) {
178                 WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2));
179                 return DISP_E_EXCEPTION;
180             }
181
182             strbuf_write(rep_iter->item, buf, -1);
183         }
184
185         iter2 = ++iter;
186         iter = strchrW(iter, '%');
187     }
188
189     strbuf_write(iter2, buf, -1);
190     TRACE("%s\n", debugstr_w(buf->str));
191
192     return S_OK;
193 }
194
195 static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
196 {
197     LPCOLESTR iter = *pstr;
198     HRESULT hres;
199     LONG lres;
200     HKEY hkey = 0;
201     strbuf name;
202     
203     enum {
204         NORMAL,
205         NO_REMOVE,
206         IS_VAL,
207         FORCE_REMOVE,
208         DO_DELETE
209     } key_type = NORMAL; 
210
211     static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
212     static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
213     static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
214     static const WCHAR wstrval[] = {'v','a','l',0};
215
216     iter = *pstr;
217     hres = get_word(&iter, buf);
218     if(FAILED(hres))
219         return hres;
220     strbuf_init(&name);
221
222     while(buf->str[1] || buf->str[0] != '}') {
223         key_type = NORMAL;
224         if(!lstrcmpiW(buf->str, wstrNoRemove))
225             key_type = NO_REMOVE;
226         else if(!lstrcmpiW(buf->str, wstrForceRemove))
227             key_type = FORCE_REMOVE;
228         else if(!lstrcmpiW(buf->str, wstrval))
229             key_type = IS_VAL;
230         else if(!lstrcmpiW(buf->str, wstrDelete))
231             key_type = DO_DELETE;
232
233         if(key_type != NORMAL) {
234             hres = get_word(&iter, buf);
235             if(FAILED(hres))
236                 break;
237         }
238         TRACE("name = %s\n", debugstr_w(buf->str));
239     
240         if(do_register) {
241             if(key_type == IS_VAL) {
242                 hkey = parent_key;
243                 strbuf_write(buf->str, &name, -1);
244             }else if(key_type == DO_DELETE) {
245                 TRACE("Deleting %s\n", debugstr_w(buf->str));
246                 lres = SHDeleteKeyW(parent_key, buf->str);
247             }else {
248                 if(key_type == FORCE_REMOVE)
249                     SHDeleteKeyW(parent_key, buf->str);
250                 lres = RegCreateKeyW(parent_key, buf->str, &hkey);
251                 if(lres != ERROR_SUCCESS) {
252                     WARN("Could not create(open) key: %08x\n", lres);
253                     hres = HRESULT_FROM_WIN32(lres);
254                     break;
255                 }
256             }
257         }else if(key_type != IS_VAL && key_type != DO_DELETE) {
258             strbuf_write(buf->str, &name, -1);
259             lres = RegOpenKeyW(parent_key, buf->str, &hkey);
260               if(lres != ERROR_SUCCESS)
261                 WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
262         }
263
264         if(key_type != DO_DELETE && *iter == '=') {
265             iter++;
266             hres = get_word(&iter, buf);
267             if(FAILED(hres))
268                 break;
269             if(buf->len != 1) {
270                 WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
271                 hres = DISP_E_EXCEPTION;
272                 break;
273             }
274             if(do_register) {
275                 switch(buf->str[0]) {
276                 case 's':
277                     hres = get_word(&iter, buf);
278                     if(FAILED(hres))
279                         break;
280                     lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_SZ, (PBYTE)buf->str,
281                             (lstrlenW(buf->str)+1)*sizeof(WCHAR));
282                     if(lres != ERROR_SUCCESS) {
283                         WARN("Could set value of key: %08x\n", lres);
284                         hres = HRESULT_FROM_WIN32(lres);
285                         break;
286                     }
287                     break;
288                 case 'd': {
289                     WCHAR *end;
290                     DWORD dw;
291                     if(*iter == '0' && iter[1] == 'x') {
292                         iter += 2;
293                         dw = strtolW(iter, &end, 16);
294                     }else {
295                         dw = strtolW(iter, &end, 10);
296                     }
297                     iter = end;
298                     lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_DWORD,
299                             (PBYTE)&dw, sizeof(dw));
300                     if(lres != ERROR_SUCCESS) {
301                         WARN("Could set value of key: %08x\n", lres);
302                         hres = HRESULT_FROM_WIN32(lres);
303                         break;
304                     }
305                     break;
306                 }
307                 default:
308                     WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
309                     hres = DISP_E_EXCEPTION;
310                 };
311                 if(FAILED(hres))
312                     break;
313             }else {
314                 if(*iter == '-')
315                     iter++;
316                 hres = get_word(&iter, buf);
317                 if(FAILED(hres))
318                     break;
319             }
320         }else if(key_type == IS_VAL) {
321             WARN("value not set!\n");
322             hres = DISP_E_EXCEPTION;
323             break;
324         }
325
326         if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && isspaceW(iter[1])) {
327             hres = get_word(&iter, buf);
328             if(FAILED(hres))
329                 break;
330             hres = do_process_key(&iter, hkey, buf, do_register);
331             if(FAILED(hres))
332                 break;
333         }
334
335         TRACE("%x %x\n", do_register, key_type);
336         if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
337             TRACE("Deleting %s\n", debugstr_w(name.str));
338             RegDeleteKeyW(parent_key, name.str);
339         }
340
341         if(hkey && key_type != IS_VAL)
342             RegCloseKey(hkey);
343         hkey = 0;
344         name.len = 0;
345         
346         hres = get_word(&iter, buf);
347         if(FAILED(hres))
348             break;
349     }
350
351     HeapFree(GetProcessHeap(), 0, name.str);
352     if(hkey && key_type != IS_VAL)
353         RegCloseKey(hkey);
354     *pstr = iter;
355     return hres;
356 }
357
358 static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
359 {
360     LPCOLESTR iter = data;
361     strbuf buf;
362     HRESULT hres = S_OK;
363     int i;
364
365     strbuf_init(&buf);
366     hres = get_word(&iter, &buf);
367     if(FAILED(hres))
368         return hres;
369
370     while(*iter) {
371         if(!buf.len) {
372             WARN("ward.len == 0, failed\n");
373             hres = DISP_E_EXCEPTION;
374             break;
375         }
376         for(i=0; i<sizeof(root_keys)/sizeof(root_keys[0]); i++) {
377             if(!lstrcmpiW(buf.str, root_keys[i].name))
378                 break;
379         }
380         if(i == sizeof(root_keys)/sizeof(root_keys[0])) {
381             WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
382             hres = DISP_E_EXCEPTION;
383             break;
384         }
385         hres = get_word(&iter, &buf);
386         if(FAILED(hres))
387             break;
388         if(buf.str[1] || buf.str[0] != '{') {
389             WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
390             hres = DISP_E_EXCEPTION;
391             break;
392         }
393         hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
394         if(FAILED(hres)) {
395             WARN("Processing key failed: %08x\n", hres);
396             break;
397         }
398         hres = get_word(&iter, &buf);
399         if(FAILED(hres))
400             break;
401     }
402     HeapFree(GetProcessHeap(), 0, buf.str);
403     return hres;
404 }
405
406 static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
407 {
408     strbuf buf;
409     HRESULT hres;
410
411     TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
412
413     strbuf_init(&buf);
414     hres = do_preprocess(This, data, &buf);
415     if(FAILED(hres)) {
416         WARN("preprocessing failed!\n");
417         HeapFree(GetProcessHeap(), 0, buf.str);
418         return hres;
419     }
420
421     hres = do_process_root_key(buf.str, do_register);
422     if(FAILED(hres) && do_register)
423         do_process_root_key(buf.str, FALSE);
424
425     HeapFree(GetProcessHeap(), 0, buf.str);
426     return hres;
427 }
428
429 static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
430                         LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
431 {
432     HINSTANCE hins;
433     HRSRC src;
434     LPSTR regstra;
435     LPWSTR regstrw;
436     DWORD len, reslen;
437     HRESULT hres;
438
439     hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
440     if(hins) {
441         src = FindResourceW(hins, szID, szType);
442         if(src) {
443             regstra = (LPSTR)LoadResource(hins, src);
444             reslen = SizeofResource(hins, src);
445             if(regstra) {
446                 len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
447                 regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
448                 MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, -1);
449                 regstrw[len-1] = '\0';
450
451                 hres = string_register(This, regstrw, do_register);
452
453                 HeapFree(GetProcessHeap(), 0, regstrw);
454             }else {
455                 WARN("could not load resource\n");
456                 hres = HRESULT_FROM_WIN32(GetLastError());
457             }
458             HeapFree(GetProcessHeap(), 0, regstra);
459         }else {
460             WARN("Could not find source\n");
461             hres = HRESULT_FROM_WIN32(GetLastError());
462         }
463         FreeLibrary(hins);
464     }else {
465         WARN("Could not load resource file\n");
466         hres = HRESULT_FROM_WIN32(GetLastError());
467     }
468
469     return hres;
470 }
471
472 static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
473 {
474     HANDLE file;
475     DWORD filelen, len;
476     LPWSTR regstrw;
477     LPSTR regstra;
478     LRESULT lres;
479     HRESULT hres;
480
481     file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
482     if(file) {
483         filelen = GetFileSize(file, NULL);
484         regstra = HeapAlloc(GetProcessHeap(), 0, filelen);
485         lres = ReadFile(file, regstra, filelen, NULL, NULL);
486         if(lres == ERROR_SUCCESS) {
487             len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0)+1;
488             regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
489             MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, -1);
490             regstrw[len-1] = '\0';
491             
492             hres = string_register(This, regstrw, do_register);
493
494             HeapFree(GetProcessHeap(), 0, regstrw);
495         }else {
496             WARN("Failed to read faile\n");
497             hres = HRESULT_FROM_WIN32(lres);
498         }
499         HeapFree(GetProcessHeap(), 0, regstra);
500         CloseHandle(file);
501     }else {
502         WARN("Could not open file\n");
503         hres = HRESULT_FROM_WIN32(GetLastError());
504     }
505
506     return hres;
507 }
508
509 static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
510 {
511     TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
512
513     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
514         IRegistrar_AddRef(iface);
515         *ppvObject = iface;
516         return S_OK;
517     }
518     return E_NOINTERFACE;
519 }
520
521 static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
522 {
523     Registrar *This = (Registrar*)iface;
524     ULONG ref = InterlockedIncrement(&This->ref);
525     TRACE("(%p) ->%d\n", This, ref);
526     return ref;
527 }
528
529 static ULONG WINAPI Registrar_Release(IRegistrar *iface)
530 {
531     Registrar *This = (Registrar*)iface;
532     ULONG ref = InterlockedDecrement(&This->ref);
533
534     TRACE("(%p) ->%d\n", This, ref);
535     if(!ref) {
536         IRegistrar_ClearReplacements(iface);
537         HeapFree(GetProcessHeap(), 0, This);
538         InterlockedDecrement(&dll_count);
539     }
540     return ref;
541 }
542
543 static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
544 {
545     Registrar *This = (Registrar*)iface;
546     int len;
547     rep_list *new_rep;
548
549     TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
550
551     new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
552
553     new_rep->key_len  = lstrlenW(Key);
554     new_rep->key = HeapAlloc(GetProcessHeap(), 0, new_rep->key_len*sizeof(OLECHAR)+1);
555     memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
556
557     len = lstrlenW(item)+1;
558     new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
559     memcpy(new_rep->item, item, len*sizeof(OLECHAR));
560
561     new_rep->next = This->rep;
562     This->rep = new_rep;
563     
564     return S_OK;
565 }
566
567 static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
568 {
569     Registrar *This = (Registrar*)iface;
570     rep_list *iter, *iter2;
571
572     TRACE("(%p)\n", This);
573
574     if(!This->rep)
575         return S_OK;
576
577     iter = This->rep;
578     while(iter) {
579         iter2 = iter->next;
580         HeapFree(GetProcessHeap(), 0, iter->key);
581         HeapFree(GetProcessHeap(), 0, iter->item);
582         HeapFree(GetProcessHeap(), 0, iter);
583         iter = iter2;
584     }
585
586     This->rep = NULL;
587     return S_OK;
588 }
589
590 static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
591                 LPCOLESTR szID, LPCOLESTR szType)
592 {
593     Registrar *This = (Registrar*)iface;
594     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
595     return resource_register(This, resFileName, szID, szType, TRUE);
596 }
597
598 static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
599                 LPCOLESTR szID, LPCOLESTR szType)
600 {
601     Registrar *This = (Registrar*)iface;
602     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
603     return resource_register(This, resFileName, szID, szType, FALSE);
604 }
605
606 static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
607 {
608     Registrar *This = (Registrar*)iface;
609     TRACE("(%p)->(%s)\n", This, debugstr_w(fileName));
610     return file_register(This, fileName, TRUE);
611 }
612
613 static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
614 {
615     Registrar *This = (Registrar*)iface;
616     FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
617     return file_register(This, fileName, FALSE);
618 }
619
620 static HRESULT WINAPI Registrar_StringRegister(IRegistrar* iface, LPCOLESTR data)
621 {
622     Registrar *This = (Registrar*)iface;
623     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
624     return string_register(This, data, TRUE);
625 }
626
627 static HRESULT WINAPI Registrar_StringUnregister(IRegistrar* iface, LPCOLESTR data)
628 {
629     Registrar *This = (Registrar*)iface;
630     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
631     return string_register(This, data, FALSE);
632 }
633
634 static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
635                 UINT nID, LPCOLESTR szType)
636 {
637     Registrar *This = (Registrar*)iface;
638     TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
639     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, TRUE);
640 }
641
642 static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
643                 UINT nID, LPCOLESTR szType)
644 {
645     Registrar *This = (Registrar*)iface;
646     TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
647     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, FALSE);
648 }
649
650 static const IRegistrarVtbl RegistrarVtbl = {
651     Registrar_QueryInterface,
652     Registrar_AddRef,
653     Registrar_Release,
654     Registrar_AddReplacement,
655     Registrar_ClearReplacements,
656     Registrar_ResourceRegisterSz,
657     Registrar_ResourceUnregisterSz,
658     Registrar_FileRegister,
659     Registrar_FileUnregister,
660     Registrar_StringRegister,
661     Registrar_StringUnregister,
662     Registrar_ResourceRegister,
663     Registrar_ResourceUnregister,
664 };
665
666 static HRESULT Registrar_create(LPUNKNOWN pUnkOuter, REFIID riid, void **ppvObject)
667 {
668     Registrar *ret;
669
670     if(!IsEqualGUID(&IID_IUnknown, riid) && !IsEqualGUID(&IID_IRegistrar, riid))
671         return E_NOINTERFACE;
672
673     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(Registrar));
674     ret->lpVtbl = &RegistrarVtbl;
675     ret->ref = 1;
676     ret->rep = NULL;
677     *ppvObject = ret;
678
679     InterlockedIncrement(&dll_count);
680
681     return S_OK;
682 }
683
684 /**************************************************************
685  * ClassFactory implementation
686  */
687
688 static HRESULT WINAPI RegistrarCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppvObject)
689 {
690     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
691
692     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
693         *ppvObject = iface;
694         return S_OK;
695     }
696
697     return E_NOINTERFACE;
698 }
699
700 static ULONG WINAPI RegistrarCF_AddRef(IClassFactory *iface)
701 {
702     InterlockedIncrement(&dll_count);
703     return 2;
704 }
705
706 static ULONG WINAPI RegistrarCF_Release(IClassFactory *iface)
707 {
708     InterlockedDecrement(&dll_count);
709     return 1;
710 }
711
712 static HRESULT WINAPI RegistrarCF_CreateInstance(IClassFactory *iface, LPUNKNOWN pUnkOuter,
713                                                 REFIID riid, void **ppvObject)
714 {
715     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
716     return Registrar_create(pUnkOuter, riid, ppvObject);
717 }
718
719 static HRESULT WINAPI RegistrarCF_LockServer(IClassFactory *iface, BOOL lock)
720 {
721     TRACE("(%p)->(%x)\n", iface, lock);
722
723     if(lock)
724         InterlockedIncrement(&dll_count);
725     else
726         InterlockedDecrement(&dll_count);
727
728     return S_OK;
729 }
730
731 static const IClassFactoryVtbl IRegistrarCFVtbl = {
732     RegistrarCF_QueryInterface,
733     RegistrarCF_AddRef,
734     RegistrarCF_Release,
735     RegistrarCF_CreateInstance,
736     RegistrarCF_LockServer
737 };
738
739 static IClassFactory RegistrarCF = { &IRegistrarCFVtbl };
740
741 /**************************************************************
742  * DllGetClassObject (ATL.2)
743  */
744 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, LPVOID *ppvObject)
745 {
746     TRACE("(%s %s %p)\n", debugstr_guid(clsid), debugstr_guid(riid), ppvObject);
747
748     if(IsEqualGUID(&CLSID_ATLRegistrar, clsid)) {
749         *ppvObject = &RegistrarCF;
750         return S_OK;
751     }
752
753     FIXME("Not supported class %s\n", debugstr_guid(clsid));
754     return CLASS_E_CLASSNOTAVAILABLE;
755 }
756
757 extern HINSTANCE hInst;
758
759 static HRESULT do_register_dll_server(LPCOLESTR wszDll, LPCOLESTR wszId, BOOL do_register)
760 {
761     WCHAR buf[MAX_PATH];
762     HRESULT hres;
763     IRegistrar *pRegistrar;
764
765     static const WCHAR wszModule[] = {'M','O','D','U','L','E',0};
766     static const WCHAR wszRegistry[] = {'R','E','G','I','S','T','R','Y',0};
767     static const WCHAR wszCLSID_ATLRegistrar[] =
768             {'C','L','S','I','D','_','A','T','L','R','e','g','i','s','t','r','a','r',0};
769
770     Registrar_create(NULL, &IID_IRegistrar, (void**)&pRegistrar);
771     IRegistrar_AddReplacement(pRegistrar, wszModule, wszDll);
772
773     StringFromGUID2(&CLSID_ATLRegistrar, buf, sizeof(buf)/sizeof(buf[0]));
774     IRegistrar_AddReplacement(pRegistrar, wszCLSID_ATLRegistrar, buf);
775
776     if(do_register)
777         hres = IRegistrar_ResourceRegisterSz(pRegistrar, wszDll, wszId, wszRegistry);
778     else
779         hres = IRegistrar_ResourceUnregisterSz(pRegistrar, wszDll, wszId, wszRegistry);
780
781     IRegistrar_Release(pRegistrar);
782     return hres;
783 }
784
785 static HRESULT do_register_server(BOOL do_register)
786 {
787     static const WCHAR wszDll[] = {'a','t','l','.','d','l','l',0};
788     return do_register_dll_server(wszDll, MAKEINTRESOURCEW(101), do_register);
789 }
790
791 /***********************************************************************
792  *           AtlModuleUpdateRegistryFromResourceD         [ATL.@]
793  *
794  */
795 HRESULT WINAPI AtlModuleUpdateRegistryFromResourceD(_ATL_MODULEW* pM, LPCOLESTR lpszRes,
796                 BOOL bRegister, struct _ATL_REGMAP_ENTRY* pMapEntries, IRegistrar* pReg)
797 {
798     HINSTANCE lhInst = pM->m_hInst;
799     /* everything inside this function below this point
800      * should go into atl71.AtlUpdateRegistryFromResourceD
801      */
802     WCHAR module_name[MAX_PATH];
803
804     if(pMapEntries || pReg) {
805         FIXME("MapEntries and Registrar parameter not supported\n");
806         return E_FAIL;
807     }
808
809     if(!GetModuleFileNameW(lhInst, module_name, MAX_PATH)) {
810         FIXME("hinst %p: did not get module name\n",
811         lhInst);
812         return E_FAIL;
813     }
814
815     TRACE("%p (%s), %s, %d, %p, %p\n", hInst, debugstr_w(module_name),
816         debugstr_w(lpszRes), bRegister, pMapEntries, pReg);
817
818     return do_register_dll_server(module_name, lpszRes, bRegister);
819 }
820
821 /***********************************************************************
822  *              DllRegisterServer (ATL.@)
823  */
824 HRESULT WINAPI DllRegisterServer(void)
825 {
826     TRACE("\n");
827     return do_register_server(TRUE);
828 }
829
830 /***********************************************************************
831  *              DllRegisterServer (ATL.@)
832  */
833 HRESULT WINAPI DllUnregisterServer(void)
834 {
835     TRACE("\n");
836     return do_register_server(FALSE);
837 }
838
839 /***********************************************************************
840  *              DllCanUnloadNow (ATL.@)
841  */
842 HRESULT WINAPI DllCanUnloadNow(void)
843 {
844     TRACE("dll_count = %u\n", dll_count);
845     return dll_count ? S_FALSE : S_OK;
846 }