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**)®istrar);
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 }
940
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.