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