?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedbg: Change the prefix on bison-generated names to avoid the name-prefix directive.
[wine.git] / dlls / quartz / regsvr.c
bloba6bd671f19a37e9f0587cf87ba9162056d6ae24f
1 /*
2 * self-registerable dll functions for quartz.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 #define NONAMELESSUNION
22 #define NONAMELESSSTRUCT
23 #define COBJMACROS
24 #define COM_NO_WINDOWS_H
25 #include <stdarg.h>
26 #include <string.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winuser.h"
31 #include "winreg.h"
32 #include "winerror.h"
33
34 #include "ole2.h"
35 #include "uuids.h"
36 #include "strmif.h"
37
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
41
42 /*
43 * Near the bottom of this file are the exported DllRegisterServer and
44 * DllUnregisterServer, which make all this worthwhile.
45 */
46
47 /***********************************************************************
48 * interface for self-registering
49 */
50 struct regsvr_interface
51 {
52 IID const *iid; /* NULL for end of list */
53 LPCSTR name; /* can be NULL to omit */
54 IID const *base_iid; /* can be NULL to omit */
55 int num_methods; /* can be <0 to omit */
56 CLSID const *ps_clsid; /* can be NULL to omit */
57 CLSID const *ps_clsid32; /* can be NULL to omit */
58 };
59
60 static HRESULT register_interfaces(struct regsvr_interface const *list);
61 static HRESULT unregister_interfaces(struct regsvr_interface const *list);
62
63 struct regsvr_coclass
64 {
65 CLSID const *clsid; /* NULL for end of list */
66 LPCSTR name; /* can be NULL to omit */
67 LPCSTR ips; /* can be NULL to omit */
68 LPCSTR ips32; /* can be NULL to omit */
69 LPCSTR ips32_tmodel; /* can be NULL to omit */
70 LPCSTR progid; /* can be NULL to omit */
71 LPCSTR viprogid; /* can be NULL to omit */
72 LPCSTR progid_extra; /* can be NULL to omit */
73 };
74
75 static HRESULT register_coclasses(struct regsvr_coclass const *list);
76 static HRESULT unregister_coclasses(struct regsvr_coclass const *list);
77
78 struct regsvr_mediatype_parsing
79 {
80 CLSID const *majortype; /* NULL for end of list */
81 CLSID const *subtype;
82 LPCSTR line[11]; /* NULL for end of list */
83 };
84
85 static HRESULT register_mediatypes_parsing(struct regsvr_mediatype_parsing const *list);
86 static HRESULT unregister_mediatypes_parsing(struct regsvr_mediatype_parsing const *list);
87
88 struct regsvr_mediatype_extension
89 {
90 CLSID const *majortype; /* NULL for end of list */
91 CLSID const *subtype;
92 LPCSTR extension;
93 };
94
95 struct mediatype
96 {
97 CLSID const *majortype; /* NULL for end of list */
98 CLSID const *subtype;
99 DWORD fourcc;
100 };
101
102 struct pin
103 {
104 DWORD flags; /* 0xFFFFFFFF for end of list */
105 struct mediatype mediatypes[11];
106 };
107
108 struct regsvr_filter
109 {
110 CLSID const *clsid; /* NULL for end of list */
111 CLSID const *category;
112 WCHAR name[50];
113 DWORD merit;
114 struct pin pins[11];
115 };
116
117 static HRESULT register_mediatypes_extension(struct regsvr_mediatype_extension const *list);
118 static HRESULT unregister_mediatypes_extension(struct regsvr_mediatype_extension const *list);
119
120 static HRESULT register_filters(struct regsvr_filter const *list);
121 static HRESULT unregister_filters(struct regsvr_filter const *list);
122
123 /***********************************************************************
124 * static string constants
125 */
126 static WCHAR const interface_keyname[10] = {
127 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };
128 static WCHAR const base_ifa_keyname[14] = {
129 'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c',
130 'e', 0 };
131 static WCHAR const num_methods_keyname[11] = {
132 'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };
133 static WCHAR const ps_clsid_keyname[15] = {
134 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
135 'i', 'd', 0 };
136 static WCHAR const ps_clsid32_keyname[17] = {
137 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
138 'i', 'd', '3', '2', 0 };
139 static WCHAR const clsid_keyname[6] = {
140 'C', 'L', 'S', 'I', 'D', 0 };
141 static WCHAR const curver_keyname[7] = {
142 'C', 'u', 'r', 'V', 'e', 'r', 0 };
143 static WCHAR const ips_keyname[13] = {
144 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
145 0 };
146 static WCHAR const ips32_keyname[15] = {
147 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
148 '3', '2', 0 };
149 static WCHAR const progid_keyname[7] = {
150 'P', 'r', 'o', 'g', 'I', 'D', 0 };
151 static WCHAR const viprogid_keyname[25] = {
152 'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p',
153 'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D',
154 0 };
155 static char const tmodel_valuename[] = "ThreadingModel";
156 static WCHAR const mediatype_name[11] = {
157 'M', 'e', 'd', 'i', 'a', ' ', 'T', 'y', 'p', 'e', 0 };
158 static WCHAR const subtype_valuename[8] = {
159 'S', 'u', 'b', 't', 'y', 'p', 'e', 0 };
160 static WCHAR const sourcefilter_valuename[14] = {
161 'S', 'o', 'u', 'r', 'c', 'e', ' ', 'F', 'i', 'l', 't', 'e', 'r', 0 };
162 static WCHAR const extensions_keyname[11] = {
163 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 0 };
164
165 /***********************************************************************
166 * static helper functions
167 */
168 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);
169 static LONG register_key_defvalueW(HKEY base, WCHAR const *name,
170 WCHAR const *value);
171 static LONG register_key_defvalueA(HKEY base, WCHAR const *name,
172 char const *value);
173 static LONG register_progid(WCHAR const *clsid,
174 char const *progid, char const *curver_progid,
175 char const *name, char const *extra);
176 static LONG recursive_delete_key(HKEY key);
177 static LONG recursive_delete_keyA(HKEY base, char const *name);
178 static LONG recursive_delete_keyW(HKEY base, WCHAR const *name);
179
180 /***********************************************************************
181 * register_interfaces
182 */
183 static HRESULT register_interfaces(struct regsvr_interface const *list)
184 {
185 LONG res = ERROR_SUCCESS;
186 HKEY interface_key;
187
188 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
189 KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
190 if (res != ERROR_SUCCESS) goto error_return;
191
192 for (; res == ERROR_SUCCESS && list->iid; ++list) {
193 WCHAR buf[39];
194 HKEY iid_key;
195
196 StringFromGUID2(list->iid, buf, 39);
197 res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
198 KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
199 if (res != ERROR_SUCCESS) goto error_close_interface_key;
200
201 if (list->name) {
202 res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
203 (CONST BYTE*)(list->name),
204 strlen(list->name) + 1);
205 if (res != ERROR_SUCCESS) goto error_close_iid_key;
206 }
207
208 if (list->base_iid) {
209 res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
210 if (res != ERROR_SUCCESS) goto error_close_iid_key;
211 }
212
213 if (0 <= list->num_methods) {
214 static WCHAR const fmt[3] = { '%', 'd', 0 };
215 HKEY key;
216
217 res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
218 KEY_READ | KEY_WRITE, NULL, &key, NULL);
219 if (res != ERROR_SUCCESS) goto error_close_iid_key;
220
221 wsprintfW(buf, fmt, list->num_methods);
222 res = RegSetValueExW(key, NULL, 0, REG_SZ,
223 (CONST BYTE*)buf,
224 (lstrlenW(buf) + 1) * sizeof(WCHAR));
225 RegCloseKey(key);
226
227 if (res != ERROR_SUCCESS) goto error_close_iid_key;
228 }
229
230 if (list->ps_clsid) {
231 res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
232 if (res != ERROR_SUCCESS) goto error_close_iid_key;
233 }
234
235 if (list->ps_clsid32) {
236 res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
237 if (res != ERROR_SUCCESS) goto error_close_iid_key;
238 }
239
240 error_close_iid_key:
241 RegCloseKey(iid_key);
242 }
243
244 error_close_interface_key:
245 RegCloseKey(interface_key);
246 error_return:
247 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
248 }
249
250 /***********************************************************************
251 * unregister_interfaces
252 */
253 static HRESULT unregister_interfaces(struct regsvr_interface const *list)
254 {
255 LONG res = ERROR_SUCCESS;
256 HKEY interface_key;
257
258 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
259 KEY_READ | KEY_WRITE, &interface_key);
260 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
261 if (res != ERROR_SUCCESS) goto error_return;
262
263 for (; res == ERROR_SUCCESS && list->iid; ++list) {
264 WCHAR buf[39];
265
266 StringFromGUID2(list->iid, buf, 39);
267 res = recursive_delete_keyW(interface_key, buf);
268 }
269
270 RegCloseKey(interface_key);
271 error_return:
272 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
273 }
274
275 /***********************************************************************
276 * register_coclasses
277 */
278 static HRESULT register_coclasses(struct regsvr_coclass const *list)
279 {
280 LONG res = ERROR_SUCCESS;
281 HKEY coclass_key;
282
283 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
284 KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
285 if (res != ERROR_SUCCESS) goto error_return;
286
287 for (; res == ERROR_SUCCESS && list->clsid; ++list) {
288 WCHAR buf[39];
289 HKEY clsid_key;
290
291 StringFromGUID2(list->clsid, buf, 39);
292 res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
293 KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
294 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
295
296 if (list->name) {
297 res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
298 (CONST BYTE*)(list->name),
299 strlen(list->name) + 1);
300 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
301 }
302
303 if (list->ips) {
304 res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
305 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
306 }
307
308 if (list->ips32) {
309 HKEY ips32_key;
310
311 res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
312 KEY_READ | KEY_WRITE, NULL,
313 &ips32_key, NULL);
314 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
315
316 res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
317 (CONST BYTE*)list->ips32,
318 lstrlenA(list->ips32) + 1);
319 if (res == ERROR_SUCCESS && list->ips32_tmodel)
320 res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
321 (CONST BYTE*)list->ips32_tmodel,
322 strlen(list->ips32_tmodel) + 1);
323 RegCloseKey(ips32_key);
324 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
325 }
326
327 if (list->progid) {
328 res = register_key_defvalueA(clsid_key, progid_keyname,
329 list->progid);
330 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
331
332 res = register_progid(buf, list->progid, NULL,
333 list->name, list->progid_extra);
334 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
335 }
336
337 if (list->viprogid) {
338 res = register_key_defvalueA(clsid_key, viprogid_keyname,
339 list->viprogid);
340 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
341
342 res = register_progid(buf, list->viprogid, list->progid,
343 list->name, list->progid_extra);
344 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
345 }
346
347 error_close_clsid_key:
348 RegCloseKey(clsid_key);
349 }
350
351 error_close_coclass_key:
352 RegCloseKey(coclass_key);
353 error_return:
354 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
355 }
356
357 /***********************************************************************
358 * unregister_coclasses
359 */
360 static HRESULT unregister_coclasses(struct regsvr_coclass const *list)
361 {
362 LONG res = ERROR_SUCCESS;
363 HKEY coclass_key;
364
365 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
366 KEY_READ | KEY_WRITE, &coclass_key);
367 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
368 if (res != ERROR_SUCCESS) goto error_return;
369
370 for (; res == ERROR_SUCCESS && list->clsid; ++list) {
371 WCHAR buf[39];
372
373 StringFromGUID2(list->clsid, buf, 39);
374 res = recursive_delete_keyW(coclass_key, buf);
375 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
376
377 if (list->progid) {
378 res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->progid);
379 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
380 }
381
382 if (list->viprogid) {
383 res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->viprogid);
384 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
385 }
386 }
387
388 error_close_coclass_key:
389 RegCloseKey(coclass_key);
390 error_return:
391 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
392 }
393
394 /***********************************************************************
395 * register_mediatypes_parsing
396 */
397 static HRESULT register_mediatypes_parsing(struct regsvr_mediatype_parsing const *list)
398 {
399 LONG res = ERROR_SUCCESS;
400 HKEY mediatype_key;
401 WCHAR buf[39];
402 int i;
403
404 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, NULL, 0,
405 KEY_READ | KEY_WRITE, NULL, &mediatype_key, NULL);
406 if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
407
408 for (; res == ERROR_SUCCESS && list->majortype; ++list) {
409 HKEY majortype_key = NULL;
410 HKEY subtype_key = NULL;
411
412 StringFromGUID2(list->majortype, buf, 39);
413 res = RegCreateKeyExW(mediatype_key, buf, 0, NULL, 0,
414 KEY_READ | KEY_WRITE, NULL, &majortype_key, NULL);
415 if (res != ERROR_SUCCESS) goto error_close_keys;
416
417 StringFromGUID2(list->subtype, buf, 39);
418 res = RegCreateKeyExW(majortype_key, buf, 0, NULL, 0,
419 KEY_READ | KEY_WRITE, NULL, &subtype_key, NULL);
420 if (res != ERROR_SUCCESS) goto error_close_keys;
421
422 StringFromGUID2(&CLSID_AsyncReader, buf, 39);
423 res = RegSetValueExW(subtype_key, sourcefilter_valuename, 0, REG_SZ, (CONST BYTE*)buf,
424 (lstrlenW(buf) + 1) * sizeof(WCHAR));
425 if (res != ERROR_SUCCESS) goto error_close_keys;
426
427 for(i = 0; list->line[i]; i++) {
428 char buffer[3];
429 wsprintfA(buffer, "%d", i);
430 res = RegSetValueExA(subtype_key, buffer, 0, REG_SZ, (CONST BYTE*)list->line[i],
431 lstrlenA(list->line[i]));
432 if (res != ERROR_SUCCESS) goto error_close_keys;
433 }
434
435 error_close_keys:
436 if (majortype_key)
437 RegCloseKey(majortype_key);
438 if (subtype_key)
439 RegCloseKey(subtype_key);
440 }
441
442 RegCloseKey(mediatype_key);
443
444 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
445 }
446
447 /***********************************************************************
448 * register_mediatypes_extension
449 */
450 static HRESULT register_mediatypes_extension(struct regsvr_mediatype_extension const *list)
451 {
452 LONG res = ERROR_SUCCESS;
453 HKEY mediatype_key;
454 HKEY extensions_root_key = NULL;
455 WCHAR buf[39];
456
457 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, NULL, 0,
458 KEY_READ | KEY_WRITE, NULL, &mediatype_key, NULL);
459 if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
460
461 res = RegCreateKeyExW(mediatype_key, extensions_keyname, 0, NULL, 0,
462 KEY_READ | KEY_WRITE, NULL, &extensions_root_key, NULL);
463 if (res != ERROR_SUCCESS) goto error_return;
464
465 for (; res == ERROR_SUCCESS && list->majortype; ++list) {
466 HKEY extension_key;
467
468 res = RegCreateKeyExA(extensions_root_key, list->extension, 0, NULL, 0,
469 KEY_READ | KEY_WRITE, NULL, &extension_key, NULL);
470 if (res != ERROR_SUCCESS) break;
471
472 StringFromGUID2(list->majortype, buf, 39);
473 res = RegSetValueExW(extension_key, mediatype_name, 0, REG_SZ, (CONST BYTE*)buf,
474 (lstrlenW(buf) + 1) * sizeof(WCHAR));
475 if (res != ERROR_SUCCESS) goto error_close_key;
476
477 StringFromGUID2(list->subtype, buf, 39);
478 res = RegSetValueExW(extension_key, subtype_valuename, 0, REG_SZ, (CONST BYTE*)buf,
479 (lstrlenW(buf) + 1) * sizeof(WCHAR));
480 if (res != ERROR_SUCCESS) goto error_close_key;
481
482 StringFromGUID2(&CLSID_AsyncReader, buf, 39);
483 res = RegSetValueExW(extension_key, sourcefilter_valuename, 0, REG_SZ, (CONST BYTE*)buf,
484 (lstrlenW(buf) + 1) * sizeof(WCHAR));
485 if (res != ERROR_SUCCESS) goto error_close_key;
486
487 error_close_key:
488 RegCloseKey(extension_key);
489 }
490
491 error_return:
492 RegCloseKey(mediatype_key);
493 if (extensions_root_key)
494 RegCloseKey(extensions_root_key);
495
496 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
497 }
498
499 /***********************************************************************
500 * unregister_mediatypes_parsing
501 */
502 static HRESULT unregister_mediatypes_parsing(struct regsvr_mediatype_parsing const *list)
503 {
504 LONG res;
505 HKEY mediatype_key;
506 HKEY majortype_key;
507 WCHAR buf[39];
508
509 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0,
510 KEY_READ | KEY_WRITE, &mediatype_key);
511 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
512 if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
513
514 for (; res == ERROR_SUCCESS && list->majortype; ++list) {
515 StringFromGUID2(list->majortype, buf, 39);
516 res = RegOpenKeyExW(mediatype_key, buf, 0,
517 KEY_READ | KEY_WRITE, &majortype_key);
518 if (res == ERROR_FILE_NOT_FOUND) {
519 res = ERROR_SUCCESS;
520 continue;
521 }
522 if (res != ERROR_SUCCESS) break;
523
524 StringFromGUID2(list->subtype, buf, 39);
525 res = recursive_delete_keyW(majortype_key, buf);
526 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
527
528 /* Removed majortype key if there is no more subtype key */
529 res = RegDeleteKeyW(majortype_key, 0);
530 if (res == ERROR_ACCESS_DENIED) res = ERROR_SUCCESS;
531
532 RegCloseKey(majortype_key);
533 }
534
535 RegCloseKey(mediatype_key);
536
537 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
538 }
539
540 /***********************************************************************
541 * unregister_mediatypes_extension
542 */
543 static HRESULT unregister_mediatypes_extension(struct regsvr_mediatype_extension const *list)
544 {
545 LONG res;
546 HKEY mediatype_key;
547 HKEY extensions_root_key = NULL;
548
549 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0,
550 KEY_READ | KEY_WRITE, &mediatype_key);
551 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
552 if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
553
554 res = RegOpenKeyExW(mediatype_key, extensions_keyname, 0,
555 KEY_READ | KEY_WRITE, &extensions_root_key);
556 if (res == ERROR_FILE_NOT_FOUND)
557 res = ERROR_SUCCESS;
558 else if (res == ERROR_SUCCESS)
559 for (; res == ERROR_SUCCESS && list->majortype; ++list) {
560 res = recursive_delete_keyA(extensions_root_key, list->extension);
561 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
562 }
563
564 RegCloseKey(mediatype_key);
565 if (extensions_root_key)
566 RegCloseKey(extensions_root_key);
567
568 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
569 }
570
571 /***********************************************************************
572 * register_filters
573 */
574 static HRESULT register_filters(struct regsvr_filter const *list)
575 {
576 HRESULT hr;
577 IFilterMapper2* pFM2 = NULL;
578
579 CoInitialize(NULL);
580 hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pFM2);
581
582 if (SUCCEEDED(hr)) {
583 for (; SUCCEEDED(hr) && list->clsid; ++list) {
584 REGFILTER2 rf2;
585 REGFILTERPINS2* prfp2;
586 int i;
587
588 for (i = 0; list->pins[i].flags != 0xFFFFFFFF; i++) ;
589 rf2.dwVersion = 2;
590 rf2.dwMerit = list->merit;
591 rf2.u.s1.cPins2 = i;
592 rf2.u.s1.rgPins2 = prfp2 = (REGFILTERPINS2*) CoTaskMemAlloc(i*sizeof(REGFILTERPINS2));
593 if (!prfp2) {
594 hr = E_OUTOFMEMORY;
595 break;
596 }
597 for (i = 0; list->pins[i].flags != 0xFFFFFFFF; i++) {
598 REGPINTYPES* lpMediatype;
599 CLSID* lpClsid;
600 int j, nbmt;
601
602 for (nbmt = 0; list->pins[i].mediatypes[nbmt].majortype; nbmt++) ;
603 /* Allocate a single buffer for regpintypes struct and clsids */
604 lpMediatype = (REGPINTYPES*) CoTaskMemAlloc(nbmt*(sizeof(REGPINTYPES) + 2*sizeof(CLSID)));
605 if (!lpMediatype) {
606 hr = E_OUTOFMEMORY;
607 break;
608 }
609 lpClsid = (CLSID*) (lpMediatype + nbmt);
610 for (j = 0; j < nbmt; j++) {
611 (lpMediatype + j)->clsMajorType = lpClsid + j*2;
612 memcpy(lpClsid + j*2, list->pins[i].mediatypes[j].majortype, sizeof(CLSID));
613 (lpMediatype + j)->clsMinorType = lpClsid + j*2 + 1;
614 if (list->pins[i].mediatypes[j].subtype)
615 memcpy(lpClsid + j*2 + 1, list->pins[i].mediatypes[j].subtype, sizeof(CLSID));
616 else {
617 /* Subtype are often a combination of major type + fourcc/tag */
618 memcpy(lpClsid + j*2 + 1, list->pins[i].mediatypes[j].majortype, sizeof(CLSID));
619 *(DWORD*)(lpClsid + j*2 + 1) = list->pins[i].mediatypes[j].fourcc;
620 }
621 }
622 prfp2[i].dwFlags = list->pins[i].flags;
623 prfp2[i].cInstances = 0;
624 prfp2[i].nMediaTypes = j;
625 prfp2[i].lpMediaType = lpMediatype;
626 prfp2[i].nMediums = 0;
627 prfp2[i].lpMedium = NULL;
628 prfp2[i].clsPinCategory = NULL;
629 }
630
631 if (FAILED(hr)) {
632 ERR("failed to register with hresult 0x%lx\n", hr);
633 CoTaskMemFree(prfp2);
634 break;
635 }
636
637 hr = IFilterMapper2_RegisterFilter(pFM2, list->clsid, list->name, NULL, list->category, NULL, &rf2);
638
639 while (i) {
640 CoTaskMemFree((REGPINTYPES*)prfp2[i-1].lpMediaType);
641 i--;
642 }
643 CoTaskMemFree(prfp2);
644 }
645 }
646
647 if (pFM2)
648 IFilterMapper2_Release(pFM2);
649
650 CoUninitialize();
651
652 return hr;
653 }
654
655 /***********************************************************************
656 * unregister_filters
657 */
658 static HRESULT unregister_filters(struct regsvr_filter const *list)
659 {
660 HRESULT hr;
661 IFilterMapper2* pFM2;
662
663 CoInitialize(NULL);
664
665 hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pFM2);
666
667 if (SUCCEEDED(hr)) {
668 for (; SUCCEEDED(hr) && list->clsid; ++list)
669 hr = IFilterMapper2_UnregisterFilter(pFM2, list->category, NULL, list->clsid);
670 IFilterMapper2_Release(pFM2);
671 }
672
673 CoUninitialize();
674
675 return hr;
676 }
677
678 /***********************************************************************
679 * regsvr_key_guid
680 */
681 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid)
682 {
683 WCHAR buf[39];
684
685 StringFromGUID2(guid, buf, 39);
686 return register_key_defvalueW(base, name, buf);
687 }
688
689 /***********************************************************************
690 * regsvr_key_defvalueW
691 */
692 static LONG register_key_defvalueW(
693 HKEY base,
694 WCHAR const *name,
695 WCHAR const *value)
696 {
697 LONG res;
698 HKEY key;
699
700 res = RegCreateKeyExW(base, name, 0, NULL, 0,
701 KEY_READ | KEY_WRITE, NULL, &key, NULL);
702 if (res != ERROR_SUCCESS) return res;
703 res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
704 (lstrlenW(value) + 1) * sizeof(WCHAR));
705 RegCloseKey(key);
706 return res;
707 }
708
709 /***********************************************************************
710 * regsvr_key_defvalueA
711 */
712 static LONG register_key_defvalueA(
713 HKEY base,
714 WCHAR const *name,
715 char const *value)
716 {
717 LONG res;
718 HKEY key;
719
720 res = RegCreateKeyExW(base, name, 0, NULL, 0,
721 KEY_READ | KEY_WRITE, NULL, &key, NULL);
722 if (res != ERROR_SUCCESS) return res;
723 res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
724 lstrlenA(value) + 1);
725 RegCloseKey(key);
726 return res;
727 }
728
729 /***********************************************************************
730 * regsvr_progid
731 */
732 static LONG register_progid(
733 WCHAR const *clsid,
734 char const *progid,
735 char const *curver_progid,
736 char const *name,
737 char const *extra)
738 {
739 LONG res;
740 HKEY progid_key;
741
742 res = RegCreateKeyExA(HKEY_CLASSES_ROOT, progid, 0,
743 NULL, 0, KEY_READ | KEY_WRITE, NULL,
744 &progid_key, NULL);
745 if (res != ERROR_SUCCESS) return res;
746
747 if (name) {
748 res = RegSetValueExA(progid_key, NULL, 0, REG_SZ,
749 (CONST BYTE*)name, strlen(name) + 1);
750 if (res != ERROR_SUCCESS) goto error_close_progid_key;
751 }
752
753 if (clsid) {
754 res = register_key_defvalueW(progid_key, clsid_keyname, clsid);
755 if (res != ERROR_SUCCESS) goto error_close_progid_key;
756 }
757
758 if (curver_progid) {
759 res = register_key_defvalueA(progid_key, curver_keyname,
760 curver_progid);
761 if (res != ERROR_SUCCESS) goto error_close_progid_key;
762 }
763
764 if (extra) {
765 HKEY extra_key;
766
767 res = RegCreateKeyExA(progid_key, extra, 0,
768 NULL, 0, KEY_READ | KEY_WRITE, NULL,
769 &extra_key, NULL);
770 if (res == ERROR_SUCCESS)
771 RegCloseKey(extra_key);
772 }
773
774 error_close_progid_key:
775 RegCloseKey(progid_key);
776 return res;
777 }
778
779 /***********************************************************************
780 * recursive_delete_key
781 */
782 static LONG recursive_delete_key(HKEY key)
783 {
784 LONG res;
785 WCHAR subkey_name[MAX_PATH];
786 DWORD cName;
787 HKEY subkey;
788
789 for (;;) {
790 cName = sizeof(subkey_name) / sizeof(WCHAR);
791 res = RegEnumKeyExW(key, 0, subkey_name, &cName,
792 NULL, NULL, NULL, NULL);
793 if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) {
794 res = ERROR_SUCCESS; /* presumably we're done enumerating */
795 break;
796 }
797 res = RegOpenKeyExW(key, subkey_name, 0,
798 KEY_READ | KEY_WRITE, &subkey);
799 if (res == ERROR_FILE_NOT_FOUND) continue;
800 if (res != ERROR_SUCCESS) break;
801
802 res = recursive_delete_key(subkey);
803 RegCloseKey(subkey);
804 if (res != ERROR_SUCCESS) break;
805 }
806
807 if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0);
808 return res;
809 }
810
811 /***********************************************************************
812 * recursive_delete_keyA
813 */
814 static LONG recursive_delete_keyA(HKEY base, char const *name)
815 {
816 LONG res;
817 HKEY key;
818
819 res = RegOpenKeyExA(base, name, 0, KEY_READ | KEY_WRITE, &key);
820 if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
821 if (res != ERROR_SUCCESS) return res;
822 res = recursive_delete_key(key);
823 RegCloseKey(key);
824 return res;
825 }
826
827 /***********************************************************************
828 * recursive_delete_keyW
829 */
830 static LONG recursive_delete_keyW(HKEY base, WCHAR const *name)
831 {
832 LONG res;
833 HKEY key;
834
835 res = RegOpenKeyExW(base, name, 0, KEY_READ | KEY_WRITE, &key);
836 if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
837 if (res != ERROR_SUCCESS) return res;
838 res = recursive_delete_key(key);
839 RegCloseKey(key);
840 return res;
841 }
842
843
844 static GUID const CLSID_PSFactoryBuffer = {
845 0x92a3a302, 0xda7c, 0x4a1f, {0xba,0x7e,0x18,0x02,0xbb,0x5d,0x2d,0x02} };
846
847 /***********************************************************************
848 * coclass list
849 */
850 static struct regsvr_coclass const coclass_list[] = {
851 { &CLSID_FilterGraph,
852 "Filter Graph",
853 NULL,
854 "quartz.dll",
855 "Both"
856 },
857 { &CLSID_FilterGraphNoThread,
858 "Filter Graph",
859 NULL,
860 "quartz.dll",
861 "Both"
862 },
863 { &CLSID_FilterMapper,
864 "Filter Mapper",
865 NULL,
866 "quartz.dll",
867 "Both"
868 },
869 { &CLSID_FilterMapper2,
870 "Filter Mapper2",
871 NULL,
872 "quartz.dll",
873 "Both"
874 },
875 { &CLSID_SystemClock,
876 "System Clock",
877 NULL,
878 "quartz.dll",
879 "Both"
880 },
881 { &CLSID_MemoryAllocator,
882 "Memory Allocator",
883 NULL,
884 "quartz.dll",
885 "Both"
886 },
887 { &CLSID_SeekingPassThru,
888 "Seeking",
889 NULL,
890 "quartz.dll",
891 "Both"
892 },
893 { &CLSID_AsyncReader,
894 "File Source Filter",
895 NULL,
896 "quartz.dll",
897 "Both"
898 },
899 { &CLSID_AviSplitter,
900 "AVI Splitter",
901 NULL,
902 "quartz.dll",
903 "Both"
904 },
905 { &CLSID_AVIDec,
906 "AVI Decompressor",
907 NULL,
908 "quartz.dll",
909 "Both"
910 },
911 { &CLSID_DSoundRender,
912 "DirectSound Audio Renderer",
913 NULL,
914 "quartz.dll",
915 "Both"
916 },
917 { &CLSID_VideoRenderer,
918 "Video Renderer",
919 NULL,
920 "quartz.dll",
921 "Both"
922 },
923 { &CLSID_ACMWrapper,
924 "ACM wrapper",
925 NULL,
926 "quartz.dll",
927 "Both"
928 },
929 { &CLSID_WAVEParser,
930 "Wave Parser",
931 NULL,
932 "quartz.dll",
933 "Both"
934 },
935 { NULL } /* list terminator */
936 };
937
938 /***********************************************************************
939 * interface list
940 */
941
942 static struct regsvr_interface const interface_list[] = {
943 { &IID_IFilterGraph,
944 "IFilterGraph",
945 NULL,
946 11,
947 NULL,
948 &CLSID_PSFactoryBuffer
949 },
950 { &IID_IFilterGraph2,
951 "IFilterGraph2",
952 NULL,
953 21,
954 NULL,
955 &CLSID_PSFactoryBuffer
956 },
957 { &IID_IFilterMapper,
958 "IFilterMapper",
959 NULL,
960 11,
961 NULL,
962 &CLSID_PSFactoryBuffer
963 },
964 { &IID_IFilterMapper2,
965 "IFilterMapper2",
966 NULL,
967 7,
968 NULL,
969 &CLSID_PSFactoryBuffer
970 },
971 /* FIXME:
972 { &IID_SeekingPassThru,
973 "ISeekingPassThru",
974 NULL,
975 4,
976 NULL,
977 &CLSID_PSFactoryBuffer
978 },
979 { &IID_AsyncReader,
980 "IAsyncReader",
981 NULL,
982 11,
983 NULL,
984 &CLSID_PSFactoryBuffer
985 },
986 { &IID_WAVEParser,
987 "IWAVEParser",
988 NULL,
989 11,
990 NULL,
991 &CLSID_PSFactoryBuffer
992 },*/
993 { NULL } /* list terminator */
994 };
995
996 /***********************************************************************
997 * mediatype list
998 */
999
1000 static struct regsvr_mediatype_parsing const mediatype_parsing_list[] = {
1001 { &MEDIATYPE_Stream,
1002 &MEDIASUBTYPE_Avi,
1003 { "0,4,,52494646,8,4,,41564920",
1004 NULL }
1005 },
1006 { &MEDIATYPE_Stream,
1007 &MEDIASUBTYPE_MPEG1System,
1008 { "0, 16, FFFFFFFFF100010001800001FFFFFFFF, 000001BA2100010001800001000001BB",
1009 NULL }
1010 },
1011 { &MEDIATYPE_Stream,
1012 &MEDIASUBTYPE_MPEG1VideoCD,
1013 { "0, 4, , 52494646, 8, 8, , 43445841666D7420, 36, 20, FFFFFFFF00000000FFFFFFFFFFFFFFFFFFFFFFFF, 646174610000000000FFFFFFFFFFFFFFFFFFFF00",
1014 NULL }
1015 },
1016 { &MEDIATYPE_Stream,
1017 &MEDIASUBTYPE_MPEG1Video,
1018 { "0, 4, , 000001B3",
1019 NULL }
1020 },
1021 { &MEDIATYPE_Stream,
1022 &MEDIASUBTYPE_MPEG1Audio,
1023 { "0, 2, FFE0, FFE0",
1024 "0, 10, FFFFFFFF000000000000, 494433030080808080",
1025 NULL }
1026 },
1027 { &MEDIATYPE_Stream,
1028 &MEDIASUBTYPE_QTMovie,
1029 { "4, 4, , 6d646174",
1030 "4, 4, , 6d6f6f76",
1031 NULL }
1032 },
1033 { &MEDIATYPE_Stream,
1034 &MEDIASUBTYPE_WAVE,
1035 { "0,4,,52494646,8,4,,57415645",
1036 NULL }
1037 },
1038 { &MEDIATYPE_Stream,
1039 &MEDIASUBTYPE_AU,
1040 { "0,4,,2e736e64",
1041 NULL }
1042 },
1043 { &MEDIATYPE_Stream,
1044 &MEDIASUBTYPE_AIFF,
1045 { "0,4,,464f524d,8,4,,41494646",
1046 "0,4,,464f524d,8,4,,41494643",
1047 NULL }
1048 },
1049 { &MEDIATYPE_Stream,
1050 &MEDIATYPE_Text,
1051 { "0,4,,4C595249",
1052 "0,4,,6C797269",
1053 NULL }
1054 },
1055 { &MEDIATYPE_Stream,
1056 &MEDIATYPE_Midi,
1057 { "0,4,,52494646,8,4,,524D4944",
1058 "0,4,,4D546864",
1059 NULL }
1060 },
1061 { NULL } /* list terminator */
1062 };
1063
1064 /***********************************************************************
1065 * mediatype list
1066 */
1067
1068 static struct regsvr_mediatype_extension const mediatype_extension_list[] = {
1069 { &MEDIATYPE_Stream,
1070 &MEDIASUBTYPE_MPEG1Audio,
1071 ".mp3"
1072 },
1073 { NULL } /* list terminator */
1074 };
1075
1076 /***********************************************************************
1077 * filter list
1078 */
1079
1080 static struct regsvr_filter const filter_list[] = {
1081 { &CLSID_AviSplitter,
1082 &CLSID_LegacyAmFilterCategory,
1083 {'A','V','I',' ','S','p','l','i','t','t','e','r',0},
1084 0x600000,
1085 { { 0,
1086 { { &MEDIATYPE_Stream, &MEDIASUBTYPE_Avi },
1087 { NULL }
1088 },
1089 },
1090 { REG_PINFLAG_B_OUTPUT,
1091 { { &MEDIATYPE_Video, &GUID_NULL },
1092 { NULL }
1093 },
1094 },
1095 { 0xFFFFFFFF },
1096 }
1097 },
1098 { &CLSID_VideoRenderer,
1099 &CLSID_LegacyAmFilterCategory,
1100 {'V','i','d','e','o',' ','R','e','n','d','e','r','e','r',0},
1101 0x800000,
1102 { { REG_PINFLAG_B_RENDERER,
1103 { { &MEDIATYPE_Video, &GUID_NULL },
1104 { NULL }
1105 },
1106 },
1107 { 0xFFFFFFFF },
1108 }
1109 },
1110 { &CLSID_AVIDec,
1111 &CLSID_LegacyAmFilterCategory,
1112 {'A','V','I',' ','D','e','c','o','m','p','r','e','s','s','o','r',0},
1113 0x600000,
1114 { { 0,
1115 { { &MEDIATYPE_Video, &GUID_NULL },
1116 { NULL }
1117 },
1118 },
1119 { REG_PINFLAG_B_OUTPUT,
1120 { { &MEDIATYPE_Video, &GUID_NULL },
1121 { NULL }
1122 },
1123 },
1124 { 0xFFFFFFFF },
1125 }
1126 },
1127 { &CLSID_AsyncReader,
1128 &CLSID_LegacyAmFilterCategory,
1129 {'F','i','l','e',' ','S','o','u','r','c','e',' ','(','A','s','y','n','c','.',')',0},
1130 0x400000,
1131 { { REG_PINFLAG_B_OUTPUT,
1132 { { &MEDIATYPE_Stream, &GUID_NULL },
1133 { NULL }
1134 },
1135 },
1136 { 0xFFFFFFFF },
1137 }
1138 },
1139 { &CLSID_ACMWrapper,
1140 &CLSID_LegacyAmFilterCategory,
1141 {'A','C','M',' ','W','r','a','p','p','e','r',0},
1142 0x600000,
1143 { { 0,
1144 { { &MEDIATYPE_Audio, &GUID_NULL },
1145 { NULL }
1146 },
1147 },
1148 { REG_PINFLAG_B_OUTPUT,
1149 { { &MEDIATYPE_Audio, &GUID_NULL },
1150 { NULL }
1151 },
1152 },
1153 { 0xFFFFFFFF },
1154 }
1155 },
1156 { &CLSID_WAVEParser,
1157 &CLSID_LegacyAmFilterCategory,
1158 {'W','a','v','e',' ','P','a','r','s','e','r',0},
1159 0x400000,
1160 { { 0,
1161 { { &MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE },
1162 { &MEDIATYPE_Stream, &MEDIASUBTYPE_AU },
1163 { &MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF },
1164 { NULL }
1165 },
1166 },
1167 { REG_PINFLAG_B_OUTPUT,
1168 { { &MEDIATYPE_Audio, &GUID_NULL },
1169 { NULL }
1170 },
1171 },
1172 { 0xFFFFFFFF },
1173 }
1174 },
1175 { NULL } /* list terminator */
1176 };
1177
1178 /***********************************************************************
1179 * DllRegisterServer (QUARTZ.@)
1180 */
1181 HRESULT WINAPI DllRegisterServer(void)
1182 {
1183 HRESULT hr;
1184
1185 TRACE("\n");
1186
1187 hr = register_coclasses(coclass_list);
1188 if (SUCCEEDED(hr))
1189 hr = register_interfaces(interface_list);
1190 if (SUCCEEDED(hr))
1191 hr = register_mediatypes_parsing(mediatype_parsing_list);
1192 if (SUCCEEDED(hr))
1193 hr = register_mediatypes_extension(mediatype_extension_list);
1194 if (SUCCEEDED(hr))
1195 hr = register_filters(filter_list);
1196 return hr;
1197 }
1198
1199 /***********************************************************************
1200 * DllUnregisterServer (QUARTZ.@)
1201 */
1202 HRESULT WINAPI DllUnregisterServer(void)
1203 {
1204 HRESULT hr;
1205
1206 TRACE("\n");
1207
1208 hr = unregister_filters(filter_list);
1209 if (SUCCEEDED(hr))
1210 hr = unregister_coclasses(coclass_list);
1211 if (SUCCEEDED(hr))
1212 hr = unregister_interfaces(interface_list);
1213 if (SUCCEEDED(hr))
1214 hr = unregister_mediatypes_parsing(mediatype_parsing_list);
1215 if (SUCCEEDED(hr))
1216 hr = unregister_mediatypes_extension(mediatype_extension_list);
1217 return hr;
1218 }
Windows API implementation