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