wpa_supplicant/wps_supplicant.c

   1 /*
   2  * wpa_supplicant / WPS integration
   3  * Copyright (c) 2008-2014, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "eloop.h"
  13 #include "uuid.h"
  14 #include "crypto/random.h"
  15 #include "crypto/dh_group5.h"
  16 #include "common/ieee802_11_defs.h"
  17 #include "common/ieee802_11_common.h"
  18 #include "common/wpa_common.h"
  19 #include "common/wpa_ctrl.h"
  20 #include "eap_common/eap_wsc_common.h"
  21 #include "eap_peer/eap.h"
  22 #include "eapol_supp/eapol_supp_sm.h"
  23 #include "rsn_supp/wpa.h"
  24 #include "wps/wps_attr_parse.h"
  25 #include "config.h"
  26 #include "wpa_supplicant_i.h"
  27 #include "driver_i.h"
  28 #include "notify.h"
  29 #include "blacklist.h"
  30 #include "bss.h"
  31 #include "scan.h"
  32 #include "ap.h"
  33 #include "p2p/p2p.h"
  34 #include "p2p_supplicant.h"
  35 #include "wps_supplicant.h"
  36
  37
  38 #ifndef WPS_PIN_SCAN_IGNORE_SEL_REG
  39 #define WPS_PIN_SCAN_IGNORE_SEL_REG 3
  40 #endif /* WPS_PIN_SCAN_IGNORE_SEL_REG */
  41
  42 static void wpas_wps_timeout(void *eloop_ctx, void *timeout_ctx);
  43 static void wpas_clear_wps(struct wpa_supplicant *wpa_s);
  44
  45
  46 static void wpas_wps_clear_ap_info(struct wpa_supplicant *wpa_s)
  47 {
  48         os_free(wpa_s->wps_ap);
  49         wpa_s->wps_ap = NULL;
  50         wpa_s->num_wps_ap = 0;
  51         wpa_s->wps_ap_iter = 0;
  52 }
  53
  54
  55 static void wpas_wps_assoc_with_cred(void *eloop_ctx, void *timeout_ctx)
  56 {
  57         struct wpa_supplicant *wpa_s = eloop_ctx;
  58         int use_fast_assoc = timeout_ctx != NULL;
  59
  60         wpa_printf(MSG_DEBUG, "WPS: Continuing association after eapol_cb");
  61         if (!use_fast_assoc ||
  62             wpa_supplicant_fast_associate(wpa_s) != 1)
  63                 wpa_supplicant_req_scan(wpa_s, 0, 0);
  64 }
  65
  66
  67 static void wpas_wps_assoc_with_cred_cancel(struct wpa_supplicant *wpa_s)
  68 {
  69         eloop_cancel_timeout(wpas_wps_assoc_with_cred, wpa_s, (void *) 0);
  70         eloop_cancel_timeout(wpas_wps_assoc_with_cred, wpa_s, (void *) 1);
  71 }
  72
  73
  74 int wpas_wps_eapol_cb(struct wpa_supplicant *wpa_s)
  75 {
  76 #ifdef CONFIG_P2P
  77         if (wpas_p2p_wps_eapol_cb(wpa_s) > 0)
  78                 return 1;
  79 #endif /* CONFIG_P2P */
  80
  81         if (!wpa_s->wps_success &&
  82             wpa_s->current_ssid &&
  83             eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
  84                 const u8 *bssid = wpa_s->bssid;
  85                 if (is_zero_ether_addr(bssid))
  86                         bssid = wpa_s->pending_bssid;
  87
  88                 wpa_printf(MSG_DEBUG, "WPS: PIN registration with " MACSTR
  89                            " did not succeed - continue trying to find "
  90                            "suitable AP", MAC2STR(bssid));
  91                 wpa_blacklist_add(wpa_s, bssid);
  92
  93                 wpa_supplicant_deauthenticate(wpa_s,
  94                                               WLAN_REASON_DEAUTH_LEAVING);
  95                 wpa_s->reassociate = 1;
  96                 wpa_supplicant_req_scan(wpa_s,
  97                                         wpa_s->blacklist_cleared ? 5 : 0, 0);
  98                 wpa_s->blacklist_cleared = 0;
  99                 return 1;
 100         }
 101
 102         wpas_wps_clear_ap_info(wpa_s);
 103         eloop_cancel_timeout(wpas_wps_timeout, wpa_s, NULL);
 104         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && !wpa_s->wps_success)
 105                 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_FAIL);
 106
 107         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && wpa_s->current_ssid &&
 108             !(wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
 109                 int disabled = wpa_s->current_ssid->disabled;
 110                 unsigned int freq = wpa_s->assoc_freq;
 111                 struct wpa_bss *bss;
 112                 struct wpa_ssid *ssid = NULL;
 113                 int use_fast_assoc = 0;
 114
 115                 wpa_printf(MSG_DEBUG, "WPS: Network configuration replaced - "
 116                            "try to associate with the received credential "
 117                            "(freq=%u)", freq);
 118                 wpa_supplicant_deauthenticate(wpa_s,
 119                                               WLAN_REASON_DEAUTH_LEAVING);
 120                 if (disabled) {
 121                         wpa_printf(MSG_DEBUG, "WPS: Current network is "
 122                                    "disabled - wait for user to enable");
 123                         return 1;
 124                 }
 125                 wpa_s->after_wps = 5;
 126                 wpa_s->wps_freq = freq;
 127                 wpa_s->normal_scans = 0;
 128                 wpa_s->reassociate = 1;
 129
 130                 wpa_printf(MSG_DEBUG, "WPS: Checking whether fast association "
 131                            "without a new scan can be used");
 132                 bss = wpa_supplicant_pick_network(wpa_s, &ssid);
 133                 if (bss) {
 134                         struct wpabuf *wps;
 135                         struct wps_parse_attr attr;
 136
 137                         wps = wpa_bss_get_vendor_ie_multi(bss,
 138                                                           WPS_IE_VENDOR_TYPE);
 139                         if (wps && wps_parse_msg(wps, &attr) == 0 &&
 140                             attr.wps_state &&
 141                             *attr.wps_state == WPS_STATE_CONFIGURED)
 142                                 use_fast_assoc = 1;
 143                         wpabuf_free(wps);
 144                 }
 145
 146                 /*
 147                  * Complete the next step from an eloop timeout to allow pending
 148                  * driver events related to the disconnection to be processed
 149                  * first. This makes it less likely for disconnection event to
 150                  * cause problems with the following connection.
 151                  */
 152                 wpa_printf(MSG_DEBUG, "WPS: Continue association from timeout");
 153                 wpas_wps_assoc_with_cred_cancel(wpa_s);
 154                 eloop_register_timeout(0, 10000,
 155                                        wpas_wps_assoc_with_cred, wpa_s,
 156                                        use_fast_assoc ? (void *) 1 :
 157                                        (void *) 0);
 158                 return 1;
 159         }
 160
 161         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && wpa_s->current_ssid) {
 162                 wpa_printf(MSG_DEBUG, "WPS: Registration completed - waiting "
 163                            "for external credential processing");
 164                 wpas_clear_wps(wpa_s);
 165                 wpa_supplicant_deauthenticate(wpa_s,
 166                                               WLAN_REASON_DEAUTH_LEAVING);
 167                 return 1;
 168         }
 169
 170         return 0;
 171 }
 172
 173
 174 static void wpas_wps_security_workaround(struct wpa_supplicant *wpa_s,
 175                                          struct wpa_ssid *ssid,
 176                                          const struct wps_credential *cred)
 177 {
 178         struct wpa_driver_capa capa;
 179         struct wpa_bss *bss;
 180         const u8 *ie;
 181         struct wpa_ie_data adv;
 182         int wpa2 = 0, ccmp = 0;
 183
 184         /*
 185          * Many existing WPS APs do not know how to negotiate WPA2 or CCMP in
 186          * case they are configured for mixed mode operation (WPA+WPA2 and
 187          * TKIP+CCMP). Try to use scan results to figure out whether the AP
 188          * actually supports stronger security and select that if the client
 189          * has support for it, too.
 190          */
 191
 192         if (wpa_drv_get_capa(wpa_s, &capa))
 193                 return; /* Unknown what driver supports */
 194
 195         if (ssid->ssid == NULL)
 196                 return;
 197         bss = wpa_bss_get(wpa_s, cred->mac_addr, ssid->ssid, ssid->ssid_len);
 198         if (bss == NULL) {
 199                 wpa_printf(MSG_DEBUG, "WPS: The AP was not found from BSS "
 200                            "table - use credential as-is");
 201                 return;
 202         }
 203
 204         wpa_printf(MSG_DEBUG, "WPS: AP found from BSS table");
 205
 206         ie = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 207         if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &adv) == 0) {
 208                 wpa2 = 1;
 209                 if (adv.pairwise_cipher & WPA_CIPHER_CCMP)
 210                         ccmp = 1;
 211         } else {
 212                 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 213                 if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &adv) == 0 &&
 214                     adv.pairwise_cipher & WPA_CIPHER_CCMP)
 215                         ccmp = 1;
 216         }
 217
 218         if (ie == NULL && (ssid->proto & WPA_PROTO_WPA) &&
 219             (ssid->pairwise_cipher & WPA_CIPHER_TKIP)) {
 220                 /*
 221                  * TODO: This could be the initial AP configuration and the
 222                  * Beacon contents could change shortly. Should request a new
 223                  * scan and delay addition of the network until the updated
 224                  * scan results are available.
 225                  */
 226                 wpa_printf(MSG_DEBUG, "WPS: The AP did not yet advertise WPA "
 227                            "support - use credential as-is");
 228                 return;
 229         }
 230
 231         if (ccmp && !(ssid->pairwise_cipher & WPA_CIPHER_CCMP) &&
 232             (ssid->pairwise_cipher & WPA_CIPHER_TKIP) &&
 233             (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
 234                 wpa_printf(MSG_DEBUG, "WPS: Add CCMP into the credential "
 235                            "based on scan results");
 236                 if (wpa_s->conf->ap_scan == 1)
 237                         ssid->pairwise_cipher |= WPA_CIPHER_CCMP;
 238                 else
 239                         ssid->pairwise_cipher = WPA_CIPHER_CCMP;
 240         }
 241
 242         if (wpa2 && !(ssid->proto & WPA_PROTO_RSN) &&
 243             (ssid->proto & WPA_PROTO_WPA) &&
 244             (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP)) {
 245                 wpa_printf(MSG_DEBUG, "WPS: Add WPA2 into the credential "
 246                            "based on scan results");
 247                 if (wpa_s->conf->ap_scan == 1)
 248                         ssid->proto |= WPA_PROTO_RSN;
 249                 else
 250                         ssid->proto = WPA_PROTO_RSN;
 251         }
 252 }
 253
 254
 255 static void wpas_wps_remove_dup_network(struct wpa_supplicant *wpa_s,
 256                                         struct wpa_ssid *new_ssid)
 257 {
 258         struct wpa_ssid *ssid, *next;
 259
 260         for (ssid = wpa_s->conf->ssid, next = ssid ? ssid->next : NULL; ssid;
 261              ssid = next, next = ssid ? ssid->next : NULL) {
 262                 /*
 263                  * new_ssid has already been added to the list in
 264                  * wpas_wps_add_network(), so skip it.
 265                  */
 266                 if (ssid == new_ssid)
 267                         continue;
 268
 269                 if (ssid->bssid_set || new_ssid->bssid_set) {
 270                         if (ssid->bssid_set != new_ssid->bssid_set)
 271                                 continue;
 272                         if (os_memcmp(ssid->bssid, new_ssid->bssid, ETH_ALEN) !=
 273                             0)
 274                                 continue;
 275                 }
 276
 277                 /* compare SSID */
 278                 if (ssid->ssid_len == 0 || ssid->ssid_len != new_ssid->ssid_len)
 279                         continue;
 280
 281                 if (ssid->ssid && new_ssid->ssid) {
 282                         if (os_memcmp(ssid->ssid, new_ssid->ssid,
 283                                       ssid->ssid_len) != 0)
 284                                 continue;
 285                 } else if (ssid->ssid || new_ssid->ssid)
 286                         continue;
 287
 288                 /* compare security parameters */
 289                 if (ssid->auth_alg != new_ssid->auth_alg ||
 290                     ssid->key_mgmt != new_ssid->key_mgmt ||
 291                     ssid->proto != new_ssid->proto ||
 292                     ssid->pairwise_cipher != new_ssid->pairwise_cipher ||
 293                     ssid->group_cipher != new_ssid->group_cipher)
 294                         continue;
 295
 296                 /* Remove the duplicated older network entry. */
 297                 wpa_printf(MSG_DEBUG, "Remove duplicate network %d", ssid->id);
 298                 wpas_notify_network_removed(wpa_s, ssid);
 299                 wpa_config_remove_network(wpa_s->conf, ssid->id);
 300         }
 301 }
 302
 303
 304 static int wpa_supplicant_wps_cred(void *ctx,
 305                                    const struct wps_credential *cred)
 306 {
 307         struct wpa_supplicant *wpa_s = ctx;
 308         struct wpa_ssid *ssid = wpa_s->current_ssid;
 309         u16 auth_type;
 310 #ifdef CONFIG_WPS_REG_DISABLE_OPEN
 311         int registrar = 0;
 312 #endif /* CONFIG_WPS_REG_DISABLE_OPEN */
 313
 314         if ((wpa_s->conf->wps_cred_processing == 1 ||
 315              wpa_s->conf->wps_cred_processing == 2) && cred->cred_attr) {
 316                 size_t blen = cred->cred_attr_len * 2 + 1;
 317                 char *buf = os_malloc(blen);
 318                 if (buf) {
 319                         wpa_snprintf_hex(buf, blen,
 320                                          cred->cred_attr, cred->cred_attr_len);
 321                         wpa_msg(wpa_s, MSG_INFO, "%s%s",
 322                                 WPS_EVENT_CRED_RECEIVED, buf);
 323                         os_free(buf);
 324                 }
 325
 326                 wpas_notify_wps_credential(wpa_s, cred);
 327         } else
 328                 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_CRED_RECEIVED);
 329
 330         wpa_hexdump_key(MSG_DEBUG, "WPS: Received Credential attribute",
 331                         cred->cred_attr, cred->cred_attr_len);
 332
 333         if (wpa_s->conf->wps_cred_processing == 1)
 334                 return 0;
 335
 336         wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID", cred->ssid, cred->ssid_len);
 337         wpa_printf(MSG_DEBUG, "WPS: Authentication Type 0x%x",
 338                    cred->auth_type);
 339         wpa_printf(MSG_DEBUG, "WPS: Encryption Type 0x%x", cred->encr_type);
 340         wpa_printf(MSG_DEBUG, "WPS: Network Key Index %d", cred->key_idx);
 341         wpa_hexdump_key(MSG_DEBUG, "WPS: Network Key",
 342                         cred->key, cred->key_len);
 343         wpa_printf(MSG_DEBUG, "WPS: MAC Address " MACSTR,
 344                    MAC2STR(cred->mac_addr));
 345
 346         auth_type = cred->auth_type;
 347         if (auth_type == (WPS_AUTH_WPAPSK | WPS_AUTH_WPA2PSK)) {
 348                 wpa_printf(MSG_DEBUG, "WPS: Workaround - convert mixed-mode "
 349                            "auth_type into WPA2PSK");
 350                 auth_type = WPS_AUTH_WPA2PSK;
 351         }
 352
 353         if (auth_type != WPS_AUTH_OPEN &&
 354             auth_type != WPS_AUTH_WPAPSK &&
 355             auth_type != WPS_AUTH_WPA2PSK) {
 356                 wpa_printf(MSG_DEBUG, "WPS: Ignored credentials for "
 357                            "unsupported authentication type 0x%x",
 358                            auth_type);
 359                 return 0;
 360         }
 361
 362         if (auth_type == WPS_AUTH_WPAPSK || auth_type == WPS_AUTH_WPA2PSK) {
 363                 if (cred->key_len < 8 || cred->key_len > 2 * PMK_LEN) {
 364                         wpa_printf(MSG_ERROR, "WPS: Reject PSK credential with "
 365                                    "invalid Network Key length %lu",
 366                                    (unsigned long) cred->key_len);
 367                         return -1;
 368                 }
 369         }
 370
 371         if (ssid && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
 372                 wpa_printf(MSG_DEBUG, "WPS: Replace WPS network block based "
 373                            "on the received credential");
 374 #ifdef CONFIG_WPS_REG_DISABLE_OPEN
 375                 if (ssid->eap.identity &&
 376                     ssid->eap.identity_len == WSC_ID_REGISTRAR_LEN &&
 377                     os_memcmp(ssid->eap.identity, WSC_ID_REGISTRAR,
 378                               WSC_ID_REGISTRAR_LEN) == 0)
 379                         registrar = 1;
 380 #endif /* CONFIG_WPS_REG_DISABLE_OPEN */
 381                 os_free(ssid->eap.identity);
 382                 ssid->eap.identity = NULL;
 383                 ssid->eap.identity_len = 0;
 384                 os_free(ssid->eap.phase1);
 385                 ssid->eap.phase1 = NULL;
 386                 os_free(ssid->eap.eap_methods);
 387                 ssid->eap.eap_methods = NULL;
 388                 if (!ssid->p2p_group) {
 389                         ssid->temporary = 0;
 390                         ssid->bssid_set = 0;
 391                 }
 392                 ssid->disabled_until.sec = 0;
 393                 ssid->disabled_until.usec = 0;
 394                 ssid->auth_failures = 0;
 395         } else {
 396                 wpa_printf(MSG_DEBUG, "WPS: Create a new network based on the "
 397                            "received credential");
 398                 ssid = wpa_config_add_network(wpa_s->conf);
 399                 if (ssid == NULL)
 400                         return -1;
 401                 if (wpa_s->current_ssid) {
 402                         /*
 403                          * Should the GO issue multiple credentials for some
 404                          * reason, each credential should be marked as a
 405                          * temporary P2P group similarly to the one that gets
 406                          * marked as such based on the pre-configured values
 407                          * used for the WPS network block.
 408                          */
 409                         ssid->p2p_group = wpa_s->current_ssid->p2p_group;
 410                         ssid->temporary = wpa_s->current_ssid->temporary;
 411                 }
 412                 wpas_notify_network_added(wpa_s, ssid);
 413         }
 414
 415         wpa_config_set_network_defaults(ssid);
 416
 417         os_free(ssid->ssid);
 418         ssid->ssid = os_malloc(cred->ssid_len);
 419         if (ssid->ssid) {
 420                 os_memcpy(ssid->ssid, cred->ssid, cred->ssid_len);
 421                 ssid->ssid_len = cred->ssid_len;
 422         }
 423
 424         switch (cred->encr_type) {
 425         case WPS_ENCR_NONE:
 426                 break;
 427         case WPS_ENCR_TKIP:
 428                 ssid->pairwise_cipher = WPA_CIPHER_TKIP;
 429                 break;
 430         case WPS_ENCR_AES:
 431                 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
 432                 break;
 433         }
 434
 435         switch (auth_type) {
 436         case WPS_AUTH_OPEN:
 437                 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
 438                 ssid->key_mgmt = WPA_KEY_MGMT_NONE;
 439                 ssid->proto = 0;
 440 #ifdef CONFIG_WPS_REG_DISABLE_OPEN
 441                 if (registrar) {
 442                         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_OPEN_NETWORK
 443                                 "id=%d - Credentials for an open "
 444                                 "network disabled by default - use "
 445                                 "'select_network %d' to enable",
 446                                 ssid->id, ssid->id);
 447                         ssid->disabled = 1;
 448                 }
 449 #endif /* CONFIG_WPS_REG_DISABLE_OPEN */
 450                 break;
 451         case WPS_AUTH_WPAPSK:
 452                 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
 453                 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
 454                 ssid->proto = WPA_PROTO_WPA;
 455                 break;
 456         case WPS_AUTH_WPA2PSK:
 457                 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
 458                 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
 459                 ssid->proto = WPA_PROTO_RSN;
 460                 break;
 461         }
 462
 463         if (ssid->key_mgmt == WPA_KEY_MGMT_PSK) {
 464                 if (cred->key_len == 2 * PMK_LEN) {
 465                         if (hexstr2bin((const char *) cred->key, ssid->psk,
 466                                        PMK_LEN)) {
 467                                 wpa_printf(MSG_ERROR, "WPS: Invalid Network "
 468                                            "Key");
 469                                 return -1;
 470                         }
 471                         ssid->psk_set = 1;
 472                         ssid->export_keys = 1;
 473                 } else if (cred->key_len >= 8 && cred->key_len < 2 * PMK_LEN) {
 474                         os_free(ssid->passphrase);
 475                         ssid->passphrase = os_malloc(cred->key_len + 1);
 476                         if (ssid->passphrase == NULL)
 477                                 return -1;
 478                         os_memcpy(ssid->passphrase, cred->key, cred->key_len);
 479                         ssid->passphrase[cred->key_len] = '\0';
 480                         wpa_config_update_psk(ssid);
 481                         ssid->export_keys = 1;
 482                 } else {
 483                         wpa_printf(MSG_ERROR, "WPS: Invalid Network Key "
 484                                    "length %lu",
 485                                    (unsigned long) cred->key_len);
 486                         return -1;
 487                 }
 488         }
 489
 490         wpas_wps_security_workaround(wpa_s, ssid, cred);
 491
 492         wpas_wps_remove_dup_network(wpa_s, ssid);
 493
 494 #ifndef CONFIG_NO_CONFIG_WRITE
 495         if (wpa_s->conf->update_config &&
 496             wpa_config_write(wpa_s->confname, wpa_s->conf)) {
 497                 wpa_printf(MSG_DEBUG, "WPS: Failed to update configuration");
 498                 return -1;
 499         }
 500 #endif /* CONFIG_NO_CONFIG_WRITE */
 501
 502         /*
 503          * Optimize the post-WPS scan based on the channel used during
 504          * the provisioning in case EAP-Failure is not received.
 505          */
 506         wpa_s->after_wps = 5;
 507         wpa_s->wps_freq = wpa_s->assoc_freq;
 508
 509         return 0;
 510 }
 511
 512
 513 static void wpa_supplicant_wps_event_m2d(struct wpa_supplicant *wpa_s,
 514                                          struct wps_event_m2d *m2d)
 515 {
 516         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_M2D
 517                 "dev_password_id=%d config_error=%d",
 518                 m2d->dev_password_id, m2d->config_error);
 519         wpas_notify_wps_event_m2d(wpa_s, m2d);
 520 #ifdef CONFIG_P2P
 521         if (wpa_s->parent && wpa_s->parent != wpa_s) {
 522                 wpa_msg(wpa_s->parent, MSG_INFO, WPS_EVENT_M2D
 523                         "dev_password_id=%d config_error=%d",
 524                         m2d->dev_password_id, m2d->config_error);
 525         }
 526         if (m2d->config_error == WPS_CFG_MULTIPLE_PBC_DETECTED) {
 527                 /*
 528                  * Notify P2P from eloop timeout to avoid issues with the
 529                  * interface getting removed while processing a message.
 530                  */
 531                 eloop_register_timeout(0, 0, wpas_p2p_pbc_overlap_cb, wpa_s,
 532                                        NULL);
 533         }
 534 #endif /* CONFIG_P2P */
 535 }
 536
 537
 538 static void wpas_wps_clear_timeout(void *eloop_ctx, void *timeout_ctx)
 539 {
 540         struct wpa_supplicant *wpa_s = eloop_ctx;
 541         wpa_printf(MSG_DEBUG, "WPS: Clear WPS network from timeout");
 542         wpas_clear_wps(wpa_s);
 543 }
 544
 545
 546 static void wpa_supplicant_wps_event_fail(struct wpa_supplicant *wpa_s,
 547                                           struct wps_event_fail *fail)
 548 {
 549         if (fail->error_indication > 0 &&
 550             fail->error_indication < NUM_WPS_EI_VALUES) {
 551                 wpa_msg(wpa_s, MSG_INFO,
 552                         WPS_EVENT_FAIL "msg=%d config_error=%d reason=%d (%s)",
 553                         fail->msg, fail->config_error, fail->error_indication,
 554                         wps_ei_str(fail->error_indication));
 555                 if (wpa_s->parent && wpa_s->parent != wpa_s)
 556                         wpa_msg(wpa_s->parent, MSG_INFO, WPS_EVENT_FAIL
 557                                 "msg=%d config_error=%d reason=%d (%s)",
 558                                 fail->msg, fail->config_error,
 559                                 fail->error_indication,
 560                                 wps_ei_str(fail->error_indication));
 561         } else {
 562                 wpa_msg(wpa_s, MSG_INFO,
 563                         WPS_EVENT_FAIL "msg=%d config_error=%d",
 564                         fail->msg, fail->config_error);
 565                 if (wpa_s->parent && wpa_s->parent != wpa_s)
 566                         wpa_msg(wpa_s->parent, MSG_INFO, WPS_EVENT_FAIL
 567                                 "msg=%d config_error=%d",
 568                                 fail->msg, fail->config_error);
 569         }
 570
 571         /*
 572          * Need to allow WPS processing to complete, e.g., by sending WSC_NACK.
 573          */
 574         wpa_printf(MSG_DEBUG, "WPS: Register timeout to clear WPS network");
 575         eloop_cancel_timeout(wpas_wps_clear_timeout, wpa_s, NULL);
 576         eloop_register_timeout(0, 100000, wpas_wps_clear_timeout, wpa_s, NULL);
 577
 578         wpas_notify_wps_event_fail(wpa_s, fail);
 579 #ifdef CONFIG_P2P
 580         wpas_p2p_wps_failed(wpa_s, fail);
 581 #endif /* CONFIG_P2P */
 582 }
 583
 584
 585 static void wpas_wps_reenable_networks_cb(void *eloop_ctx, void *timeout_ctx);
 586
 587 static void wpas_wps_reenable_networks(struct wpa_supplicant *wpa_s)
 588 {
 589         struct wpa_ssid *ssid;
 590         int changed = 0;
 591
 592         eloop_cancel_timeout(wpas_wps_reenable_networks_cb, wpa_s, NULL);
 593
 594         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
 595                 if (ssid->disabled_for_connect && ssid->disabled) {
 596                         ssid->disabled_for_connect = 0;
 597                         ssid->disabled = 0;
 598                         wpas_notify_network_enabled_changed(wpa_s, ssid);
 599                         changed++;
 600                 }
 601         }
 602
 603         if (changed) {
 604 #ifndef CONFIG_NO_CONFIG_WRITE
 605                 if (wpa_s->conf->update_config &&
 606                     wpa_config_write(wpa_s->confname, wpa_s->conf)) {
 607                         wpa_printf(MSG_DEBUG, "WPS: Failed to update "
 608                                    "configuration");
 609                 }
 610 #endif /* CONFIG_NO_CONFIG_WRITE */
 611         }
 612 }
 613
 614
 615 static void wpas_wps_reenable_networks_cb(void *eloop_ctx, void *timeout_ctx)
 616 {
 617         struct wpa_supplicant *wpa_s = eloop_ctx;
 618         /* Enable the networks disabled during wpas_wps_reassoc */
 619         wpas_wps_reenable_networks(wpa_s);
 620 }
 621
 622
 623 static void wpa_supplicant_wps_event_success(struct wpa_supplicant *wpa_s)
 624 {
 625         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_SUCCESS);
 626         wpa_s->wps_success = 1;
 627         wpas_notify_wps_event_success(wpa_s);
 628         if (wpa_s->current_ssid)
 629                 wpas_clear_temp_disabled(wpa_s, wpa_s->current_ssid, 1);
 630         wpa_s->extra_blacklist_count = 0;
 631
 632         /*
 633          * Enable the networks disabled during wpas_wps_reassoc after 10
 634          * seconds. The 10 seconds timer is to allow the data connection to be
 635          * formed before allowing other networks to be selected.
 636          */
 637         eloop_register_timeout(10, 0, wpas_wps_reenable_networks_cb, wpa_s,
 638                                NULL);
 639
 640 #ifdef CONFIG_P2P
 641         wpas_p2p_wps_success(wpa_s, wpa_s->bssid, 0);
 642 #endif /* CONFIG_P2P */
 643 }
 644
 645
 646 static void wpa_supplicant_wps_event_er_ap_add(struct wpa_supplicant *wpa_s,
 647                                                struct wps_event_er_ap *ap)
 648 {
 649         char uuid_str[100];
 650         char dev_type[WPS_DEV_TYPE_BUFSIZE];
 651
 652         uuid_bin2str(ap->uuid, uuid_str, sizeof(uuid_str));
 653         if (ap->pri_dev_type)
 654                 wps_dev_type_bin2str(ap->pri_dev_type, dev_type,
 655                                      sizeof(dev_type));
 656         else
 657                 dev_type[0] = '\0';
 658
 659         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ER_AP_ADD "%s " MACSTR
 660                 " pri_dev_type=%s wps_state=%d |%s|%s|%s|%s|%s|%s|",
 661                 uuid_str, MAC2STR(ap->mac_addr), dev_type, ap->wps_state,
 662                 ap->friendly_name ? ap->friendly_name : "",
 663                 ap->manufacturer ? ap->manufacturer : "",
 664                 ap->model_description ? ap->model_description : "",
 665                 ap->model_name ? ap->model_name : "",
 666                 ap->manufacturer_url ? ap->manufacturer_url : "",
 667                 ap->model_url ? ap->model_url : "");
 668 }
 669
 670
 671 static void wpa_supplicant_wps_event_er_ap_remove(struct wpa_supplicant *wpa_s,
 672                                                   struct wps_event_er_ap *ap)
 673 {
 674         char uuid_str[100];
 675         uuid_bin2str(ap->uuid, uuid_str, sizeof(uuid_str));
 676         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ER_AP_REMOVE "%s", uuid_str);
 677 }
 678
 679
 680 static void wpa_supplicant_wps_event_er_enrollee_add(
 681         struct wpa_supplicant *wpa_s, struct wps_event_er_enrollee *enrollee)
 682 {
 683         char uuid_str[100];
 684         char dev_type[WPS_DEV_TYPE_BUFSIZE];
 685
 686         uuid_bin2str(enrollee->uuid, uuid_str, sizeof(uuid_str));
 687         if (enrollee->pri_dev_type)
 688                 wps_dev_type_bin2str(enrollee->pri_dev_type, dev_type,
 689                                      sizeof(dev_type));
 690         else
 691                 dev_type[0] = '\0';
 692
 693         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ER_ENROLLEE_ADD "%s " MACSTR
 694                 " M1=%d config_methods=0x%x dev_passwd_id=%d pri_dev_type=%s "
 695                 "|%s|%s|%s|%s|%s|",
 696                 uuid_str, MAC2STR(enrollee->mac_addr), enrollee->m1_received,
 697                 enrollee->config_methods, enrollee->dev_passwd_id, dev_type,
 698                 enrollee->dev_name ? enrollee->dev_name : "",
 699                 enrollee->manufacturer ? enrollee->manufacturer : "",
 700                 enrollee->model_name ? enrollee->model_name : "",
 701                 enrollee->model_number ? enrollee->model_number : "",
 702                 enrollee->serial_number ? enrollee->serial_number : "");
 703 }
 704
 705
 706 static void wpa_supplicant_wps_event_er_enrollee_remove(
 707         struct wpa_supplicant *wpa_s, struct wps_event_er_enrollee *enrollee)
 708 {
 709         char uuid_str[100];
 710         uuid_bin2str(enrollee->uuid, uuid_str, sizeof(uuid_str));
 711         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ER_ENROLLEE_REMOVE "%s " MACSTR,
 712                 uuid_str, MAC2STR(enrollee->mac_addr));
 713 }
 714
 715
 716 static void wpa_supplicant_wps_event_er_ap_settings(
 717         struct wpa_supplicant *wpa_s,
 718         struct wps_event_er_ap_settings *ap_settings)
 719 {
 720         char uuid_str[100];
 721         char key_str[65];
 722         const struct wps_credential *cred = ap_settings->cred;
 723
 724         key_str[0] = '\0';
 725         if (cred->auth_type & (WPS_AUTH_WPAPSK | WPS_AUTH_WPA2PSK)) {
 726                 if (cred->key_len >= 8 && cred->key_len <= 64) {
 727                         os_memcpy(key_str, cred->key, cred->key_len);
 728                         key_str[cred->key_len] = '\0';
 729                 }
 730         }
 731
 732         uuid_bin2str(ap_settings->uuid, uuid_str, sizeof(uuid_str));
 733         /* Use wpa_msg_ctrl to avoid showing the key in debug log */
 734         wpa_msg_ctrl(wpa_s, MSG_INFO, WPS_EVENT_ER_AP_SETTINGS
 735                      "uuid=%s ssid=%s auth_type=0x%04x encr_type=0x%04x "
 736                      "key=%s",
 737                      uuid_str, wpa_ssid_txt(cred->ssid, cred->ssid_len),
 738                      cred->auth_type, cred->encr_type, key_str);
 739 }
 740
 741
 742 static void wpa_supplicant_wps_event_er_set_sel_reg(
 743         struct wpa_supplicant *wpa_s,
 744         struct wps_event_er_set_selected_registrar *ev)
 745 {
 746         char uuid_str[100];
 747
 748         uuid_bin2str(ev->uuid, uuid_str, sizeof(uuid_str));
 749         switch (ev->state) {
 750         case WPS_ER_SET_SEL_REG_START:
 751                 wpa_msg(wpa_s, MSG_DEBUG, WPS_EVENT_ER_SET_SEL_REG
 752                         "uuid=%s state=START sel_reg=%d dev_passwd_id=%u "
 753                         "sel_reg_config_methods=0x%x",
 754                         uuid_str, ev->sel_reg, ev->dev_passwd_id,
 755                         ev->sel_reg_config_methods);
 756                 break;
 757         case WPS_ER_SET_SEL_REG_DONE:
 758                 wpa_msg(wpa_s, MSG_DEBUG, WPS_EVENT_ER_SET_SEL_REG
 759                         "uuid=%s state=DONE", uuid_str);
 760                 break;
 761         case WPS_ER_SET_SEL_REG_FAILED:
 762                 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ER_SET_SEL_REG
 763                         "uuid=%s state=FAILED", uuid_str);
 764                 break;
 765         }
 766 }
 767
 768
 769 static void wpa_supplicant_wps_event(void *ctx, enum wps_event event,
 770                                      union wps_event_data *data)
 771 {
 772         struct wpa_supplicant *wpa_s = ctx;
 773         switch (event) {
 774         case WPS_EV_M2D:
 775                 wpa_supplicant_wps_event_m2d(wpa_s, &data->m2d);
 776                 break;
 777         case WPS_EV_FAIL:
 778                 wpa_supplicant_wps_event_fail(wpa_s, &data->fail);
 779                 break;
 780         case WPS_EV_SUCCESS:
 781                 wpa_supplicant_wps_event_success(wpa_s);
 782                 break;
 783         case WPS_EV_PWD_AUTH_FAIL:
 784 #ifdef CONFIG_AP
 785                 if (wpa_s->ap_iface && data->pwd_auth_fail.enrollee)
 786                         wpa_supplicant_ap_pwd_auth_fail(wpa_s);
 787 #endif /* CONFIG_AP */
 788                 break;
 789         case WPS_EV_PBC_OVERLAP:
 790                 break;
 791         case WPS_EV_PBC_TIMEOUT:
 792                 break;
 793         case WPS_EV_PBC_ACTIVE:
 794                 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_ACTIVE);
 795                 break;
 796         case WPS_EV_PBC_DISABLE:
 797                 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_DISABLE);
 798                 break;
 799         case WPS_EV_ER_AP_ADD:
 800                 wpa_supplicant_wps_event_er_ap_add(wpa_s, &data->ap);
 801                 break;
 802         case WPS_EV_ER_AP_REMOVE:
 803                 wpa_supplicant_wps_event_er_ap_remove(wpa_s, &data->ap);
 804                 break;
 805         case WPS_EV_ER_ENROLLEE_ADD:
 806                 wpa_supplicant_wps_event_er_enrollee_add(wpa_s,
 807                                                          &data->enrollee);
 808                 break;
 809         case WPS_EV_ER_ENROLLEE_REMOVE:
 810                 wpa_supplicant_wps_event_er_enrollee_remove(wpa_s,
 811                                                             &data->enrollee);
 812                 break;
 813         case WPS_EV_ER_AP_SETTINGS:
 814                 wpa_supplicant_wps_event_er_ap_settings(wpa_s,
 815                                                         &data->ap_settings);
 816                 break;
 817         case WPS_EV_ER_SET_SELECTED_REGISTRAR:
 818                 wpa_supplicant_wps_event_er_set_sel_reg(wpa_s,
 819                                                         &data->set_sel_reg);
 820                 break;
 821         case WPS_EV_AP_PIN_SUCCESS:
 822                 break;
 823         }
 824 }
 825
 826
 827 static int wpa_supplicant_wps_rf_band(void *ctx)
 828 {
 829         struct wpa_supplicant *wpa_s = ctx;
 830
 831         if (!wpa_s->current_ssid || !wpa_s->assoc_freq)
 832                 return 0;
 833
 834         return (wpa_s->assoc_freq > 2484) ? WPS_RF_50GHZ : WPS_RF_24GHZ;
 835 }
 836
 837
 838 enum wps_request_type wpas_wps_get_req_type(struct wpa_ssid *ssid)
 839 {
 840         if (eap_is_wps_pbc_enrollee(&ssid->eap) ||
 841             eap_is_wps_pin_enrollee(&ssid->eap))
 842                 return WPS_REQ_ENROLLEE;
 843         else
 844                 return WPS_REQ_REGISTRAR;
 845 }
 846
 847
 848 static void wpas_clear_wps(struct wpa_supplicant *wpa_s)
 849 {
 850         int id;
 851         struct wpa_ssid *ssid, *remove_ssid = NULL, *prev_current;
 852
 853         wpa_s->after_wps = 0;
 854         wpa_s->known_wps_freq = 0;
 855
 856         prev_current = wpa_s->current_ssid;
 857
 858         /* Enable the networks disabled during wpas_wps_reassoc */
 859         wpas_wps_reenable_networks(wpa_s);
 860
 861         eloop_cancel_timeout(wpas_wps_timeout, wpa_s, NULL);
 862         eloop_cancel_timeout(wpas_wps_clear_timeout, wpa_s, NULL);
 863
 864         /* Remove any existing WPS network from configuration */
 865         ssid = wpa_s->conf->ssid;
 866         while (ssid) {
 867                 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
 868                         if (ssid == wpa_s->current_ssid) {
 869                                 wpa_supplicant_deauthenticate(
 870                                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 871                         }
 872                         id = ssid->id;
 873                         remove_ssid = ssid;
 874                 } else
 875                         id = -1;
 876                 ssid = ssid->next;
 877                 if (id >= 0) {
 878                         if (prev_current == remove_ssid) {
 879                                 wpa_sm_set_config(wpa_s->wpa, NULL);
 880                                 eapol_sm_notify_config(wpa_s->eapol, NULL,
 881                                                        NULL);
 882                         }
 883                         wpas_notify_network_removed(wpa_s, remove_ssid);
 884                         wpa_config_remove_network(wpa_s->conf, id);
 885                 }
 886         }
 887
 888         wpas_wps_clear_ap_info(wpa_s);
 889 }
 890
 891
 892 static void wpas_wps_timeout(void *eloop_ctx, void *timeout_ctx)
 893 {
 894         struct wpa_supplicant *wpa_s = eloop_ctx;
 895         wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_TIMEOUT "Requested operation timed "
 896                 "out");
 897         wpas_clear_wps(wpa_s);
 898 }
 899
 900
 901 static struct wpa_ssid * wpas_wps_add_network(struct wpa_supplicant *wpa_s,
 902                                               int registrar, const u8 *dev_addr,
 903                                               const u8 *bssid)
 904 {
 905         struct wpa_ssid *ssid;
 906
 907         ssid = wpa_config_add_network(wpa_s->conf);
 908         if (ssid == NULL)
 909                 return NULL;
 910         wpas_notify_network_added(wpa_s, ssid);
 911         wpa_config_set_network_defaults(ssid);
 912         ssid->temporary = 1;
 913         if (wpa_config_set(ssid, "key_mgmt", "WPS", 0) < 0 ||
 914             wpa_config_set(ssid, "eap", "WSC", 0) < 0 ||
 915             wpa_config_set(ssid, "identity", registrar ?
 916                            "\"" WSC_ID_REGISTRAR "\"" :
 917                            "\"" WSC_ID_ENROLLEE "\"", 0) < 0) {
 918                 wpas_notify_network_removed(wpa_s, ssid);
 919                 wpa_config_remove_network(wpa_s->conf, ssid->id);
 920                 return NULL;
 921         }
 922
 923 #ifdef CONFIG_P2P
 924         if (dev_addr)
 925                 os_memcpy(ssid->go_p2p_dev_addr, dev_addr, ETH_ALEN);
 926 #endif /* CONFIG_P2P */
 927
 928         if (bssid) {
 929 #ifndef CONFIG_P2P
 930                 struct wpa_bss *bss;
 931                 int count = 0;
 932 #endif /* CONFIG_P2P */
 933
 934                 os_memcpy(ssid->bssid, bssid, ETH_ALEN);
 935                 ssid->bssid_set = 1;
 936
 937                 /*
 938                  * Note: With P2P, the SSID may change at the time the WPS
 939                  * provisioning is started, so better not filter the AP based
 940                  * on the current SSID in the scan results.
 941                  */
 942 #ifndef CONFIG_P2P
 943                 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
 944                         if (os_memcmp(bssid, bss->bssid, ETH_ALEN) != 0)
 945                                 continue;
 946
 947                         os_free(ssid->ssid);
 948                         ssid->ssid = os_malloc(bss->ssid_len);
 949                         if (ssid->ssid == NULL)
 950                                 break;
 951                         os_memcpy(ssid->ssid, bss->ssid, bss->ssid_len);
 952                         ssid->ssid_len = bss->ssid_len;
 953                         wpa_hexdump_ascii(MSG_DEBUG, "WPS: Picked SSID from "
 954                                           "scan results",
 955                                           ssid->ssid, ssid->ssid_len);
 956                         count++;
 957                 }
 958
 959                 if (count > 1) {
 960                         wpa_printf(MSG_DEBUG, "WPS: More than one SSID found "
 961                                    "for the AP; use wildcard");
 962                         os_free(ssid->ssid);
 963                         ssid->ssid = NULL;
 964                         ssid->ssid_len = 0;
 965                 }
 966 #endif /* CONFIG_P2P */
 967         }
 968
 969         return ssid;
 970 }
 971
 972
 973 static void wpas_wps_temp_disable(struct wpa_supplicant *wpa_s,
 974                                   struct wpa_ssid *selected)
 975 {
 976         struct wpa_ssid *ssid;
 977
 978         if (wpa_s->current_ssid)
 979                 wpa_supplicant_deauthenticate(
 980                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 981
 982         /* Mark all other networks disabled and trigger reassociation */
 983         ssid = wpa_s->conf->ssid;
 984         while (ssid) {
 985                 int was_disabled = ssid->disabled;
 986                 ssid->disabled_for_connect = 0;
 987                 /*
 988                  * In case the network object corresponds to a persistent group
 989                  * then do not send out network disabled signal. In addition,
 990                  * do not change disabled status of persistent network objects
 991                  * from 2 to 1 should we connect to another network.
 992                  */
 993                 if (was_disabled != 2) {
 994                         ssid->disabled = ssid != selected;
 995                         if (was_disabled != ssid->disabled) {
 996                                 if (ssid->disabled)
 997                                         ssid->disabled_for_connect = 1;
 998                                 wpas_notify_network_enabled_changed(wpa_s,
 999                                                                     ssid);
1000                         }
1001                 }
1002                 ssid = ssid->next;
1003         }
1004 }
1005
1006
1007 static void wpas_wps_reassoc(struct wpa_supplicant *wpa_s,
1008                              struct wpa_ssid *selected, const u8 *bssid,
1009                              int freq)
1010 {
1011         struct wpa_bss *bss;
1012
1013         wpa_s->after_wps = 0;
1014         wpa_s->known_wps_freq = 0;
1015         if (freq) {
1016                 wpa_s->after_wps = 5;
1017                 wpa_s->wps_freq = freq;
1018         } else if (bssid) {
1019                 bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
1020                 if (bss && bss->freq > 0) {
1021                         wpa_s->known_wps_freq = 1;
1022                         wpa_s->wps_freq = bss->freq;
1023                 }
1024         }
1025
1026         wpas_wps_temp_disable(wpa_s, selected);
1027
1028         wpa_s->disconnected = 0;
1029         wpa_s->reassociate = 1;
1030         wpa_s->scan_runs = 0;
1031         wpa_s->normal_scans = 0;
1032         wpa_s->wps_success = 0;
1033         wpa_s->blacklist_cleared = 0;
1034
1035         wpa_supplicant_cancel_sched_scan(wpa_s);
1036         wpa_supplicant_req_scan(wpa_s, 0, 0);
1037 }
1038
1039
1040 int wpas_wps_start_pbc(struct wpa_supplicant *wpa_s, const u8 *bssid,
1041                        int p2p_group)
1042 {
1043         struct wpa_ssid *ssid;
1044         wpas_clear_wps(wpa_s);
1045         ssid = wpas_wps_add_network(wpa_s, 0, NULL, bssid);
1046         if (ssid == NULL)
1047                 return -1;
1048         ssid->temporary = 1;
1049         ssid->p2p_group = p2p_group;
1050 #ifdef CONFIG_P2P
1051         if (p2p_group && wpa_s->go_params && wpa_s->go_params->ssid_len) {
1052                 ssid->ssid = os_zalloc(wpa_s->go_params->ssid_len + 1);
1053                 if (ssid->ssid) {
1054                         ssid->ssid_len = wpa_s->go_params->ssid_len;
1055                         os_memcpy(ssid->ssid, wpa_s->go_params->ssid,
1056                                   ssid->ssid_len);
1057                         wpa_hexdump_ascii(MSG_DEBUG, "WPS: Use specific AP "
1058                                           "SSID", ssid->ssid, ssid->ssid_len);
1059                 }
1060         }
1061 #endif /* CONFIG_P2P */
1062         if (wpa_config_set(ssid, "phase1", "\"pbc=1\"", 0) < 0)
1063                 return -1;
1064         if (wpa_s->wps_fragment_size)
1065                 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1066         eloop_register_timeout(WPS_PBC_WALK_TIME, 0, wpas_wps_timeout,
1067                                wpa_s, NULL);
1068         wpas_wps_reassoc(wpa_s, ssid, bssid, 0);
1069         return 0;
1070 }
1071
1072
1073 static int wpas_wps_start_dev_pw(struct wpa_supplicant *wpa_s,
1074                                  const u8 *dev_addr, const u8 *bssid,
1075                                  const char *pin, int p2p_group, u16 dev_pw_id,
1076                                  const u8 *peer_pubkey_hash,
1077                                  const u8 *ssid_val, size_t ssid_len, int freq)
1078 {
1079         struct wpa_ssid *ssid;
1080         char val[128 + 2 * WPS_OOB_PUBKEY_HASH_LEN];
1081         unsigned int rpin = 0;
1082         char hash[2 * WPS_OOB_PUBKEY_HASH_LEN + 10];
1083
1084         wpas_clear_wps(wpa_s);
1085         if (bssid && is_zero_ether_addr(bssid))
1086                 bssid = NULL;
1087         ssid = wpas_wps_add_network(wpa_s, 0, dev_addr, bssid);
1088         if (ssid == NULL) {
1089                 wpa_printf(MSG_DEBUG, "WPS: Could not add network");
1090                 return -1;
1091         }
1092         ssid->temporary = 1;
1093         ssid->p2p_group = p2p_group;
1094         if (ssid_val) {
1095                 ssid->ssid = os_malloc(ssid_len);
1096                 if (ssid->ssid) {
1097                         os_memcpy(ssid->ssid, ssid_val, ssid_len);
1098                         ssid->ssid_len = ssid_len;
1099                 }
1100         }
1101         if (peer_pubkey_hash) {
1102                 os_memcpy(hash, " pkhash=", 8);
1103                 wpa_snprintf_hex_uppercase(hash + 8, sizeof(hash) - 8,
1104                                            peer_pubkey_hash,
1105                                            WPS_OOB_PUBKEY_HASH_LEN);
1106         } else {
1107                 hash[0] = '\0';
1108         }
1109 #ifdef CONFIG_P2P
1110         if (p2p_group && wpa_s->go_params && wpa_s->go_params->ssid_len) {
1111                 ssid->ssid = os_zalloc(wpa_s->go_params->ssid_len + 1);
1112                 if (ssid->ssid) {
1113                         ssid->ssid_len = wpa_s->go_params->ssid_len;
1114                         os_memcpy(ssid->ssid, wpa_s->go_params->ssid,
1115                                   ssid->ssid_len);
1116                         wpa_hexdump_ascii(MSG_DEBUG, "WPS: Use specific AP "
1117                                           "SSID", ssid->ssid, ssid->ssid_len);
1118                 }
1119         }
1120 #endif /* CONFIG_P2P */
1121         if (pin)
1122                 os_snprintf(val, sizeof(val), "\"pin=%s dev_pw_id=%u%s\"",
1123                             pin, dev_pw_id, hash);
1124         else if (pin == NULL && dev_pw_id == DEV_PW_NFC_CONNECTION_HANDOVER) {
1125                 os_snprintf(val, sizeof(val), "\"dev_pw_id=%u%s\"",
1126                             dev_pw_id, hash);
1127         } else {
1128                 rpin = wps_generate_pin();
1129                 os_snprintf(val, sizeof(val), "\"pin=%08d dev_pw_id=%u%s\"",
1130                             rpin, dev_pw_id, hash);
1131         }
1132         if (wpa_config_set(ssid, "phase1", val, 0) < 0) {
1133                 wpa_printf(MSG_DEBUG, "WPS: Failed to set phase1 '%s'", val);
1134                 return -1;
1135         }
1136         if (wpa_s->wps_fragment_size)
1137                 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1138         eloop_register_timeout(WPS_PBC_WALK_TIME, 0, wpas_wps_timeout,
1139                                wpa_s, NULL);
1140         wpa_s->wps_ap_iter = 1;
1141         wpas_wps_reassoc(wpa_s, ssid, bssid, freq);
1142         return rpin;
1143 }
1144
1145
1146 int wpas_wps_start_pin(struct wpa_supplicant *wpa_s, const u8 *bssid,
1147                        const char *pin, int p2p_group, u16 dev_pw_id)
1148 {
1149         return wpas_wps_start_dev_pw(wpa_s, NULL, bssid, pin, p2p_group,
1150                                      dev_pw_id, NULL, NULL, 0, 0);
1151 }
1152
1153
1154 /* Cancel the wps pbc/pin requests */
1155 int wpas_wps_cancel(struct wpa_supplicant *wpa_s)
1156 {
1157 #ifdef CONFIG_AP
1158         if (wpa_s->ap_iface) {
1159                 wpa_printf(MSG_DEBUG, "WPS: Cancelling in AP mode");
1160                 return wpa_supplicant_ap_wps_cancel(wpa_s);
1161         }
1162 #endif /* CONFIG_AP */
1163
1164         if (wpa_s->wpa_state == WPA_SCANNING ||
1165             wpa_s->wpa_state == WPA_DISCONNECTED) {
1166                 wpa_printf(MSG_DEBUG, "WPS: Cancel operation - cancel scan");
1167                 wpa_supplicant_cancel_scan(wpa_s);
1168                 wpas_clear_wps(wpa_s);
1169         } else if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
1170                 wpa_printf(MSG_DEBUG, "WPS: Cancel operation - "
1171                            "deauthenticate");
1172                 wpa_supplicant_deauthenticate(wpa_s,
1173                                               WLAN_REASON_DEAUTH_LEAVING);
1174                 wpas_clear_wps(wpa_s);
1175         } else {
1176                 wpas_wps_reenable_networks(wpa_s);
1177                 wpas_wps_clear_ap_info(wpa_s);
1178                 if (eloop_cancel_timeout(wpas_wps_clear_timeout, wpa_s, NULL) >
1179                     0)
1180                         wpas_clear_wps(wpa_s);
1181         }
1182
1183         wpa_s->after_wps = 0;
1184
1185         return 0;
1186 }
1187
1188
1189 int wpas_wps_start_reg(struct wpa_supplicant *wpa_s, const u8 *bssid,
1190                        const char *pin, struct wps_new_ap_settings *settings)
1191 {
1192         struct wpa_ssid *ssid;
1193         char val[200];
1194         char *pos, *end;
1195         int res;
1196
1197         if (!pin)
1198                 return -1;
1199         wpas_clear_wps(wpa_s);
1200         ssid = wpas_wps_add_network(wpa_s, 1, NULL, bssid);
1201         if (ssid == NULL)
1202                 return -1;
1203         ssid->temporary = 1;
1204         pos = val;
1205         end = pos + sizeof(val);
1206         res = os_snprintf(pos, end - pos, "\"pin=%s", pin);
1207         if (res < 0 || res >= end - pos)
1208                 return -1;
1209         pos += res;
1210         if (settings) {
1211                 res = os_snprintf(pos, end - pos, " new_ssid=%s new_auth=%s "
1212                                   "new_encr=%s new_key=%s",
1213                                   settings->ssid_hex, settings->auth,
1214                                   settings->encr, settings->key_hex);
1215                 if (res < 0 || res >= end - pos)
1216                         return -1;
1217                 pos += res;
1218         }
1219         res = os_snprintf(pos, end - pos, "\"");
1220         if (res < 0 || res >= end - pos)
1221                 return -1;
1222         if (wpa_config_set(ssid, "phase1", val, 0) < 0)
1223                 return -1;
1224         if (wpa_s->wps_fragment_size)
1225                 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1226         eloop_register_timeout(WPS_PBC_WALK_TIME, 0, wpas_wps_timeout,
1227                                wpa_s, NULL);
1228         wpas_wps_reassoc(wpa_s, ssid, bssid, 0);
1229         return 0;
1230 }
1231
1232
1233 static int wpas_wps_new_psk_cb(void *ctx, const u8 *mac_addr,
1234                                const u8 *p2p_dev_addr, const u8 *psk,
1235                                size_t psk_len)
1236 {
1237         if (is_zero_ether_addr(p2p_dev_addr)) {
1238                 wpa_printf(MSG_DEBUG,
1239                            "Received new WPA/WPA2-PSK from WPS for STA " MACSTR,
1240                            MAC2STR(mac_addr));
1241         } else {
1242                 wpa_printf(MSG_DEBUG,
1243                            "Received new WPA/WPA2-PSK from WPS for STA " MACSTR
1244                            " P2P Device Addr " MACSTR,
1245                            MAC2STR(mac_addr), MAC2STR(p2p_dev_addr));
1246         }
1247         wpa_hexdump_key(MSG_DEBUG, "Per-device PSK", psk, psk_len);
1248
1249         /* TODO */
1250
1251         return 0;
1252 }
1253
1254
1255 static void wpas_wps_pin_needed_cb(void *ctx, const u8 *uuid_e,
1256                                    const struct wps_device_data *dev)
1257 {
1258         char uuid[40], txt[400];
1259         int len;
1260         char devtype[WPS_DEV_TYPE_BUFSIZE];
1261         if (uuid_bin2str(uuid_e, uuid, sizeof(uuid)))
1262                 return;
1263         wpa_printf(MSG_DEBUG, "WPS: PIN needed for UUID-E %s", uuid);
1264         len = os_snprintf(txt, sizeof(txt), "WPS-EVENT-PIN-NEEDED %s " MACSTR
1265                           " [%s|%s|%s|%s|%s|%s]",
1266                           uuid, MAC2STR(dev->mac_addr), dev->device_name,
1267                           dev->manufacturer, dev->model_name,
1268                           dev->model_number, dev->serial_number,
1269                           wps_dev_type_bin2str(dev->pri_dev_type, devtype,
1270                                                sizeof(devtype)));
1271         if (len > 0 && len < (int) sizeof(txt))
1272                 wpa_printf(MSG_INFO, "%s", txt);
1273 }
1274
1275
1276 static void wpas_wps_set_sel_reg_cb(void *ctx, int sel_reg, u16 dev_passwd_id,
1277                                     u16 sel_reg_config_methods)
1278 {
1279 #ifdef CONFIG_WPS_ER
1280         struct wpa_supplicant *wpa_s = ctx;
1281
1282         if (wpa_s->wps_er == NULL)
1283                 return;
1284         wpa_printf(MSG_DEBUG, "WPS ER: SetSelectedRegistrar - sel_reg=%d "
1285                    "dev_password_id=%u sel_reg_config_methods=0x%x",
1286                    sel_reg, dev_passwd_id, sel_reg_config_methods);
1287         wps_er_set_sel_reg(wpa_s->wps_er, sel_reg, dev_passwd_id,
1288                            sel_reg_config_methods);
1289 #endif /* CONFIG_WPS_ER */
1290 }
1291
1292
1293 static u16 wps_fix_config_methods(u16 config_methods)
1294 {
1295         if ((config_methods &
1296              (WPS_CONFIG_DISPLAY | WPS_CONFIG_VIRT_DISPLAY |
1297               WPS_CONFIG_PHY_DISPLAY)) == WPS_CONFIG_DISPLAY) {
1298                 wpa_printf(MSG_INFO, "WPS: Converting display to "
1299                            "virtual_display for WPS 2.0 compliance");
1300                 config_methods |= WPS_CONFIG_VIRT_DISPLAY;
1301         }
1302         if ((config_methods &
1303              (WPS_CONFIG_PUSHBUTTON | WPS_CONFIG_VIRT_PUSHBUTTON |
1304               WPS_CONFIG_PHY_PUSHBUTTON)) == WPS_CONFIG_PUSHBUTTON) {
1305                 wpa_printf(MSG_INFO, "WPS: Converting push_button to "
1306                            "virtual_push_button for WPS 2.0 compliance");
1307                 config_methods |= WPS_CONFIG_VIRT_PUSHBUTTON;
1308         }
1309
1310         return config_methods;
1311 }
1312
1313
1314 static void wpas_wps_set_uuid(struct wpa_supplicant *wpa_s,
1315                               struct wps_context *wps)
1316 {
1317         char buf[50];
1318         const char *src;
1319
1320         if (is_nil_uuid(wpa_s->conf->uuid)) {
1321                 struct wpa_supplicant *first;
1322                 first = wpa_s->global->ifaces;
1323                 while (first && first->next)
1324                         first = first->next;
1325                 if (first && first != wpa_s) {
1326                         if (wps != wpa_s->global->ifaces->wps)
1327                                 os_memcpy(wps->uuid,
1328                                           wpa_s->global->ifaces->wps->uuid,
1329                                           WPS_UUID_LEN);
1330                         src = "from the first interface";
1331                 } else {
1332                         uuid_gen_mac_addr(wpa_s->own_addr, wps->uuid);
1333                         src = "based on MAC address";
1334                 }
1335         } else {
1336                 os_memcpy(wps->uuid, wpa_s->conf->uuid, WPS_UUID_LEN);
1337                 src = "based on configuration";
1338         }
1339
1340         uuid_bin2str(wps->uuid, buf, sizeof(buf));
1341         wpa_dbg(wpa_s, MSG_DEBUG, "WPS: UUID %s: %s", src, buf);
1342 }
1343
1344
1345 static void wpas_wps_set_vendor_ext_m1(struct wpa_supplicant *wpa_s,
1346                                        struct wps_context *wps)
1347 {
1348         wpabuf_free(wps->dev.vendor_ext_m1);
1349         wps->dev.vendor_ext_m1 = NULL;
1350
1351         if (wpa_s->conf->wps_vendor_ext_m1) {
1352                 wps->dev.vendor_ext_m1 =
1353                         wpabuf_dup(wpa_s->conf->wps_vendor_ext_m1);
1354                 if (!wps->dev.vendor_ext_m1) {
1355                         wpa_printf(MSG_ERROR, "WPS: Cannot "
1356                                    "allocate memory for vendor_ext_m1");
1357                 }
1358         }
1359 }
1360
1361
1362 int wpas_wps_init(struct wpa_supplicant *wpa_s)
1363 {
1364         struct wps_context *wps;
1365         struct wps_registrar_config rcfg;
1366         struct hostapd_hw_modes *modes;
1367         u16 m;
1368
1369         wps = os_zalloc(sizeof(*wps));
1370         if (wps == NULL)
1371                 return -1;
1372
1373         wps->cred_cb = wpa_supplicant_wps_cred;
1374         wps->event_cb = wpa_supplicant_wps_event;
1375         wps->rf_band_cb = wpa_supplicant_wps_rf_band;
1376         wps->cb_ctx = wpa_s;
1377
1378         wps->dev.device_name = wpa_s->conf->device_name;
1379         wps->dev.manufacturer = wpa_s->conf->manufacturer;
1380         wps->dev.model_name = wpa_s->conf->model_name;
1381         wps->dev.model_number = wpa_s->conf->model_number;
1382         wps->dev.serial_number = wpa_s->conf->serial_number;
1383         wps->config_methods =
1384                 wps_config_methods_str2bin(wpa_s->conf->config_methods);
1385         if ((wps->config_methods & (WPS_CONFIG_DISPLAY | WPS_CONFIG_LABEL)) ==
1386             (WPS_CONFIG_DISPLAY | WPS_CONFIG_LABEL)) {
1387                 wpa_printf(MSG_ERROR, "WPS: Both Label and Display config "
1388                            "methods are not allowed at the same time");
1389                 os_free(wps);
1390                 return -1;
1391         }
1392         wps->config_methods = wps_fix_config_methods(wps->config_methods);
1393         wps->dev.config_methods = wps->config_methods;
1394         os_memcpy(wps->dev.pri_dev_type, wpa_s->conf->device_type,
1395                   WPS_DEV_TYPE_LEN);
1396
1397         wps->dev.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
1398         os_memcpy(wps->dev.sec_dev_type, wpa_s->conf->sec_device_type,
1399                   WPS_DEV_TYPE_LEN * wps->dev.num_sec_dev_types);
1400
1401         wpas_wps_set_vendor_ext_m1(wpa_s, wps);
1402
1403         wps->dev.os_version = WPA_GET_BE32(wpa_s->conf->os_version);
1404         modes = wpa_s->hw.modes;
1405         if (modes) {
1406                 for (m = 0; m < wpa_s->hw.num_modes; m++) {
1407                         if (modes[m].mode == HOSTAPD_MODE_IEEE80211B ||
1408                             modes[m].mode == HOSTAPD_MODE_IEEE80211G)
1409                                 wps->dev.rf_bands |= WPS_RF_24GHZ;
1410                         else if (modes[m].mode == HOSTAPD_MODE_IEEE80211A)
1411                                 wps->dev.rf_bands |= WPS_RF_50GHZ;
1412                 }
1413         }
1414         if (wps->dev.rf_bands == 0) {
1415                 /*
1416                  * Default to claiming support for both bands if the driver
1417                  * does not provide support for fetching supported bands.
1418                  */
1419                 wps->dev.rf_bands = WPS_RF_24GHZ | WPS_RF_50GHZ;
1420         }
1421         os_memcpy(wps->dev.mac_addr, wpa_s->own_addr, ETH_ALEN);
1422         wpas_wps_set_uuid(wpa_s, wps);
1423
1424         wps->auth_types = WPS_AUTH_WPA2PSK | WPS_AUTH_WPAPSK;
1425         wps->encr_types = WPS_ENCR_AES | WPS_ENCR_TKIP;
1426
1427         os_memset(&rcfg, 0, sizeof(rcfg));
1428         rcfg.new_psk_cb = wpas_wps_new_psk_cb;
1429         rcfg.pin_needed_cb = wpas_wps_pin_needed_cb;
1430         rcfg.set_sel_reg_cb = wpas_wps_set_sel_reg_cb;
1431         rcfg.cb_ctx = wpa_s;
1432
1433         wps->registrar = wps_registrar_init(wps, &rcfg);
1434         if (wps->registrar == NULL) {
1435                 wpa_printf(MSG_DEBUG, "Failed to initialize WPS Registrar");
1436                 os_free(wps);
1437                 return -1;
1438         }
1439
1440         wpa_s->wps = wps;
1441
1442         return 0;
1443 }
1444
1445
1446 #ifdef CONFIG_WPS_ER
1447 static void wpas_wps_nfc_clear(struct wps_context *wps)
1448 {
1449         wps->ap_nfc_dev_pw_id = 0;
1450         wpabuf_free(wps->ap_nfc_dh_pubkey);
1451         wps->ap_nfc_dh_pubkey = NULL;
1452         wpabuf_free(wps->ap_nfc_dh_privkey);
1453         wps->ap_nfc_dh_privkey = NULL;
1454         wpabuf_free(wps->ap_nfc_dev_pw);
1455         wps->ap_nfc_dev_pw = NULL;
1456 }
1457 #endif /* CONFIG_WPS_ER */
1458
1459
1460 void wpas_wps_deinit(struct wpa_supplicant *wpa_s)
1461 {
1462         wpas_wps_assoc_with_cred_cancel(wpa_s);
1463         eloop_cancel_timeout(wpas_wps_timeout, wpa_s, NULL);
1464         eloop_cancel_timeout(wpas_wps_clear_timeout, wpa_s, NULL);
1465         eloop_cancel_timeout(wpas_wps_reenable_networks_cb, wpa_s, NULL);
1466         wpas_wps_clear_ap_info(wpa_s);
1467
1468 #ifdef CONFIG_P2P
1469         eloop_cancel_timeout(wpas_p2p_pbc_overlap_cb, wpa_s, NULL);
1470 #endif /* CONFIG_P2P */
1471
1472         if (wpa_s->wps == NULL)
1473                 return;
1474
1475 #ifdef CONFIG_WPS_ER
1476         wps_er_deinit(wpa_s->wps_er, NULL, NULL);
1477         wpa_s->wps_er = NULL;
1478         wpas_wps_nfc_clear(wpa_s->wps);
1479 #endif /* CONFIG_WPS_ER */
1480
1481         wps_registrar_deinit(wpa_s->wps->registrar);
1482         wpabuf_free(wpa_s->wps->dh_pubkey);
1483         wpabuf_free(wpa_s->wps->dh_privkey);
1484         wpabuf_free(wpa_s->wps->dev.vendor_ext_m1);
1485         os_free(wpa_s->wps->network_key);
1486         os_free(wpa_s->wps);
1487         wpa_s->wps = NULL;
1488 }
1489
1490
1491 int wpas_wps_ssid_bss_match(struct wpa_supplicant *wpa_s,
1492                             struct wpa_ssid *ssid, struct wpa_bss *bss)
1493 {
1494         struct wpabuf *wps_ie;
1495
1496         if (!(ssid->key_mgmt & WPA_KEY_MGMT_WPS))
1497                 return -1;
1498
1499         wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1500         if (eap_is_wps_pbc_enrollee(&ssid->eap)) {
1501                 if (!wps_ie) {
1502                         wpa_printf(MSG_DEBUG, "   skip - non-WPS AP");
1503                         return 0;
1504                 }
1505
1506                 if (!wps_is_selected_pbc_registrar(wps_ie)) {
1507                         wpa_printf(MSG_DEBUG, "   skip - WPS AP "
1508                                    "without active PBC Registrar");
1509                         wpabuf_free(wps_ie);
1510                         return 0;
1511                 }
1512
1513                 /* TODO: overlap detection */
1514                 wpa_printf(MSG_DEBUG, "   selected based on WPS IE "
1515                            "(Active PBC)");
1516                 wpabuf_free(wps_ie);
1517                 return 1;
1518         }
1519
1520         if (eap_is_wps_pin_enrollee(&ssid->eap)) {
1521                 if (!wps_ie) {
1522                         wpa_printf(MSG_DEBUG, "   skip - non-WPS AP");
1523                         return 0;
1524                 }
1525
1526                 /*
1527                  * Start with WPS APs that advertise our address as an
1528                  * authorized MAC (v2.0) or active PIN Registrar (v1.0) and
1529                  * allow any WPS AP after couple of scans since some APs do not
1530                  * set Selected Registrar attribute properly when using
1531                  * external Registrar.
1532                  */
1533                 if (!wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1)) {
1534                         if (wpa_s->scan_runs < WPS_PIN_SCAN_IGNORE_SEL_REG) {
1535                                 wpa_printf(MSG_DEBUG, "   skip - WPS AP "
1536                                            "without active PIN Registrar");
1537                                 wpabuf_free(wps_ie);
1538                                 return 0;
1539                         }
1540                         wpa_printf(MSG_DEBUG, "   selected based on WPS IE");
1541                 } else {
1542                         wpa_printf(MSG_DEBUG, "   selected based on WPS IE "
1543                                    "(Authorized MAC or Active PIN)");
1544                 }
1545                 wpabuf_free(wps_ie);
1546                 return 1;
1547         }
1548
1549         if (wps_ie) {
1550                 wpa_printf(MSG_DEBUG, "   selected based on WPS IE");
1551                 wpabuf_free(wps_ie);
1552                 return 1;
1553         }
1554
1555         return -1;
1556 }
1557
1558
1559 int wpas_wps_ssid_wildcard_ok(struct wpa_supplicant *wpa_s,
1560                               struct wpa_ssid *ssid,
1561                               struct wpa_bss *bss)
1562 {
1563         struct wpabuf *wps_ie = NULL;
1564         int ret = 0;
1565
1566         if (eap_is_wps_pbc_enrollee(&ssid->eap)) {
1567                 wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1568                 if (wps_ie && wps_is_selected_pbc_registrar(wps_ie)) {
1569                         /* allow wildcard SSID for WPS PBC */
1570                         ret = 1;
1571                 }
1572         } else if (eap_is_wps_pin_enrollee(&ssid->eap)) {
1573                 wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1574                 if (wps_ie &&
1575                     (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1) ||
1576                      wpa_s->scan_runs >= WPS_PIN_SCAN_IGNORE_SEL_REG)) {
1577                         /* allow wildcard SSID for WPS PIN */
1578                         ret = 1;
1579                 }
1580         }
1581
1582         if (!ret && ssid->bssid_set &&
1583             os_memcmp(ssid->bssid, bss->bssid, ETH_ALEN) == 0) {
1584                 /* allow wildcard SSID due to hardcoded BSSID match */
1585                 ret = 1;
1586         }
1587
1588 #ifdef CONFIG_WPS_STRICT
1589         if (wps_ie) {
1590                 if (wps_validate_beacon_probe_resp(wps_ie, bss->beacon_ie_len >
1591                                                    0, bss->bssid) < 0)
1592                         ret = 0;
1593                 if (bss->beacon_ie_len) {
1594                         struct wpabuf *bcn_wps;
1595                         bcn_wps = wpa_bss_get_vendor_ie_multi_beacon(
1596                                 bss, WPS_IE_VENDOR_TYPE);
1597                         if (bcn_wps == NULL) {
1598                                 wpa_printf(MSG_DEBUG, "WPS: Mandatory WPS IE "
1599                                            "missing from AP Beacon");
1600                                 ret = 0;
1601                         } else {
1602                                 if (wps_validate_beacon(wps_ie) < 0)
1603                                         ret = 0;
1604                                 wpabuf_free(bcn_wps);
1605                         }
1606                 }
1607         }
1608 #endif /* CONFIG_WPS_STRICT */
1609
1610         wpabuf_free(wps_ie);
1611
1612         return ret;
1613 }
1614
1615
1616 int wpas_wps_scan_pbc_overlap(struct wpa_supplicant *wpa_s,
1617                               struct wpa_bss *selected, struct wpa_ssid *ssid)
1618 {
1619         const u8 *sel_uuid, *uuid;
1620         struct wpabuf *wps_ie;
1621         int ret = 0;
1622         struct wpa_bss *bss;
1623
1624         if (!eap_is_wps_pbc_enrollee(&ssid->eap))
1625                 return 0;
1626
1627         wpa_printf(MSG_DEBUG, "WPS: Check whether PBC session overlap is "
1628                    "present in scan results; selected BSSID " MACSTR,
1629                    MAC2STR(selected->bssid));
1630
1631         /* Make sure that only one AP is in active PBC mode */
1632         wps_ie = wpa_bss_get_vendor_ie_multi(selected, WPS_IE_VENDOR_TYPE);
1633         if (wps_ie) {
1634                 sel_uuid = wps_get_uuid_e(wps_ie);
1635                 wpa_hexdump(MSG_DEBUG, "WPS: UUID of the selected BSS",
1636                             sel_uuid, UUID_LEN);
1637         } else {
1638                 wpa_printf(MSG_DEBUG, "WPS: Selected BSS does not include "
1639                            "WPS IE?!");
1640                 sel_uuid = NULL;
1641         }
1642
1643         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1644                 struct wpabuf *ie;
1645                 if (bss == selected)
1646                         continue;
1647                 ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1648                 if (!ie)
1649                         continue;
1650                 if (!wps_is_selected_pbc_registrar(ie)) {
1651                         wpabuf_free(ie);
1652                         continue;
1653                 }
1654                 wpa_printf(MSG_DEBUG, "WPS: Another BSS in active PBC mode: "
1655                            MACSTR, MAC2STR(bss->bssid));
1656                 uuid = wps_get_uuid_e(ie);
1657                 wpa_hexdump(MSG_DEBUG, "WPS: UUID of the other BSS",
1658                             uuid, UUID_LEN);
1659                 if (sel_uuid == NULL || uuid == NULL ||
1660                     os_memcmp(sel_uuid, uuid, UUID_LEN) != 0) {
1661                         ret = 1; /* PBC overlap */
1662                         wpa_msg(wpa_s, MSG_INFO, "WPS: PBC overlap detected: "
1663                                 MACSTR " and " MACSTR,
1664                                 MAC2STR(selected->bssid),
1665                                 MAC2STR(bss->bssid));
1666                         wpabuf_free(ie);
1667                         break;
1668                 }
1669
1670                 /* TODO: verify that this is reasonable dual-band situation */
1671
1672                 wpabuf_free(ie);
1673         }
1674
1675         wpabuf_free(wps_ie);
1676
1677         return ret;
1678 }
1679
1680
1681 void wpas_wps_notify_scan_results(struct wpa_supplicant *wpa_s)
1682 {
1683         struct wpa_bss *bss;
1684         unsigned int pbc = 0, auth = 0, pin = 0, wps = 0;
1685
1686         if (wpa_s->disconnected || wpa_s->wpa_state >= WPA_ASSOCIATED)
1687                 return;
1688
1689         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1690                 struct wpabuf *ie;
1691                 ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1692                 if (!ie)
1693                         continue;
1694                 if (wps_is_selected_pbc_registrar(ie))
1695                         pbc++;
1696                 else if (wps_is_addr_authorized(ie, wpa_s->own_addr, 0))
1697                         auth++;
1698                 else if (wps_is_selected_pin_registrar(ie))
1699                         pin++;
1700                 else
1701                         wps++;
1702                 wpabuf_free(ie);
1703         }
1704
1705         if (pbc)
1706                 wpa_msg_ctrl(wpa_s, MSG_INFO, WPS_EVENT_AP_AVAILABLE_PBC);
1707         else if (auth)
1708                 wpa_msg_ctrl(wpa_s, MSG_INFO, WPS_EVENT_AP_AVAILABLE_AUTH);
1709         else if (pin)
1710                 wpa_msg_ctrl(wpa_s, MSG_INFO, WPS_EVENT_AP_AVAILABLE_PIN);
1711         else if (wps)
1712                 wpa_msg_ctrl(wpa_s, MSG_INFO, WPS_EVENT_AP_AVAILABLE);
1713 }
1714
1715
1716 int wpas_wps_searching(struct wpa_supplicant *wpa_s)
1717 {
1718         struct wpa_ssid *ssid;
1719
1720         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1721                 if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && !ssid->disabled)
1722                         return 1;
1723         }
1724
1725         return 0;
1726 }
1727
1728
1729 int wpas_wps_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
1730                               char *end)
1731 {
1732         struct wpabuf *wps_ie;
1733         int ret;
1734
1735         wps_ie = ieee802_11_vendor_ie_concat(ies, ies_len, WPS_DEV_OUI_WFA);
1736         if (wps_ie == NULL)
1737                 return 0;
1738
1739         ret = wps_attr_text(wps_ie, buf, end);
1740         wpabuf_free(wps_ie);
1741         return ret;
1742 }
1743
1744
1745 int wpas_wps_er_start(struct wpa_supplicant *wpa_s, const char *filter)
1746 {
1747 #ifdef CONFIG_WPS_ER
1748         if (wpa_s->wps_er) {
1749                 wps_er_refresh(wpa_s->wps_er);
1750                 return 0;
1751         }
1752         wpa_s->wps_er = wps_er_init(wpa_s->wps, wpa_s->ifname, filter);
1753         if (wpa_s->wps_er == NULL)
1754                 return -1;
1755         return 0;
1756 #else /* CONFIG_WPS_ER */
1757         return 0;
1758 #endif /* CONFIG_WPS_ER */
1759 }
1760
1761
1762 int wpas_wps_er_stop(struct wpa_supplicant *wpa_s)
1763 {
1764 #ifdef CONFIG_WPS_ER
1765         wps_er_deinit(wpa_s->wps_er, NULL, NULL);
1766         wpa_s->wps_er = NULL;
1767 #endif /* CONFIG_WPS_ER */
1768         return 0;
1769 }
1770
1771
1772 #ifdef CONFIG_WPS_ER
1773 int wpas_wps_er_add_pin(struct wpa_supplicant *wpa_s, const u8 *addr,
1774                         const char *uuid, const char *pin)
1775 {
1776         u8 u[UUID_LEN];
1777         const u8 *use_uuid = NULL;
1778         u8 addr_buf[ETH_ALEN];
1779
1780         if (os_strcmp(uuid, "any") == 0) {
1781         } else if (uuid_str2bin(uuid, u) == 0) {
1782                 use_uuid = u;
1783         } else if (hwaddr_aton(uuid, addr_buf) == 0) {
1784                 use_uuid = wps_er_get_sta_uuid(wpa_s->wps_er, addr_buf);
1785                 if (use_uuid == NULL)
1786                         return -1;
1787         } else
1788                 return -1;
1789         return wps_registrar_add_pin(wpa_s->wps->registrar, addr,
1790                                      use_uuid,
1791                                      (const u8 *) pin, os_strlen(pin), 300);
1792 }
1793
1794
1795 int wpas_wps_er_pbc(struct wpa_supplicant *wpa_s, const char *uuid)
1796 {
1797         u8 u[UUID_LEN], *use_uuid = NULL;
1798         u8 addr[ETH_ALEN], *use_addr = NULL;
1799
1800         if (uuid_str2bin(uuid, u) == 0)
1801                 use_uuid = u;
1802         else if (hwaddr_aton(uuid, addr) == 0)
1803                 use_addr = addr;
1804         else
1805                 return -1;
1806         return wps_er_pbc(wpa_s->wps_er, use_uuid, use_addr);
1807 }
1808
1809
1810 int wpas_wps_er_learn(struct wpa_supplicant *wpa_s, const char *uuid,
1811                       const char *pin)
1812 {
1813         u8 u[UUID_LEN], *use_uuid = NULL;
1814         u8 addr[ETH_ALEN], *use_addr = NULL;
1815
1816         if (uuid_str2bin(uuid, u) == 0)
1817                 use_uuid = u;
1818         else if (hwaddr_aton(uuid, addr) == 0)
1819                 use_addr = addr;
1820         else
1821                 return -1;
1822
1823         return wps_er_learn(wpa_s->wps_er, use_uuid, use_addr, (const u8 *) pin,
1824                             os_strlen(pin));
1825 }
1826
1827
1828 static int wpas_wps_network_to_cred(struct wpa_ssid *ssid,
1829                                     struct wps_credential *cred)
1830 {
1831         os_memset(cred, 0, sizeof(*cred));
1832         if (ssid->ssid_len > 32)
1833                 return -1;
1834         os_memcpy(cred->ssid, ssid->ssid, ssid->ssid_len);
1835         cred->ssid_len = ssid->ssid_len;
1836         if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
1837                 cred->auth_type = (ssid->proto & WPA_PROTO_RSN) ?
1838                         WPS_AUTH_WPA2PSK : WPS_AUTH_WPAPSK;
1839                 if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)
1840                         cred->encr_type = WPS_ENCR_AES;
1841                 else
1842                         cred->encr_type = WPS_ENCR_TKIP;
1843                 if (ssid->passphrase) {
1844                         cred->key_len = os_strlen(ssid->passphrase);
1845                         if (cred->key_len >= 64)
1846                                 return -1;
1847                         os_memcpy(cred->key, ssid->passphrase, cred->key_len);
1848                 } else if (ssid->psk_set) {
1849                         cred->key_len = 32;
1850                         os_memcpy(cred->key, ssid->psk, 32);
1851                 } else
1852                         return -1;
1853         } else {
1854                 cred->auth_type = WPS_AUTH_OPEN;
1855                 cred->encr_type = WPS_ENCR_NONE;
1856         }
1857
1858         return 0;
1859 }
1860
1861
1862 int wpas_wps_er_set_config(struct wpa_supplicant *wpa_s, const char *uuid,
1863                            int id)
1864 {
1865         u8 u[UUID_LEN], *use_uuid = NULL;
1866         u8 addr[ETH_ALEN], *use_addr = NULL;
1867         struct wpa_ssid *ssid;
1868         struct wps_credential cred;
1869
1870         if (uuid_str2bin(uuid, u) == 0)
1871                 use_uuid = u;
1872         else if (hwaddr_aton(uuid, addr) == 0)
1873                 use_addr = addr;
1874         else
1875                 return -1;
1876         ssid = wpa_config_get_network(wpa_s->conf, id);
1877         if (ssid == NULL || ssid->ssid == NULL)
1878                 return -1;
1879
1880         if (wpas_wps_network_to_cred(ssid, &cred) < 0)
1881                 return -1;
1882         return wps_er_set_config(wpa_s->wps_er, use_uuid, use_addr, &cred);
1883 }
1884
1885
1886 int wpas_wps_er_config(struct wpa_supplicant *wpa_s, const char *uuid,
1887                        const char *pin, struct wps_new_ap_settings *settings)
1888 {
1889         u8 u[UUID_LEN], *use_uuid = NULL;
1890         u8 addr[ETH_ALEN], *use_addr = NULL;
1891         struct wps_credential cred;
1892         size_t len;
1893
1894         if (uuid_str2bin(uuid, u) == 0)
1895                 use_uuid = u;
1896         else if (hwaddr_aton(uuid, addr) == 0)
1897                 use_addr = addr;
1898         else
1899                 return -1;
1900         if (settings->ssid_hex == NULL || settings->auth == NULL ||
1901             settings->encr == NULL || settings->key_hex == NULL)
1902                 return -1;
1903
1904         os_memset(&cred, 0, sizeof(cred));
1905         len = os_strlen(settings->ssid_hex);
1906         if ((len & 1) || len > 2 * sizeof(cred.ssid) ||
1907             hexstr2bin(settings->ssid_hex, cred.ssid, len / 2))
1908                 return -1;
1909         cred.ssid_len = len / 2;
1910
1911         len = os_strlen(settings->key_hex);
1912         if ((len & 1) || len > 2 * sizeof(cred.key) ||
1913             hexstr2bin(settings->key_hex, cred.key, len / 2))
1914                 return -1;
1915         cred.key_len = len / 2;
1916
1917         if (os_strcmp(settings->auth, "OPEN") == 0)
1918                 cred.auth_type = WPS_AUTH_OPEN;
1919         else if (os_strcmp(settings->auth, "WPAPSK") == 0)
1920                 cred.auth_type = WPS_AUTH_WPAPSK;
1921         else if (os_strcmp(settings->auth, "WPA2PSK") == 0)
1922                 cred.auth_type = WPS_AUTH_WPA2PSK;
1923         else
1924                 return -1;
1925
1926         if (os_strcmp(settings->encr, "NONE") == 0)
1927                 cred.encr_type = WPS_ENCR_NONE;
1928 #ifdef CONFIG_TESTING_OPTIONS
1929         else if (os_strcmp(settings->encr, "WEP") == 0)
1930                 cred.encr_type = WPS_ENCR_WEP;
1931 #endif /* CONFIG_TESTING_OPTIONS */
1932         else if (os_strcmp(settings->encr, "TKIP") == 0)
1933                 cred.encr_type = WPS_ENCR_TKIP;
1934         else if (os_strcmp(settings->encr, "CCMP") == 0)
1935                 cred.encr_type = WPS_ENCR_AES;
1936         else
1937                 return -1;
1938
1939         return wps_er_config(wpa_s->wps_er, use_uuid, use_addr,
1940                              (const u8 *) pin, os_strlen(pin), &cred);
1941 }
1942
1943
1944 #ifdef CONFIG_WPS_NFC
1945 struct wpabuf * wpas_wps_er_nfc_config_token(struct wpa_supplicant *wpa_s,
1946                                              int ndef, const char *uuid)
1947 {
1948         struct wpabuf *ret;
1949         u8 u[UUID_LEN], *use_uuid = NULL;
1950         u8 addr[ETH_ALEN], *use_addr = NULL;
1951
1952         if (!wpa_s->wps_er)
1953                 return NULL;
1954
1955         if (uuid_str2bin(uuid, u) == 0)
1956                 use_uuid = u;
1957         else if (hwaddr_aton(uuid, addr) == 0)
1958                 use_addr = addr;
1959         else
1960                 return NULL;
1961
1962         ret = wps_er_nfc_config_token(wpa_s->wps_er, use_uuid, use_addr);
1963         if (ndef && ret) {
1964                 struct wpabuf *tmp;
1965                 tmp = ndef_build_wifi(ret);
1966                 wpabuf_free(ret);
1967                 if (tmp == NULL)
1968                         return NULL;
1969                 ret = tmp;
1970         }
1971
1972         return ret;
1973 }
1974 #endif /* CONFIG_WPS_NFC */
1975
1976
1977 static int callbacks_pending = 0;
1978
1979 static void wpas_wps_terminate_cb(void *ctx)
1980 {
1981         wpa_printf(MSG_DEBUG, "WPS ER: Terminated");
1982         if (--callbacks_pending <= 0)
1983                 eloop_terminate();
1984 }
1985 #endif /* CONFIG_WPS_ER */
1986
1987
1988 int wpas_wps_terminate_pending(struct wpa_supplicant *wpa_s)
1989 {
1990 #ifdef CONFIG_WPS_ER
1991         if (wpa_s->wps_er) {
1992                 callbacks_pending++;
1993                 wps_er_deinit(wpa_s->wps_er, wpas_wps_terminate_cb, wpa_s);
1994                 wpa_s->wps_er = NULL;
1995                 return 1;
1996         }
1997 #endif /* CONFIG_WPS_ER */
1998         return 0;
1999 }
2000
2001
2002 void wpas_wps_update_config(struct wpa_supplicant *wpa_s)
2003 {
2004         struct wps_context *wps = wpa_s->wps;
2005
2006         if (wps == NULL)
2007                 return;
2008
2009         if (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS) {
2010                 wps->config_methods = wps_config_methods_str2bin(
2011                         wpa_s->conf->config_methods);
2012                 if ((wps->config_methods &
2013                      (WPS_CONFIG_DISPLAY | WPS_CONFIG_LABEL)) ==
2014                     (WPS_CONFIG_DISPLAY | WPS_CONFIG_LABEL)) {
2015                         wpa_printf(MSG_ERROR, "WPS: Both Label and Display "
2016                                    "config methods are not allowed at the "
2017                                    "same time");
2018                         wps->config_methods &= ~WPS_CONFIG_LABEL;
2019                 }
2020         }
2021         wps->config_methods = wps_fix_config_methods(wps->config_methods);
2022         wps->dev.config_methods = wps->config_methods;
2023
2024         if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
2025                 os_memcpy(wps->dev.pri_dev_type, wpa_s->conf->device_type,
2026                           WPS_DEV_TYPE_LEN);
2027
2028         if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE) {
2029                 wps->dev.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
2030                 os_memcpy(wps->dev.sec_dev_type, wpa_s->conf->sec_device_type,
2031                           wps->dev.num_sec_dev_types * WPS_DEV_TYPE_LEN);
2032         }
2033
2034         if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION)
2035                 wpas_wps_set_vendor_ext_m1(wpa_s, wps);
2036
2037         if (wpa_s->conf->changed_parameters & CFG_CHANGED_OS_VERSION)
2038                 wps->dev.os_version = WPA_GET_BE32(wpa_s->conf->os_version);
2039
2040         if (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID)
2041                 wpas_wps_set_uuid(wpa_s, wps);
2042
2043         if (wpa_s->conf->changed_parameters &
2044             (CFG_CHANGED_DEVICE_NAME | CFG_CHANGED_WPS_STRING)) {
2045                 /* Update pointers to make sure they refer current values */
2046                 wps->dev.device_name = wpa_s->conf->device_name;
2047                 wps->dev.manufacturer = wpa_s->conf->manufacturer;
2048                 wps->dev.model_name = wpa_s->conf->model_name;
2049                 wps->dev.model_number = wpa_s->conf->model_number;
2050                 wps->dev.serial_number = wpa_s->conf->serial_number;
2051         }
2052 }
2053
2054
2055 #ifdef CONFIG_WPS_NFC
2056
2057 #ifdef CONFIG_WPS_ER
2058 static struct wpabuf *
2059 wpas_wps_network_config_token(struct wpa_supplicant *wpa_s, int ndef,
2060                               struct wpa_ssid *ssid)
2061 {
2062         struct wpabuf *ret;
2063         struct wps_credential cred;
2064
2065         if (wpas_wps_network_to_cred(ssid, &cred) < 0)
2066                 return NULL;
2067
2068         ret = wps_er_config_token_from_cred(wpa_s->wps, &cred);
2069
2070         if (ndef && ret) {
2071                 struct wpabuf *tmp;
2072                 tmp = ndef_build_wifi(ret);
2073                 wpabuf_free(ret);
2074                 if (tmp == NULL)
2075                         return NULL;
2076                 ret = tmp;
2077         }
2078
2079         return ret;
2080 }
2081 #endif /* CONFIG_WPS_ER */
2082
2083
2084 struct wpabuf * wpas_wps_nfc_config_token(struct wpa_supplicant *wpa_s,
2085                                           int ndef, const char *id_str)
2086 {
2087 #ifdef CONFIG_WPS_ER
2088         if (id_str) {
2089                 int id;
2090                 char *end = NULL;
2091                 struct wpa_ssid *ssid;
2092
2093                 id = strtol(id_str, &end, 10);
2094                 if (end && *end)
2095                         return NULL;
2096
2097                 ssid = wpa_config_get_network(wpa_s->conf, id);
2098                 if (ssid == NULL)
2099                         return NULL;
2100                 return wpas_wps_network_config_token(wpa_s, ndef, ssid);
2101         }
2102 #endif /* CONFIG_WPS_ER */
2103 #ifdef CONFIG_AP
2104         if (wpa_s->ap_iface)
2105                 return wpas_ap_wps_nfc_config_token(wpa_s, ndef);
2106 #endif /* CONFIG_AP */
2107         return NULL;
2108 }
2109
2110
2111 struct wpabuf * wpas_wps_nfc_token(struct wpa_supplicant *wpa_s, int ndef)
2112 {
2113         if (wpa_s->conf->wps_nfc_pw_from_config) {
2114                 return wps_nfc_token_build(ndef,
2115                                            wpa_s->conf->wps_nfc_dev_pw_id,
2116                                            wpa_s->conf->wps_nfc_dh_pubkey,
2117                                            wpa_s->conf->wps_nfc_dev_pw);
2118         }
2119
2120         return wps_nfc_token_gen(ndef, &wpa_s->conf->wps_nfc_dev_pw_id,
2121                                  &wpa_s->conf->wps_nfc_dh_pubkey,
2122                                  &wpa_s->conf->wps_nfc_dh_privkey,
2123                                  &wpa_s->conf->wps_nfc_dev_pw);
2124 }
2125
2126
2127 int wpas_wps_start_nfc(struct wpa_supplicant *wpa_s, const u8 *go_dev_addr,
2128                        const u8 *bssid,
2129                        const struct wpabuf *dev_pw, u16 dev_pw_id,
2130                        int p2p_group, const u8 *peer_pubkey_hash,
2131                        const u8 *ssid, size_t ssid_len, int freq)
2132 {
2133         struct wps_context *wps = wpa_s->wps;
2134         char pw[32 * 2 + 1];
2135
2136         if (dev_pw_id != DEV_PW_NFC_CONNECTION_HANDOVER && dev_pw == NULL) {
2137                 dev_pw = wpa_s->conf->wps_nfc_dev_pw;
2138                 dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
2139         }
2140
2141         if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
2142             wpa_s->conf->wps_nfc_dh_privkey == NULL) {
2143                 wpa_printf(MSG_DEBUG, "WPS: Missing DH params - "
2144                            "cannot start NFC-triggered connection");
2145                 return -1;
2146         }
2147
2148         if (dev_pw_id != DEV_PW_NFC_CONNECTION_HANDOVER && dev_pw == NULL) {
2149                 wpa_printf(MSG_DEBUG, "WPS: Missing Device Password (id=%u) - "
2150                            "cannot start NFC-triggered connection", dev_pw_id);
2151                 return -1;
2152         }
2153
2154         dh5_free(wps->dh_ctx);
2155         wpabuf_free(wps->dh_pubkey);
2156         wpabuf_free(wps->dh_privkey);
2157         wps->dh_privkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
2158         wps->dh_pubkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
2159         if (wps->dh_privkey == NULL || wps->dh_pubkey == NULL) {
2160                 wps->dh_ctx = NULL;
2161                 wpabuf_free(wps->dh_pubkey);
2162                 wps->dh_pubkey = NULL;
2163                 wpabuf_free(wps->dh_privkey);
2164                 wps->dh_privkey = NULL;
2165                 wpa_printf(MSG_DEBUG, "WPS: Failed to get DH priv/pub key");
2166                 return -1;
2167         }
2168         wps->dh_ctx = dh5_init_fixed(wps->dh_privkey, wps->dh_pubkey);
2169         if (wps->dh_ctx == NULL) {
2170                 wpabuf_free(wps->dh_pubkey);
2171                 wps->dh_pubkey = NULL;
2172                 wpabuf_free(wps->dh_privkey);
2173                 wps->dh_privkey = NULL;
2174                 wpa_printf(MSG_DEBUG, "WPS: Failed to initialize DH context");
2175                 return -1;
2176         }
2177
2178         if (dev_pw) {
2179                 wpa_snprintf_hex_uppercase(pw, sizeof(pw),
2180                                            wpabuf_head(dev_pw),
2181                                            wpabuf_len(dev_pw));
2182         }
2183         return wpas_wps_start_dev_pw(wpa_s, go_dev_addr, bssid,
2184                                      dev_pw ? pw : NULL,
2185                                      p2p_group, dev_pw_id, peer_pubkey_hash,
2186                                      ssid, ssid_len, freq);
2187 }
2188
2189
2190 static int wpas_wps_use_cred(struct wpa_supplicant *wpa_s,
2191                              struct wps_parse_attr *attr)
2192 {
2193         /*
2194          * Disable existing networks temporarily to allow the newly learned
2195          * credential to be preferred. Enable the temporarily disabled networks
2196          * after 10 seconds.
2197          */
2198         wpas_wps_temp_disable(wpa_s, NULL);
2199         eloop_register_timeout(10, 0, wpas_wps_reenable_networks_cb, wpa_s,
2200                                NULL);
2201
2202         if (wps_oob_use_cred(wpa_s->wps, attr) < 0)
2203                 return -1;
2204
2205         if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
2206                 return 0;
2207
2208         if (attr->ap_channel) {
2209                 u16 chan = WPA_GET_BE16(attr->ap_channel);
2210                 int freq = 0;
2211
2212                 if (chan >= 1 && chan <= 13)
2213                         freq = 2407 + 5 * chan;
2214                 else if (chan == 14)
2215                         freq = 2484;
2216                 else if (chan >= 30)
2217                         freq = 5000 + 5 * chan;
2218
2219                 if (freq) {
2220                         wpa_printf(MSG_DEBUG, "WPS: Credential container indicated AP channel %u -> %u MHz",
2221                                    chan, freq);
2222                         wpa_s->after_wps = 5;
2223                         wpa_s->wps_freq = freq;
2224                 }
2225         }
2226
2227         wpa_printf(MSG_DEBUG, "WPS: Request reconnection with new network "
2228                    "based on the received credential added");
2229         wpa_s->normal_scans = 0;
2230         wpa_supplicant_reinit_autoscan(wpa_s);
2231         wpa_s->disconnected = 0;
2232         wpa_s->reassociate = 1;
2233
2234         wpa_supplicant_cancel_sched_scan(wpa_s);
2235         wpa_supplicant_req_scan(wpa_s, 0, 0);
2236
2237         return 0;
2238 }
2239
2240
2241 #ifdef CONFIG_WPS_ER
2242 static int wpas_wps_add_nfc_password_token(struct wpa_supplicant *wpa_s,
2243                                            struct wps_parse_attr *attr)
2244 {
2245         return wps_registrar_add_nfc_password_token(
2246                 wpa_s->wps->registrar, attr->oob_dev_password,
2247                 attr->oob_dev_password_len);
2248 }
2249 #endif /* CONFIG_WPS_ER */
2250
2251
2252 static int wpas_wps_nfc_tag_process(struct wpa_supplicant *wpa_s,
2253                                     const struct wpabuf *wps)
2254 {
2255         struct wps_parse_attr attr;
2256
2257         wpa_hexdump_buf(MSG_DEBUG, "WPS: Received NFC tag payload", wps);
2258
2259         if (wps_parse_msg(wps, &attr)) {
2260                 wpa_printf(MSG_DEBUG, "WPS: Ignore invalid data from NFC tag");
2261                 return -1;
2262         }
2263
2264         if (attr.num_cred)
2265                 return wpas_wps_use_cred(wpa_s, &attr);
2266
2267 #ifdef CONFIG_WPS_ER
2268         if (attr.oob_dev_password)
2269                 return wpas_wps_add_nfc_password_token(wpa_s, &attr);
2270 #endif /* CONFIG_WPS_ER */
2271
2272         wpa_printf(MSG_DEBUG, "WPS: Ignore unrecognized NFC tag");
2273         return -1;
2274 }
2275
2276
2277 int wpas_wps_nfc_tag_read(struct wpa_supplicant *wpa_s,
2278                           const struct wpabuf *data, int forced_freq)
2279 {
2280         const struct wpabuf *wps = data;
2281         struct wpabuf *tmp = NULL;
2282         int ret;
2283
2284         if (wpabuf_len(data) < 4)
2285                 return -1;
2286
2287         if (*wpabuf_head_u8(data) != 0x10) {
2288                 /* Assume this contains full NDEF record */
2289                 tmp = ndef_parse_wifi(data);
2290                 if (tmp == NULL) {
2291 #ifdef CONFIG_P2P
2292                         tmp = ndef_parse_p2p(data);
2293                         if (tmp) {
2294                                 ret = wpas_p2p_nfc_tag_process(wpa_s, tmp,
2295                                                                forced_freq);
2296                                 wpabuf_free(tmp);
2297                                 return ret;
2298                         }
2299 #endif /* CONFIG_P2P */
2300                         wpa_printf(MSG_DEBUG, "WPS: Could not parse NDEF");
2301                         return -1;
2302                 }
2303                 wps = tmp;
2304         }
2305
2306         ret = wpas_wps_nfc_tag_process(wpa_s, wps);
2307         wpabuf_free(tmp);
2308         return ret;
2309 }
2310
2311
2312 struct wpabuf * wpas_wps_nfc_handover_req(struct wpa_supplicant *wpa_s,
2313                                           int ndef)
2314 {
2315         struct wpabuf *ret;
2316
2317         if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
2318             wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
2319                            &wpa_s->conf->wps_nfc_dh_privkey) < 0)
2320                 return NULL;
2321
2322         ret = wps_build_nfc_handover_req(wpa_s->wps,
2323                                          wpa_s->conf->wps_nfc_dh_pubkey);
2324
2325         if (ndef && ret) {
2326                 struct wpabuf *tmp;
2327                 tmp = ndef_build_wifi(ret);
2328                 wpabuf_free(ret);
2329                 if (tmp == NULL)
2330                         return NULL;
2331                 ret = tmp;
2332         }
2333
2334         return ret;
2335 }
2336
2337
2338 #ifdef CONFIG_WPS_NFC
2339
2340 static struct wpabuf *
2341 wpas_wps_er_nfc_handover_sel(struct wpa_supplicant *wpa_s, int ndef,
2342                              const char *uuid)
2343 {
2344 #ifdef CONFIG_WPS_ER
2345         struct wpabuf *ret;
2346         u8 u[UUID_LEN], *use_uuid = NULL;
2347         u8 addr[ETH_ALEN], *use_addr = NULL;
2348         struct wps_context *wps = wpa_s->wps;
2349
2350         if (wps == NULL)
2351                 return NULL;
2352
2353         if (uuid == NULL)
2354                 return NULL;
2355         if (uuid_str2bin(uuid, u) == 0)
2356                 use_uuid = u;
2357         else if (hwaddr_aton(uuid, addr) == 0)
2358                 use_addr = addr;
2359         else
2360                 return NULL;
2361
2362         if (wpa_s->conf->wps_nfc_dh_pubkey == NULL) {
2363                 if (wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
2364                                    &wpa_s->conf->wps_nfc_dh_privkey) < 0)
2365                         return NULL;
2366         }
2367
2368         wpas_wps_nfc_clear(wps);
2369         wps->ap_nfc_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
2370         wps->ap_nfc_dh_pubkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
2371         wps->ap_nfc_dh_privkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
2372         if (!wps->ap_nfc_dh_pubkey || !wps->ap_nfc_dh_privkey) {
2373                 wpas_wps_nfc_clear(wps);
2374                 return NULL;
2375         }
2376
2377         ret = wps_er_nfc_handover_sel(wpa_s->wps_er, wpa_s->wps, use_uuid,
2378                                       use_addr, wpa_s->conf->wps_nfc_dh_pubkey);
2379         if (ndef && ret) {
2380                 struct wpabuf *tmp;
2381                 tmp = ndef_build_wifi(ret);
2382                 wpabuf_free(ret);
2383                 if (tmp == NULL)
2384                         return NULL;
2385                 ret = tmp;
2386         }
2387
2388         return ret;
2389 #else /* CONFIG_WPS_ER */
2390         return NULL;
2391 #endif /* CONFIG_WPS_ER */
2392 }
2393 #endif /* CONFIG_WPS_NFC */
2394
2395
2396 struct wpabuf * wpas_wps_nfc_handover_sel(struct wpa_supplicant *wpa_s,
2397                                           int ndef, int cr, const char *uuid)
2398 {
2399         struct wpabuf *ret;
2400         if (!cr)
2401                 return NULL;
2402         ret = wpas_ap_wps_nfc_handover_sel(wpa_s, ndef);
2403         if (ret)
2404                 return ret;
2405         return wpas_wps_er_nfc_handover_sel(wpa_s, ndef, uuid);
2406 }
2407
2408
2409 static int wpas_wps_nfc_rx_handover_sel(struct wpa_supplicant *wpa_s,
2410                                         const struct wpabuf *data)
2411 {
2412         struct wpabuf *wps;
2413         int ret = -1;
2414         u16 wsc_len;
2415         const u8 *pos;
2416         struct wpabuf msg;
2417         struct wps_parse_attr attr;
2418         u16 dev_pw_id;
2419         const u8 *bssid = NULL;
2420         int freq = 0;
2421
2422         wps = ndef_parse_wifi(data);
2423         if (wps == NULL)
2424                 return -1;
2425         wpa_printf(MSG_DEBUG, "WPS: Received application/vnd.wfa.wsc "
2426                    "payload from NFC connection handover");
2427         wpa_hexdump_buf(MSG_DEBUG, "WPS: NFC payload", wps);
2428         if (wpabuf_len(wps) < 2) {
2429                 wpa_printf(MSG_DEBUG, "WPS: Too short Wi-Fi Handover Select "
2430                            "Message");
2431                 goto out;
2432         }
2433         pos = wpabuf_head(wps);
2434         wsc_len = WPA_GET_BE16(pos);
2435         if (wsc_len > wpabuf_len(wps) - 2) {
2436                 wpa_printf(MSG_DEBUG, "WPS: Invalid WSC attribute length (%u) "
2437                            "in Wi-Fi Handover Select Message", wsc_len);
2438                 goto out;
2439         }
2440         pos += 2;
2441
2442         wpa_hexdump(MSG_DEBUG,
2443                     "WPS: WSC attributes in Wi-Fi Handover Select Message",
2444                     pos, wsc_len);
2445         if (wsc_len < wpabuf_len(wps) - 2) {
2446                 wpa_hexdump(MSG_DEBUG,
2447                             "WPS: Ignore extra data after WSC attributes",
2448                             pos + wsc_len, wpabuf_len(wps) - 2 - wsc_len);
2449         }
2450
2451         wpabuf_set(&msg, pos, wsc_len);
2452         ret = wps_parse_msg(&msg, &attr);
2453         if (ret < 0) {
2454                 wpa_printf(MSG_DEBUG, "WPS: Could not parse WSC attributes in "
2455                            "Wi-Fi Handover Select Message");
2456                 goto out;
2457         }
2458
2459         if (attr.oob_dev_password == NULL ||
2460             attr.oob_dev_password_len < WPS_OOB_PUBKEY_HASH_LEN + 2) {
2461                 wpa_printf(MSG_DEBUG, "WPS: No Out-of-Band Device Password "
2462                            "included in Wi-Fi Handover Select Message");
2463                 ret = -1;
2464                 goto out;
2465         }
2466
2467         if (attr.ssid == NULL) {
2468                 wpa_printf(MSG_DEBUG, "WPS: No SSID included in Wi-Fi Handover "
2469                            "Select Message");
2470                 ret = -1;
2471                 goto out;
2472         }
2473
2474         wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID", attr.ssid, attr.ssid_len);
2475
2476         if (attr.mac_addr) {
2477                 bssid = attr.mac_addr;
2478                 wpa_printf(MSG_DEBUG, "WPS: MAC Address (BSSID): " MACSTR,
2479                            MAC2STR(bssid));
2480         }
2481
2482         if (attr.rf_bands)
2483                 wpa_printf(MSG_DEBUG, "WPS: RF Bands: %d", *attr.rf_bands);
2484
2485         if (attr.ap_channel) {
2486                 u16 chan = WPA_GET_BE16(attr.ap_channel);
2487
2488                 wpa_printf(MSG_DEBUG, "WPS: AP Channel: %d", chan);
2489
2490                 if (chan >= 1 && chan <= 13 &&
2491                     (attr.rf_bands == NULL || *attr.rf_bands & WPS_RF_24GHZ))
2492                         freq = 2407 + 5 * chan;
2493                 else if (chan == 14 &&
2494                          (attr.rf_bands == NULL ||
2495                           *attr.rf_bands & WPS_RF_24GHZ))
2496                         freq = 2484;
2497                 else if (chan >= 30 &&
2498                          (attr.rf_bands == NULL ||
2499                           *attr.rf_bands & WPS_RF_50GHZ))
2500                         freq = 5000 + 5 * chan;
2501
2502                 if (freq) {
2503                         wpa_printf(MSG_DEBUG,
2504                                    "WPS: AP indicated channel %u -> %u MHz",
2505                                    chan, freq);
2506                 }
2507         }
2508
2509         wpa_hexdump(MSG_DEBUG, "WPS: Out-of-Band Device Password",
2510                     attr.oob_dev_password, attr.oob_dev_password_len);
2511         dev_pw_id = WPA_GET_BE16(attr.oob_dev_password +
2512                                  WPS_OOB_PUBKEY_HASH_LEN);
2513         if (dev_pw_id != DEV_PW_NFC_CONNECTION_HANDOVER) {
2514                 wpa_printf(MSG_DEBUG, "WPS: Unexpected OOB Device Password ID "
2515                            "%u in Wi-Fi Handover Select Message", dev_pw_id);
2516                 ret = -1;
2517                 goto out;
2518         }
2519         wpa_hexdump(MSG_DEBUG, "WPS: AP Public Key hash",
2520                     attr.oob_dev_password, WPS_OOB_PUBKEY_HASH_LEN);
2521
2522         ret = wpas_wps_start_nfc(wpa_s, NULL, bssid, NULL, dev_pw_id, 0,
2523                                  attr.oob_dev_password,
2524                                  attr.ssid, attr.ssid_len, freq);
2525
2526 out:
2527         wpabuf_free(wps);
2528         return ret;
2529 }
2530
2531
2532 int wpas_wps_nfc_report_handover(struct wpa_supplicant *wpa_s,
2533                                  const struct wpabuf *req,
2534                                  const struct wpabuf *sel)
2535 {
2536         wpa_printf(MSG_DEBUG, "NFC: WPS connection handover reported");
2537         wpa_hexdump_buf_key(MSG_DEBUG, "WPS: Carrier record in request", req);
2538         wpa_hexdump_buf_key(MSG_DEBUG, "WPS: Carrier record in select", sel);
2539         return wpas_wps_nfc_rx_handover_sel(wpa_s, sel);
2540 }
2541
2542
2543 int wpas_er_wps_nfc_report_handover(struct wpa_supplicant *wpa_s,
2544                                     const struct wpabuf *req,
2545                                     const struct wpabuf *sel)
2546 {
2547         struct wpabuf *wps;
2548         int ret = -1;
2549         u16 wsc_len;
2550         const u8 *pos;
2551         struct wpabuf msg;
2552         struct wps_parse_attr attr;
2553         u16 dev_pw_id;
2554
2555         /*
2556          * Enrollee/station is always initiator of the NFC connection handover,
2557          * so use the request message here to find Enrollee public key hash.
2558          */
2559         wps = ndef_parse_wifi(req);
2560         if (wps == NULL)
2561                 return -1;
2562         wpa_printf(MSG_DEBUG, "WPS: Received application/vnd.wfa.wsc "
2563                    "payload from NFC connection handover");
2564         wpa_hexdump_buf(MSG_DEBUG, "WPS: NFC payload", wps);
2565         if (wpabuf_len(wps) < 2) {
2566                 wpa_printf(MSG_DEBUG, "WPS: Too short Wi-Fi Handover Request "
2567                            "Message");
2568                 goto out;
2569         }
2570         pos = wpabuf_head(wps);
2571         wsc_len = WPA_GET_BE16(pos);
2572         if (wsc_len > wpabuf_len(wps) - 2) {
2573                 wpa_printf(MSG_DEBUG, "WPS: Invalid WSC attribute length (%u) "
2574                            "in rt Wi-Fi Handover Request Message", wsc_len);
2575                 goto out;
2576         }
2577         pos += 2;
2578
2579         wpa_hexdump(MSG_DEBUG,
2580                     "WPS: WSC attributes in Wi-Fi Handover Request Message",
2581                     pos, wsc_len);
2582         if (wsc_len < wpabuf_len(wps) - 2) {
2583                 wpa_hexdump(MSG_DEBUG,
2584                             "WPS: Ignore extra data after WSC attributes",
2585                             pos + wsc_len, wpabuf_len(wps) - 2 - wsc_len);
2586         }
2587
2588         wpabuf_set(&msg, pos, wsc_len);
2589         ret = wps_parse_msg(&msg, &attr);
2590         if (ret < 0) {
2591                 wpa_printf(MSG_DEBUG, "WPS: Could not parse WSC attributes in "
2592                            "Wi-Fi Handover Request Message");
2593                 goto out;
2594         }
2595
2596         if (attr.oob_dev_password == NULL ||
2597             attr.oob_dev_password_len < WPS_OOB_PUBKEY_HASH_LEN + 2) {
2598                 wpa_printf(MSG_DEBUG, "WPS: No Out-of-Band Device Password "
2599                            "included in Wi-Fi Handover Request Message");
2600                 ret = -1;
2601                 goto out;
2602         }
2603
2604         if (attr.uuid_e == NULL) {
2605                 wpa_printf(MSG_DEBUG, "WPS: No UUID-E included in Wi-Fi "
2606                            "Handover Request Message");
2607                 ret = -1;
2608                 goto out;
2609         }
2610
2611         wpa_hexdump(MSG_DEBUG, "WPS: UUID-E", attr.uuid_e, WPS_UUID_LEN);
2612
2613         wpa_hexdump(MSG_DEBUG, "WPS: Out-of-Band Device Password",
2614                     attr.oob_dev_password, attr.oob_dev_password_len);
2615         dev_pw_id = WPA_GET_BE16(attr.oob_dev_password +
2616                                  WPS_OOB_PUBKEY_HASH_LEN);
2617         if (dev_pw_id != DEV_PW_NFC_CONNECTION_HANDOVER) {
2618                 wpa_printf(MSG_DEBUG, "WPS: Unexpected OOB Device Password ID "
2619                            "%u in Wi-Fi Handover Request Message", dev_pw_id);
2620                 ret = -1;
2621                 goto out;
2622         }
2623         wpa_hexdump(MSG_DEBUG, "WPS: Enrollee Public Key hash",
2624                     attr.oob_dev_password, WPS_OOB_PUBKEY_HASH_LEN);
2625
2626         ret = wps_registrar_add_nfc_pw_token(wpa_s->wps->registrar,
2627                                              attr.oob_dev_password,
2628                                              DEV_PW_NFC_CONNECTION_HANDOVER,
2629                                              NULL, 0, 1);
2630
2631 out:
2632         wpabuf_free(wps);
2633         return ret;
2634 }
2635
2636 #endif /* CONFIG_WPS_NFC */
2637
2638
2639 static void wpas_wps_dump_ap_info(struct wpa_supplicant *wpa_s)
2640 {
2641         size_t i;
2642         struct os_reltime now;
2643
2644         if (wpa_debug_level > MSG_DEBUG)
2645                 return;
2646
2647         if (wpa_s->wps_ap == NULL)
2648                 return;
2649
2650         os_get_reltime(&now);
2651
2652         for (i = 0; i < wpa_s->num_wps_ap; i++) {
2653                 struct wps_ap_info *ap = &wpa_s->wps_ap[i];
2654                 struct wpa_blacklist *e = wpa_blacklist_get(wpa_s, ap->bssid);
2655
2656                 wpa_printf(MSG_DEBUG, "WPS: AP[%d] " MACSTR " type=%d "
2657                            "tries=%d last_attempt=%d sec ago blacklist=%d",
2658                            (int) i, MAC2STR(ap->bssid), ap->type, ap->tries,
2659                            ap->last_attempt.sec > 0 ?
2660                            (int) now.sec - (int) ap->last_attempt.sec : -1,
2661                            e ? e->count : 0);
2662         }
2663 }
2664
2665
2666 static struct wps_ap_info * wpas_wps_get_ap_info(struct wpa_supplicant *wpa_s,
2667                                                  const u8 *bssid)
2668 {
2669         size_t i;
2670
2671         if (wpa_s->wps_ap == NULL)
2672                 return NULL;
2673
2674         for (i = 0; i < wpa_s->num_wps_ap; i++) {
2675                 struct wps_ap_info *ap = &wpa_s->wps_ap[i];
2676                 if (os_memcmp(ap->bssid, bssid, ETH_ALEN) == 0)
2677                         return ap;
2678         }
2679
2680         return NULL;
2681 }
2682
2683
2684 static void wpas_wps_update_ap_info_bss(struct wpa_supplicant *wpa_s,
2685                                         struct wpa_scan_res *res)
2686 {
2687         struct wpabuf *wps;
2688         enum wps_ap_info_type type;
2689         struct wps_ap_info *ap;
2690         int r;
2691
2692         if (wpa_scan_get_vendor_ie(res, WPS_IE_VENDOR_TYPE) == NULL)
2693                 return;
2694
2695         wps = wpa_scan_get_vendor_ie_multi(res, WPS_IE_VENDOR_TYPE);
2696         if (wps == NULL)
2697                 return;
2698
2699         r = wps_is_addr_authorized(wps, wpa_s->own_addr, 1);
2700         if (r == 2)
2701                 type = WPS_AP_SEL_REG_OUR;
2702         else if (r == 1)
2703                 type = WPS_AP_SEL_REG;
2704         else
2705                 type = WPS_AP_NOT_SEL_REG;
2706
2707         wpabuf_free(wps);
2708
2709         ap = wpas_wps_get_ap_info(wpa_s, res->bssid);
2710         if (ap) {
2711                 if (ap->type != type) {
2712                         wpa_printf(MSG_DEBUG, "WPS: AP " MACSTR
2713                                    " changed type %d -> %d",
2714                                    MAC2STR(res->bssid), ap->type, type);
2715                         ap->type = type;
2716                         if (type != WPS_AP_NOT_SEL_REG)
2717                                 wpa_blacklist_del(wpa_s, ap->bssid);
2718                 }
2719                 return;
2720         }
2721
2722         ap = os_realloc_array(wpa_s->wps_ap, wpa_s->num_wps_ap + 1,
2723                               sizeof(struct wps_ap_info));
2724         if (ap == NULL)
2725                 return;
2726
2727         wpa_s->wps_ap = ap;
2728         ap = &wpa_s->wps_ap[wpa_s->num_wps_ap];
2729         wpa_s->num_wps_ap++;
2730
2731         os_memset(ap, 0, sizeof(*ap));
2732         os_memcpy(ap->bssid, res->bssid, ETH_ALEN);
2733         ap->type = type;
2734         wpa_printf(MSG_DEBUG, "WPS: AP " MACSTR " type %d added",
2735                    MAC2STR(ap->bssid), ap->type);
2736 }
2737
2738
2739 void wpas_wps_update_ap_info(struct wpa_supplicant *wpa_s,
2740                              struct wpa_scan_results *scan_res)
2741 {
2742         size_t i;
2743
2744         for (i = 0; i < scan_res->num; i++)
2745                 wpas_wps_update_ap_info_bss(wpa_s, scan_res->res[i]);
2746
2747         wpas_wps_dump_ap_info(wpa_s);
2748 }
2749
2750
2751 void wpas_wps_notify_assoc(struct wpa_supplicant *wpa_s, const u8 *bssid)
2752 {
2753         struct wps_ap_info *ap;
2754
2755         wpa_s->after_wps = 0;
2756
2757         if (!wpa_s->wps_ap_iter)
2758                 return;
2759         ap = wpas_wps_get_ap_info(wpa_s, bssid);
2760         if (ap == NULL)
2761                 return;
2762         ap->tries++;
2763         os_get_reltime(&ap->last_attempt);
2764 }