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