ReactOS  0.4.14-dev-593-g1793dcc
registrar.c
Go to the documentation of this file.
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 #define COBJMACROS
20 
21 #include "wine/atlbase.h"
22 
23 #include "wine/debug.h"
24 
26 
27 /**************************************************************
28  * ATLRegistrar implementation
29  */
30 
31 static const struct {
32  WCHAR name[22];
34 } root_keys[] = {
35  {{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
37  {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
39  {{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
41  {{'H','K','E','Y','_','U','S','E','R','S',0},
42  HKEY_USERS},
43  {{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
45  {{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
47  {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
49  {{'H','K','C','R',0}, HKEY_CLASSES_ROOT},
50  {{'H','K','C','U',0}, HKEY_CURRENT_USER},
51  {{'H','K','L','M',0}, HKEY_LOCAL_MACHINE},
52  {{'H','K','U',0}, HKEY_USERS},
53  {{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA},
54  {{'H','K','D','D',0}, HKEY_DYN_DATA},
55  {{'H','K','C','C',0}, HKEY_CURRENT_CONFIG}
56 };
57 
58 typedef struct rep_list_str {
61  int key_len;
62  struct rep_list_str *next;
63 } rep_list;
64 
65 typedef struct {
69 } Registrar;
70 
71 typedef struct {
75 } strbuf;
76 
78 {
79  return CONTAINING_RECORD(iface, Registrar, IRegistrar_iface);
80 }
81 
82 static void strbuf_init(strbuf *buf)
83 {
84  buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
85  buf->alloc = 128;
86  buf->len = 0;
87 }
88 
89 static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
90 {
91  if(len == -1)
92  len = lstrlenW(str);
93  if(buf->len+len+1 >= buf->alloc) {
94  buf->alloc = (buf->len+len)<<1;
95  buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
96  }
97  memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
98  buf->len += len;
99  buf->str[buf->len] = '\0';
100 }
101 
102 static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
103 {
104  LPCOLESTR iter, iter2 = *str;
105 
106  buf->len = 0;
107  buf->str[0] = '\0';
108 
109  while(iswspace(*iter2))
110  iter2++;
111  iter = iter2;
112  if(!*iter) {
113  *str = iter;
114  return S_OK;
115  }
116 
117  if(*iter == '}' || *iter == '=') {
118  strbuf_write(iter++, buf, 1);
119  }else if(*iter == '\'') {
120  iter2 = ++iter;
121  iter = wcschr(iter, '\'');
122  if(!iter) {
123  WARN("Unexpected end of script\n");
124  *str = iter;
125  return DISP_E_EXCEPTION;
126  }
127  strbuf_write(iter2, buf, iter-iter2);
128  iter++;
129  }else {
130  while(*iter && !iswspace(*iter))
131  iter++;
132  strbuf_write(iter2, buf, iter-iter2);
133  }
134 
135  while(iswspace(*iter))
136  iter++;
137  *str = iter;
138  return S_OK;
139 }
140 
141 static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf)
142 {
143  LPCOLESTR iter, iter2 = data;
144  rep_list *rep_iter;
145  static const WCHAR wstr[] = {'%',0};
146 
147  iter = wcschr(data, '%');
148  while(iter) {
149  strbuf_write(iter2, buf, iter-iter2);
150 
151  iter2 = ++iter;
152  if(!*iter2)
153  return DISP_E_EXCEPTION;
154  iter = wcschr(iter2, '%');
155  if(!iter)
156  return DISP_E_EXCEPTION;
157 
158  if(iter == iter2) {
159  strbuf_write(wstr, buf, 1);
160  }else {
161  for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
162  if(rep_iter->key_len == iter-iter2
163  && !_wcsnicmp(iter2, rep_iter->key, rep_iter->key_len))
164  break;
165  }
166  if(!rep_iter) {
167  WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2));
168  return DISP_E_EXCEPTION;
169  }
170 
171  strbuf_write(rep_iter->item, buf, -1);
172  }
173 
174  iter2 = ++iter;
175  iter = wcschr(iter, '%');
176  }
177 
178  strbuf_write(iter2, buf, -1);
179  TRACE("%s\n", debugstr_w(buf->str));
180 
181  return S_OK;
182 }
183 
184 static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
185 {
186  LPCOLESTR iter;
187  HRESULT hres;
188  LONG lres;
189  HKEY hkey = 0;
190  strbuf name;
191 
192  enum {
193  NORMAL,
194  NO_REMOVE,
195  IS_VAL,
196  FORCE_REMOVE,
197  DO_DELETE
198  } key_type = NORMAL;
199 
200  static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
201  static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
202  static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
203  static const WCHAR wstrval[] = {'v','a','l',0};
204 
205  iter = *pstr;
206  hres = get_word(&iter, buf);
207  if(FAILED(hres))
208  return hres;
209  strbuf_init(&name);
210 
211  while(buf->str[1] || buf->str[0] != '}') {
212  key_type = NORMAL;
213  if(!lstrcmpiW(buf->str, wstrNoRemove))
214  key_type = NO_REMOVE;
215  else if(!lstrcmpiW(buf->str, wstrForceRemove))
216  key_type = FORCE_REMOVE;
217  else if(!lstrcmpiW(buf->str, wstrval))
218  key_type = IS_VAL;
219  else if(!lstrcmpiW(buf->str, wstrDelete))
220  key_type = DO_DELETE;
221 
222  if(key_type != NORMAL) {
223  hres = get_word(&iter, buf);
224  if(FAILED(hres))
225  break;
226  }
227  TRACE("name = %s\n", debugstr_w(buf->str));
228 
229  if(do_register) {
230  if(key_type == IS_VAL) {
231  hkey = parent_key;
232  strbuf_write(buf->str, &name, -1);
233  }else if(key_type == DO_DELETE) {
234  TRACE("Deleting %s\n", debugstr_w(buf->str));
235  RegDeleteTreeW(parent_key, buf->str);
236  }else {
237  if(key_type == FORCE_REMOVE)
238  RegDeleteTreeW(parent_key, buf->str);
239  lres = RegCreateKeyW(parent_key, buf->str, &hkey);
240  if(lres != ERROR_SUCCESS) {
241  WARN("Could not create(open) key: %08x\n", lres);
242  hres = HRESULT_FROM_WIN32(lres);
243  break;
244  }
245  }
246  }else if(key_type != IS_VAL && key_type != DO_DELETE) {
247  strbuf_write(buf->str, &name, -1);
248  lres = RegOpenKeyW(parent_key, buf->str, &hkey);
249  if(lres != ERROR_SUCCESS)
250  WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
251  }
252 
253  if(key_type != DO_DELETE && *iter == '=') {
254  iter++;
255  hres = get_word(&iter, buf);
256  if(FAILED(hres))
257  break;
258  if(buf->len != 1) {
259  WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
261  break;
262  }
263  if(do_register) {
264  switch(buf->str[0]) {
265  case 's':
266  hres = get_word(&iter, buf);
267  if(FAILED(hres))
268  break;
269  lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_SZ, (PBYTE)buf->str,
270  (lstrlenW(buf->str)+1)*sizeof(WCHAR));
271  if(lres != ERROR_SUCCESS) {
272  WARN("Could set value of key: %08x\n", lres);
273  hres = HRESULT_FROM_WIN32(lres);
274  break;
275  }
276  break;
277  case 'd': {
278  DWORD dw;
279  hres = get_word(&iter, buf);
280  if(FAILED(hres))
281  break;
282  dw = wcstol(buf->str, NULL, 10);
283  lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_DWORD,
284  (PBYTE)&dw, sizeof(dw));
285  if(lres != ERROR_SUCCESS) {
286  WARN("Could set value of key: %08x\n", lres);
287  hres = HRESULT_FROM_WIN32(lres);
288  break;
289  }
290  break;
291  }
292  case 'b': {
293  BYTE *bytes;
294  DWORD count;
295  DWORD i;
296  hres = get_word(&iter, buf);
297  if(FAILED(hres))
298  break;
299  count = (lstrlenW(buf->str) + 1) / 2;
301  if(bytes == NULL) {
303  break;
304  }
305  for(i = 0; i < count && buf->str[2*i]; i++) {
306  WCHAR digits[3];
307  if(!iswxdigit(buf->str[2*i]) || !iswxdigit(buf->str[2*i + 1])) {
308  hres = E_FAIL;
309  break;
310  }
311  digits[0] = buf->str[2*i];
312  digits[1] = buf->str[2*i + 1];
313  digits[2] = 0;
314  bytes[i] = (BYTE) wcstoul(digits, NULL, 16);
315  }
316  if(SUCCEEDED(hres)) {
317  lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_BINARY,
318  bytes, count);
319  if(lres != ERROR_SUCCESS) {
320  WARN("Could not set value of key: 0x%08x\n", lres);
321  hres = HRESULT_FROM_WIN32(lres);
322  }
323  }
325  break;
326  }
327  default:
328  WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
330  };
331  if(FAILED(hres))
332  break;
333  }else {
334  if(*iter == '-')
335  iter++;
336  hres = get_word(&iter, buf);
337  if(FAILED(hres))
338  break;
339  }
340  }else if(key_type == IS_VAL) {
341  WARN("value not set!\n");
343  break;
344  }
345 
346  if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && iswspace(iter[1])) {
347  hres = get_word(&iter, buf);
348  if(FAILED(hres))
349  break;
350  hres = do_process_key(&iter, hkey, buf, do_register);
351  if(FAILED(hres))
352  break;
353  }
354 
355  TRACE("%x %x\n", do_register, key_type);
356  if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
357  TRACE("Deleting %s\n", debugstr_w(name.str));
358  RegDeleteKeyW(parent_key, name.str);
359  }
360 
361  if(hkey && key_type != IS_VAL)
362  RegCloseKey(hkey);
363  hkey = 0;
364  name.len = 0;
365 
366  hres = get_word(&iter, buf);
367  if(FAILED(hres))
368  break;
369  }
370 
371  HeapFree(GetProcessHeap(), 0, name.str);
372  if(hkey && key_type != IS_VAL)
373  RegCloseKey(hkey);
374  *pstr = iter;
375  return hres;
376 }
377 
378 static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
379 {
380  LPCOLESTR iter = data;
381  strbuf buf;
382  HRESULT hres;
383  unsigned int i;
384 
385  strbuf_init(&buf);
386  hres = get_word(&iter, &buf);
387  if(FAILED(hres))
388  return hres;
389 
390  while(*iter) {
391  if(!buf.len) {
392  WARN("ward.len == 0, failed\n");
394  break;
395  }
396  for(i=0; i<ARRAY_SIZE(root_keys); i++) {
397  if(!lstrcmpiW(buf.str, root_keys[i].name))
398  break;
399  }
400  if(i == ARRAY_SIZE(root_keys)) {
401  WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
403  break;
404  }
405  hres = get_word(&iter, &buf);
406  if(FAILED(hres))
407  break;
408  if(buf.str[1] || buf.str[0] != '{') {
409  WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
411  break;
412  }
413  hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
414  if(FAILED(hres)) {
415  WARN("Processing key failed: %08x\n", hres);
416  break;
417  }
418  hres = get_word(&iter, &buf);
419  if(FAILED(hres))
420  break;
421  }
422  HeapFree(GetProcessHeap(), 0, buf.str);
423  return hres;
424 }
425 
426 static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
427 {
428  strbuf buf;
429  HRESULT hres;
430 
431  TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
432 
433  strbuf_init(&buf);
435  if(FAILED(hres)) {
436  WARN("preprocessing failed!\n");
437  HeapFree(GetProcessHeap(), 0, buf.str);
438  return hres;
439  }
440 
441  hres = do_process_root_key(buf.str, do_register);
442  if(FAILED(hres) && do_register)
444 
445  HeapFree(GetProcessHeap(), 0, buf.str);
446  return hres;
447 }
448 
449 static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
450  LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
451 {
452  HINSTANCE hins;
453  HRSRC src;
454  LPSTR regstra;
455  LPWSTR regstrw;
456  DWORD len, reslen;
457  HRESULT hres;
458 
459  hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
460  if(hins) {
461  src = FindResourceW(hins, szID, szType);
462  if(src) {
463  regstra = LoadResource(hins, src);
464  reslen = SizeofResource(hins, src);
465  if(regstra) {
466  len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
467  regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
468  MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, len);
469  regstrw[len-1] = '\0';
470 
471  hres = string_register(This, regstrw, do_register);
472 
473  HeapFree(GetProcessHeap(), 0, regstrw);
474  }else {
475  WARN("could not load resource\n");
477  }
478  }else {
479  WARN("Could not find source\n");
481  }
482  FreeLibrary(hins);
483  }else {
484  WARN("Could not load resource file\n");
486  }
487 
488  return hres;
489 }
490 
491 static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
492 {
493  HANDLE file;
494  DWORD filelen, len;
495  LPWSTR regstrw;
496  LPSTR regstra;
497  HRESULT hres;
498 
500  if(file != INVALID_HANDLE_VALUE) {
501  filelen = GetFileSize(file, NULL);
502  regstra = HeapAlloc(GetProcessHeap(), 0, filelen);
503  if(ReadFile(file, regstra, filelen, NULL, NULL)) {
504  len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0)+1;
505  regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
506  MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
507  regstrw[len-1] = '\0';
508 
509  hres = string_register(This, regstrw, do_register);
510 
511  HeapFree(GetProcessHeap(), 0, regstrw);
512  }else {
513  WARN("Failed to read file %s\n", debugstr_w(fileName));
515  }
516  HeapFree(GetProcessHeap(), 0, regstra);
517  CloseHandle(file);
518  }else {
519  WARN("Could not open file %s\n", debugstr_w(fileName));
521  }
522 
523  return hres;
524 }
525 
527 {
528  TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
529 
531  || IsEqualGUID(&IID_IRegistrar, riid)
532  || IsEqualGUID(&IID_IRegistrarBase, riid)) {
533  IRegistrar_AddRef(iface);
534  *ppvObject = iface;
535  return S_OK;
536  }
537  return E_NOINTERFACE;
538 }
539 
541 {
544  TRACE("(%p) ->%d\n", This, ref);
545  return ref;
546 }
547 
549 {
552 
553  TRACE("(%p) ->%d\n", This, ref);
554  if(!ref) {
555  IRegistrar_ClearReplacements(iface);
557  }
558  return ref;
559 }
560 
561 static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
562 {
564  int len;
565  rep_list *new_rep;
566 
567  TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
568 
569  new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
570 
571  new_rep->key_len = lstrlenW(Key);
572  new_rep->key = HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR));
573  memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
574 
575  len = lstrlenW(item)+1;
576  new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
577  memcpy(new_rep->item, item, len*sizeof(OLECHAR));
578 
579  new_rep->next = This->rep;
580  This->rep = new_rep;
581 
582  return S_OK;
583 }
584 
586 {
588  rep_list *iter, *iter2;
589 
590  TRACE("(%p)\n", This);
591 
592  if(!This->rep)
593  return S_OK;
594 
595  iter = This->rep;
596  while(iter) {
597  iter2 = iter->next;
598  HeapFree(GetProcessHeap(), 0, iter->key);
599  HeapFree(GetProcessHeap(), 0, iter->item);
600  HeapFree(GetProcessHeap(), 0, iter);
601  iter = iter2;
602  }
603 
604  This->rep = NULL;
605  return S_OK;
606 }
607 
608 static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
609  LPCOLESTR szID, LPCOLESTR szType)
610 {
612  TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
613  return resource_register(This, resFileName, szID, szType, TRUE);
614 }
615 
616 static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
617  LPCOLESTR szID, LPCOLESTR szType)
618 {
620  TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
621  return resource_register(This, resFileName, szID, szType, FALSE);
622 }
623 
624 static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
625 {
627  TRACE("(%p)->(%s)\n", This, debugstr_w(fileName));
628  return file_register(This, fileName, TRUE);
629 }
630 
631 static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
632 {
634  FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
635  return file_register(This, fileName, FALSE);
636 }
637 
639 {
641  TRACE("(%p)->(%s)\n", This, debugstr_w(data));
642  return string_register(This, data, TRUE);
643 }
644 
646 {
648  TRACE("(%p)->(%s)\n", This, debugstr_w(data));
649  return string_register(This, data, FALSE);
650 }
651 
652 static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
653  UINT nID, LPCOLESTR szType)
654 {
656  TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
657  return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, TRUE);
658 }
659 
660 static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
661  UINT nID, LPCOLESTR szType)
662 {
664  TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
665  return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, FALSE);
666 }
667 
668 static const IRegistrarVtbl RegistrarVtbl = {
682 };
683 
684 /***********************************************************************
685  * AtlCreateRegistrar [atl100.@]
686  */
688 {
689  Registrar *registrar;
690 
691  registrar = HeapAlloc(GetProcessHeap(), 0, sizeof(*registrar));
692  if(!registrar)
693  return E_OUTOFMEMORY;
694 
695  registrar->IRegistrar_iface.lpVtbl = &RegistrarVtbl;
696  registrar->ref = 1;
697  registrar->rep = NULL;
698 
699  *ret = &registrar->IRegistrar_iface;
700  return S_OK;
701 }
702 
703 /***********************************************************************
704  * AtlUpdateRegistryFromResourceD [atl100.@]
705  */
707  BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries, IRegistrar *pReg)
708 {
709  const struct _ATL_REGMAP_ENTRY *iter;
711  IRegistrar *registrar;
712  HRESULT hres;
713 
714  static const WCHAR moduleW[] = {'M','O','D','U','L','E',0};
715  static const WCHAR registryW[] = {'R','E','G','I','S','T','R','Y',0};
716 
718  FIXME("hinst %p: did not get module name\n", inst);
719  return E_FAIL;
720  }
721 
722  TRACE("%p (%s), %s, %d, %p, %p\n", inst, debugstr_w(module_name),
723  debugstr_w(res), bRegister, pMapEntries, pReg);
724 
725  if(pReg) {
726  registrar = pReg;
727  }else {
728  hres = AtlCreateRegistrar(&registrar);
729  if(FAILED(hres))
730  return hres;
731  }
732 
733  IRegistrar_AddReplacement(registrar, moduleW, module_name);
734 
735  for (iter = pMapEntries; iter && iter->szKey; iter++)
736  IRegistrar_AddReplacement(registrar, iter->szKey, iter->szData);
737 
738  if(bRegister)
739  hres = IRegistrar_ResourceRegisterSz(registrar, module_name, res, registryW);
740  else
741  hres = IRegistrar_ResourceUnregisterSz(registrar, module_name, res, registryW);
742 
743  if(registrar != pReg)
744  IRegistrar_Release(registrar);
745  return hres;
746 }
#define HKEY_USERS
Definition: winreg.h:13
#define DISP_E_EXCEPTION
Definition: winerror.h:2518
LPOLESTR key
Definition: registrar.c:59
WCHAR OLECHAR
Definition: compat.h:1941
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:609
LONG ref
Definition: registrar.c:67
LPCOLESTR szData
Definition: atlbase.h:244
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:406
#define E_NOINTERFACE
Definition: winerror.h:2364
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
HRESULT WINAPI AtlCreateRegistrar(IRegistrar **ret)
Definition: registrar.c:687
#define ERROR_SUCCESS
Definition: deptool.c:10
IRegistrar IRegistrar_iface
Definition: registrar.c:66
static LPCWSTR LPCWSTR module_name
Definition: db.cpp:168
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define REG_BINARY
Definition: nt_native.h:1496
REFIID riid
Definition: precomp.h:44
#define iswxdigit(_c)
Definition: ctype.h:668
#define CP_ACP
Definition: compat.h:99
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define HKEY_CURRENT_USER
Definition: winreg.h:11
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
Definition: loader.c:288
#define WARN(fmt,...)
Definition: debug.h:111
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1237
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
static HRESULT WINAPI Registrar_FileRegister(IRegistrar *iface, LPCOLESTR fileName)
Definition: registrar.c:624
#define INVALID_HANDLE_VALUE
Definition: compat.h:399
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define HKEY_DYN_DATA
Definition: winreg.h:16
LPOLESTR str
Definition: registrar.c:72
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
_Check_return_ unsigned long __cdecl wcstoul(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
char * LPSTR
Definition: xmlstorage.h:182
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
static LPOLESTR
Definition: stg_prop.c:27
static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar *iface, LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
Definition: registrar.c:652
#define lstrlenW
Definition: compat.h:415
#define E_FAIL
Definition: ddrawi.h:102
Definition: send.c:47
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
Definition: res.c:176
DWORD alloc
Definition: registrar.c:73
#define FILE_SHARE_READ
Definition: compat.h:125
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
WCHAR name[22]
Definition: registrar.c:32
static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar *iface, LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
Definition: registrar.c:608
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3296
static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
Definition: registrar.c:184
#define debugstr_w
Definition: kernel32.h:32
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
LPCOLESTR szKey
Definition: atlbase.h:243
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
#define OPEN_EXISTING
Definition: compat.h:434
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
rep_list * rep
Definition: registrar.c:68
struct rep_list_str rep_list
static Registrar * impl_from_IRegistrar(IRegistrar *iface)
Definition: registrar.c:77
static const struct @318 root_keys[]
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4895
HKEY key
Definition: registrar.c:33
static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
Definition: registrar.c:561
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:413
HRESULT hres
Definition: protocol.c:465
static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
Definition: registrar.c:426
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
const GUID IID_IUnknown
#define MAX_PATH
Definition: compat.h:26
static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
Definition: registrar.c:526
#define WINAPI
Definition: msvc.h:6
const char file[]
Definition: icontest.c:11
static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
Definition: registrar.c:449
unsigned long DWORD
Definition: ntddk_ex.h:95
static void strbuf_init(strbuf *buf)
Definition: registrar.c:82
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:481
REFIID LPVOID DWORD dw
Definition: atlbase.h:40
struct rep_list_str * next
Definition: registrar.c:62
LPOLESTR item
Definition: registrar.c:60
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static const IRegistrarVtbl RegistrarVtbl
Definition: registrar.c:668
static HRESULT WINAPI Registrar_StringRegister(IRegistrar *iface, LPCOLESTR data)
Definition: registrar.c:638
HRESULT WINAPI AtlUpdateRegistryFromResourceD(HINSTANCE inst, LPCOLESTR res, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries, IRegistrar *pReg)
Definition: registrar.c:706
#define iswspace(_c)
Definition: ctype.h:669
#define NO_REMOVE
Definition: classpnp.h:93
static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
Definition: registrar.c:585
int ret
#define InterlockedDecrement
Definition: armddk.h:52
static HRESULT WINAPI Registrar_FileUnregister(IRegistrar *iface, LPCOLESTR fileName)
Definition: registrar.c:631
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
LONG WINAPI RegCreateKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:1199
REFIID LPVOID * ppvObject
Definition: precomp.h:44
#define GENERIC_READ
Definition: compat.h:124
GLenum src
Definition: glext.h:6340
#define debugstr_wn
Definition: kernel32.h:33
static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
Definition: registrar.c:378
static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar *iface, LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
Definition: registrar.c:660
LSTATUS WINAPI RegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
Definition: reg.c:1746
#define LOAD_LIBRARY_AS_DATAFILE
Definition: winbase.h:338
#define S_OK
Definition: intsafe.h:59
static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf)
Definition: registrar.c:141
#define InterlockedIncrement
Definition: armddk.h:53
static ATOM item
Definition: dde.c:856
#define ARRAY_SIZE(a)
Definition: main.h:24
#define HeapReAlloc
Definition: compat.h:401
static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
Definition: registrar.c:89
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
Definition: registrar.c:102
static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar *iface, LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
Definition: registrar.c:616
Definition: atlbase.h:241
static ULONG WINAPI Registrar_Release(IRegistrar *iface)
Definition: registrar.c:548
#define MultiByteToWideChar
Definition: compat.h:100
#define CreateFileW
Definition: compat.h:408
static HRESULT WINAPI Registrar_StringUnregister(IRegistrar *iface, LPCOLESTR data)
Definition: registrar.c:645
static const WCHAR moduleW[]
Definition: register.c:35
Definition: name.c:38
GLuint res
Definition: glext.h:9613
static DWORD LPDWORD reslen
Definition: directory.c:51
unsigned int ULONG
Definition: retypes.h:1
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define HKEY_PERFORMANCE_DATA
Definition: winreg.h:14
WCHAR * LPWSTR
Definition: xmlstorage.h:184
DWORD len
Definition: registrar.c:74
WINE_DEFAULT_DEBUG_CHANNEL(atl)
BOOL WINAPI ReadFile(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead, OUT LPDWORD lpNumberOfBytesRead OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:123
#define REG_DWORD
Definition: sdbapi.c:596
BYTE * PBYTE
Definition: pedump.c:66
static const int digits[]
Definition: decode.c:71
#define HeapFree(x, y, z)
Definition: compat.h:402
static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
Definition: registrar.c:540
static const WCHAR szType[]
Definition: table.c:81
#define SUCCEEDED(hr)
Definition: intsafe.h:57
Definition: path.c:41
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
Definition: registrar.c:491
Definition: fci.c:126
#define REG_SZ
Definition: layer.c:22
Definition: cdmake.c:189