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