wpa_supplicant/config_winreg.c

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