kernel32: Remove a useless error message.
[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     IRegistrar IRegistrar_iface;
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 inline Registrar *impl_from_IRegistrar(IRegistrar *iface)
93 {
94     return CONTAINING_RECORD(iface, Registrar, IRegistrar_iface);
95 }
96
97 static void strbuf_init(strbuf *buf)
98 {
99     buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
100     buf->alloc = 128;
101     buf->len = 0;
102 }
103
104 static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
105 {
106     if(len == -1)
107         len = lstrlenW(str);
108     if(buf->len+len+1 >= buf->alloc) {
109         buf->alloc = (buf->len+len)<<1;
110         buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
111     }
112     memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
113     buf->len += len;
114     buf->str[buf->len] = '\0';
115 }
116
117 static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
118 {
119     LPCOLESTR iter, iter2 = *str;
120
121     buf->len = 0;
122     buf->str[0] = '\0';
123
124     while(isspaceW(*iter2))
125         iter2++;
126     iter = iter2;
127     if(!*iter) {
128         *str = iter;
129         return S_OK;
130     }
131
132     if(*iter == '}' || *iter == '=') {
133         strbuf_write(iter++, buf, 1);
134     }else if(*iter == '\'') {
135         iter2 = ++iter;
136         iter = strchrW(iter, '\'');
137         if(!iter) {
138             WARN("Unexpected end of script\n");
139             *str = iter;
140             return DISP_E_EXCEPTION;
141         }
142         strbuf_write(iter2, buf, iter-iter2);
143         iter++;
144     }else {
145         while(*iter && !isspaceW(*iter))
146             iter++;
147         strbuf_write(iter2, buf, iter-iter2);
148     }
149
150     while(isspaceW(*iter))
151         iter++;
152     *str = iter;
153     return S_OK;
154 }
155
156 static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf)
157 {
158     LPCOLESTR iter, iter2 = data;
159     rep_list *rep_iter;
160     static const WCHAR wstr[] = {'%',0};
161
162     iter = strchrW(data, '%');
163     while(iter) {
164         strbuf_write(iter2, buf, iter-iter2);
165
166         iter2 = ++iter;
167         if(!*iter2)
168             return DISP_E_EXCEPTION;
169         iter = strchrW(iter2, '%');
170         if(!iter)
171             return DISP_E_EXCEPTION;
172
173         if(iter == iter2) {
174             strbuf_write(wstr, buf, 1);
175         }else {
176             for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
177                 if(rep_iter->key_len == iter-iter2
178                         && !memicmpW(iter2, rep_iter->key, rep_iter->key_len))
179                     break;
180             }
181             if(!rep_iter) {
182                 WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2));
183                 return DISP_E_EXCEPTION;
184             }
185
186             strbuf_write(rep_iter->item, buf, -1);
187         }
188
189         iter2 = ++iter;
190         iter = strchrW(iter, '%');
191     }
192
193     strbuf_write(iter2, buf, -1);
194     TRACE("%s\n", debugstr_w(buf->str));
195
196     return S_OK;
197 }
198
199 static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
200 {
201     LPCOLESTR iter = *pstr;
202     HRESULT hres;
203     LONG lres;
204     HKEY hkey = 0;
205     strbuf name;
206     
207     enum {
208         NORMAL,
209         NO_REMOVE,
210         IS_VAL,
211         FORCE_REMOVE,
212         DO_DELETE
213     } key_type = NORMAL; 
214
215     static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
216     static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
217     static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
218     static const WCHAR wstrval[] = {'v','a','l',0};
219
220     iter = *pstr;
221     hres = get_word(&iter, buf);
222     if(FAILED(hres))
223         return hres;
224     strbuf_init(&name);
225
226     while(buf->str[1] || buf->str[0] != '}') {
227         key_type = NORMAL;
228         if(!lstrcmpiW(buf->str, wstrNoRemove))
229             key_type = NO_REMOVE;
230         else if(!lstrcmpiW(buf->str, wstrForceRemove))
231             key_type = FORCE_REMOVE;
232         else if(!lstrcmpiW(buf->str, wstrval))
233             key_type = IS_VAL;
234         else if(!lstrcmpiW(buf->str, wstrDelete))
235             key_type = DO_DELETE;
236
237         if(key_type != NORMAL) {
238             hres = get_word(&iter, buf);
239             if(FAILED(hres))
240                 break;
241         }
242         TRACE("name = %s\n", debugstr_w(buf->str));
243     
244         if(do_register) {
245             if(key_type == IS_VAL) {
246                 hkey = parent_key;
247                 strbuf_write(buf->str, &name, -1);
248             }else if(key_type == DO_DELETE) {
249                 TRACE("Deleting %s\n", debugstr_w(buf->str));
250                 RegDeleteTreeW(parent_key, buf->str);
251             }else {
252                 if(key_type == FORCE_REMOVE)
253                     RegDeleteTreeW(parent_key, buf->str);
254                 lres = RegCreateKeyW(parent_key, buf->str, &hkey);
255                 if(lres != ERROR_SUCCESS) {
256                     WARN("Could not create(open) key: %08x\n", lres);
257                     hres = HRESULT_FROM_WIN32(lres);
258                     break;
259                 }
260             }
261         }else if(key_type != IS_VAL && key_type != DO_DELETE) {
262             strbuf_write(buf->str, &name, -1);
263             lres = RegOpenKeyW(parent_key, buf->str, &hkey);
264               if(lres != ERROR_SUCCESS)
265                 WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
266         }
267
268         if(key_type != DO_DELETE && *iter == '=') {
269             iter++;
270             hres = get_word(&iter, buf);
271             if(FAILED(hres))
272                 break;
273             if(buf->len != 1) {
274                 WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
275                 hres = DISP_E_EXCEPTION;
276                 break;
277             }
278             if(do_register) {
279                 switch(buf->str[0]) {
280                 case 's':
281                     hres = get_word(&iter, buf);
282                     if(FAILED(hres))
283                         break;
284                     lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_SZ, (PBYTE)buf->str,
285                             (lstrlenW(buf->str)+1)*sizeof(WCHAR));
286                     if(lres != ERROR_SUCCESS) {
287                         WARN("Could set value of key: %08x\n", lres);
288                         hres = HRESULT_FROM_WIN32(lres);
289                         break;
290                     }
291                     break;
292                 case 'd': {
293                     DWORD dw;
294                     hres = get_word(&iter, buf);
295                     if(FAILED(hres))
296                         break;
297                     dw = atoiW(buf->str);
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                 case 'b': {
308                     BYTE *bytes;
309                     DWORD count;
310                     DWORD i;
311                     hres = get_word(&iter, buf);
312                     if(FAILED(hres))
313                         break;
314                     count = (lstrlenW(buf->str) + 1) / 2;
315                     bytes = HeapAlloc(GetProcessHeap(), 0, count);
316                     if(bytes == NULL) {
317                         hres = E_OUTOFMEMORY;
318                         break;
319                     }
320                     for(i = 0; i < count && buf->str[2*i]; i++) {
321                         WCHAR digits[3];
322                         if(!isxdigitW(buf->str[2*i]) || !isxdigitW(buf->str[2*i + 1])) {
323                             hres = E_FAIL;
324                             break;
325                         }
326                         digits[0] = buf->str[2*i];
327                         digits[1] = buf->str[2*i + 1];
328                         digits[2] = 0;
329                         bytes[i] = (BYTE) strtoulW(digits, NULL, 16);
330                     }
331                     if(SUCCEEDED(hres)) {
332                         lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_BINARY,
333                             bytes, count);
334                         if(lres != ERROR_SUCCESS) {
335                             WARN("Could not set value of key: 0x%08x\n", lres);
336                             hres = HRESULT_FROM_WIN32(lres);
337                         }
338                     }
339                     HeapFree(GetProcessHeap(), 0, bytes);
340                     break;
341                 }
342                 default:
343                     WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
344                     hres = DISP_E_EXCEPTION;
345                 };
346                 if(FAILED(hres))
347                     break;
348             }else {
349                 if(*iter == '-')
350                     iter++;
351                 hres = get_word(&iter, buf);
352                 if(FAILED(hres))
353                     break;
354             }
355         }else if(key_type == IS_VAL) {
356             WARN("value not set!\n");
357             hres = DISP_E_EXCEPTION;
358             break;
359         }
360
361         if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && isspaceW(iter[1])) {
362             hres = get_word(&iter, buf);
363             if(FAILED(hres))
364                 break;
365             hres = do_process_key(&iter, hkey, buf, do_register);
366             if(FAILED(hres))
367                 break;
368         }
369
370         TRACE("%x %x\n", do_register, key_type);
371         if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
372             TRACE("Deleting %s\n", debugstr_w(name.str));
373             RegDeleteKeyW(parent_key, name.str);
374         }
375
376         if(hkey && key_type != IS_VAL)
377             RegCloseKey(hkey);
378         hkey = 0;
379         name.len = 0;
380         
381         hres = get_word(&iter, buf);
382         if(FAILED(hres))
383             break;
384     }
385
386     HeapFree(GetProcessHeap(), 0, name.str);
387     if(hkey && key_type != IS_VAL)
388         RegCloseKey(hkey);
389     *pstr = iter;
390     return hres;
391 }
392
393 static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
394 {
395     LPCOLESTR iter = data;
396     strbuf buf;
397     HRESULT hres = S_OK;
398     unsigned int i;
399
400     strbuf_init(&buf);
401     hres = get_word(&iter, &buf);
402     if(FAILED(hres))
403         return hres;
404
405     while(*iter) {
406         if(!buf.len) {
407             WARN("ward.len == 0, failed\n");
408             hres = DISP_E_EXCEPTION;
409             break;
410         }
411         for(i=0; i<sizeof(root_keys)/sizeof(root_keys[0]); i++) {
412             if(!lstrcmpiW(buf.str, root_keys[i].name))
413                 break;
414         }
415         if(i == sizeof(root_keys)/sizeof(root_keys[0])) {
416             WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
417             hres = DISP_E_EXCEPTION;
418             break;
419         }
420         hres = get_word(&iter, &buf);
421         if(FAILED(hres))
422             break;
423         if(buf.str[1] || buf.str[0] != '{') {
424             WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
425             hres = DISP_E_EXCEPTION;
426             break;
427         }
428         hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
429         if(FAILED(hres)) {
430             WARN("Processing key failed: %08x\n", hres);
431             break;
432         }
433         hres = get_word(&iter, &buf);
434         if(FAILED(hres))
435             break;
436     }
437     HeapFree(GetProcessHeap(), 0, buf.str);
438     return hres;
439 }
440
441 static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
442 {
443     strbuf buf;
444     HRESULT hres;
445
446     TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
447
448     strbuf_init(&buf);
449     hres = do_preprocess(This, data, &buf);
450     if(FAILED(hres)) {
451         WARN("preprocessing failed!\n");
452         HeapFree(GetProcessHeap(), 0, buf.str);
453         return hres;
454     }
455
456     hres = do_process_root_key(buf.str, do_register);
457     if(FAILED(hres) && do_register)
458         do_process_root_key(buf.str, FALSE);
459
460     HeapFree(GetProcessHeap(), 0, buf.str);
461     return hres;
462 }
463
464 static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
465                         LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
466 {
467     HINSTANCE hins;
468     HRSRC src;
469     LPSTR regstra;
470     LPWSTR regstrw;
471     DWORD len, reslen;
472     HRESULT hres;
473
474     hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
475     if(hins) {
476         src = FindResourceW(hins, szID, szType);
477         if(src) {
478             regstra = LoadResource(hins, src);
479             reslen = SizeofResource(hins, src);
480             if(regstra) {
481                 len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
482                 regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
483                 MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, len);
484                 regstrw[len-1] = '\0';
485
486                 hres = string_register(This, regstrw, do_register);
487
488                 HeapFree(GetProcessHeap(), 0, regstrw);
489             }else {
490                 WARN("could not load resource\n");
491                 hres = HRESULT_FROM_WIN32(GetLastError());
492             }
493         }else {
494             WARN("Could not find source\n");
495             hres = HRESULT_FROM_WIN32(GetLastError());
496         }
497         FreeLibrary(hins);
498     }else {
499         WARN("Could not load resource file\n");
500         hres = HRESULT_FROM_WIN32(GetLastError());
501     }
502
503     return hres;
504 }
505
506 static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
507 {
508     HANDLE file;
509     DWORD filelen, len;
510     LPWSTR regstrw;
511     LPSTR regstra;
512     LRESULT lres;
513     HRESULT hres;
514
515     file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
516     if(file != INVALID_HANDLE_VALUE) {
517         filelen = GetFileSize(file, NULL);
518         regstra = HeapAlloc(GetProcessHeap(), 0, filelen);
519         lres = ReadFile(file, regstra, filelen, NULL, NULL);
520         if(lres == ERROR_SUCCESS) {
521             len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0)+1;
522             regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
523             MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
524             regstrw[len-1] = '\0';
525             
526             hres = string_register(This, regstrw, do_register);
527
528             HeapFree(GetProcessHeap(), 0, regstrw);
529         }else {
530             WARN("Failed to read faile\n");
531             hres = HRESULT_FROM_WIN32(lres);
532         }
533         HeapFree(GetProcessHeap(), 0, regstra);
534         CloseHandle(file);
535     }else {
536         WARN("Could not open file\n");
537         hres = HRESULT_FROM_WIN32(GetLastError());
538     }
539
540     return hres;
541 }
542
543 static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
544 {
545     TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
546
547     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
548         IRegistrar_AddRef(iface);
549         *ppvObject = iface;
550         return S_OK;
551     }
552     return E_NOINTERFACE;
553 }
554
555 static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
556 {
557     Registrar *This = impl_from_IRegistrar(iface);
558     ULONG ref = InterlockedIncrement(&This->ref);
559     TRACE("(%p) ->%d\n", This, ref);
560     return ref;
561 }
562
563 static ULONG WINAPI Registrar_Release(IRegistrar *iface)
564 {
565     Registrar *This = impl_from_IRegistrar(iface);
566     ULONG ref = InterlockedDecrement(&This->ref);
567
568     TRACE("(%p) ->%d\n", This, ref);
569     if(!ref) {
570         IRegistrar_ClearReplacements(iface);
571         HeapFree(GetProcessHeap(), 0, This);
572         InterlockedDecrement(&dll_count);
573     }
574     return ref;
575 }
576
577 static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
578 {
579     Registrar *This = impl_from_IRegistrar(iface);
580     int len;
581     rep_list *new_rep;
582
583     TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
584
585     new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
586
587     new_rep->key_len  = lstrlenW(Key);
588     new_rep->key = HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR));
589     memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
590
591     len = lstrlenW(item)+1;
592     new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
593     memcpy(new_rep->item, item, len*sizeof(OLECHAR));
594
595     new_rep->next = This->rep;
596     This->rep = new_rep;
597     
598     return S_OK;
599 }
600
601 static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
602 {
603     Registrar *This = impl_from_IRegistrar(iface);
604     rep_list *iter, *iter2;
605
606     TRACE("(%p)\n", This);
607
608     if(!This->rep)
609         return S_OK;
610
611     iter = This->rep;
612     while(iter) {
613         iter2 = iter->next;
614         HeapFree(GetProcessHeap(), 0, iter->key);
615         HeapFree(GetProcessHeap(), 0, iter->item);
616         HeapFree(GetProcessHeap(), 0, iter);
617         iter = iter2;
618     }
619
620     This->rep = NULL;
621     return S_OK;
622 }
623
624 static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
625                 LPCOLESTR szID, LPCOLESTR szType)
626 {
627     Registrar *This = impl_from_IRegistrar(iface);
628     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
629     return resource_register(This, resFileName, szID, szType, TRUE);
630 }
631
632 static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
633                 LPCOLESTR szID, LPCOLESTR szType)
634 {
635     Registrar *This = impl_from_IRegistrar(iface);
636     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
637     return resource_register(This, resFileName, szID, szType, FALSE);
638 }
639
640 static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
641 {
642     Registrar *This = impl_from_IRegistrar(iface);
643     TRACE("(%p)->(%s)\n", This, debugstr_w(fileName));
644     return file_register(This, fileName, TRUE);
645 }
646
647 static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
648 {
649     Registrar *This = impl_from_IRegistrar(iface);
650     FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
651     return file_register(This, fileName, FALSE);
652 }
653
654 static HRESULT WINAPI Registrar_StringRegister(IRegistrar* iface, LPCOLESTR data)
655 {
656     Registrar *This = impl_from_IRegistrar(iface);
657     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
658     return string_register(This, data, TRUE);
659 }
660
661 static HRESULT WINAPI Registrar_StringUnregister(IRegistrar* iface, LPCOLESTR data)
662 {
663     Registrar *This = impl_from_IRegistrar(iface);
664     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
665     return string_register(This, data, FALSE);
666 }
667
668 static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
669                 UINT nID, LPCOLESTR szType)
670 {
671     Registrar *This = impl_from_IRegistrar(iface);
672     TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
673     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, TRUE);
674 }
675
676 static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
677                 UINT nID, LPCOLESTR szType)
678 {
679     Registrar *This = impl_from_IRegistrar(iface);
680     TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
681     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, FALSE);
682 }
683
684 static const IRegistrarVtbl RegistrarVtbl = {
685     Registrar_QueryInterface,
686     Registrar_AddRef,
687     Registrar_Release,
688     Registrar_AddReplacement,
689     Registrar_ClearReplacements,
690     Registrar_ResourceRegisterSz,
691     Registrar_ResourceUnregisterSz,
692     Registrar_FileRegister,
693     Registrar_FileUnregister,
694     Registrar_StringRegister,
695     Registrar_StringUnregister,
696     Registrar_ResourceRegister,
697     Registrar_ResourceUnregister,
698 };
699
700 static HRESULT Registrar_create(const IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
701 {
702     Registrar *ret;
703
704     if(!IsEqualGUID(&IID_IUnknown, riid) && !IsEqualGUID(&IID_IRegistrar, riid))
705         return E_NOINTERFACE;
706
707     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(Registrar));
708     ret->IRegistrar_iface.lpVtbl = &RegistrarVtbl;
709     ret->ref = 1;
710     ret->rep = NULL;
711     *ppvObject = ret;
712
713     InterlockedIncrement(&dll_count);
714
715     return S_OK;
716 }
717
718 /**************************************************************
719  * ClassFactory implementation
720  */
721
722 static HRESULT WINAPI RegistrarCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppvObject)
723 {
724     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
725
726     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
727         *ppvObject = iface;
728         IClassFactory_AddRef( iface );
729         return S_OK;
730     }
731
732     return E_NOINTERFACE;
733 }
734
735 static ULONG WINAPI RegistrarCF_AddRef(IClassFactory *iface)
736 {
737     InterlockedIncrement(&dll_count);
738     return 2;
739 }
740
741 static ULONG WINAPI RegistrarCF_Release(IClassFactory *iface)
742 {
743     InterlockedDecrement(&dll_count);
744     return 1;
745 }
746
747 static HRESULT WINAPI RegistrarCF_CreateInstance(IClassFactory *iface, LPUNKNOWN pUnkOuter,
748                                                 REFIID riid, void **ppvObject)
749 {
750     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
751     return Registrar_create(pUnkOuter, riid, ppvObject);
752 }
753
754 static HRESULT WINAPI RegistrarCF_LockServer(IClassFactory *iface, BOOL lock)
755 {
756     TRACE("(%p)->(%x)\n", iface, lock);
757
758     if(lock)
759         InterlockedIncrement(&dll_count);
760     else
761         InterlockedDecrement(&dll_count);
762
763     return S_OK;
764 }
765
766 static const IClassFactoryVtbl IRegistrarCFVtbl = {
767     RegistrarCF_QueryInterface,
768     RegistrarCF_AddRef,
769     RegistrarCF_Release,
770     RegistrarCF_CreateInstance,
771     RegistrarCF_LockServer
772 };
773
774 static IClassFactory RegistrarCF = { &IRegistrarCFVtbl };
775
776 /**************************************************************
777  * DllGetClassObject (ATL.2)
778  */
779 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, LPVOID *ppvObject)
780 {
781     TRACE("(%s %s %p)\n", debugstr_guid(clsid), debugstr_guid(riid), ppvObject);
782
783     if(IsEqualGUID(&CLSID_Registrar, clsid))
784         return IClassFactory_QueryInterface( &RegistrarCF, riid, ppvObject );
785
786     FIXME("Not supported class %s\n", debugstr_guid(clsid));
787     return CLASS_E_CLASSNOTAVAILABLE;
788 }
789
790 extern HINSTANCE hInst;
791
792 /* this is a copy of the winecrt0 registration code that creates the registrar directly, */
793 /* since we can't do it through ole32 until it has been registered */
794
795 struct reg_info
796 {
797     IRegistrar  *registrar;
798     BOOL         do_register;
799     HRESULT      result;
800 };
801
802 static IRegistrar *create_registrar( HMODULE inst, struct reg_info *info )
803 {
804     info->result = Registrar_create( NULL, &IID_IRegistrar, (void**)&info->registrar );
805     if (SUCCEEDED( info->result ))
806     {
807         static const WCHAR moduleW[] = {'M','O','D','U','L','E',0};
808         WCHAR str[MAX_PATH];
809
810         GetModuleFileNameW( hInst, str, MAX_PATH );
811         IRegistrar_AddReplacement( info->registrar, moduleW, str );
812     }
813     return info->registrar;
814 }
815
816 static BOOL CALLBACK register_resource( HMODULE module, LPCWSTR type, LPWSTR name, LONG_PTR arg )
817 {
818     struct reg_info *info = (struct reg_info *)arg;
819     WCHAR *buffer;
820     HRSRC rsrc = FindResourceW( module, name, type );
821     char *str = LoadResource( module, rsrc );
822     DWORD lenW, lenA = SizeofResource( module, rsrc );
823
824     if (!str) return FALSE;
825     if (!info->registrar && !create_registrar( module, info )) return FALSE;
826     lenW = MultiByteToWideChar( CP_UTF8, 0, str, lenA, NULL, 0 ) + 1;
827     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
828     {
829         info->result = E_OUTOFMEMORY;
830         return FALSE;
831     }
832     MultiByteToWideChar( CP_UTF8, 0, str, lenA, buffer, lenW );
833     buffer[lenW - 1] = 0;
834
835     if (info->do_register)
836         info->result = IRegistrar_StringRegister( info->registrar, buffer );
837     else
838         info->result = IRegistrar_StringUnregister( info->registrar, buffer );
839
840     HeapFree( GetProcessHeap(), 0, buffer );
841     return SUCCEEDED(info->result);
842 }
843
844 static HRESULT do_register_dll_server(IRegistrar *pRegistrar, LPCOLESTR wszDll,
845                                       LPCOLESTR wszId, BOOL do_register,
846                                       const struct _ATL_REGMAP_ENTRY* pMapEntries)
847 {
848     IRegistrar *registrar;
849     HRESULT hres;
850     const struct _ATL_REGMAP_ENTRY *pMapEntry;
851
852     static const WCHAR wszModule[] = {'M','O','D','U','L','E',0};
853     static const WCHAR wszRegistry[] = {'R','E','G','I','S','T','R','Y',0};
854
855     if (pRegistrar)
856         registrar = pRegistrar;
857     else
858         Registrar_create(NULL, &IID_IRegistrar, (void**)&registrar);
859
860     IRegistrar_AddReplacement(registrar, wszModule, wszDll);
861
862     for (pMapEntry = pMapEntries; pMapEntry && pMapEntry->szKey; pMapEntry++)
863         IRegistrar_AddReplacement(registrar, pMapEntry->szKey, pMapEntry->szData);
864
865     if(do_register)
866         hres = IRegistrar_ResourceRegisterSz(registrar, wszDll, wszId, wszRegistry);
867     else
868         hres = IRegistrar_ResourceUnregisterSz(registrar, wszDll, wszId, wszRegistry);
869
870     if(registrar != pRegistrar)
871         IRegistrar_Release(registrar);
872     return hres;
873 }
874
875 /***********************************************************************
876  *           AtlModuleUpdateRegistryFromResourceD         [ATL.@]
877  *
878  */
879 HRESULT WINAPI AtlModuleUpdateRegistryFromResourceD(_ATL_MODULEW* pM, LPCOLESTR lpszRes,
880                 BOOL bRegister, struct _ATL_REGMAP_ENTRY* pMapEntries, IRegistrar* pReg)
881 {
882     HINSTANCE lhInst = pM->m_hInst;
883     /* everything inside this function below this point
884      * should go into atl71.AtlUpdateRegistryFromResourceD
885      */
886     WCHAR module_name[MAX_PATH];
887
888     if(!GetModuleFileNameW(lhInst, module_name, MAX_PATH)) {
889         FIXME("hinst %p: did not get module name\n",
890         lhInst);
891         return E_FAIL;
892     }
893
894     TRACE("%p (%s), %s, %d, %p, %p\n", hInst, debugstr_w(module_name),
895         debugstr_w(lpszRes), bRegister, pMapEntries, pReg);
896
897     return do_register_dll_server(pReg, module_name, lpszRes, bRegister, pMapEntries);
898 }
899
900 static const WCHAR regtypeW[] = {'W','I','N','E','_','R','E','G','I','S','T','R','Y',0};
901
902 /***********************************************************************
903  *              DllRegisterServer (ATL.@)
904  */
905 HRESULT WINAPI DllRegisterServer(void)
906 {
907     struct reg_info info;
908
909     info.registrar = NULL;
910     info.do_register = TRUE;
911     info.result = S_OK;
912     EnumResourceNamesW( hInst, regtypeW, register_resource, (LONG_PTR)&info );
913     if (info.registrar) IRegistrar_Release( info.registrar );
914     return info.result;
915 }
916
917 /***********************************************************************
918  *              DllUnRegisterServer (ATL.@)
919  */
920 HRESULT WINAPI DllUnregisterServer(void)
921 {
922     struct reg_info info;
923
924     info.registrar = NULL;
925     info.do_register = FALSE;
926     info.result = S_OK;
927     EnumResourceNamesW( hInst, regtypeW, register_resource, (LONG_PTR)&info );
928     if (info.registrar) IRegistrar_Release( info.registrar );
929     return info.result;
930 }
931
932 /***********************************************************************
933  *              DllCanUnloadNow (ATL.@)
934  */
935 HRESULT WINAPI DllCanUnloadNow(void)
936 {
937     TRACE("dll_count = %u\n", dll_count);
938     return dll_count ? S_FALSE : S_OK;
939 }