config_winreg.c 23 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010
  1. /*
  2. * WPA Supplicant / Configuration backend: Windows registry
  3. * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
  4. *
  5. * This software may be distributed under the terms of the BSD license.
  6. * See README for more details.
  7. *
  8. * This file implements a configuration backend for Windows registry. All the
  9. * configuration information is stored in the registry and the format for
  10. * network configuration fields is same as described in the sample
  11. * configuration file, wpa_supplicant.conf.
  12. *
  13. * Configuration data is in
  14. * \a HKEY_LOCAL_MACHINE\\SOFTWARE\\%wpa_supplicant\\configs
  15. * key. Each configuration profile has its own key under this. In terms of text
  16. * files, each profile would map to a separate text file with possibly multiple
  17. * networks. Under each profile, there is a networks key that lists all
  18. * networks as a subkey. Each network has set of values in the same way as
  19. * network block in the configuration file. In addition, blobs subkey has
  20. * possible blobs as values.
  21. *
  22. * Example network configuration block:
  23. * \verbatim
  24. HKEY_LOCAL_MACHINE\SOFTWARE\wpa_supplicant\configs\test\networks\0000
  25. ssid="example"
  26. key_mgmt=WPA-PSK
  27. \endverbatim
  28. */
  29. #include "includes.h"
  30. #include "common.h"
  31. #include "uuid.h"
  32. #include "config.h"
  33. #ifndef WPA_KEY_ROOT
  34. #define WPA_KEY_ROOT HKEY_LOCAL_MACHINE
  35. #endif
  36. #ifndef WPA_KEY_PREFIX
  37. #define WPA_KEY_PREFIX TEXT("SOFTWARE\\wpa_supplicant")
  38. #endif
  39. #ifdef UNICODE
  40. #define TSTR "%S"
  41. #else /* UNICODE */
  42. #define TSTR "%s"
  43. #endif /* UNICODE */
  44. static int wpa_config_read_blobs(struct wpa_config *config, HKEY hk)
  45. {
  46. struct wpa_config_blob *blob;
  47. int errors = 0;
  48. HKEY bhk;
  49. LONG ret;
  50. DWORD i;
  51. ret = RegOpenKeyEx(hk, TEXT("blobs"), 0, KEY_QUERY_VALUE, &bhk);
  52. if (ret != ERROR_SUCCESS) {
  53. wpa_printf(MSG_DEBUG, "Could not open wpa_supplicant config "
  54. "blobs key");
  55. return 0; /* assume no blobs */
  56. }
  57. for (i = 0; ; i++) {
  58. #define TNAMELEN 255
  59. TCHAR name[TNAMELEN];
  60. char data[4096];
  61. DWORD namelen, datalen, type;
  62. namelen = TNAMELEN;
  63. datalen = sizeof(data);
  64. ret = RegEnumValue(bhk, i, name, &namelen, NULL, &type,
  65. (LPBYTE) data, &datalen);
  66. if (ret == ERROR_NO_MORE_ITEMS)
  67. break;
  68. if (ret != ERROR_SUCCESS) {
  69. wpa_printf(MSG_DEBUG, "RegEnumValue failed: 0x%x",
  70. (unsigned int) ret);
  71. break;
  72. }
  73. if (namelen >= TNAMELEN)
  74. namelen = TNAMELEN - 1;
  75. name[namelen] = TEXT('\0');
  76. wpa_unicode2ascii_inplace(name);
  77. if (datalen >= sizeof(data))
  78. datalen = sizeof(data) - 1;
  79. wpa_printf(MSG_MSGDUMP, "blob %d: field='%s' len %d",
  80. (int) i, name, (int) datalen);
  81. blob = os_zalloc(sizeof(*blob));
  82. if (blob == NULL) {
  83. errors++;
  84. break;
  85. }
  86. blob->name = os_strdup((char *) name);
  87. blob->data = os_malloc(datalen);
  88. if (blob->name == NULL || blob->data == NULL) {
  89. wpa_config_free_blob(blob);
  90. errors++;
  91. break;
  92. }
  93. os_memcpy(blob->data, data, datalen);
  94. blob->len = datalen;
  95. wpa_config_set_blob(config, blob);
  96. }
  97. RegCloseKey(bhk);
  98. return errors ? -1 : 0;
  99. }
  100. static int wpa_config_read_reg_dword(HKEY hk, const TCHAR *name, int *_val)
  101. {
  102. DWORD val, buflen;
  103. LONG ret;
  104. buflen = sizeof(val);
  105. ret = RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE) &val, &buflen);
  106. if (ret == ERROR_SUCCESS && buflen == sizeof(val)) {
  107. wpa_printf(MSG_DEBUG, TSTR "=%d", name, (int) val);
  108. *_val = val;
  109. return 0;
  110. }
  111. return -1;
  112. }
  113. static char * wpa_config_read_reg_string(HKEY hk, const TCHAR *name)
  114. {
  115. DWORD buflen;
  116. LONG ret;
  117. TCHAR *val;
  118. buflen = 0;
  119. ret = RegQueryValueEx(hk, name, NULL, NULL, NULL, &buflen);
  120. if (ret != ERROR_SUCCESS)
  121. return NULL;
  122. val = os_malloc(buflen);
  123. if (val == NULL)
  124. return NULL;
  125. ret = RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE) val, &buflen);
  126. if (ret != ERROR_SUCCESS) {
  127. os_free(val);
  128. return NULL;
  129. }
  130. wpa_unicode2ascii_inplace(val);
  131. wpa_printf(MSG_DEBUG, TSTR "=%s", name, (char *) val);
  132. return (char *) val;
  133. }
  134. #ifdef CONFIG_WPS
  135. static int wpa_config_read_global_uuid(struct wpa_config *config, HKEY hk)
  136. {
  137. char *str;
  138. int ret = 0;
  139. str = wpa_config_read_reg_string(hk, TEXT("uuid"));
  140. if (str == NULL)
  141. return 0;
  142. if (uuid_str2bin(str, config->uuid))
  143. ret = -1;
  144. os_free(str);
  145. return ret;
  146. }
  147. static int wpa_config_read_global_os_version(struct wpa_config *config,
  148. HKEY hk)
  149. {
  150. char *str;
  151. int ret = 0;
  152. str = wpa_config_read_reg_string(hk, TEXT("os_version"));
  153. if (str == NULL)
  154. return 0;
  155. if (hexstr2bin(str, config->os_version, 4))
  156. ret = -1;
  157. os_free(str);
  158. return ret;
  159. }
  160. #endif /* CONFIG_WPS */
  161. static int wpa_config_read_global(struct wpa_config *config, HKEY hk)
  162. {
  163. int errors = 0;
  164. wpa_config_read_reg_dword(hk, TEXT("ap_scan"), &config->ap_scan);
  165. wpa_config_read_reg_dword(hk, TEXT("fast_reauth"),
  166. &config->fast_reauth);
  167. wpa_config_read_reg_dword(hk, TEXT("dot11RSNAConfigPMKLifetime"),
  168. (int *) &config->dot11RSNAConfigPMKLifetime);
  169. wpa_config_read_reg_dword(hk,
  170. TEXT("dot11RSNAConfigPMKReauthThreshold"),
  171. (int *)
  172. &config->dot11RSNAConfigPMKReauthThreshold);
  173. wpa_config_read_reg_dword(hk, TEXT("dot11RSNAConfigSATimeout"),
  174. (int *) &config->dot11RSNAConfigSATimeout);
  175. wpa_config_read_reg_dword(hk, TEXT("update_config"),
  176. &config->update_config);
  177. if (wpa_config_read_reg_dword(hk, TEXT("eapol_version"),
  178. &config->eapol_version) == 0) {
  179. if (config->eapol_version < 1 ||
  180. config->eapol_version > 2) {
  181. wpa_printf(MSG_ERROR, "Invalid EAPOL version (%d)",
  182. config->eapol_version);
  183. errors++;
  184. }
  185. }
  186. config->ctrl_interface = wpa_config_read_reg_string(
  187. hk, TEXT("ctrl_interface"));
  188. #ifdef CONFIG_WPS
  189. if (wpa_config_read_global_uuid(config, hk))
  190. errors++;
  191. config->device_name = wpa_config_read_reg_string(
  192. hk, TEXT("device_name"));
  193. config->manufacturer = wpa_config_read_reg_string(
  194. hk, TEXT("manufacturer"));
  195. config->model_name = wpa_config_read_reg_string(
  196. hk, TEXT("model_name"));
  197. config->serial_number = wpa_config_read_reg_string(
  198. hk, TEXT("serial_number"));
  199. {
  200. char *t = wpa_config_read_reg_string(
  201. hk, TEXT("device_type"));
  202. if (t && wps_dev_type_str2bin(t, config->device_type))
  203. errors++;
  204. os_free(t);
  205. }
  206. config->config_methods = wpa_config_read_reg_string(
  207. hk, TEXT("config_methods"));
  208. if (wpa_config_read_global_os_version(config, hk))
  209. errors++;
  210. wpa_config_read_reg_dword(hk, TEXT("wps_cred_processing"),
  211. &config->wps_cred_processing);
  212. #endif /* CONFIG_WPS */
  213. #ifdef CONFIG_P2P
  214. config->p2p_ssid_postfix = wpa_config_read_reg_string(
  215. hk, TEXT("p2p_ssid_postfix"));
  216. wpa_config_read_reg_dword(hk, TEXT("p2p_group_idle"),
  217. (int *) &config->p2p_group_idle);
  218. #endif /* CONFIG_P2P */
  219. wpa_config_read_reg_dword(hk, TEXT("bss_max_count"),
  220. (int *) &config->bss_max_count);
  221. wpa_config_read_reg_dword(hk, TEXT("filter_ssids"),
  222. &config->filter_ssids);
  223. wpa_config_read_reg_dword(hk, TEXT("max_num_sta"),
  224. (int *) &config->max_num_sta);
  225. wpa_config_read_reg_dword(hk, TEXT("disassoc_low_ack"),
  226. (int *) &config->disassoc_low_ack);
  227. return errors ? -1 : 0;
  228. }
  229. static struct wpa_ssid * wpa_config_read_network(HKEY hk, const TCHAR *netw,
  230. int id)
  231. {
  232. HKEY nhk;
  233. LONG ret;
  234. DWORD i;
  235. struct wpa_ssid *ssid;
  236. int errors = 0;
  237. ret = RegOpenKeyEx(hk, netw, 0, KEY_QUERY_VALUE, &nhk);
  238. if (ret != ERROR_SUCCESS) {
  239. wpa_printf(MSG_DEBUG, "Could not open wpa_supplicant config "
  240. "network '" TSTR "'", netw);
  241. return NULL;
  242. }
  243. wpa_printf(MSG_MSGDUMP, "Start of a new network '" TSTR "'", netw);
  244. ssid = os_zalloc(sizeof(*ssid));
  245. if (ssid == NULL) {
  246. RegCloseKey(nhk);
  247. return NULL;
  248. }
  249. ssid->id = id;
  250. wpa_config_set_network_defaults(ssid);
  251. for (i = 0; ; i++) {
  252. TCHAR name[255], data[1024];
  253. DWORD namelen, datalen, type;
  254. namelen = 255;
  255. datalen = sizeof(data);
  256. ret = RegEnumValue(nhk, i, name, &namelen, NULL, &type,
  257. (LPBYTE) data, &datalen);
  258. if (ret == ERROR_NO_MORE_ITEMS)
  259. break;
  260. if (ret != ERROR_SUCCESS) {
  261. wpa_printf(MSG_ERROR, "RegEnumValue failed: 0x%x",
  262. (unsigned int) ret);
  263. break;
  264. }
  265. if (namelen >= 255)
  266. namelen = 255 - 1;
  267. name[namelen] = TEXT('\0');
  268. if (datalen >= 1024)
  269. datalen = 1024 - 1;
  270. data[datalen] = TEXT('\0');
  271. wpa_unicode2ascii_inplace(name);
  272. wpa_unicode2ascii_inplace(data);
  273. if (wpa_config_set(ssid, (char *) name, (char *) data, 0) < 0)
  274. errors++;
  275. }
  276. RegCloseKey(nhk);
  277. if (ssid->passphrase) {
  278. if (ssid->psk_set) {
  279. wpa_printf(MSG_ERROR, "Both PSK and passphrase "
  280. "configured for network '" TSTR "'.", netw);
  281. errors++;
  282. }
  283. wpa_config_update_psk(ssid);
  284. }
  285. if ((ssid->group_cipher & WPA_CIPHER_CCMP) &&
  286. !(ssid->pairwise_cipher & WPA_CIPHER_CCMP) &&
  287. !(ssid->pairwise_cipher & WPA_CIPHER_NONE)) {
  288. /* Group cipher cannot be stronger than the pairwise cipher. */
  289. wpa_printf(MSG_DEBUG, "Removed CCMP from group cipher "
  290. "list since it was not allowed for pairwise "
  291. "cipher for network '" TSTR "'.", netw);
  292. ssid->group_cipher &= ~WPA_CIPHER_CCMP;
  293. }
  294. if (errors) {
  295. wpa_config_free_ssid(ssid);
  296. ssid = NULL;
  297. }
  298. return ssid;
  299. }
  300. static int wpa_config_read_networks(struct wpa_config *config, HKEY hk)
  301. {
  302. HKEY nhk;
  303. struct wpa_ssid *ssid, *tail = NULL, *head = NULL;
  304. int errors = 0;
  305. LONG ret;
  306. DWORD i;
  307. ret = RegOpenKeyEx(hk, TEXT("networks"), 0, KEY_ENUMERATE_SUB_KEYS,
  308. &nhk);
  309. if (ret != ERROR_SUCCESS) {
  310. wpa_printf(MSG_ERROR, "Could not open wpa_supplicant networks "
  311. "registry key");
  312. return -1;
  313. }
  314. for (i = 0; ; i++) {
  315. TCHAR name[255];
  316. DWORD namelen;
  317. namelen = 255;
  318. ret = RegEnumKeyEx(nhk, i, name, &namelen, NULL, NULL, NULL,
  319. NULL);
  320. if (ret == ERROR_NO_MORE_ITEMS)
  321. break;
  322. if (ret != ERROR_SUCCESS) {
  323. wpa_printf(MSG_DEBUG, "RegEnumKeyEx failed: 0x%x",
  324. (unsigned int) ret);
  325. break;
  326. }
  327. if (namelen >= 255)
  328. namelen = 255 - 1;
  329. name[namelen] = '\0';
  330. ssid = wpa_config_read_network(nhk, name, i);
  331. if (ssid == NULL) {
  332. wpa_printf(MSG_ERROR, "Failed to parse network "
  333. "profile '%s'.", name);
  334. errors++;
  335. continue;
  336. }
  337. if (head == NULL) {
  338. head = tail = ssid;
  339. } else {
  340. tail->next = ssid;
  341. tail = ssid;
  342. }
  343. if (wpa_config_add_prio_network(config, ssid)) {
  344. wpa_printf(MSG_ERROR, "Failed to add network profile "
  345. "'%s' to priority list.", name);
  346. errors++;
  347. continue;
  348. }
  349. }
  350. RegCloseKey(nhk);
  351. config->ssid = head;
  352. return errors ? -1 : 0;
  353. }
  354. struct wpa_config * wpa_config_read(const char *name)
  355. {
  356. TCHAR buf[256];
  357. int errors = 0;
  358. struct wpa_config *config;
  359. HKEY hk;
  360. LONG ret;
  361. config = wpa_config_alloc_empty(NULL, NULL);
  362. if (config == NULL)
  363. return NULL;
  364. wpa_printf(MSG_DEBUG, "Reading configuration profile '%s'", name);
  365. #ifdef UNICODE
  366. _snwprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%S"), name);
  367. #else /* UNICODE */
  368. os_snprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%s"), name);
  369. #endif /* UNICODE */
  370. ret = RegOpenKeyEx(WPA_KEY_ROOT, buf, 0, KEY_QUERY_VALUE, &hk);
  371. if (ret != ERROR_SUCCESS) {
  372. wpa_printf(MSG_ERROR, "Could not open wpa_supplicant "
  373. "configuration registry HKLM\\" TSTR, buf);
  374. os_free(config);
  375. return NULL;
  376. }
  377. if (wpa_config_read_global(config, hk))
  378. errors++;
  379. if (wpa_config_read_networks(config, hk))
  380. errors++;
  381. if (wpa_config_read_blobs(config, hk))
  382. errors++;
  383. wpa_config_debug_dump_networks(config);
  384. RegCloseKey(hk);
  385. if (errors) {
  386. wpa_config_free(config);
  387. config = NULL;
  388. }
  389. return config;
  390. }
  391. static int wpa_config_write_reg_dword(HKEY hk, const TCHAR *name, int val,
  392. int def)
  393. {
  394. LONG ret;
  395. DWORD _val = val;
  396. if (val == def) {
  397. RegDeleteValue(hk, name);
  398. return 0;
  399. }
  400. ret = RegSetValueEx(hk, name, 0, REG_DWORD, (LPBYTE) &_val,
  401. sizeof(_val));
  402. if (ret != ERROR_SUCCESS) {
  403. wpa_printf(MSG_ERROR, "WINREG: Failed to set %s=%d: error %d",
  404. name, val, (int) GetLastError());
  405. return -1;
  406. }
  407. return 0;
  408. }
  409. static int wpa_config_write_reg_string(HKEY hk, const char *name,
  410. const char *val)
  411. {
  412. LONG ret;
  413. TCHAR *_name, *_val;
  414. _name = wpa_strdup_tchar(name);
  415. if (_name == NULL)
  416. return -1;
  417. if (val == NULL) {
  418. RegDeleteValue(hk, _name);
  419. os_free(_name);
  420. return 0;
  421. }
  422. _val = wpa_strdup_tchar(val);
  423. if (_val == NULL) {
  424. os_free(_name);
  425. return -1;
  426. }
  427. ret = RegSetValueEx(hk, _name, 0, REG_SZ, (BYTE *) _val,
  428. (os_strlen(val) + 1) * sizeof(TCHAR));
  429. if (ret != ERROR_SUCCESS) {
  430. wpa_printf(MSG_ERROR, "WINREG: Failed to set %s='%s': "
  431. "error %d", name, val, (int) GetLastError());
  432. os_free(_name);
  433. os_free(_val);
  434. return -1;
  435. }
  436. os_free(_name);
  437. os_free(_val);
  438. return 0;
  439. }
  440. static int wpa_config_write_global(struct wpa_config *config, HKEY hk)
  441. {
  442. #ifdef CONFIG_CTRL_IFACE
  443. wpa_config_write_reg_string(hk, "ctrl_interface",
  444. config->ctrl_interface);
  445. #endif /* CONFIG_CTRL_IFACE */
  446. wpa_config_write_reg_dword(hk, TEXT("eapol_version"),
  447. config->eapol_version,
  448. DEFAULT_EAPOL_VERSION);
  449. wpa_config_write_reg_dword(hk, TEXT("ap_scan"), config->ap_scan,
  450. DEFAULT_AP_SCAN);
  451. wpa_config_write_reg_dword(hk, TEXT("fast_reauth"),
  452. config->fast_reauth, DEFAULT_FAST_REAUTH);
  453. wpa_config_write_reg_dword(hk, TEXT("dot11RSNAConfigPMKLifetime"),
  454. config->dot11RSNAConfigPMKLifetime, 0);
  455. wpa_config_write_reg_dword(hk,
  456. TEXT("dot11RSNAConfigPMKReauthThreshold"),
  457. config->dot11RSNAConfigPMKReauthThreshold,
  458. 0);
  459. wpa_config_write_reg_dword(hk, TEXT("dot11RSNAConfigSATimeout"),
  460. config->dot11RSNAConfigSATimeout, 0);
  461. wpa_config_write_reg_dword(hk, TEXT("update_config"),
  462. config->update_config,
  463. 0);
  464. #ifdef CONFIG_WPS
  465. if (!is_nil_uuid(config->uuid)) {
  466. char buf[40];
  467. uuid_bin2str(config->uuid, buf, sizeof(buf));
  468. wpa_config_write_reg_string(hk, "uuid", buf);
  469. }
  470. wpa_config_write_reg_string(hk, "device_name", config->device_name);
  471. wpa_config_write_reg_string(hk, "manufacturer", config->manufacturer);
  472. wpa_config_write_reg_string(hk, "model_name", config->model_name);
  473. wpa_config_write_reg_string(hk, "model_number", config->model_number);
  474. wpa_config_write_reg_string(hk, "serial_number",
  475. config->serial_number);
  476. {
  477. char _buf[WPS_DEV_TYPE_BUFSIZE], *buf;
  478. buf = wps_dev_type_bin2str(config->device_type,
  479. _buf, sizeof(_buf));
  480. wpa_config_write_reg_string(hk, "device_type", buf);
  481. }
  482. wpa_config_write_reg_string(hk, "config_methods",
  483. config->config_methods);
  484. if (WPA_GET_BE32(config->os_version)) {
  485. char vbuf[10];
  486. os_snprintf(vbuf, sizeof(vbuf), "%08x",
  487. WPA_GET_BE32(config->os_version));
  488. wpa_config_write_reg_string(hk, "os_version", vbuf);
  489. }
  490. wpa_config_write_reg_dword(hk, TEXT("wps_cred_processing"),
  491. config->wps_cred_processing, 0);
  492. #endif /* CONFIG_WPS */
  493. #ifdef CONFIG_P2P
  494. wpa_config_write_reg_string(hk, "p2p_ssid_postfix",
  495. config->p2p_ssid_postfix);
  496. wpa_config_write_reg_dword(hk, TEXT("p2p_group_idle"),
  497. config->p2p_group_idle, 0);
  498. #endif /* CONFIG_P2P */
  499. wpa_config_write_reg_dword(hk, TEXT("bss_max_count"),
  500. config->bss_max_count,
  501. DEFAULT_BSS_MAX_COUNT);
  502. wpa_config_write_reg_dword(hk, TEXT("filter_ssids"),
  503. config->filter_ssids, 0);
  504. wpa_config_write_reg_dword(hk, TEXT("max_num_sta"),
  505. config->max_num_sta, DEFAULT_MAX_NUM_STA);
  506. wpa_config_write_reg_dword(hk, TEXT("disassoc_low_ack"),
  507. config->disassoc_low_ack, 0);
  508. return 0;
  509. }
  510. static int wpa_config_delete_subkeys(HKEY hk, const TCHAR *key)
  511. {
  512. HKEY nhk;
  513. int i, errors = 0;
  514. LONG ret;
  515. ret = RegOpenKeyEx(hk, key, 0, KEY_ENUMERATE_SUB_KEYS | DELETE, &nhk);
  516. if (ret != ERROR_SUCCESS) {
  517. wpa_printf(MSG_DEBUG, "WINREG: Could not open key '" TSTR
  518. "' for subkey deletion: error 0x%x (%d)", key,
  519. (unsigned int) ret, (int) GetLastError());
  520. return 0;
  521. }
  522. for (i = 0; ; i++) {
  523. TCHAR name[255];
  524. DWORD namelen;
  525. namelen = 255;
  526. ret = RegEnumKeyEx(nhk, i, name, &namelen, NULL, NULL, NULL,
  527. NULL);
  528. if (ret == ERROR_NO_MORE_ITEMS)
  529. break;
  530. if (ret != ERROR_SUCCESS) {
  531. wpa_printf(MSG_DEBUG, "RegEnumKeyEx failed: 0x%x (%d)",
  532. (unsigned int) ret, (int) GetLastError());
  533. break;
  534. }
  535. if (namelen >= 255)
  536. namelen = 255 - 1;
  537. name[namelen] = TEXT('\0');
  538. ret = RegDeleteKey(nhk, name);
  539. if (ret != ERROR_SUCCESS) {
  540. wpa_printf(MSG_DEBUG, "RegDeleteKey failed: 0x%x (%d)",
  541. (unsigned int) ret, (int) GetLastError());
  542. errors++;
  543. }
  544. }
  545. RegCloseKey(nhk);
  546. return errors ? -1 : 0;
  547. }
  548. static void write_str(HKEY hk, const char *field, struct wpa_ssid *ssid)
  549. {
  550. char *value = wpa_config_get(ssid, field);
  551. if (value == NULL)
  552. return;
  553. wpa_config_write_reg_string(hk, field, value);
  554. os_free(value);
  555. }
  556. static void write_int(HKEY hk, const char *field, int value, int def)
  557. {
  558. char val[20];
  559. if (value == def)
  560. return;
  561. os_snprintf(val, sizeof(val), "%d", value);
  562. wpa_config_write_reg_string(hk, field, val);
  563. }
  564. static void write_bssid(HKEY hk, struct wpa_ssid *ssid)
  565. {
  566. char *value = wpa_config_get(ssid, "bssid");
  567. if (value == NULL)
  568. return;
  569. wpa_config_write_reg_string(hk, "bssid", value);
  570. os_free(value);
  571. }
  572. static void write_psk(HKEY hk, struct wpa_ssid *ssid)
  573. {
  574. char *value = wpa_config_get(ssid, "psk");
  575. if (value == NULL)
  576. return;
  577. wpa_config_write_reg_string(hk, "psk", value);
  578. os_free(value);
  579. }
  580. static void write_proto(HKEY hk, struct wpa_ssid *ssid)
  581. {
  582. char *value;
  583. if (ssid->proto == DEFAULT_PROTO)
  584. return;
  585. value = wpa_config_get(ssid, "proto");
  586. if (value == NULL)
  587. return;
  588. if (value[0])
  589. wpa_config_write_reg_string(hk, "proto", value);
  590. os_free(value);
  591. }
  592. static void write_key_mgmt(HKEY hk, struct wpa_ssid *ssid)
  593. {
  594. char *value;
  595. if (ssid->key_mgmt == DEFAULT_KEY_MGMT)
  596. return;
  597. value = wpa_config_get(ssid, "key_mgmt");
  598. if (value == NULL)
  599. return;
  600. if (value[0])
  601. wpa_config_write_reg_string(hk, "key_mgmt", value);
  602. os_free(value);
  603. }
  604. static void write_pairwise(HKEY hk, struct wpa_ssid *ssid)
  605. {
  606. char *value;
  607. if (ssid->pairwise_cipher == DEFAULT_PAIRWISE)
  608. return;
  609. value = wpa_config_get(ssid, "pairwise");
  610. if (value == NULL)
  611. return;
  612. if (value[0])
  613. wpa_config_write_reg_string(hk, "pairwise", value);
  614. os_free(value);
  615. }
  616. static void write_group(HKEY hk, struct wpa_ssid *ssid)
  617. {
  618. char *value;
  619. if (ssid->group_cipher == DEFAULT_GROUP)
  620. return;
  621. value = wpa_config_get(ssid, "group");
  622. if (value == NULL)
  623. return;
  624. if (value[0])
  625. wpa_config_write_reg_string(hk, "group", value);
  626. os_free(value);
  627. }
  628. static void write_auth_alg(HKEY hk, struct wpa_ssid *ssid)
  629. {
  630. char *value;
  631. if (ssid->auth_alg == 0)
  632. return;
  633. value = wpa_config_get(ssid, "auth_alg");
  634. if (value == NULL)
  635. return;
  636. if (value[0])
  637. wpa_config_write_reg_string(hk, "auth_alg", value);
  638. os_free(value);
  639. }
  640. #ifdef IEEE8021X_EAPOL
  641. static void write_eap(HKEY hk, struct wpa_ssid *ssid)
  642. {
  643. char *value;
  644. value = wpa_config_get(ssid, "eap");
  645. if (value == NULL)
  646. return;
  647. if (value[0])
  648. wpa_config_write_reg_string(hk, "eap", value);
  649. os_free(value);
  650. }
  651. #endif /* IEEE8021X_EAPOL */
  652. static void write_wep_key(HKEY hk, int idx, struct wpa_ssid *ssid)
  653. {
  654. char field[20], *value;
  655. os_snprintf(field, sizeof(field), "wep_key%d", idx);
  656. value = wpa_config_get(ssid, field);
  657. if (value) {
  658. wpa_config_write_reg_string(hk, field, value);
  659. os_free(value);
  660. }
  661. }
  662. static int wpa_config_write_network(HKEY hk, struct wpa_ssid *ssid, int id)
  663. {
  664. int i, errors = 0;
  665. HKEY nhk, netw;
  666. LONG ret;
  667. TCHAR name[5];
  668. ret = RegOpenKeyEx(hk, TEXT("networks"), 0, KEY_CREATE_SUB_KEY, &nhk);
  669. if (ret != ERROR_SUCCESS) {
  670. wpa_printf(MSG_DEBUG, "WINREG: Could not open networks key "
  671. "for subkey addition: error 0x%x (%d)",
  672. (unsigned int) ret, (int) GetLastError());
  673. return 0;
  674. }
  675. #ifdef UNICODE
  676. wsprintf(name, L"%04d", id);
  677. #else /* UNICODE */
  678. os_snprintf(name, sizeof(name), "%04d", id);
  679. #endif /* UNICODE */
  680. ret = RegCreateKeyEx(nhk, name, 0, NULL, 0, KEY_WRITE, NULL, &netw,
  681. NULL);
  682. RegCloseKey(nhk);
  683. if (ret != ERROR_SUCCESS) {
  684. wpa_printf(MSG_DEBUG, "WINREG: Could not add network key '%s':"
  685. " error 0x%x (%d)",
  686. name, (unsigned int) ret, (int) GetLastError());
  687. return -1;
  688. }
  689. #define STR(t) write_str(netw, #t, ssid)
  690. #define INT(t) write_int(netw, #t, ssid->t, 0)
  691. #define INTe(t) write_int(netw, #t, ssid->eap.t, 0)
  692. #define INT_DEF(t, def) write_int(netw, #t, ssid->t, def)
  693. #define INT_DEFe(t, def) write_int(netw, #t, ssid->eap.t, def)
  694. STR(ssid);
  695. INT(scan_ssid);
  696. write_bssid(netw, ssid);
  697. write_psk(netw, ssid);
  698. write_proto(netw, ssid);
  699. write_key_mgmt(netw, ssid);
  700. write_pairwise(netw, ssid);
  701. write_group(netw, ssid);
  702. write_auth_alg(netw, ssid);
  703. #ifdef IEEE8021X_EAPOL
  704. write_eap(netw, ssid);
  705. STR(identity);
  706. STR(anonymous_identity);
  707. STR(password);
  708. STR(ca_cert);
  709. STR(ca_path);
  710. STR(client_cert);
  711. STR(private_key);
  712. STR(private_key_passwd);
  713. STR(dh_file);
  714. STR(subject_match);
  715. STR(altsubject_match);
  716. STR(ca_cert2);
  717. STR(ca_path2);
  718. STR(client_cert2);
  719. STR(private_key2);
  720. STR(private_key2_passwd);
  721. STR(dh_file2);
  722. STR(subject_match2);
  723. STR(altsubject_match2);
  724. STR(phase1);
  725. STR(phase2);
  726. STR(pcsc);
  727. STR(pin);
  728. STR(engine_id);
  729. STR(key_id);
  730. STR(cert_id);
  731. STR(ca_cert_id);
  732. STR(key2_id);
  733. STR(pin2);
  734. STR(engine2_id);
  735. STR(cert2_id);
  736. STR(ca_cert2_id);
  737. INTe(engine);
  738. INTe(engine2);
  739. INT_DEF(eapol_flags, DEFAULT_EAPOL_FLAGS);
  740. #endif /* IEEE8021X_EAPOL */
  741. for (i = 0; i < 4; i++)
  742. write_wep_key(netw, i, ssid);
  743. INT(wep_tx_keyidx);
  744. INT(priority);
  745. #ifdef IEEE8021X_EAPOL
  746. INT_DEF(eap_workaround, DEFAULT_EAP_WORKAROUND);
  747. STR(pac_file);
  748. INT_DEFe(fragment_size, DEFAULT_FRAGMENT_SIZE);
  749. #endif /* IEEE8021X_EAPOL */
  750. INT(mode);
  751. INT(proactive_key_caching);
  752. INT(disabled);
  753. INT(peerkey);
  754. #ifdef CONFIG_IEEE80211W
  755. INT(ieee80211w);
  756. #endif /* CONFIG_IEEE80211W */
  757. STR(id_str);
  758. #undef STR
  759. #undef INT
  760. #undef INT_DEF
  761. RegCloseKey(netw);
  762. return errors ? -1 : 0;
  763. }
  764. static int wpa_config_write_blob(HKEY hk, struct wpa_config_blob *blob)
  765. {
  766. HKEY bhk;
  767. LONG ret;
  768. TCHAR *name;
  769. ret = RegCreateKeyEx(hk, TEXT("blobs"), 0, NULL, 0, KEY_WRITE, NULL,
  770. &bhk, NULL);
  771. if (ret != ERROR_SUCCESS) {
  772. wpa_printf(MSG_DEBUG, "WINREG: Could not add blobs key: "
  773. "error 0x%x (%d)",
  774. (unsigned int) ret, (int) GetLastError());
  775. return -1;
  776. }
  777. name = wpa_strdup_tchar(blob->name);
  778. ret = RegSetValueEx(bhk, name, 0, REG_BINARY, blob->data,
  779. blob->len);
  780. if (ret != ERROR_SUCCESS) {
  781. wpa_printf(MSG_ERROR, "WINREG: Failed to set blob %s': "
  782. "error 0x%x (%d)", blob->name, (unsigned int) ret,
  783. (int) GetLastError());
  784. RegCloseKey(bhk);
  785. os_free(name);
  786. return -1;
  787. }
  788. os_free(name);
  789. RegCloseKey(bhk);
  790. return 0;
  791. }
  792. int wpa_config_write(const char *name, struct wpa_config *config)
  793. {
  794. TCHAR buf[256];
  795. HKEY hk;
  796. LONG ret;
  797. int errors = 0;
  798. struct wpa_ssid *ssid;
  799. struct wpa_config_blob *blob;
  800. int id;
  801. wpa_printf(MSG_DEBUG, "Writing configuration file '%s'", name);
  802. #ifdef UNICODE
  803. _snwprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%S"), name);
  804. #else /* UNICODE */
  805. os_snprintf(buf, 256, WPA_KEY_PREFIX TEXT("\\configs\\%s"), name);
  806. #endif /* UNICODE */
  807. ret = RegOpenKeyEx(WPA_KEY_ROOT, buf, 0, KEY_SET_VALUE | DELETE, &hk);
  808. if (ret != ERROR_SUCCESS) {
  809. wpa_printf(MSG_ERROR, "Could not open wpa_supplicant "
  810. "configuration registry %s: error %d", buf,
  811. (int) GetLastError());
  812. return -1;
  813. }
  814. if (wpa_config_write_global(config, hk)) {
  815. wpa_printf(MSG_ERROR, "Failed to write global configuration "
  816. "data");
  817. errors++;
  818. }
  819. wpa_config_delete_subkeys(hk, TEXT("networks"));
  820. for (ssid = config->ssid, id = 0; ssid; ssid = ssid->next, id++) {
  821. if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
  822. continue; /* do not save temporary WPS networks */
  823. if (wpa_config_write_network(hk, ssid, id))
  824. errors++;
  825. }
  826. RegDeleteKey(hk, TEXT("blobs"));
  827. for (blob = config->blobs; blob; blob = blob->next) {
  828. if (wpa_config_write_blob(hk, blob))
  829. errors++;
  830. }
  831. RegCloseKey(hk);
  832. wpa_printf(MSG_DEBUG, "Configuration '%s' written %ssuccessfully",
  833. name, errors ? "un" : "");
  834. return errors ? -1 : 0;
  835. }