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