wined3d: Honor the driver's min point size.
[wine] / dlls / dmloader / regsvr.c
1 /*
2  *      self-registerable dll functions for dmloader.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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "dmloader_private.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(dmloader);
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
105 /***********************************************************************
106  *              register_interfaces
107  */
108 static HRESULT register_interfaces(struct regsvr_interface const *list) {
109     LONG res = ERROR_SUCCESS;
110     HKEY interface_key;
111
112     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
113                           KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
114     if (res != ERROR_SUCCESS) goto error_return;
115
116     for (; res == ERROR_SUCCESS && list->iid; ++list) {
117         WCHAR buf[39];
118         HKEY iid_key;
119
120         StringFromGUID2(list->iid, buf, 39);
121         res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
122                               KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
123         if (res != ERROR_SUCCESS) goto error_close_interface_key;
124
125         if (list->name) {
126             res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
127                                  (CONST BYTE*)(list->name),
128                                  strlen(list->name) + 1);
129             if (res != ERROR_SUCCESS) goto error_close_iid_key;
130         }
131
132         if (list->base_iid) {
133             res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
134             if (res != ERROR_SUCCESS) goto error_close_iid_key;
135         }
136
137         if (0 <= list->num_methods) {
138             static WCHAR const fmt[3] = { '%', 'd', 0 };
139             HKEY key;
140
141             res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
142                                   KEY_READ | KEY_WRITE, NULL, &key, NULL);
143             if (res != ERROR_SUCCESS) goto error_close_iid_key;
144
145             wsprintfW(buf, fmt, list->num_methods);
146             res = RegSetValueExW(key, NULL, 0, REG_SZ,
147                                  (CONST BYTE*)buf,
148                                  (lstrlenW(buf) + 1) * sizeof(WCHAR));
149             RegCloseKey(key);
150
151             if (res != ERROR_SUCCESS) goto error_close_iid_key;
152         }
153
154         if (list->ps_clsid) {
155             res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
156             if (res != ERROR_SUCCESS) goto error_close_iid_key;
157         }
158
159         if (list->ps_clsid32) {
160             res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
161             if (res != ERROR_SUCCESS) goto error_close_iid_key;
162         }
163
164     error_close_iid_key:
165         RegCloseKey(iid_key);
166     }
167
168 error_close_interface_key:
169     RegCloseKey(interface_key);
170 error_return:
171     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
172 }
173
174 /***********************************************************************
175  *              unregister_interfaces
176  */
177 static HRESULT unregister_interfaces(struct regsvr_interface const *list) {
178     LONG res = ERROR_SUCCESS;
179     HKEY interface_key;
180
181     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
182                         KEY_READ | KEY_WRITE, &interface_key);
183     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
184     if (res != ERROR_SUCCESS) goto error_return;
185
186     for (; res == ERROR_SUCCESS && list->iid; ++list) {
187         WCHAR buf[39];
188
189         StringFromGUID2(list->iid, buf, 39);
190         res = RegDeleteTreeW(interface_key, buf);
191         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
192     }
193
194     RegCloseKey(interface_key);
195 error_return:
196     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
197 }
198
199 /***********************************************************************
200  *              register_coclasses
201  */
202 static HRESULT register_coclasses(struct regsvr_coclass const *list) {
203     LONG res = ERROR_SUCCESS;
204     HKEY coclass_key;
205
206     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
207                           KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
208     if (res != ERROR_SUCCESS) goto error_return;
209
210     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
211         WCHAR buf[39];
212         HKEY clsid_key;
213
214         StringFromGUID2(list->clsid, buf, 39);
215         res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
216                               KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
217         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
218
219         if (list->name) {
220             res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
221                                  (CONST BYTE*)(list->name),
222                                  strlen(list->name) + 1);
223             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
224         }
225
226         if (list->ips) {
227             res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
228             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
229         }
230
231         if (list->ips32) {
232             HKEY ips32_key;
233
234             res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
235                                   KEY_READ | KEY_WRITE, NULL,
236                                   &ips32_key, NULL);
237             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
238
239             res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
240                                  (CONST BYTE*)list->ips32,
241                                  lstrlenA(list->ips32) + 1);
242             if (res == ERROR_SUCCESS && list->ips32_tmodel)
243                 res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
244                                      (CONST BYTE*)list->ips32_tmodel,
245                                      strlen(list->ips32_tmodel) + 1);
246             RegCloseKey(ips32_key);
247             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
248         }
249
250         if (list->progid) {
251             res = register_key_defvalueA(clsid_key, progid_keyname,
252                                          list->progid);
253             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
254
255             res = register_progid(buf, list->progid, NULL,
256                                   list->name, list->progid_extra);
257             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
258         }
259
260         if (list->viprogid) {
261             res = register_key_defvalueA(clsid_key, viprogid_keyname,
262                                          list->viprogid);
263             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
264
265             res = register_progid(buf, list->viprogid, list->progid,
266                                   list->name, list->progid_extra);
267             if (res != ERROR_SUCCESS) goto error_close_clsid_key;
268         }
269
270     error_close_clsid_key:
271         RegCloseKey(clsid_key);
272     }
273
274 error_close_coclass_key:
275     RegCloseKey(coclass_key);
276 error_return:
277     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
278 }
279
280 /***********************************************************************
281  *              unregister_coclasses
282  */
283 static HRESULT unregister_coclasses(struct regsvr_coclass const *list) {
284     LONG res = ERROR_SUCCESS;
285     HKEY coclass_key;
286
287     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
288                         KEY_READ | KEY_WRITE, &coclass_key);
289     if (res == ERROR_FILE_NOT_FOUND) return S_OK;
290     if (res != ERROR_SUCCESS) goto error_return;
291
292     for (; res == ERROR_SUCCESS && list->clsid; ++list) {
293         WCHAR buf[39];
294
295         StringFromGUID2(list->clsid, buf, 39);
296         res = RegDeleteTreeW(coclass_key, buf);
297         if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
298         if (res != ERROR_SUCCESS) goto error_close_coclass_key;
299
300         if (list->progid) {
301             res = RegDeleteTreeA(HKEY_CLASSES_ROOT, list->progid);
302             if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
303             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
304         }
305
306         if (list->viprogid) {
307             res = RegDeleteTreeA(HKEY_CLASSES_ROOT, list->viprogid);
308             if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
309             if (res != ERROR_SUCCESS) goto error_close_coclass_key;
310         }
311     }
312
313 error_close_coclass_key:
314     RegCloseKey(coclass_key);
315 error_return:
316     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
317 }
318
319 /***********************************************************************
320  *              regsvr_key_guid
321  */
322 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid) {
323     WCHAR buf[39];
324
325     StringFromGUID2(guid, buf, 39);
326     return register_key_defvalueW(base, name, buf);
327 }
328
329 /***********************************************************************
330  *              regsvr_key_defvalueW
331  */
332 static LONG register_key_defvalueW(
333     HKEY base,
334     WCHAR const *name,
335     WCHAR const *value) {
336     LONG res;
337     HKEY key;
338
339     res = RegCreateKeyExW(base, name, 0, NULL, 0,
340                           KEY_READ | KEY_WRITE, NULL, &key, NULL);
341     if (res != ERROR_SUCCESS) return res;
342     res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
343                          (lstrlenW(value) + 1) * sizeof(WCHAR));
344     RegCloseKey(key);
345     return res;
346 }
347
348 /***********************************************************************
349  *              regsvr_key_defvalueA
350  */
351 static LONG register_key_defvalueA(
352     HKEY base,
353     WCHAR const *name,
354     char const *value) {
355     LONG res;
356     HKEY key;
357
358     res = RegCreateKeyExW(base, name, 0, NULL, 0,
359                           KEY_READ | KEY_WRITE, NULL, &key, NULL);
360     if (res != ERROR_SUCCESS) return res;
361     res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
362                          lstrlenA(value) + 1);
363     RegCloseKey(key);
364     return res;
365 }
366
367 /***********************************************************************
368  *              regsvr_progid
369  */
370 static LONG register_progid(
371     WCHAR const *clsid,
372     char const *progid,
373     char const *curver_progid,
374     char const *name,
375     char const *extra) {
376     LONG res;
377     HKEY progid_key;
378
379     res = RegCreateKeyExA(HKEY_CLASSES_ROOT, progid, 0,
380                           NULL, 0, KEY_READ | KEY_WRITE, NULL,
381                           &progid_key, NULL);
382     if (res != ERROR_SUCCESS) return res;
383
384     if (name) {
385         res = RegSetValueExA(progid_key, NULL, 0, REG_SZ,
386                              (CONST BYTE*)name, strlen(name) + 1);
387         if (res != ERROR_SUCCESS) goto error_close_progid_key;
388     }
389
390     if (clsid) {
391         res = register_key_defvalueW(progid_key, clsid_keyname, clsid);
392         if (res != ERROR_SUCCESS) goto error_close_progid_key;
393     }
394
395     if (curver_progid) {
396         res = register_key_defvalueA(progid_key, curver_keyname,
397                                      curver_progid);
398         if (res != ERROR_SUCCESS) goto error_close_progid_key;
399     }
400
401     if (extra) {
402         HKEY extra_key;
403
404         res = RegCreateKeyExA(progid_key, extra, 0,
405                               NULL, 0, KEY_READ | KEY_WRITE, NULL,
406                               &extra_key, NULL);
407         if (res == ERROR_SUCCESS)
408             RegCloseKey(extra_key);
409     }
410
411 error_close_progid_key:
412     RegCloseKey(progid_key);
413     return res;
414 }
415
416 /***********************************************************************
417  *              coclass list
418  */
419 static struct regsvr_coclass const coclass_list[] = {
420     {   &CLSID_DirectMusicLoader,
421     "DirectMusicLoader",
422         NULL,
423         "dmloader.dll",
424         "Both",
425         "Microsoft.DirectMusicLoader.1",
426         "Microsoft.DirectMusicLoader"
427     },
428     {   &CLSID_DirectMusicContainer,
429     "DirectMusicContainer",
430         NULL,
431         "dmloader.dll",
432         "Both",
433         "Microsoft.DirectMusicContainer.1",
434         "Microsoft.DirectMusicContainer"
435     },
436     { NULL }                    /* list terminator */
437 };
438
439 /***********************************************************************
440  *              interface list
441  */
442
443 static struct regsvr_interface const interface_list[] = {
444     { NULL }                    /* list terminator */
445 };
446
447 /***********************************************************************
448  *              DllRegisterServer (DMLOADER.3)
449  */
450 HRESULT WINAPI DllRegisterServer(void)
451 {
452     HRESULT hr;
453
454     TRACE("\n");
455
456     hr = register_coclasses(coclass_list);
457     if (SUCCEEDED(hr))
458         hr = register_interfaces(interface_list);
459     return hr;
460 }
461
462 /***********************************************************************
463  *              DllUnregisterServer (DMLOADER.4)
464  */
465 HRESULT WINAPI DllUnregisterServer(void)
466 {
467     HRESULT hr;
468
469     TRACE("\n");
470
471     hr = unregister_coclasses(coclass_list);
472     if (SUCCEEDED(hr))
473         hr = unregister_interfaces(interface_list);
474     return hr;
475 }