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