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