WineASIO
/
wineasio
mirror of https://github.com/wineasio/wineasio
1
0
Fork 0
Code Releases 3 Activity
ASIO to JACK driver for WINE
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100 Commits
2 Branches
1.1MB
Branch: mod-desktop
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'mod-desktop'
${ noResults }
wineasio/regsvr.c

594 lines
17KB
Raw Permalink Blame History 

  1. /*

  2.  *	self-registerable dll functions for wineasio.dll

  3.  *

  4.  * Copyright (C) 2003 John K. Hohm

  5.  * Copyright (C) 2006 Robert Reif

  6.  *

  7.  * This library is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * This library is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with this library; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

  20.  */

  21. 

  22. #include <stdarg.h>

  23. 

  24. #define NONAMELESSSTRUCT

  25. #define NONAMELESSUNION

  26. #include "windef.h"

  27. #include "winbase.h"

  28. #include "winuser.h"

  29. #include "winreg.h"

  30. #include "objbase.h"

  31. 

  32. #ifdef DEBUG

  33. #include "wine/debug.h"

  34. #endif

  35. 

  36. /* WINE_DEFAULT_DEBUG_CHANNEL(asio); */

  37. 

  38. /*

  39.  * Near the bottom of this file are the exported DllRegisterServer and

  40.  * DllUnregisterServer, which make all this worthwhile.

  41.  */

  42. 

  43. /***********************************************************************

  44.  *		interface for self-registering

  45.  */

  46. struct regsvr_interface

  47. {

  48.     IID const *iid;		/* NULL for end of list */

  49.     LPCSTR name;		/* can be NULL to omit */

  50.     IID const *base_iid;	/* can be NULL to omit */

  51.     int num_methods;		/* can be <0 to omit */

  52.     CLSID const *ps_clsid;	/* can be NULL to omit */

  53.     CLSID const *ps_clsid32;	/* can be NULL to omit */

  54. };

  55. 

  56. static HRESULT register_interfaces(struct regsvr_interface const *list);

  57. static HRESULT unregister_interfaces(struct regsvr_interface const *list);

  58. 

  59. struct regsvr_coclass

  60. {

  61.     CLSID const *clsid;		/* NULL for end of list */

  62.     LPCSTR name;		/* can be NULL to omit */

  63.     LPCSTR ips;			/* can be NULL to omit */

  64.     LPCSTR ips32;		/* can be NULL to omit */

  65.     LPCSTR ips32_tmodel;	/* can be NULL to omit */

  66.     LPCSTR progid;		/* can be NULL to omit */

  67.     LPCSTR viprogid;		/* can be NULL to omit */

  68.     LPCSTR progid_extra;	/* can be NULL to omit */

  69. };

  70. 

  71. static HRESULT register_coclasses(struct regsvr_coclass const *list);

  72. static HRESULT unregister_coclasses(struct regsvr_coclass const *list);

  73. 

  74. /***********************************************************************

  75.  *		static string constants

  76.  */

  77. static WCHAR const interface_keyname[10] = {

  78.     'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };

  79. static WCHAR const base_ifa_keyname[14] = {

  80.     'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };

  81. static WCHAR const num_methods_keyname[11] = {

  82.     'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };

  83. static WCHAR const ps_clsid_keyname[15] = {

  84.     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's', 'i', 'd', 0 };

  85. static WCHAR const ps_clsid32_keyname[17] = {

  86.     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's', 'i', 'd', '3', '2', 0 };

  87. static WCHAR const clsid_keyname[6] = {

  88.     'C', 'L', 'S', 'I', 'D', 0 };

  89. static WCHAR const curver_keyname[7] = {

  90.     'C', 'u', 'r', 'V', 'e', 'r', 0 };

  91. static WCHAR const ips_keyname[13] = {

  92.     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r', 0 };

  93. static WCHAR const ips32_keyname[15] = {

  94.     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r', '3', '2', 0 };

  95. static WCHAR const progid_keyname[7] = {

  96.     'P', 'r', 'o', 'g', 'I', 'D', 0 };

  97. static WCHAR const viprogid_keyname[25] = {

  98.     'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D', 0 };

  99. static char const tmodel_valuename[] = "ThreadingModel";

  100. 

  101. /***********************************************************************

  102.  *		static helper functions

  103.  */

  104. static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);

  105. static LONG register_key_defvalueW(HKEY base, WCHAR const *name,

  106. 				   WCHAR const *value);

  107. static LONG register_key_defvalueA(HKEY base, WCHAR const *name,

  108. 				   char const *value);

  109. static LONG register_progid(WCHAR const *clsid,

  110. 			    char const *progid, char const *curver_progid,

  111. 			    char const *name, char const *extra);

  112. static LONG recursive_delete_key(HKEY key);

  113. static LONG recursive_delete_keyA(HKEY base, char const *name);

  114. static LONG recursive_delete_keyW(HKEY base, WCHAR const *name);

  115. 

  116. /***********************************************************************

  117.  *		register_interfaces

  118.  */

  119. static HRESULT register_interfaces(struct regsvr_interface const *list)

  120. {

  121.     LONG res = ERROR_SUCCESS;

  122.     HKEY interface_key;

  123. 

  124.     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,

  125. 			  KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);

  126.     if (res != ERROR_SUCCESS) goto error_return;

  127. 

  128.     for (; res == ERROR_SUCCESS && list->iid; ++list) {

  129. 	WCHAR buf[39];

  130. 	HKEY iid_key;

  131. 

  132. 	StringFromGUID2(list->iid, buf, 39);

  133. 	res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,

  134. 			      KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);

  135. 	if (res != ERROR_SUCCESS) goto error_close_interface_key;

  136. 

  137. 	if (list->name) {

  138. 	    res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,

  139. 				 (const BYTE*)(list->name),

  140. 				 strlen(list->name) + 1);

  141. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  142. 	}

  143. 

  144. 	if (list->base_iid) {

  145. 	    res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);

  146. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  147. 	}

  148. 

  149. 	if (0 <= list->num_methods) {

  150. 	    static WCHAR const fmt[3] = { '%', 'd', 0 };

  151. 	    HKEY key;

  152. 

  153. 	    res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,

  154. 				  KEY_READ | KEY_WRITE, NULL, &key, NULL);

  155. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  156. 

  157. 	    wsprintfW(buf, fmt, list->num_methods);

  158. 	    res = RegSetValueExW(key, NULL, 0, REG_SZ,

  159. 				 (const BYTE*)buf,

  160. 				 (lstrlenW(buf) + 1) * sizeof(WCHAR));

  161. 	    RegCloseKey(key);

  162. 

  163. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  164. 	}

  165. 

  166. 	if (list->ps_clsid) {

  167. 	    res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);

  168. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  169. 	}

  170. 

  171. 	if (list->ps_clsid32) {

  172. 	    res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);

  173. 	    if (res != ERROR_SUCCESS) goto error_close_iid_key;

  174. 	}

  175. 

  176.     error_close_iid_key:

  177. 	RegCloseKey(iid_key);

  178.     }

  179. 

  180. error_close_interface_key:

  181.     RegCloseKey(interface_key);

  182. error_return:

  183.     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;

  184. }

  185. 

  186. /***********************************************************************

  187.  *		unregister_interfaces

  188.  */

  189. static HRESULT unregister_interfaces(struct regsvr_interface const *list)

  190. {

  191.     LONG res = ERROR_SUCCESS;

  192.     HKEY interface_key;

  193. 

  194.     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,

  195. 			KEY_READ | KEY_WRITE, &interface_key);

  196.     if (res == ERROR_FILE_NOT_FOUND) return S_OK;

  197.     if (res != ERROR_SUCCESS) goto error_return;

  198. 

  199.     for (; res == ERROR_SUCCESS && list->iid; ++list) {

  200. 	WCHAR buf[39];

  201. 

  202. 	StringFromGUID2(list->iid, buf, 39);

  203. 	res = recursive_delete_keyW(interface_key, buf);

  204.     }

  205. 

  206.     RegCloseKey(interface_key);

  207. error_return:

  208.     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;

  209. }

  210. 

  211. /***********************************************************************

  212.  *		register_coclasses

  213.  */

  214. static HRESULT register_coclasses(struct regsvr_coclass const *list)

  215. {

  216.     LONG res = ERROR_SUCCESS;

  217.     HKEY coclass_key;

  218. 

  219.     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,

  220. 			  KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);

  221.     if (res != ERROR_SUCCESS) goto error_return;

  222. 

  223.     for (; res == ERROR_SUCCESS && list->clsid; ++list) {

  224. 	WCHAR buf[39];

  225. 	HKEY clsid_key;

  226. 

  227. 	StringFromGUID2(list->clsid, buf, 39);

  228. 	res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,

  229. 			      KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);

  230. 	if (res != ERROR_SUCCESS) goto error_close_coclass_key;

  231. 

  232. 	if (list->name) {

  233. 	    res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,

  234. 				 (const BYTE*)(list->name),

  235. 				 strlen(list->name) + 1);

  236. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  237. 	}

  238. 

  239. 	if (list->ips) {

  240. 	    res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);

  241. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  242. 	}

  243. 

  244. 	if (list->ips32) {

  245. 	    HKEY ips32_key;

  246. 

  247. 	    res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,

  248. 				  KEY_READ | KEY_WRITE, NULL,

  249. 				  &ips32_key, NULL);

  250. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  251. 

  252. 	    res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,

  253. 				 (const BYTE*)list->ips32,

  254. 				 lstrlenA(list->ips32) + 1);

  255. 	    if (res == ERROR_SUCCESS && list->ips32_tmodel)

  256. 		res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,

  257. 				     (const BYTE*)list->ips32_tmodel,

  258. 				     strlen(list->ips32_tmodel) + 1);

  259. 	    RegCloseKey(ips32_key);

  260. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  261. 	}

  262. 

  263. 	if (list->progid) {

  264. 	    res = register_key_defvalueA(clsid_key, progid_keyname,

  265. 					 list->progid);

  266. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  267. 

  268. 	    res = register_progid(buf, list->progid, NULL,

  269. 				  list->name, list->progid_extra);

  270. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  271. 	}

  272. 

  273. 	if (list->viprogid) {

  274. 	    res = register_key_defvalueA(clsid_key, viprogid_keyname,

  275. 					 list->viprogid);

  276. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  277. 

  278. 	    res = register_progid(buf, list->viprogid, list->progid,

  279. 				  list->name, list->progid_extra);

  280. 	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;

  281. 	}

  282. 

  283.     error_close_clsid_key:

  284. 	RegCloseKey(clsid_key);

  285.     }

  286. 

  287. error_close_coclass_key:

  288.     RegCloseKey(coclass_key);

  289. error_return:

  290.     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;

  291. }

  292. 

  293. /***********************************************************************

  294.  *		unregister_coclasses

  295.  */

  296. static HRESULT unregister_coclasses(struct regsvr_coclass const *list)

  297. {

  298.     LONG res = ERROR_SUCCESS;

  299.     HKEY coclass_key;

  300. 

  301.     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,

  302. 			KEY_READ | KEY_WRITE, &coclass_key);

  303.     if (res == ERROR_FILE_NOT_FOUND) return S_OK;

  304.     if (res != ERROR_SUCCESS) goto error_return;

  305. 

  306.     for (; res == ERROR_SUCCESS && list->clsid; ++list) {

  307. 	WCHAR buf[39];

  308. 

  309. 	StringFromGUID2(list->clsid, buf, 39);

  310. 	res = recursive_delete_keyW(coclass_key, buf);

  311. 	if (res != ERROR_SUCCESS) goto error_close_coclass_key;

  312. 

  313. 	if (list->progid) {

  314. 	    res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->progid);

  315. 	    if (res != ERROR_SUCCESS) goto error_close_coclass_key;

  316. 	}

  317. 

  318. 	if (list->viprogid) {

  319. 	    res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->viprogid);

  320. 	    if (res != ERROR_SUCCESS) goto error_close_coclass_key;

  321. 	}

  322.     }

  323. 

  324. error_close_coclass_key:

  325.     RegCloseKey(coclass_key);

  326. error_return:

  327.     return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;

  328. }

  329. 

  330. /***********************************************************************

  331.  *		regsvr_key_guid

  332.  */

  333. static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid)

  334. {

  335.     WCHAR buf[39];

  336. 

  337.     StringFromGUID2(guid, buf, 39);

  338.     return register_key_defvalueW(base, name, buf);

  339. }

  340. 

  341. /***********************************************************************

  342.  *		regsvr_key_defvalueW

  343.  */

  344. static LONG register_key_defvalueW(

  345.     HKEY base,

  346.     WCHAR const *name,

  347.     WCHAR const *value)

  348. {

  349.     LONG res;

  350.     HKEY key;

  351. 

  352.     res = RegCreateKeyExW(base, name, 0, NULL, 0,

  353. 			  KEY_READ | KEY_WRITE, NULL, &key, NULL);

  354.     if (res != ERROR_SUCCESS) return res;

  355.     res = RegSetValueExW(key, NULL, 0, REG_SZ, (const BYTE*)value,

  356. 			 (lstrlenW(value) + 1) * sizeof(WCHAR));

  357.     RegCloseKey(key);

  358.     return res;

  359. }

  360. 

  361. /***********************************************************************

  362.  *		regsvr_key_defvalueA

  363.  */

  364. static LONG register_key_defvalueA(

  365.     HKEY base,

  366.     WCHAR const *name,

  367.     char const *value)

  368. {

  369.     LONG res;

  370.     HKEY key;

  371. 

  372.     res = RegCreateKeyExW(base, name, 0, NULL, 0,

  373. 			  KEY_READ | KEY_WRITE, NULL, &key, NULL);

  374.     if (res != ERROR_SUCCESS) return res;

  375.     res = RegSetValueExA(key, NULL, 0, REG_SZ, (const BYTE*)value,

  376. 			 lstrlenA(value) + 1);

  377.     RegCloseKey(key);

  378.     return res;

  379. }

  380. 

  381. /***********************************************************************

  382.  *		regsvr_progid

  383.  */

  384. static LONG register_progid(

  385.     WCHAR const *clsid,

  386.     char const *progid,

  387.     char const *curver_progid,

  388.     char const *name,

  389.     char const *extra)

  390. {

  391.     LONG res;

  392.     HKEY progid_key;

  393. 

  394.     res = RegCreateKeyExA(HKEY_CLASSES_ROOT, progid, 0,

  395. 			  NULL, 0, KEY_READ | KEY_WRITE, NULL,

  396. 			  &progid_key, NULL);

  397.     if (res != ERROR_SUCCESS) return res;

  398. 

  399.     if (name) {

  400. 	res = RegSetValueExA(progid_key, NULL, 0, REG_SZ,

  401. 			     (const BYTE*)name, strlen(name) + 1);

  402. 	if (res != ERROR_SUCCESS) goto error_close_progid_key;

  403.     }

  404. 

  405.     if (clsid) {

  406. 	res = register_key_defvalueW(progid_key, clsid_keyname, clsid);

  407. 	if (res != ERROR_SUCCESS) goto error_close_progid_key;

  408.     }

  409. 

  410.     if (curver_progid) {

  411. 	res = register_key_defvalueA(progid_key, curver_keyname,

  412. 				     curver_progid);

  413. 	if (res != ERROR_SUCCESS) goto error_close_progid_key;

  414.     }

  415. 

  416.     if (extra) {

  417. 	HKEY extra_key;

  418. 

  419. 	res = RegCreateKeyExA(progid_key, extra, 0,

  420. 			      NULL, 0, KEY_READ | KEY_WRITE, NULL,

  421. 			      &extra_key, NULL);

  422. 	if (res == ERROR_SUCCESS)

  423. 	    RegCloseKey(extra_key);

  424.     }

  425. 

  426. error_close_progid_key:

  427.     RegCloseKey(progid_key);

  428.     return res;

  429. }

  430. 

  431. /***********************************************************************

  432.  *		recursive_delete_key

  433.  */

  434. static LONG recursive_delete_key(HKEY key)

  435. {

  436.     LONG res;

  437.     WCHAR subkey_name[MAX_PATH];

  438.     DWORD cName;

  439.     HKEY subkey;

  440. 

  441.     for (;;) {

  442. 	cName = sizeof(subkey_name) / sizeof(WCHAR);

  443. 	res = RegEnumKeyExW(key, 0, subkey_name, &cName,

  444. 			    NULL, NULL, NULL, NULL);

  445. 	if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) {

  446. 	    res = ERROR_SUCCESS; /* presumably we're done enumerating */

  447. 	    break;

  448. 	}

  449. 	res = RegOpenKeyExW(key, subkey_name, 0,

  450. 			    KEY_READ | KEY_WRITE, &subkey);

  451. 	if (res == ERROR_FILE_NOT_FOUND) continue;

  452. 	if (res != ERROR_SUCCESS) break;

  453. 

  454. 	res = recursive_delete_key(subkey);

  455. 	RegCloseKey(subkey);

  456. 	if (res != ERROR_SUCCESS) break;

  457.     }

  458. 

  459.     if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0);

  460.     return res;

  461. }

  462. 

  463. /***********************************************************************

  464.  *		recursive_delete_keyA

  465.  */

  466. static LONG recursive_delete_keyA(HKEY base, char const *name)

  467. {

  468.     LONG res;

  469.     HKEY key;

  470. 

  471.     res = RegOpenKeyExA(base, name, 0, KEY_READ | KEY_WRITE, &key);

  472.     if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;

  473.     if (res != ERROR_SUCCESS) return res;

  474.     res = recursive_delete_key(key);

  475.     RegCloseKey(key);

  476.     return res;

  477. }

  478. 

  479. /***********************************************************************

  480.  *		recursive_delete_keyW

  481.  */

  482. static LONG recursive_delete_keyW(HKEY base, WCHAR const *name)

  483. {

  484.     LONG res;

  485.     HKEY key;

  486. 

  487.     res = RegOpenKeyExW(base, name, 0, KEY_READ | KEY_WRITE, &key);

  488.     if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;

  489.     if (res != ERROR_SUCCESS) return res;

  490.     res = recursive_delete_key(key);

  491.     RegCloseKey(key);

  492.     return res;

  493. }

  494. 

  495. /***********************************************************************

  496.  *		coclass list

  497.  */

  498. // {48D0C522-BFCC-45cc-8B84-17F25F33E6E9}

  499. static GUID const CLSID_WineASIO = {

  500. 0x48d0c522, 0xbfcc, 0x45cc, { 0x8b, 0x84, 0x17, 0xf2, 0x5f, 0x33, 0xe6, 0xe9 } };

  501. 

  502. static struct regsvr_coclass const coclass_list[] = {

  503.     { &CLSID_WineASIO, "MOD Desktop ASIO Object", NULL, "mod-desktop-asio.dll", "Apartment" },

  504.     { NULL }			/* list terminator */

  505. };

  506. 

  507. /***********************************************************************

  508.  *		interface list

  509.  */

  510. 

  511. static struct regsvr_interface const interface_list[] = {

  512.     { NULL }			/* list terminator */

  513. };

  514. 

  515. /***********************************************************************

  516.  *		register driver

  517.  */

  518. static HRESULT register_driver(void)

  519. {

  520.     LPCSTR asio_key = "Software\\ASIO\\MOD Desktop";

  521.     LPCSTR clsid = "CLSID";

  522.     LPCSTR wine_clsid = "{48D0C522-BFCC-45CC-8B84-17F25F33E6E9}";

  523.     LPCSTR desc = "Description";

  524.     LPCSTR wine_desc = "MOD Desktop";

  525.     HKEY key;

  526.     LONG rc;

  527. 

  528.     rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, asio_key, 0, KEY_READ | KEY_WRITE, &key);

  529. 

  530.     if (rc != ERROR_SUCCESS)

  531.         rc = RegCreateKeyExA(HKEY_LOCAL_MACHINE, asio_key, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &key, 0);

  532. 

  533.     if (rc == ERROR_SUCCESS)

  534.     {

  535.         rc = RegSetValueExA(key, clsid, 0, REG_SZ, (const BYTE *)wine_clsid, strlen(wine_clsid) + 1);

  536. 

  537.         if (rc == ERROR_SUCCESS)

  538.             rc = RegSetValueExA(key, desc, 0, REG_SZ, (const BYTE *)wine_desc, strlen(wine_desc) + 1);

  539. 

  540.         RegCloseKey(key);

  541.     }

  542. 

  543.     return rc;

  544. }

  545. 

  546. /***********************************************************************

  547.  *		DllRegisterServer (wineasio.@)

  548.  */

  549. HRESULT WINAPI DllRegisterServer(void)

  550. {

  551.     HRESULT hr;

  552. 

  553.     /* TRACE("\n"); */

  554. 

  555.     hr = register_coclasses(coclass_list);

  556.     if (SUCCEEDED(hr))

  557.     {

  558. 	hr = register_interfaces(interface_list);

  559.         if (SUCCEEDED(hr))

  560.             hr = register_driver();

  561.     }

  562.     return hr;

  563. }

  564. 

  565. /***********************************************************************

  566.  *		register driver

  567.  */

  568. static HRESULT unregister_driver(void)

  569. {

  570.     LPCSTR asio_key = "Software\\ASIO\\MOD Desktop";

  571. 

  572.     /* FIXME */

  573.     return recursive_delete_keyA(HKEY_LOCAL_MACHINE, asio_key);

  574. }

  575. 

  576. /***********************************************************************

  577.  *		DllUnregisterServer (wineasio.@)

  578.  */

  579. HRESULT WINAPI DllUnregisterServer(void)

  580. {

  581.     HRESULT hr;

  582. 

  583.     /* TRACE("\n"); */

  584. 

  585.     hr = unregister_coclasses(coclass_list);

  586.     if (SUCCEEDED(hr))

  587.     {

  588. 	hr = unregister_interfaces(interface_list);

  589.         if (SUCCEEDED(hr))

  590.             hr = unregister_driver();

  591.     }

  592.     return hr;

  593. }