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.
89 Commits
2 Branches
1.1MB
Tree: b845678722
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b845678722'
${ noResults }
wineasio/regsvr.c

606 lines
17KB
Raw 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',

  81.     'e', 0 };

  82. static WCHAR const num_methods_keyname[11] = {

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

  84. static WCHAR const ps_clsid_keyname[15] = {

  85.     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',

  86.     'i', 'd', 0 };

  87. static WCHAR const ps_clsid32_keyname[17] = {

  88.     'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',

  89.     'i', 'd', '3', '2', 0 };

  90. static WCHAR const clsid_keyname[6] = {

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

  92. static WCHAR const curver_keyname[7] = {

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

  94. static WCHAR const ips_keyname[13] = {

  95.     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',

  96.     0 };

  97. static WCHAR const ips32_keyname[15] = {

  98.     'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',

  99.     '3', '2', 0 };

  100. static WCHAR const progid_keyname[7] = {

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

  102. static WCHAR const viprogid_keyname[25] = {

  103.     'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p',

  104.     'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D',

  105.     0 };

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

  107. 

  108. /***********************************************************************

  109.  *		static helper functions

  110.  */

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

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

  113. 				   WCHAR const *value);

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

  115. 				   char const *value);

  116. static LONG register_progid(WCHAR const *clsid,

  117. 			    char const *progid, char const *curver_progid,

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

  119. static LONG recursive_delete_key(HKEY key);

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

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

  122. 

  123. /***********************************************************************

  124.  *		register_interfaces

  125.  */

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

  127. {

  128.     LONG res = ERROR_SUCCESS;

  129.     HKEY interface_key;

  130. 

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

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

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

  134. 

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

  136. 	WCHAR buf[39];

  137. 	HKEY iid_key;

  138. 

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

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

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

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

  143. 

  144. 	if (list->name) {

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

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

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

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

  149. 	}

  150. 

  151. 	if (list->base_iid) {

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

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

  154. 	}

  155. 

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

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

  158. 	    HKEY key;

  159. 

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

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

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

  163. 

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

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

  166. 				 (const BYTE*)buf,

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

  168. 	    RegCloseKey(key);

  169. 

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

  171. 	}

  172. 

  173. 	if (list->ps_clsid) {

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

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

  176. 	}

  177. 

  178. 	if (list->ps_clsid32) {

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

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

  181. 	}

  182. 

  183.     error_close_iid_key:

  184. 	RegCloseKey(iid_key);

  185.     }

  186. 

  187. error_close_interface_key:

  188.     RegCloseKey(interface_key);

  189. error_return:

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

  191. }

  192. 

  193. /***********************************************************************

  194.  *		unregister_interfaces

  195.  */

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

  197. {

  198.     LONG res = ERROR_SUCCESS;

  199.     HKEY interface_key;

  200. 

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

  202. 			KEY_READ | KEY_WRITE, &interface_key);

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

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

  205. 

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

  207. 	WCHAR buf[39];

  208. 

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

  210. 	res = recursive_delete_keyW(interface_key, buf);

  211.     }

  212. 

  213.     RegCloseKey(interface_key);

  214. error_return:

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

  216. }

  217. 

  218. /***********************************************************************

  219.  *		register_coclasses

  220.  */

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

  222. {

  223.     LONG res = ERROR_SUCCESS;

  224.     HKEY coclass_key;

  225. 

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

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

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

  229. 

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

  231. 	WCHAR buf[39];

  232. 	HKEY clsid_key;

  233. 

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

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

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

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

  238. 

  239. 	if (list->name) {

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

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

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

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

  244. 	}

  245. 

  246. 	if (list->ips) {

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

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

  249. 	}

  250. 

  251. 	if (list->ips32) {

  252. 	    HKEY ips32_key;

  253. 

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

  255. 				  KEY_READ | KEY_WRITE, NULL,

  256. 				  &ips32_key, NULL);

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

  258. 

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

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

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

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

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

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

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

  266. 	    RegCloseKey(ips32_key);

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

  268. 	}

  269. 

  270. 	if (list->progid) {

  271. 	    res = register_key_defvalueA(clsid_key, progid_keyname,

  272. 					 list->progid);

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

  274. 

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

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

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

  278. 	}

  279. 

  280. 	if (list->viprogid) {

  281. 	    res = register_key_defvalueA(clsid_key, viprogid_keyname,

  282. 					 list->viprogid);

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

  284. 

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

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

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

  288. 	}

  289. 

  290.     error_close_clsid_key:

  291. 	RegCloseKey(clsid_key);

  292.     }

  293. 

  294. error_close_coclass_key:

  295.     RegCloseKey(coclass_key);

  296. error_return:

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

  298. }

  299. 

  300. /***********************************************************************

  301.  *		unregister_coclasses

  302.  */

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

  304. {

  305.     LONG res = ERROR_SUCCESS;

  306.     HKEY coclass_key;

  307. 

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

  309. 			KEY_READ | KEY_WRITE, &coclass_key);

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

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

  312. 

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

  314. 	WCHAR buf[39];

  315. 

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

  317. 	res = recursive_delete_keyW(coclass_key, buf);

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

  319. 

  320. 	if (list->progid) {

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

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

  323. 	}

  324. 

  325. 	if (list->viprogid) {

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

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

  328. 	}

  329.     }

  330. 

  331. error_close_coclass_key:

  332.     RegCloseKey(coclass_key);

  333. error_return:

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

  335. }

  336. 

  337. /***********************************************************************

  338.  *		regsvr_key_guid

  339.  */

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

  341. {

  342.     WCHAR buf[39];

  343. 

  344.     StringFromGUID2(guid, buf, 39);

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

  346. }

  347. 

  348. /***********************************************************************

  349.  *		regsvr_key_defvalueW

  350.  */

  351. static LONG register_key_defvalueW(

  352.     HKEY base,

  353.     WCHAR const *name,

  354.     WCHAR const *value)

  355. {

  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 = RegSetValueExW(key, NULL, 0, REG_SZ, (const BYTE*)value,

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

  364.     RegCloseKey(key);

  365.     return res;

  366. }

  367. 

  368. /***********************************************************************

  369.  *		regsvr_key_defvalueA

  370.  */

  371. static LONG register_key_defvalueA(

  372.     HKEY base,

  373.     WCHAR const *name,

  374.     char const *value)

  375. {

  376.     LONG res;

  377.     HKEY key;

  378. 

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

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

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

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

  383. 			 lstrlenA(value) + 1);

  384.     RegCloseKey(key);

  385.     return res;

  386. }

  387. 

  388. /***********************************************************************

  389.  *		regsvr_progid

  390.  */

  391. static LONG register_progid(

  392.     WCHAR const *clsid,

  393.     char const *progid,

  394.     char const *curver_progid,

  395.     char const *name,

  396.     char const *extra)

  397. {

  398.     LONG res;

  399.     HKEY progid_key;

  400. 

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

  402. 			  NULL, 0, KEY_READ | KEY_WRITE, NULL,

  403. 			  &progid_key, NULL);

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

  405. 

  406.     if (name) {

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

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

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

  410.     }

  411. 

  412.     if (clsid) {

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

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

  415.     }

  416. 

  417.     if (curver_progid) {

  418. 	res = register_key_defvalueA(progid_key, curver_keyname,

  419. 				     curver_progid);

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

  421.     }

  422. 

  423.     if (extra) {

  424. 	HKEY extra_key;

  425. 

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

  427. 			      NULL, 0, KEY_READ | KEY_WRITE, NULL,

  428. 			      &extra_key, NULL);

  429. 	if (res == ERROR_SUCCESS)

  430. 	    RegCloseKey(extra_key);

  431.     }

  432. 

  433. error_close_progid_key:

  434.     RegCloseKey(progid_key);

  435.     return res;

  436. }

  437. 

  438. /***********************************************************************

  439.  *		recursive_delete_key

  440.  */

  441. static LONG recursive_delete_key(HKEY key)

  442. {

  443.     LONG res;

  444.     WCHAR subkey_name[MAX_PATH];

  445.     DWORD cName;

  446.     HKEY subkey;

  447. 

  448.     for (;;) {

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

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

  451. 			    NULL, NULL, NULL, NULL);

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

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

  454. 	    break;

  455. 	}

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

  457. 			    KEY_READ | KEY_WRITE, &subkey);

  458. 	if (res == ERROR_FILE_NOT_FOUND) continue;

  459. 	if (res != ERROR_SUCCESS) break;

  460. 

  461. 	res = recursive_delete_key(subkey);

  462. 	RegCloseKey(subkey);

  463. 	if (res != ERROR_SUCCESS) break;

  464.     }

  465. 

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

  467.     return res;

  468. }

  469. 

  470. /***********************************************************************

  471.  *		recursive_delete_keyA

  472.  */

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

  474. {

  475.     LONG res;

  476.     HKEY key;

  477. 

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

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

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

  481.     res = recursive_delete_key(key);

  482.     RegCloseKey(key);

  483.     return res;

  484. }

  485. 

  486. /***********************************************************************

  487.  *		recursive_delete_keyW

  488.  */

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

  490. {

  491.     LONG res;

  492.     HKEY key;

  493. 

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

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

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

  497.     res = recursive_delete_key(key);

  498.     RegCloseKey(key);

  499.     return res;

  500. }

  501. 

  502. /***********************************************************************

  503.  *		coclass list

  504.  */

  505. // {48D0C522-BFCC-45cc-8B84-17F25F33E6E8}

  506. static GUID const CLSID_WineASIO = {

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

  508. 

  509. static struct regsvr_coclass const coclass_list[] = {

  510.     {   &CLSID_WineASIO,

  511. 	"WineASIO Object",

  512. 	NULL,

  513. 	"wineasio.dll",

  514. 	"Apartment"

  515.     },

  516.     { NULL }			/* list terminator */

  517. };

  518. 

  519. /***********************************************************************

  520.  *		interface list

  521.  */

  522. 

  523. static struct regsvr_interface const interface_list[] = {

  524.     { NULL }			/* list terminator */

  525. };

  526. 

  527. /***********************************************************************

  528.  *		register driver

  529.  */

  530. static HRESULT register_driver(void)

  531. {

  532.     LPCSTR asio_key = "Software\\ASIO\\WineASIO";

  533.     LPCSTR clsid = "CLSID";

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

  535.     LPCSTR desc = "Description";

  536.     LPCSTR wine_desc = "WineASIO Driver";

  537.     HKEY key;

  538.     LONG rc;

  539. 

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

  541. 

  542.     if (rc != ERROR_SUCCESS)

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

  544. 

  545.     if (rc == ERROR_SUCCESS)

  546.     {

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

  548. 

  549.         if (rc == ERROR_SUCCESS)

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

  551. 

  552.         RegCloseKey(key);

  553.     }

  554. 

  555.     return rc;

  556. }

  557. 

  558. /***********************************************************************

  559.  *		DllRegisterServer (wineasio.@)

  560.  */

  561. HRESULT WINAPI DllRegisterServer(void)

  562. {

  563.     HRESULT hr;

  564. 

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

  566. 

  567.     hr = register_coclasses(coclass_list);

  568.     if (SUCCEEDED(hr))

  569.     {

  570. 	hr = register_interfaces(interface_list);

  571.         if (SUCCEEDED(hr))

  572.             hr = register_driver();

  573.     }

  574.     return hr;

  575. }

  576. 

  577. /***********************************************************************

  578.  *		register driver

  579.  */

  580. static HRESULT unregister_driver(void)

  581. {

  582.     LPCSTR asio_key = "Software\\ASIO\\WineASIO";

  583. 

  584.     /* FIXME */

  585.     return recursive_delete_keyA(HKEY_LOCAL_MACHINE, asio_key);

  586. }

  587. 

  588. /***********************************************************************

  589.  *		DllUnregisterServer (wineasio.@)

  590.  */

  591. HRESULT WINAPI DllUnregisterServer(void)

  592. {

  593.     HRESULT hr;

  594. 

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

  596. 

  597.     hr = unregister_coclasses(coclass_list);

  598.     if (SUCCEEDED(hr))

  599.     {

  600. 	hr = unregister_interfaces(interface_list);

  601.         if (SUCCEEDED(hr))

  602.             hr = unregister_driver();

  603.     }

  604.     return hr;

  605. }