?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Read the disk prompt source list property from the user-unmanaged context.
[wine/wine-kai.git] / dlls / quartz / regsvr.c
blob98fd0bc5a295a4808e5c079db3eadffd8ce80638
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 #include <stdarg.h>
25 #include <string.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "winreg.h"
31 #include "winerror.h"
32
33 #include "ole2.h"
34 #include "uuids.h"
35 #include "strmif.h"
36
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
40
41 /*
42 * Near the bottom of this file are the exported DllRegisterServer and
43 * DllUnregisterServer, which make all this worthwhile.
44 */
45
46 /***********************************************************************
47 * interface for self-registering
48 */
49 struct regsvr_interface
50 {
51 IID const *iid; /* NULL for end of list */
52 LPCSTR name; /* can be NULL to omit */
53 IID const *base_iid; /* can be NULL to omit */
54 int num_methods; /* can be <0 to omit */
55 CLSID const *ps_clsid; /* can be NULL to omit */
56 CLSID const *ps_clsid32; /* can be NULL to omit */
57 };
58
59 static HRESULT register_interfaces(struct regsvr_interface const *list);
60 static HRESULT unregister_interfaces(struct regsvr_interface const *list);
61
62 struct regsvr_coclass
63 {
64 CLSID const *clsid; /* NULL for end of list */
65 LPCSTR name; /* can be NULL to omit */
66 LPCSTR ips; /* can be NULL to omit */
67 LPCSTR ips32; /* can be NULL to omit */
68 LPCSTR ips32_tmodel; /* can be NULL to omit */
69 LPCSTR progid; /* can be NULL to omit */
70 LPCSTR viprogid; /* can be NULL to omit */
71 LPCSTR progid_extra; /* can be NULL to omit */
72 };
73
74 static HRESULT register_coclasses(struct regsvr_coclass const *list);
75 static HRESULT unregister_coclasses(struct regsvr_coclass const *list);
76
77 struct regsvr_mediatype_parsing
78 {
79 CLSID const *majortype; /* NULL for end of list */
80 CLSID const *subtype;
81 LPCSTR line[11]; /* NULL for end of list */
82 };
83
84 static HRESULT register_mediatypes_parsing(struct regsvr_mediatype_parsing const *list);
85 static HRESULT unregister_mediatypes_parsing(struct regsvr_mediatype_parsing const *list);
86
87 struct regsvr_mediatype_extension
88 {
89 CLSID const *majortype; /* NULL for end of list */
90 CLSID const *subtype;
91 LPCSTR extension;
92 };
93
94 struct mediatype
95 {
96 CLSID const *majortype; /* NULL for end of list */
97 CLSID const *subtype;
98 DWORD fourcc;
99 };
100
101 struct pin
102 {
103 DWORD flags; /* 0xFFFFFFFF for end of list */
104 struct mediatype mediatypes[11];
105 };
106
107 struct regsvr_filter
108 {
109 CLSID const *clsid; /* NULL for end of list */
110 CLSID const *category;
111 WCHAR name[50];
112 DWORD merit;
113 struct pin pins[11];
114 };
115
116 static HRESULT register_mediatypes_extension(struct regsvr_mediatype_extension const *list);
117 static HRESULT unregister_mediatypes_extension(struct regsvr_mediatype_extension const *list);
118
119 static HRESULT register_filters(struct regsvr_filter const *list);
120 static HRESULT unregister_filters(struct regsvr_filter const *list);
121
122 /***********************************************************************
123 * static string constants
124 */
125 static WCHAR const interface_keyname[10] = {
126 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };
127 static WCHAR const base_ifa_keyname[14] = {
128 'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c',
129 'e', 0 };
130 static WCHAR const num_methods_keyname[11] = {
131 'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };
132 static WCHAR const ps_clsid_keyname[15] = {
133 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
134 'i', 'd', 0 };
135 static WCHAR const ps_clsid32_keyname[17] = {
136 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
137 'i', 'd', '3', '2', 0 };
138 static WCHAR const clsid_keyname[6] = {
139 'C', 'L', 'S', 'I', 'D', 0 };
140 static WCHAR const curver_keyname[7] = {
141 'C', 'u', 'r', 'V', 'e', 'r', 0 };
142 static WCHAR const ips_keyname[13] = {
143 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
144 0 };
145 static WCHAR const ips32_keyname[15] = {
146 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
147 '3', '2', 0 };
148 static WCHAR const progid_keyname[7] = {
149 'P', 'r', 'o', 'g', 'I', 'D', 0 };
150 static WCHAR const viprogid_keyname[25] = {
151 'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p',
152 'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D',
153 0 };
154 static char const tmodel_valuename[] = "ThreadingModel";
155 static WCHAR const mediatype_name[11] = {
156 'M', 'e', 'd', 'i', 'a', ' ', 'T', 'y', 'p', 'e', 0 };
157 static WCHAR const subtype_valuename[8] = {
158 'S', 'u', 'b', 't', 'y', 'p', 'e', 0 };
159 static WCHAR const sourcefilter_valuename[14] = {
160 'S', 'o', 'u', 'r', 'c', 'e', ' ', 'F', 'i', 'l', 't', 'e', 'r', 0 };
161 static WCHAR const extensions_keyname[11] = {
162 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 0 };
163
164 /***********************************************************************
165 * static helper functions
166 */
167 static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);
168 static LONG register_key_defvalueW(HKEY base, WCHAR const *name,
169 WCHAR const *value);
170 static LONG register_key_defvalueA(HKEY base, WCHAR const *name,
171 char const *value);
172 static LONG register_progid(WCHAR const *clsid,
173 char const *progid, char const *curver_progid,
174 char const *name, char const *extra);
175
176 /***********************************************************************
177 * register_interfaces
178 */
179 static HRESULT register_interfaces(struct regsvr_interface const *list)
180 {
181 LONG res = ERROR_SUCCESS;
182 HKEY interface_key;
183
184 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
185 KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
186 if (res != ERROR_SUCCESS) goto error_return;
187
188 for (; res == ERROR_SUCCESS && list->iid; ++list) {
189 WCHAR buf[39];
190 HKEY iid_key;
191
192 StringFromGUID2(list->iid, buf, 39);
193 res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
194 KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
195 if (res != ERROR_SUCCESS) goto error_close_interface_key;
196
197 if (list->name) {
198 res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
199 (CONST BYTE*)(list->name),
200 strlen(list->name) + 1);
201 if (res != ERROR_SUCCESS) goto error_close_iid_key;
202 }
203
204 if (list->base_iid) {
205 res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
206 if (res != ERROR_SUCCESS) goto error_close_iid_key;
207 }
208
209 if (0 <= list->num_methods) {
210 static WCHAR const fmt[3] = { '%', 'd', 0 };
211 HKEY key;
212
213 res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
214 KEY_READ | KEY_WRITE, NULL, &key, NULL);
215 if (res != ERROR_SUCCESS) goto error_close_iid_key;
216
217 wsprintfW(buf, fmt, list->num_methods);
218 res = RegSetValueExW(key, NULL, 0, REG_SZ,
219 (CONST BYTE*)buf,
220 (lstrlenW(buf) + 1) * sizeof(WCHAR));
221 RegCloseKey(key);
222
223 if (res != ERROR_SUCCESS) goto error_close_iid_key;
224 }
225
226 if (list->ps_clsid) {
227 res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
228 if (res != ERROR_SUCCESS) goto error_close_iid_key;
229 }
230
231 if (list->ps_clsid32) {
232 res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
233 if (res != ERROR_SUCCESS) goto error_close_iid_key;
234 }
235
236 error_close_iid_key:
237 RegCloseKey(iid_key);
238 }
239
240 error_close_interface_key:
241 RegCloseKey(interface_key);
242 error_return:
243 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
244 }
245
246 /***********************************************************************
247 * unregister_interfaces
248 */
249 static HRESULT unregister_interfaces(struct regsvr_interface const *list)
250 {
251 LONG res = ERROR_SUCCESS;
252 HKEY interface_key;
253
254 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
255 KEY_READ | KEY_WRITE, &interface_key);
256 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
257 if (res != ERROR_SUCCESS) goto error_return;
258
259 for (; res == ERROR_SUCCESS && list->iid; ++list) {
260 WCHAR buf[39];
261
262 StringFromGUID2(list->iid, buf, 39);
263 res = RegDeleteTreeW(interface_key, buf);
264 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
265 }
266
267 RegCloseKey(interface_key);
268 error_return:
269 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
270 }
271
272 /***********************************************************************
273 * register_coclasses
274 */
275 static HRESULT register_coclasses(struct regsvr_coclass const *list)
276 {
277 LONG res = ERROR_SUCCESS;
278 HKEY coclass_key;
279
280 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
281 KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
282 if (res != ERROR_SUCCESS) goto error_return;
283
284 for (; res == ERROR_SUCCESS && list->clsid; ++list) {
285 WCHAR buf[39];
286 HKEY clsid_key;
287
288 StringFromGUID2(list->clsid, buf, 39);
289 res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
290 KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
291 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
292
293 if (list->name) {
294 res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
295 (CONST BYTE*)(list->name),
296 strlen(list->name) + 1);
297 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
298 }
299
300 if (list->ips) {
301 res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
302 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
303 }
304
305 if (list->ips32) {
306 HKEY ips32_key;
307
308 res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
309 KEY_READ | KEY_WRITE, NULL,
310 &ips32_key, NULL);
311 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
312
313 res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
314 (CONST BYTE*)list->ips32,
315 lstrlenA(list->ips32) + 1);
316 if (res == ERROR_SUCCESS && list->ips32_tmodel)
317 res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
318 (CONST BYTE*)list->ips32_tmodel,
319 strlen(list->ips32_tmodel) + 1);
320 RegCloseKey(ips32_key);
321 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
322 }
323
324 if (list->progid) {
325 res = register_key_defvalueA(clsid_key, progid_keyname,
326 list->progid);
327 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
328
329 res = register_progid(buf, list->progid, NULL,
330 list->name, list->progid_extra);
331 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
332 }
333
334 if (list->viprogid) {
335 res = register_key_defvalueA(clsid_key, viprogid_keyname,
336 list->viprogid);
337 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
338
339 res = register_progid(buf, list->viprogid, list->progid,
340 list->name, list->progid_extra);
341 if (res != ERROR_SUCCESS) goto error_close_clsid_key;
342 }
343
344 error_close_clsid_key:
345 RegCloseKey(clsid_key);
346 }
347
348 error_close_coclass_key:
349 RegCloseKey(coclass_key);
350 error_return:
351 return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
352 }
353
354 /***********************************************************************
355 * unregister_coclasses
356 */
357 static HRESULT unregister_coclasses(struct regsvr_coclass const *list)
358 {
359 LONG res = ERROR_SUCCESS;
360 HKEY coclass_key;
361
362 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
363 KEY_READ | KEY_WRITE, &coclass_key);
364 if (res == ERROR_FILE_NOT_FOUND) return S_OK;
365 if (res != ERROR_SUCCESS) goto error_return;
366
367 for (; res == ERROR_SUCCESS && list->clsid; ++list) {
368 WCHAR buf[39];
369
370 StringFromGUID2(list->clsid, buf, 39);
371 res = RegDeleteTreeW(coclass_key, buf);
372 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
373 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
374
375 if (list->progid) {
376 res = RegDeleteTreeA(HKEY_CLASSES_ROOT, list->progid);
377 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
378 if (res != ERROR_SUCCESS) goto error_close_coclass_key;
379 }
380
381 if (list->viprogid) {
382 res = RegDeleteTreeA(HKEY_CLASSES_ROOT, list->viprogid);
383 if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
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 = RegDeleteTreeW(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 = RegDeleteTreeA(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 = 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 = 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%x\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 static GUID const CLSID_PSFactoryBuffer = {
780 0x92a3a302, 0xda7c, 0x4a1f, {0xba,0x7e,0x18,0x02,0xbb,0x5d,0x2d,0x02} };
781
782 /***********************************************************************
783 * coclass list
784 */
785 static struct regsvr_coclass const coclass_list[] = {
786 { &CLSID_FilterGraph,
787 "Filter Graph",
788 NULL,
789 "quartz.dll",
790 "Both"
791 },
792 { &CLSID_FilterGraphNoThread,
793 "Filter Graph",
794 NULL,
795 "quartz.dll",
796 "Both"
797 },
798 { &CLSID_FilterMapper,
799 "Filter Mapper",
800 NULL,
801 "quartz.dll",
802 "Both"
803 },
804 { &CLSID_FilterMapper2,
805 "Filter Mapper2",
806 NULL,
807 "quartz.dll",
808 "Both"
809 },
810 { &CLSID_SystemClock,
811 "System Clock",
812 NULL,
813 "quartz.dll",
814 "Both"
815 },
816 { &CLSID_MemoryAllocator,
817 "Memory Allocator",
818 NULL,
819 "quartz.dll",
820 "Both"
821 },
822 { &CLSID_SeekingPassThru,
823 "Seeking",
824 NULL,
825 "quartz.dll",
826 "Both"
827 },
828 { &CLSID_AsyncReader,
829 "File Source Filter",
830 NULL,
831 "quartz.dll",
832 "Both"
833 },
834 { &CLSID_AviSplitter,
835 "AVI Splitter",
836 NULL,
837 "quartz.dll",
838 "Both"
839 },
840 { &CLSID_MPEG1Splitter,
841 "MPEG-I Stream Splitter",
842 NULL,
843 "quartz.dll",
844 "Both"
845 },
846 { &CLSID_AVIDec,
847 "AVI Decompressor",
848 NULL,
849 "quartz.dll",
850 "Both"
851 },
852 { &CLSID_DSoundRender,
853 "DirectSound Audio Renderer",
854 NULL,
855 "quartz.dll",
856 "Both"
857 },
858 { &CLSID_VideoRenderer,
859 "Video Renderer",
860 NULL,
861 "quartz.dll",
862 "Both"
863 },
864 { &CLSID_VideoRendererDefault,
865 "Default Video Renderer",
866 NULL,
867 "quartz.dll",
868 "Both"
869 },
870 { &CLSID_ACMWrapper,
871 "ACM wrapper",
872 NULL,
873 "quartz.dll",
874 "Both"
875 },
876 { &CLSID_WAVEParser,
877 "Wave Parser",
878 NULL,
879 "quartz.dll",
880 "Both"
881 },
882 { NULL } /* list terminator */
883 };
884
885 /***********************************************************************
886 * interface list
887 */
888
889 static struct regsvr_interface const interface_list[] = {
890 { &IID_IFilterGraph,
891 "IFilterGraph",
892 NULL,
893 11,
894 NULL,
895 &CLSID_PSFactoryBuffer
896 },
897 { &IID_IFilterGraph2,
898 "IFilterGraph2",
899 NULL,
900 21,
901 NULL,
902 &CLSID_PSFactoryBuffer
903 },
904 { &IID_IFilterMapper,
905 "IFilterMapper",
906 NULL,
907 11,
908 NULL,
909 &CLSID_PSFactoryBuffer
910 },
911 { &IID_IFilterMapper2,
912 "IFilterMapper2",
913 NULL,
914 7,
915 NULL,
916 &CLSID_PSFactoryBuffer
917 },
918 /* FIXME:
919 { &IID_SeekingPassThru,
920 "ISeekingPassThru",
921 NULL,
922 4,
923 NULL,
924 &CLSID_PSFactoryBuffer
925 },
926 { &IID_AsyncReader,
927 "IAsyncReader",
928 NULL,
929 11,
930 NULL,
931 &CLSID_PSFactoryBuffer
932 },
933 { &IID_WAVEParser,
934 "IWAVEParser",
935 NULL,
936 11,
937 NULL,
938 &CLSID_PSFactoryBuffer
939 },*/
940 { NULL } /* list terminator */
941 };
942
943 /***********************************************************************
944 * mediatype list
945 */
946
947 static struct regsvr_mediatype_parsing const mediatype_parsing_list[] = {
948 { &MEDIATYPE_Stream,
949 &MEDIASUBTYPE_Avi,
950 { "0,4,,52494646,8,4,,41564920",
951 NULL }
952 },
953 { &MEDIATYPE_Stream,
954 &MEDIASUBTYPE_MPEG1System,
955 { "0, 16, FFFFFFFFF100010001800001FFFFFFFF, 000001BA2100010001800001000001BB",
956 NULL }
957 },
958 { &MEDIATYPE_Stream,
959 &MEDIASUBTYPE_MPEG1VideoCD,
960 { "0, 4, , 52494646, 8, 8, , 43445841666D7420, 36, 20, FFFFFFFF00000000FFFFFFFFFFFFFFFFFFFFFFFF, 646174610000000000FFFFFFFFFFFFFFFFFFFF00",
961 NULL }
962 },
963 { &MEDIATYPE_Stream,
964 &MEDIASUBTYPE_MPEG1Video,
965 { "0, 4, , 000001B3",
966 NULL }
967 },
968 { &MEDIATYPE_Stream,
969 &MEDIASUBTYPE_MPEG1Audio,
970 { "0, 2, FFE0, FFE0",
971 "0, 10, FFFFFFFF000000000000, 494433030080808080",
972 NULL }
973 },
974 { &MEDIATYPE_Stream,
975 &MEDIASUBTYPE_QTMovie,
976 { "4, 4, , 6d646174",
977 "4, 4, , 6d6f6f76",
978 NULL }
979 },
980 { &MEDIATYPE_Stream,
981 &MEDIASUBTYPE_WAVE,
982 { "0,4,,52494646,8,4,,57415645",
983 NULL }
984 },
985 { &MEDIATYPE_Stream,
986 &MEDIASUBTYPE_AU,
987 { "0,4,,2e736e64",
988 NULL }
989 },
990 { &MEDIATYPE_Stream,
991 &MEDIASUBTYPE_AIFF,
992 { "0,4,,464f524d,8,4,,41494646",
993 "0,4,,464f524d,8,4,,41494643",
994 NULL }
995 },
996 { &MEDIATYPE_Stream,
997 &MEDIATYPE_Text,
998 { "0,4,,4C595249",
999 "0,4,,6C797269",
1000 NULL }
1001 },
1002 { &MEDIATYPE_Stream,
1003 &MEDIATYPE_Midi,
1004 { "0,4,,52494646,8,4,,524D4944",
1005 "0,4,,4D546864",
1006 NULL }
1007 },
1008 { NULL } /* list terminator */
1009 };
1010
1011 /***********************************************************************
1012 * mediatype list
1013 */
1014
1015 static struct regsvr_mediatype_extension const mediatype_extension_list[] = {
1016 { &MEDIATYPE_Stream,
1017 &MEDIASUBTYPE_MPEG1Audio,
1018 ".mp3"
1019 },
1020 { NULL } /* list terminator */
1021 };
1022
1023 /***********************************************************************
1024 * filter list
1025 */
1026
1027 static struct regsvr_filter const filter_list[] = {
1028 { &CLSID_AviSplitter,
1029 &CLSID_LegacyAmFilterCategory,
1030 {'A','V','I',' ','S','p','l','i','t','t','e','r',0},
1031 0x600000,
1032 { { 0,
1033 { { &MEDIATYPE_Stream, &MEDIASUBTYPE_Avi },
1034 { NULL }
1035 },
1036 },
1037 { REG_PINFLAG_B_OUTPUT,
1038 { { &MEDIATYPE_Video, &GUID_NULL },
1039 { NULL }
1040 },
1041 },
1042 { 0xFFFFFFFF },
1043 }
1044 },
1045 { &CLSID_MPEG1Splitter,
1046 &CLSID_LegacyAmFilterCategory,
1047 {'M','P','E','G','-','I',' ','S','t','r','e','a','m',' ','S','p','l','i','t','t','e','r',0},
1048 0x600000,
1049 { { 0,
1050 { { &MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio },
1051 { &MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video },
1052 { &MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System },
1053 { &MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD },
1054 { NULL }
1055 },
1056 },
1057 { REG_PINFLAG_B_OUTPUT,
1058 { { &MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet },
1059 { &MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload },
1060 { NULL }
1061 },
1062 },
1063 { REG_PINFLAG_B_OUTPUT,
1064 { { &MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet },
1065 { &MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload },
1066 { NULL }
1067 },
1068 },
1069 { 0xFFFFFFFF },
1070 }
1071 },
1072 { &CLSID_VideoRenderer,
1073 &CLSID_LegacyAmFilterCategory,
1074 {'V','i','d','e','o',' ','R','e','n','d','e','r','e','r',0},
1075 0x800000,
1076 { { REG_PINFLAG_B_RENDERER,
1077 { { &MEDIATYPE_Video, &GUID_NULL },
1078 { NULL }
1079 },
1080 },
1081 { 0xFFFFFFFF },
1082 }
1083 },
1084 { &CLSID_VideoRendererDefault,
1085 &CLSID_LegacyAmFilterCategory,
1086 {'V','i','d','e','o',' ','R','e','n','d','e','r','e','r',0},
1087 0x800000,
1088 { { REG_PINFLAG_B_RENDERER,
1089 { { &MEDIATYPE_Video, &GUID_NULL },
1090 { NULL }
1091 },
1092 },
1093 { 0xFFFFFFFF },
1094 }
1095 },
1096 { &CLSID_AVIDec,
1097 &CLSID_LegacyAmFilterCategory,
1098 {'A','V','I',' ','D','e','c','o','m','p','r','e','s','s','o','r',0},
1099 0x600000,
1100 { { 0,
1101 { { &MEDIATYPE_Video, &GUID_NULL },
1102 { NULL }
1103 },
1104 },
1105 { REG_PINFLAG_B_OUTPUT,
1106 { { &MEDIATYPE_Video, &GUID_NULL },
1107 { NULL }
1108 },
1109 },
1110 { 0xFFFFFFFF },
1111 }
1112 },
1113 { &CLSID_AsyncReader,
1114 &CLSID_LegacyAmFilterCategory,
1115 {'F','i','l','e',' ','S','o','u','r','c','e',' ','(','A','s','y','n','c','.',')',0},
1116 0x400000,
1117 { { REG_PINFLAG_B_OUTPUT,
1118 { { &MEDIATYPE_Stream, &GUID_NULL },
1119 { NULL }
1120 },
1121 },
1122 { 0xFFFFFFFF },
1123 }
1124 },
1125 { &CLSID_ACMWrapper,
1126 &CLSID_LegacyAmFilterCategory,
1127 {'A','C','M',' ','W','r','a','p','p','e','r',0},
1128 0x600000,
1129 { { 0,
1130 { { &MEDIATYPE_Audio, &GUID_NULL },
1131 { NULL }
1132 },
1133 },
1134 { REG_PINFLAG_B_OUTPUT,
1135 { { &MEDIATYPE_Audio, &GUID_NULL },
1136 { NULL }
1137 },
1138 },
1139 { 0xFFFFFFFF },
1140 }
1141 },
1142 { &CLSID_WAVEParser,
1143 &CLSID_LegacyAmFilterCategory,
1144 {'W','a','v','e',' ','P','a','r','s','e','r',0},
1145 0x400000,
1146 { { 0,
1147 { { &MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE },
1148 { &MEDIATYPE_Stream, &MEDIASUBTYPE_AU },
1149 { &MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF },
1150 { NULL }
1151 },
1152 },
1153 { REG_PINFLAG_B_OUTPUT,
1154 { { &MEDIATYPE_Audio, &GUID_NULL },
1155 { NULL }
1156 },
1157 },
1158 { 0xFFFFFFFF },
1159 }
1160 },
1161 { NULL } /* list terminator */
1162 };
1163
1164 /***********************************************************************
1165 * DllRegisterServer (QUARTZ.@)
1166 */
1167 HRESULT WINAPI DllRegisterServer(void)
1168 {
1169 HRESULT hr;
1170
1171 TRACE("\n");
1172
1173 hr = register_coclasses(coclass_list);
1174 if (SUCCEEDED(hr))
1175 hr = register_interfaces(interface_list);
1176 if (SUCCEEDED(hr))
1177 hr = register_mediatypes_parsing(mediatype_parsing_list);
1178 if (SUCCEEDED(hr))
1179 hr = register_mediatypes_extension(mediatype_extension_list);
1180 if (SUCCEEDED(hr))
1181 hr = register_filters(filter_list);
1182 return hr;
1183 }
1184
1185 /***********************************************************************
1186 * DllUnregisterServer (QUARTZ.@)
1187 */
1188 HRESULT WINAPI DllUnregisterServer(void)
1189 {
1190 HRESULT hr;
1191
1192 TRACE("\n");
1193
1194 hr = unregister_filters(filter_list);
1195 if (SUCCEEDED(hr))
1196 hr = unregister_coclasses(coclass_list);
1197 if (SUCCEEDED(hr))
1198 hr = unregister_interfaces(interface_list);
1199 if (SUCCEEDED(hr))
1200 hr = unregister_mediatypes_parsing(mediatype_parsing_list);
1201 if (SUCCEEDED(hr))
1202 hr = unregister_mediatypes_extension(mediatype_extension_list);
1203 return hr;
1204 }
Work in progress by Kai Blin