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