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