Check the return value from register_key_guid in all the DLL registering code.
[wine] / dlls / hhctrl.ocx / regsvr.c
1 /*
2  *      self-registerable dll functions for hhctrl.ocx
3  *
4  * Copyright (C) 2004 Stefan Leichter
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #define COM_NO_WINDOWS_H
22 #include <stdarg.h>
23 #include <string.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "wingdi.h"
29 #include "winreg.h"
30 #include "winerror.h"
31
32 #include "ole2.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
37
38 /*
39  * Near the bottom of this file are the exported DllRegisterServer and
40  * DllUnregisterServer, which make all this worthwhile.
41  */
42
43 /***********************************************************************
44  *              interface for self-registering
45  */
46 struct regsvr_interface
47 {
48     IID const *iid;             /* NULL for end of list */
49     LPCSTR name;                /* can be NULL to omit */
50     IID const *base_iid;        /* can be NULL to omit */
51     int num_methods;            /* can be <0 to omit */
52     CLSID const *ps_clsid;      /* can be NULL to omit */
53     CLSID const *ps_clsid32;    /* can be NULL to omit */
54 };
55
56 static HRESULT register_interfaces(struct regsvr_interface const *list);
57 static HRESULT unregister_interfaces(struct regsvr_interface const *list);
58
59 struct regsvr_coclass
60 {
61     CLSID const *clsid;         /* NULL for end of list */
62     LPCSTR name;                /* can be NULL to omit */
63     LPCSTR ips;                 /* can be NULL to omit */
64     LPCSTR ips32;               /* can be NULL to omit */
65     LPCSTR ips32_tmodel;        /* can be NULL to omit */
66     LPCSTR progid;              /* can be NULL to omit */
67     LPCSTR viprogid;            /* can be NULL to omit */
68     LPCSTR progid_extra;        /* can be NULL to omit */
69 };
70
71 static HRESULT register_coclasses(struct regsvr_coclass const *list);
72 static HRESULT unregister_coclasses(struct regsvr_coclass const *list);
73
74 /***********************************************************************
75  *              static string constants
76  */
77 static WCHAR const interface_keyname[10] = {
78     'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };
79 static WCHAR const base_ifa_keyname[14] = {
80     'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c',
81     'e', 0 };
82 static WCHAR const num_methods_keyname[11] = {
83     'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };
84 static WCHAR const ps_clsid_keyname[15] = {
85     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
86     'i', 'd', 0 };
87 static WCHAR const ps_clsid32_keyname[17] = {
88     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
89     'i', 'd', '3', '2', 0 };
90 static WCHAR const clsid_keyname[6] = {
91     'C', 'L', 'S', 'I', 'D', 0 };
92 static WCHAR const curver_keyname[7] = {
93     'C', 'u', 'r', 'V', 'e', 'r', 0 };
94 static WCHAR const ips_keyname[13] = {
95     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
96     0 };
97 static WCHAR const ips32_keyname[15] = {
98     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
99     '3', '2', 0 };
100 static WCHAR const progid_keyname[7] = {
101     'P', 'r', 'o', 'g', 'I', 'D', 0 };
102 static WCHAR const viprogid_keyname[25] = {
103     'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p',
104     'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D',
105     0 };
106 static char const tmodel_valuename[] = "ThreadingModel";
107
108 /***********************************************************************
109  *              static helper functions
110  */
111 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);
112 static LONG register_key_defvalueW(HKEY base, WCHAR const *name,
113                                    WCHAR const *value);
114 static LONG register_key_defvalueA(HKEY base, WCHAR const *name,
115                                    char const *value);
116 static LONG register_progid(WCHAR const *clsid,
117                             char const *progid, char const *curver_progid,
118                             char const *name, char const *extra);
119 static LONG recursive_delete_key(HKEY key);
120 static LONG recursive_delete_keyA(HKEY base, char const *name);
121 static LONG recursive_delete_keyW(HKEY base, WCHAR const *name);
122
123 /***********************************************************************
124  *              register_interfaces
125  */
126 static HRESULT register_interfaces(struct regsvr_interface const *list)
127 {
128     LONG res = ERROR_SUCCESS;
129     HKEY interface_key;
130
131     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
132                           KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
133     if (res != ERROR_SUCCESS) goto error_return;
134
135     for (; res == ERROR_SUCCESS && list->iid; ++list) {
136         WCHAR buf[39];
137         HKEY iid_key;
138
139         StringFromGUID2(list->iid, buf, 39);
140         res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
141                               KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
142         if (res != ERROR_SUCCESS) goto error_close_interface_key;
143
144         if (list->name) {
145             res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
146                                  (CONST BYTE*)(list->name),
147                                  strlen(list->name) + 1);
148             if (res != ERROR_SUCCESS) goto error_close_iid_key;
149         }
150
151         if (list->base_iid) {
152             res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
153             if (res != ERROR_SUCCESS) goto error_close_iid_key;
154         }
155
156         if (0 <= list->num_methods) {
157             static WCHAR const fmt[3] = { '%', 'd', 0 };
158             HKEY key;
159
160             res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
161                                   KEY_READ | KEY_WRITE, NULL, &key, NULL);
162             if (res != ERROR_SUCCESS) goto error_close_iid_key;
163
164             wsprintfW(buf, fmt, list->num_methods);
165             res = RegSetValueExW(key, NULL, 0, REG_SZ,
166                                  (CONST BYTE*)buf,
167                                  (lstrlenW(buf) + 1) * sizeof(WCHAR));
168             RegCloseKey(key);
169
170             if (res != ERROR_SUCCESS) goto error_close_iid_key;
171         }
172
173         if (list->ps_clsid) {
174             register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
175             if (res != ERROR_SUCCESS) goto error_close_iid_key;
176         }
177
178         if (list->ps_clsid32) {
179             register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
180             if (res != ERROR_SUCCESS) goto error_close_iid_key;
181         }
182
183     error_close_iid_key:
184         RegCloseKey(iid_key);
185     }
186
187 error_close_interface_key:
188     RegCloseKey(interface_key);
189 error_return:
190     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
191 }
192
193 /***********************************************************************
194  *              unregister_interfaces
195  */
196 static HRESULT unregister_interfaces(struct regsvr_interface const *list)
197 {
198     LONG res = ERROR_SUCCESS;
199     HKEY interface_key;
200
201     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
202                         KEY_READ | KEY_WRITE, &interface_key);
203     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
204     if (res != ERROR_SUCCESS) goto error_return;
205
206     for (; res == ERROR_SUCCESS && list->iid; ++list) {
207         WCHAR buf[39];
208
209         StringFromGUID2(list->iid, buf, 39);
210         res = recursive_delete_keyW(interface_key, buf);
211     }
212
213     RegCloseKey(interface_key);
214 error_return:
215     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
216 }
217
218 /***********************************************************************
219  *              register_coclasses
220  */
221 static HRESULT register_coclasses(struct regsvr_coclass const *list)
222 {
223     LONG res = ERROR_SUCCESS;
224     HKEY coclass_key;
225
226     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
227                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
228     if (res != ERROR_SUCCESS) goto error_return;
229
230     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
231         WCHAR buf[39];
232         HKEY clsid_key;
233
234         StringFromGUID2(list->clsid, buf, 39);
235         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
236                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
237         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
238
239         if (list->name) {
240             res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
241                                  (CONST BYTE*)(list->name),
242                                  strlen(list->name) + 1);
243             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
244         }
245
246         if (list->ips) {
247             res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
248             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
249         }
250
251         if (list->ips32) {
252             HKEY ips32_key;
253
254             res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
255                                   KEY_READ | KEY_WRITE, NULL,
256                                   &ips32_key, NULL);
257             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
258
259             res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
260                                  (CONST BYTE*)list->ips32,
261                                  lstrlenA(list->ips32) + 1);
262             if (res == ERROR_SUCCESS && list->ips32_tmodel)
263                 res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
264                                      (CONST BYTE*)list->ips32_tmodel,
265                                      strlen(list->ips32_tmodel) + 1);
266             RegCloseKey(ips32_key);
267             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
268         }
269
270         if (list->progid) {
271             res = register_key_defvalueA(clsid_key, progid_keyname,
272                                          list->progid);
273             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
274
275             res = register_progid(buf, list->progid, NULL,
276                                   list->name, list->progid_extra);
277             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
278         }
279
280         if (list->viprogid) {
281             res = register_key_defvalueA(clsid_key, viprogid_keyname,
282                                          list->viprogid);
283             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
284
285             res = register_progid(buf, list->viprogid, list->progid,
286                                   list->name, list->progid_extra);
287             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
288         }
289
290     error_close_clsid_key:
291         RegCloseKey(clsid_key);
292     }
293
294 error_close_coclass_key:
295     RegCloseKey(coclass_key);
296 error_return:
297     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
298 }
299
300 /***********************************************************************
301  *              unregister_coclasses
302  */
303 static HRESULT unregister_coclasses(struct regsvr_coclass const *list)
304 {
305     LONG res = ERROR_SUCCESS;
306     HKEY coclass_key;
307
308     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
309                         KEY_READ | KEY_WRITE, &coclass_key);
310     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
311     if (res != ERROR_SUCCESS) goto error_return;
312
313     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
314         WCHAR buf[39];
315
316         StringFromGUID2(list->clsid, buf, 39);
317         res = recursive_delete_keyW(coclass_key, buf);
318         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
319
320         if (list->progid) {
321             res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->progid);
322             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
323         }
324
325         if (list->viprogid) {
326             res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->viprogid);
327             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
328         }
329     }
330
331 error_close_coclass_key:
332     RegCloseKey(coclass_key);
333 error_return:
334     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
335 }
336
337 /***********************************************************************
338  *              regsvr_key_guid
339  */
340 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid)
341 {
342     WCHAR buf[39];
343
344     StringFromGUID2(guid, buf, 39);
345     return register_key_defvalueW(base, name, buf);
346 }
347
348 /***********************************************************************
349  *              regsvr_key_defvalueW
350  */
351 static LONG register_key_defvalueW(
352     HKEY base,
353     WCHAR const *name,
354     WCHAR const *value)
355 {
356     LONG res;
357     HKEY key;
358
359     res = RegCreateKeyExW(base, name, 0, NULL, 0,
360                           KEY_READ | KEY_WRITE, NULL, &key, NULL);
361     if (res != ERROR_SUCCESS) return res;
362     res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
363                          (lstrlenW(value) + 1) * sizeof(WCHAR));
364     RegCloseKey(key);
365     return res;
366 }
367
368 /***********************************************************************
369  *              regsvr_key_defvalueA
370  */
371 static LONG register_key_defvalueA(
372     HKEY base,
373     WCHAR const *name,
374     char const *value)
375 {
376     LONG res;
377     HKEY key;
378
379     res = RegCreateKeyExW(base, name, 0, NULL, 0,
380                           KEY_READ | KEY_WRITE, NULL, &key, NULL);
381     if (res != ERROR_SUCCESS) return res;
382     res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
383                          lstrlenA(value) + 1);
384     RegCloseKey(key);
385     return res;
386 }
387
388 /***********************************************************************
389  *              regsvr_progid
390  */
391 static LONG register_progid(
392     WCHAR const *clsid,
393     char const *progid,
394     char const *curver_progid,
395     char const *name,
396     char const *extra)
397 {
398     LONG res;
399     HKEY progid_key;
400
401     res = RegCreateKeyExA(HKEY_CLASSES_ROOT, progid, 0,
402                           NULL, 0, KEY_READ | KEY_WRITE, NULL,
403                           &progid_key, NULL);
404     if (res != ERROR_SUCCESS) return res;
405
406     if (name) {
407         res = RegSetValueExA(progid_key, NULL, 0, REG_SZ,
408                              (CONST BYTE*)name, strlen(name) + 1);
409         if (res != ERROR_SUCCESS) goto error_close_progid_key;
410     }
411
412     if (clsid) {
413         res = register_key_defvalueW(progid_key, clsid_keyname, clsid);
414         if (res != ERROR_SUCCESS) goto error_close_progid_key;
415     }
416
417     if (curver_progid) {
418         res = register_key_defvalueA(progid_key, curver_keyname,
419                                      curver_progid);
420         if (res != ERROR_SUCCESS) goto error_close_progid_key;
421     }
422
423     if (extra) {
424         HKEY extra_key;
425
426         res = RegCreateKeyExA(progid_key, extra, 0,
427                               NULL, 0, KEY_READ | KEY_WRITE, NULL,
428                               &extra_key, NULL);
429         if (res == ERROR_SUCCESS)
430             RegCloseKey(extra_key);
431     }
432
433 error_close_progid_key:
434     RegCloseKey(progid_key);
435     return res;
436 }
437
438 /***********************************************************************
439  *              recursive_delete_key
440  */
441 static LONG recursive_delete_key(HKEY key)
442 {
443     LONG res;
444     WCHAR subkey_name[MAX_PATH];
445     DWORD cName;
446     HKEY subkey;
447
448     for (;;) {
449         cName = sizeof(subkey_name) / sizeof(WCHAR);
450         res = RegEnumKeyExW(key, 0, subkey_name, &cName,
451                             NULL, NULL, NULL, NULL);
452         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) {
453             res = ERROR_SUCCESS; /* presumably we're done enumerating */
454             break;
455         }
456         res = RegOpenKeyExW(key, subkey_name, 0,
457                             KEY_READ | KEY_WRITE, &subkey);
458         if (res == ERROR_FILE_NOT_FOUND) continue;
459         if (res != ERROR_SUCCESS) break;
460
461         res = recursive_delete_key(subkey);
462         RegCloseKey(subkey);
463         if (res != ERROR_SUCCESS) break;
464     }
465
466     if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0);
467     return res;
468 }
469
470 /***********************************************************************
471  *              recursive_delete_keyA
472  */
473 static LONG recursive_delete_keyA(HKEY base, char const *name)
474 {
475     LONG res;
476     HKEY key;
477
478     res = RegOpenKeyExA(base, name, 0, KEY_READ | KEY_WRITE, &key);
479     if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
480     if (res != ERROR_SUCCESS) return res;
481     res = recursive_delete_key(key);
482     RegCloseKey(key);
483     return res;
484 }
485
486 /***********************************************************************
487  *              recursive_delete_keyW
488  */
489 static LONG recursive_delete_keyW(HKEY base, WCHAR const *name)
490 {
491     LONG res;
492     HKEY key;
493
494     res = RegOpenKeyExW(base, name, 0, KEY_READ | KEY_WRITE, &key);
495     if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
496     if (res != ERROR_SUCCESS) return res;
497     res = recursive_delete_key(key);
498     RegCloseKey(key);
499     return res;
500 }
501
502 /***********************************************************************
503  *              coclass list
504  */
505 static struct regsvr_coclass const coclass_list[] = {
506 /*  {   41B23C28-488E-4E5C-ACE2-BB0BBABE99E8,
507  *      "HHCtrl Object",
508  *      NULL,
509  *      "hhctrl.ocx",
510  *      "Apartment"
511  *  },
512  *  {   4662DAB0-D393-11D0-9A56-00C04FB68B66,
513  *      "",
514  *      NULL,
515  *      "hhctrl.ocx",
516  *      "Both"
517  *  },
518  *  {   ADB880A4-D8FF-11CF-9377-00AA003B7A11,
519  *      "",
520  *      NULL,
521  *      "hhctrl.ocx",
522  *      "Both"
523  *  },
524  *  {   ADB880A6-D8FF-11CF-9377-00AA003B7A11,
525  *      "HHCtrl Object",
526  *      NULL,
527  *      "hhctrl.ocx",
528  *      "Apartment"
529  *  },
530  */
531     { NULL }                    /* list terminator */
532 };
533
534 /***********************************************************************
535  *              interface list
536  */
537
538 static struct regsvr_interface const interface_list[] = {
539     { NULL }                    /* list terminator */
540 };
541
542 /***********************************************************************
543  *              DllRegisterServer (HHCTRL.@)
544  */
545 HRESULT WINAPI DllRegisterServer(void)
546 {
547     HRESULT hr;
548
549     TRACE("\n");
550
551     hr = register_coclasses(coclass_list);
552     if (SUCCEEDED(hr))
553         hr = register_interfaces(interface_list);
554     return hr;
555 }
556
557 /***********************************************************************
558  *              DllUnregisterServer (HHCTRL.@)
559  */
560 HRESULT WINAPI DllUnregisterServer(void)
561 {
562     HRESULT hr;
563
564     TRACE("\n");
565
566     hr = unregister_coclasses(coclass_list);
567     if (SUCCEEDED(hr))
568         hr = unregister_interfaces(interface_list);
569     return hr;
570 }