Lines Matching +full:adv +full:- +full:extra +full:- +full:delay

3  * Copyright (c) 2008-2014, Jouni Malinen <j@w1.fi>
56 os_free(wpa_s->wps_ap);
57 wpa_s->wps_ap = NULL;
58 wpa_s->num_wps_ap = 0;
59 wpa_s->wps_ap_iter = 0;
87 if (bss->beacon_newer)
99 if (!wpa_s->wps_success &&
100 wpa_s->current_ssid &&
101 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
102 const u8 *bssid = wpa_s->bssid;
104 bssid = wpa_s->pending_bssid;
107 " did not succeed - continue trying to find "
113 wpa_s->reassociate = 1;
115 wpa_s->bssid_ignore_cleared ? 5 : 0, 0);
116 wpa_s->bssid_ignore_cleared = false;
122 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && !wpa_s->wps_success)
125 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && wpa_s->current_ssid &&
126 !(wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
127 int disabled = wpa_s->current_ssid->disabled;
128 unsigned int freq = wpa_s->assoc_freq;
133 wpa_printf(MSG_DEBUG, "WPS: Network configuration replaced - "
136 wpa_s->own_disconnect_req = 1;
141 "disabled - wait for user to enable");
144 wpa_s->after_wps = 5;
145 wpa_s->wps_freq = freq;
146 wpa_s->normal_scans = 0;
147 wpa_s->reassociate = 1;
179 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS && wpa_s->current_ssid) {
180 wpa_printf(MSG_DEBUG, "WPS: Registration completed - waiting "
183 wpa_s->own_disconnect_req = 1;
200 struct wpa_ie_data adv;
215 if (ssid->ssid == NULL)
217 bss = wpa_bss_get(wpa_s, cred->mac_addr, ssid->ssid, ssid->ssid_len);
219 bss = wpa_bss_get(wpa_s, wpa_s->bssid,
220 ssid->ssid, ssid->ssid_len);
223 "table - use credential as-is");
230 if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &adv) == 0) {
232 if (adv.pairwise_cipher & WPA_CIPHER_CCMP)
236 if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &adv) == 0 &&
237 adv.pairwise_cipher & WPA_CIPHER_CCMP)
241 if (ie == NULL && (ssid->proto & WPA_PROTO_WPA) &&
242 (ssid->pairwise_cipher & WPA_CIPHER_TKIP)) {
246 * scan and delay addition of the network until the updated
250 "support - use credential as-is");
254 iftype = ssid->p2p_group ? WPA_IF_P2P_CLIENT : WPA_IF_STATION;
256 if (ccmp && !(ssid->pairwise_cipher & WPA_CIPHER_CCMP) &&
257 (ssid->pairwise_cipher & WPA_CIPHER_TKIP) &&
262 if (wpa_s->conf->ap_scan == 1)
263 ssid->pairwise_cipher |= WPA_CIPHER_CCMP;
265 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
268 if (wpa2 && !(ssid->proto & WPA_PROTO_RSN) &&
269 (ssid->proto & WPA_PROTO_WPA) &&
273 if (wpa_s->conf->ap_scan == 1)
274 ssid->proto |= WPA_PROTO_RSN;
276 ssid->proto = WPA_PROTO_RSN;
286 for (ssid = wpa_s->conf->ssid, next = ssid ? ssid->next : NULL; ssid;
287 ssid = next, next = ssid ? ssid->next : NULL) {
295 if (ssid->bssid_set || new_ssid->bssid_set) {
296 if (ssid->bssid_set != new_ssid->bssid_set)
298 if (!ether_addr_equal(ssid->bssid, new_ssid->bssid))
303 if (ssid->ssid_len == 0 || ssid->ssid_len != new_ssid->ssid_len)
306 if (ssid->ssid && new_ssid->ssid) {
307 if (os_memcmp(ssid->ssid, new_ssid->ssid,
308 ssid->ssid_len) != 0)
310 } else if (ssid->ssid || new_ssid->ssid)
314 if (ssid->auth_alg != new_ssid->auth_alg ||
315 ssid->key_mgmt != new_ssid->key_mgmt ||
316 (ssid->group_cipher != new_ssid->group_cipher &&
317 !(ssid->group_cipher & new_ssid->group_cipher &
327 if (ssid->wps_run && ssid->wps_run == new_ssid->wps_run &&
328 wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
329 if (new_ssid->passphrase && ssid->passphrase &&
330 os_strcmp(new_ssid->passphrase, ssid->passphrase) !=
333 "WPS: M8 Creds with different passphrase - do not merge");
337 if (new_ssid->psk_set &&
338 (!ssid->psk_set ||
339 os_memcmp(new_ssid->psk, ssid->psk, 32) != 0)) {
341 "WPS: M8 Creds with different PSK - do not merge");
345 if ((new_ssid->passphrase && !ssid->passphrase) ||
346 (!new_ssid->passphrase && ssid->passphrase)) {
348 "WPS: M8 Creds with different passphrase/PSK type - do not merge");
353 "WPS: Workaround - merge likely WPA/WPA2-mixed mode creds in same M8 message");
354 new_ssid->proto |= ssid->proto;
355 new_ssid->pairwise_cipher |= ssid->pairwise_cipher;
359 * non-mixed-mode creds.
361 if (ssid->proto != new_ssid->proto ||
362 ssid->pairwise_cipher != new_ssid->pairwise_cipher)
367 wpa_printf(MSG_DEBUG, "Remove duplicate network %d", ssid->id);
369 wpa_config_remove_network(wpa_s->conf, ssid->id);
378 struct wpa_ssid *ssid = wpa_s->current_ssid;
385 if ((wpa_s->conf->wps_cred_processing == 1 ||
386 wpa_s->conf->wps_cred_processing == 2) && cred->cred_attr) {
387 size_t blen = cred->cred_attr_len * 2 + 1;
391 cred->cred_attr, cred->cred_attr_len);
402 cred->cred_attr, cred->cred_attr_len);
404 if (wpa_s->conf->wps_cred_processing == 1)
407 wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID", cred->ssid, cred->ssid_len);
409 cred->auth_type);
410 wpa_printf(MSG_DEBUG, "WPS: Encryption Type 0x%x", cred->encr_type);
411 wpa_printf(MSG_DEBUG, "WPS: Network Key Index %d", cred->key_idx);
413 cred->key, cred->key_len);
415 MAC2STR(cred->mac_addr));
417 auth_type = cred->auth_type;
419 wpa_printf(MSG_DEBUG, "WPS: Workaround - convert mixed-mode "
434 if (cred->key_len < 8 || cred->key_len > 2 * PMK_LEN) {
437 (unsigned long) cred->key_len);
438 return -1;
442 if (ssid && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
446 if (ssid->eap.identity &&
447 ssid->eap.identity_len == WSC_ID_REGISTRAR_LEN &&
448 os_memcmp(ssid->eap.identity, WSC_ID_REGISTRAR,
452 os_free(ssid->eap.identity);
453 ssid->eap.identity = NULL;
454 ssid->eap.identity_len = 0;
455 os_free(ssid->eap.phase1);
456 ssid->eap.phase1 = NULL;
457 os_free(ssid->eap.eap_methods);
458 ssid->eap.eap_methods = NULL;
459 if (!ssid->p2p_group) {
460 ssid->temporary = 0;
461 ssid->bssid_set = 0;
463 ssid->disabled_until.sec = 0;
464 ssid->disabled_until.usec = 0;
465 ssid->auth_failures = 0;
469 ssid = wpa_config_add_network(wpa_s->conf);
471 return -1;
472 if (wpa_s->current_ssid) {
477 * marked as such based on the pre-configured values
480 ssid->p2p_group = wpa_s->current_ssid->p2p_group;
481 ssid->temporary = wpa_s->current_ssid->temporary;
487 ssid->wps_run = wpa_s->wps_run;
489 os_free(ssid->ssid);
490 ssid->ssid = os_malloc(cred->ssid_len);
491 if (ssid->ssid) {
492 os_memcpy(ssid->ssid, cred->ssid, cred->ssid_len);
493 ssid->ssid_len = cred->ssid_len;
496 switch (cred->encr_type) {
500 ssid->pairwise_cipher = WPA_CIPHER_TKIP | WPA_CIPHER_CCMP;
503 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
504 if (wpa_s->drv_capa_known &&
505 (wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_GCMP)) {
506 ssid->pairwise_cipher |= WPA_CIPHER_GCMP;
507 ssid->group_cipher |= WPA_CIPHER_GCMP;
509 if (wpa_s->drv_capa_known &&
510 (wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_GCMP_256)) {
511 ssid->pairwise_cipher |= WPA_CIPHER_GCMP_256;
512 ssid->group_cipher |= WPA_CIPHER_GCMP_256;
514 if (wpa_s->drv_capa_known &&
515 (wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_CCMP_256)) {
516 ssid->pairwise_cipher |= WPA_CIPHER_CCMP_256;
517 ssid->group_cipher |= WPA_CIPHER_CCMP_256;
524 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
525 ssid->key_mgmt = WPA_KEY_MGMT_NONE;
526 ssid->proto = 0;
530 "id=%d - Credentials for an open "
531 "network disabled by default - use "
533 ssid->id, ssid->id);
534 ssid->disabled = 1;
539 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
540 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
541 ssid->proto = WPA_PROTO_WPA | WPA_PROTO_RSN;
544 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
545 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
546 add_sae = wpa_s->conf->wps_cred_add_sae;
548 if (ssid->p2p_group && is_p2p_6ghz_capable(wpa_s->global->p2p))
551 if (add_sae && cred->key_len != 2 * PMK_LEN) {
552 ssid->auth_alg = 0;
553 ssid->key_mgmt |= WPA_KEY_MGMT_SAE;
554 ssid->ieee80211w = MGMT_FRAME_PROTECTION_OPTIONAL;
556 ssid->proto = WPA_PROTO_RSN;
560 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
561 if (cred->key_len == 2 * PMK_LEN) {
562 if (hexstr2bin((const char *) cred->key, ssid->psk,
566 return -1;
568 ssid->psk_set = 1;
569 ssid->export_keys = 1;
570 } else if (cred->key_len >= 8 && cred->key_len < 2 * PMK_LEN) {
571 os_free(ssid->passphrase);
572 ssid->passphrase = os_malloc(cred->key_len + 1);
573 if (ssid->passphrase == NULL)
574 return -1;
575 os_memcpy(ssid->passphrase, cred->key, cred->key_len);
576 ssid->passphrase[cred->key_len] = '\0';
578 ssid->export_keys = 1;
582 (unsigned long) cred->key_len);
583 return -1;
586 ssid->priority = wpa_s->conf->wps_priority;
593 if (wpa_s->conf->update_config &&
594 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
596 return -1;
600 if (ssid->priority)
601 wpa_config_update_prio_list(wpa_s->conf);
604 * Optimize the post-WPS scan based on the channel used during
605 * the provisioning in case EAP-Failure is not received.
607 wpa_s->after_wps = 5;
608 wpa_s->wps_freq = wpa_s->assoc_freq;
619 m2d->dev_password_id, m2d->config_error);
622 if (wpa_s->p2pdev && wpa_s->p2pdev != wpa_s) {
623 wpa_msg(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_M2D
625 m2d->dev_password_id, m2d->config_error);
627 if (m2d->config_error == WPS_CFG_MULTIPLE_PBC_DETECTED) {
650 if (fail->error_indication > 0 &&
651 fail->error_indication < NUM_WPS_EI_VALUES) {
654 fail->msg, fail->config_error, fail->error_indication,
655 wps_ei_str(fail->error_indication));
656 if (wpa_s->p2pdev && wpa_s->p2pdev != wpa_s)
657 wpa_msg(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_FAIL
659 fail->msg, fail->config_error,
660 fail->error_indication,
661 wps_ei_str(fail->error_indication));
665 fail->msg, fail->config_error);
666 if (wpa_s->p2pdev && wpa_s->p2pdev != wpa_s)
667 wpa_msg(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_FAIL
669 fail->msg, fail->config_error);
693 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
694 if (ssid->disabled_for_connect && ssid->disabled) {
695 ssid->disabled_for_connect = 0;
696 ssid->disabled = 0;
704 if (wpa_s->conf->update_config &&
705 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
732 wpa_s->wps_success = 1;
734 if (wpa_s->current_ssid)
735 wpas_clear_temp_disabled(wpa_s, wpa_s->current_ssid, 1);
736 wpa_s->consecutive_conn_failures = 0;
746 wpas_p2p_wps_success(wpa_s, wpa_s->bssid, 0);
756 uuid_bin2str(ap->uuid, uuid_str, sizeof(uuid_str));
757 if (ap->pri_dev_type)
758 wps_dev_type_bin2str(ap->pri_dev_type, dev_type,
765 uuid_str, MAC2STR(ap->mac_addr), dev_type, ap->wps_state,
766 ap->friendly_name ? ap->friendly_name : "",
767 ap->manufacturer ? ap->manufacturer : "",
768 ap->model_description ? ap->model_description : "",
769 ap->model_name ? ap->model_name : "",
770 ap->manufacturer_url ? ap->manufacturer_url : "",
771 ap->model_url ? ap->model_url : "");
779 uuid_bin2str(ap->uuid, uuid_str, sizeof(uuid_str));
790 uuid_bin2str(enrollee->uuid, uuid_str, sizeof(uuid_str));
791 if (enrollee->pri_dev_type)
792 wps_dev_type_bin2str(enrollee->pri_dev_type, dev_type,
800 uuid_str, MAC2STR(enrollee->mac_addr), enrollee->m1_received,
801 enrollee->config_methods, enrollee->dev_passwd_id, dev_type,
802 enrollee->dev_name ? enrollee->dev_name : "",
803 enrollee->manufacturer ? enrollee->manufacturer : "",
804 enrollee->model_name ? enrollee->model_name : "",
805 enrollee->model_number ? enrollee->model_number : "",
806 enrollee->serial_number ? enrollee->serial_number : "");
814 uuid_bin2str(enrollee->uuid, uuid_str, sizeof(uuid_str));
816 uuid_str, MAC2STR(enrollee->mac_addr));
826 const struct wps_credential *cred = ap_settings->cred;
829 if (cred->auth_type & (WPS_AUTH_WPAPSK | WPS_AUTH_WPA2PSK)) {
830 if (cred->key_len >= 8 && cred->key_len <= 64) {
831 os_memcpy(key_str, cred->key, cred->key_len);
832 key_str[cred->key_len] = '\0';
836 uuid_bin2str(ap_settings->uuid, uuid_str, sizeof(uuid_str));
841 uuid_str, wpa_ssid_txt(cred->ssid, cred->ssid_len),
842 cred->auth_type, cred->encr_type, key_str);
852 uuid_bin2str(ev->uuid, uuid_str, sizeof(uuid_str));
853 switch (ev->state) {
858 uuid_str, ev->sel_reg, ev->dev_passwd_id,
859 ev->sel_reg_config_methods);
879 wpa_supplicant_wps_event_m2d(wpa_s, &data->m2d);
882 wpa_supplicant_wps_event_fail(wpa_s, &data->fail);
889 if (wpa_s->ap_iface && data->pwd_auth_fail.enrollee)
904 wpa_supplicant_wps_event_er_ap_add(wpa_s, &data->ap);
907 wpa_supplicant_wps_event_er_ap_remove(wpa_s, &data->ap);
911 &data->enrollee);
915 &data->enrollee);
919 &data->ap_settings);
923 &data->set_sel_reg);
935 if (!wpa_s->current_ssid || !wpa_s->assoc_freq)
938 return (wpa_s->assoc_freq > 50000) ? WPS_RF_60GHZ :
939 (wpa_s->assoc_freq > 2484) ? WPS_RF_50GHZ : WPS_RF_24GHZ;
945 if (eap_is_wps_pbc_enrollee(&ssid->eap) ||
946 eap_is_wps_pin_enrollee(&ssid->eap))
958 wpa_s->after_wps = 0;
959 wpa_s->known_wps_freq = 0;
961 prev_current = wpa_s->current_ssid;
970 ssid = wpa_s->conf->ssid;
972 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
973 if (ssid == wpa_s->current_ssid) {
974 wpa_s->own_disconnect_req = 1;
978 id = ssid->id;
981 id = -1;
982 ssid = ssid->next;
985 wpa_sm_set_config(wpa_s->wpa, NULL);
986 eapol_sm_notify_config(wpa_s->eapol, NULL,
990 wpa_config_remove_network(wpa_s->conf, id);
1012 * during an EAP-WSC exchange).
1015 wpa_s->supp_pbc_active = false;
1016 wpa_s->wps_overlap = false;
1027 ssid = wpa_config_add_network(wpa_s->conf);
1032 ssid->temporary = 1;
1039 wpa_config_remove_network(wpa_s->conf, ssid->id);
1045 os_memcpy(ssid->go_p2p_dev_addr, dev_addr, ETH_ALEN);
1054 os_memcpy(ssid->bssid, bssid, ETH_ALEN);
1055 ssid->bssid_set = 1;
1063 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1064 if (!ether_addr_equal(bssid, bss->bssid))
1067 os_free(ssid->ssid);
1068 ssid->ssid = os_memdup(bss->ssid, bss->ssid_len);
1069 if (ssid->ssid == NULL)
1071 ssid->ssid_len = bss->ssid_len;
1074 ssid->ssid, ssid->ssid_len);
1081 os_free(ssid->ssid);
1082 ssid->ssid = NULL;
1083 ssid->ssid_len = 0;
1097 if (wpa_s->current_ssid) {
1098 wpa_s->own_disconnect_req = 1;
1104 ssid = wpa_s->conf->ssid;
1106 int was_disabled = ssid->disabled;
1107 ssid->disabled_for_connect = 0;
1115 ssid->disabled = ssid != selected;
1116 if (was_disabled != ssid->disabled) {
1117 if (ssid->disabled)
1118 ssid->disabled_for_connect = 1;
1123 ssid = ssid->next;
1134 wpa_s->wps_run++;
1135 if (wpa_s->wps_run == 0)
1136 wpa_s->wps_run++;
1137 wpa_s->after_wps = 0;
1138 wpa_s->known_wps_freq = 0;
1140 wpa_s->after_wps = 5;
1141 wpa_s->wps_freq = freq;
1144 if (bss && bss->freq > 0) {
1145 wpa_s->known_wps_freq = 1;
1146 wpa_s->wps_freq = bss->freq;
1152 wpa_s->disconnected = 0;
1153 wpa_s->reassociate = 1;
1154 wpa_s->scan_runs = 0;
1155 wpa_s->normal_scans = 0;
1156 wpa_s->wps_success = 0;
1157 wpa_s->bssid_ignore_cleared = false;
1171 if (wpa_s->ap_iface) {
1174 return -1;
1180 return -1;
1181 ssid->temporary = 1;
1182 ssid->p2p_group = p2p_group;
1189 ssid->pbss = 2;
1191 if (p2p_group && wpa_s->go_params && wpa_s->go_params->ssid_len) {
1192 ssid->ssid = os_zalloc(wpa_s->go_params->ssid_len + 1);
1193 if (ssid->ssid) {
1194 ssid->ssid_len = wpa_s->go_params->ssid_len;
1195 os_memcpy(ssid->ssid, wpa_s->go_params->ssid,
1196 ssid->ssid_len);
1197 if (wpa_s->go_params->freq > 56160) {
1199 ssid->pbss = 1;
1201 if (wpa_s->go_params->edmg &&
1203 wpa_s->go_params) == 0)
1204 ssid->enable_edmg = 1;
1207 "SSID", ssid->ssid, ssid->ssid_len);
1217 return -1;
1218 if (wpa_s->wps_fragment_size)
1219 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1221 ssid->multi_ap_backhaul_sta = 1;
1222 ssid->multi_ap_profile = multi_ap_backhaul_sta;
1224 wpa_s->supp_pbc_active = true;
1225 wpa_s->wps_overlap = false;
1246 if (wpa_s->ap_iface) {
1249 return -1;
1258 return -1;
1260 ssid->temporary = 1;
1261 ssid->p2p_group = p2p_group;
1268 ssid->pbss = 2;
1270 ssid->ssid = os_malloc(ssid_len);
1271 if (ssid->ssid) {
1272 os_memcpy(ssid->ssid, ssid_val, ssid_len);
1273 ssid->ssid_len = ssid_len;
1278 wpa_snprintf_hex_uppercase(hash + 8, sizeof(hash) - 8,
1285 if (p2p_group && wpa_s->go_params && wpa_s->go_params->ssid_len) {
1286 os_free(ssid->ssid);
1287 ssid->ssid = os_zalloc(wpa_s->go_params->ssid_len + 1);
1288 if (ssid->ssid) {
1289 ssid->ssid_len = wpa_s->go_params->ssid_len;
1290 os_memcpy(ssid->ssid, wpa_s->go_params->ssid,
1291 ssid->ssid_len);
1292 if (wpa_s->go_params->freq > 56160) {
1294 ssid->pbss = 1;
1296 if (wpa_s->go_params->edmg &&
1298 wpa_s->go_params) == 0)
1299 ssid->enable_edmg = 1;
1302 "SSID", ssid->ssid, ssid->ssid_len);
1315 return -1;
1322 return -1;
1328 if (wpa_s->wps_fragment_size)
1329 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1332 wpa_s->wps_ap_iter = 1;
1341 os_get_reltime(&wpa_s->wps_pin_start_time);
1358 * during an EAP-WSC exchange).
1367 if (wpa_s->ap_iface) {
1373 if (wpa_s->wpa_state == WPA_SCANNING ||
1374 wpa_s->wpa_state == WPA_DISCONNECTED) {
1375 wpa_printf(MSG_DEBUG, "WPS: Cancel operation - cancel scan");
1378 } else if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
1379 wpa_printf(MSG_DEBUG, "WPS: Cancel operation - "
1381 wpa_s->own_disconnect_req = 1;
1393 wpa_s->supp_pbc_active = false;
1394 wpa_s->wps_overlap = false;
1396 wpa_s->after_wps = 0;
1411 if (wpa_s->ap_iface) {
1414 return -1;
1418 return -1;
1422 return -1;
1423 ssid->temporary = 1;
1426 res = os_snprintf(pos, end - pos, "\"pin=%s", pin);
1427 if (os_snprintf_error(end - pos, res))
1428 return -1;
1431 res = os_snprintf(pos, end - pos, " new_ssid=%s new_auth=%s "
1433 settings->ssid_hex, settings->auth,
1434 settings->encr, settings->key_hex);
1435 if (os_snprintf_error(end - pos, res))
1436 return -1;
1439 res = os_snprintf(pos, end - pos, "\"");
1440 if (os_snprintf_error(end - pos, res))
1441 return -1;
1443 return -1;
1444 if (wpa_s->wps_fragment_size)
1445 ssid->eap.fragment_size = wpa_s->wps_fragment_size;
1459 "Received new WPA/WPA2-PSK from WPS for STA " MACSTR,
1463 "Received new WPA/WPA2-PSK from WPS for STA " MACSTR
1467 wpa_hexdump_key(MSG_DEBUG, "Per-device PSK", psk, psk_len);
1483 wpa_printf(MSG_DEBUG, "WPS: PIN needed for UUID-E %s", uuid);
1484 len = os_snprintf(txt, sizeof(txt), "WPS-EVENT-PIN-NEEDED %s " MACSTR
1486 uuid, MAC2STR(dev->mac_addr), dev->device_name,
1487 dev->manufacturer, dev->model_name,
1488 dev->model_number, dev->serial_number,
1489 wps_dev_type_bin2str(dev->pri_dev_type, devtype,
1502 if (wpa_s->wps_er == NULL)
1504 wpa_printf(MSG_DEBUG, "WPS ER: SetSelectedRegistrar - sel_reg=%d "
1507 wps_er_set_sel_reg(wpa_s->wps_er, sel_reg, dev_passwd_id,
1540 if (is_nil_uuid(wpa_s->conf->uuid)) {
1542 first = wpa_s->global->ifaces;
1543 while (first && first->next)
1544 first = first->next;
1546 if (wps != wpa_s->global->ifaces->wps)
1547 os_memcpy(wps->uuid,
1548 wpa_s->global->ifaces->wps->uuid,
1551 } else if (wpa_s->conf->auto_uuid == 1) {
1552 uuid_random(wps->uuid);
1555 uuid_gen_mac_addr(wpa_s->own_addr, wps->uuid);
1559 os_memcpy(wps->uuid, wpa_s->conf->uuid, WPS_UUID_LEN);
1563 uuid_bin2str(wps->uuid, buf, sizeof(buf));
1571 wpabuf_free(wps->dev.vendor_ext_m1);
1572 wps->dev.vendor_ext_m1 = NULL;
1574 if (wpa_s->conf->wps_vendor_ext_m1) {
1575 wps->dev.vendor_ext_m1 =
1576 wpabuf_dup(wpa_s->conf->wps_vendor_ext_m1);
1577 if (!wps->dev.vendor_ext_m1) {
1594 return -1;
1596 wps->cred_cb = wpa_supplicant_wps_cred;
1597 wps->event_cb = wpa_supplicant_wps_event;
1598 wps->rf_band_cb = wpa_supplicant_wps_rf_band;
1599 wps->cb_ctx = wpa_s;
1601 wps->dev.device_name = wpa_s->conf->device_name;
1602 wps->dev.manufacturer = wpa_s->conf->manufacturer;
1603 wps->dev.model_name = wpa_s->conf->model_name;
1604 wps->dev.model_number = wpa_s->conf->model_number;
1605 wps->dev.serial_number = wpa_s->conf->serial_number;
1606 wps->config_methods =
1607 wps_config_methods_str2bin(wpa_s->conf->config_methods);
1608 if ((wps->config_methods & (WPS_CONFIG_DISPLAY | WPS_CONFIG_LABEL)) ==
1613 return -1;
1615 wps->config_methods = wps_fix_config_methods(wps->config_methods);
1616 wps->dev.config_methods = wps->config_methods;
1617 os_memcpy(wps->dev.pri_dev_type, wpa_s->conf->device_type,
1620 wps->dev.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
1621 os_memcpy(wps->dev.sec_dev_type, wpa_s->conf->sec_device_type,
1622 WPS_DEV_TYPE_LEN * wps->dev.num_sec_dev_types);
1626 wps->dev.os_version = WPA_GET_BE32(wpa_s->conf->os_version);
1627 modes = wpa_s->hw.modes;
1629 for (m = 0; m < wpa_s->hw.num_modes; m++) {
1632 wps->dev.rf_bands |= WPS_RF_24GHZ;
1634 wps->dev.rf_bands |= WPS_RF_50GHZ;
1636 wps->dev.rf_bands |= WPS_RF_60GHZ;
1639 if (wps->dev.rf_bands == 0) {
1644 wps->dev.rf_bands = WPS_RF_24GHZ | WPS_RF_50GHZ;
1646 os_memcpy(wps->dev.mac_addr, wpa_s->own_addr, ETH_ALEN);
1650 wps->auth_types = WPS_AUTH_WPA2PSK;
1651 wps->encr_types = WPS_ENCR_AES;
1653 wps->auth_types = WPS_AUTH_WPA2PSK | WPS_AUTH_WPAPSK;
1654 wps->encr_types = WPS_ENCR_AES | WPS_ENCR_TKIP;
1663 wps->registrar = wps_registrar_init(wps, &rcfg);
1664 if (wps->registrar == NULL) {
1667 return -1;
1670 wpa_s->wps = wps;
1679 wps->ap_nfc_dev_pw_id = 0;
1680 wpabuf_free(wps->ap_nfc_dh_pubkey);
1681 wps->ap_nfc_dh_pubkey = NULL;
1682 wpabuf_free(wps->ap_nfc_dh_privkey);
1683 wps->ap_nfc_dh_privkey = NULL;
1684 wpabuf_free(wps->ap_nfc_dev_pw);
1685 wps->ap_nfc_dev_pw = NULL;
1702 if (wpa_s->wps == NULL)
1706 wps_er_deinit(wpa_s->wps_er, NULL, NULL);
1707 wpa_s->wps_er = NULL;
1708 wpas_wps_nfc_clear(wpa_s->wps);
1711 wps_registrar_deinit(wpa_s->wps->registrar);
1712 wpabuf_free(wpa_s->wps->dh_pubkey);
1713 wpabuf_free(wpa_s->wps->dh_privkey);
1714 wpabuf_free(wpa_s->wps->dev.vendor_ext_m1);
1715 os_free(wpa_s->wps->network_key);
1716 os_free(wpa_s->wps);
1717 wpa_s->wps = NULL;
1726 if (!(ssid->key_mgmt & WPA_KEY_MGMT_WPS))
1727 return -1;
1730 if (eap_is_wps_pbc_enrollee(&ssid->eap)) {
1732 wpa_printf(MSG_DEBUG, " skip - non-WPS AP");
1737 wpa_printf(MSG_DEBUG, " skip - WPS AP "
1750 if (eap_is_wps_pin_enrollee(&ssid->eap)) {
1752 wpa_printf(MSG_DEBUG, " skip - non-WPS AP");
1763 if (!wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1)) {
1766 os_reltime_age(&wpa_s->wps_pin_start_time, &age);
1768 if (wpa_s->scan_runs < WPS_PIN_SCAN_IGNORE_SEL_REG ||
1771 " skip - WPS AP without active PIN Registrar (scan_runs=%d age=%d)",
1772 wpa_s->scan_runs, (int) age.sec);
1791 return -1;
1802 if (eap_is_wps_pbc_enrollee(&ssid->eap)) {
1808 } else if (eap_is_wps_pin_enrollee(&ssid->eap)) {
1811 (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1) ||
1812 wpa_s->scan_runs >= WPS_PIN_SCAN_IGNORE_SEL_REG)) {
1818 if (!ret && ssid->bssid_set &&
1819 ether_addr_equal(ssid->bssid, bss->bssid)) {
1826 if (wps_validate_beacon_probe_resp(wps_ie, bss->beacon_ie_len >
1827 0, bss->bssid) < 0)
1829 if (bss->beacon_ie_len) {
1857 if (!ap->pbc_active ||
1858 ether_addr_equal(selected->bssid, ap->bssid))
1861 if (!is_zero_ether_addr(ssid->bssid) &&
1862 !ether_addr_equal(ap->bssid, ssid->bssid)) {
1865 MAC2STR(ap->bssid));
1870 MAC2STR(ap->bssid));
1872 ap->uuid, UUID_LEN);
1873 if (!sel_uuid || os_memcmp(sel_uuid, ap->uuid, UUID_LEN) != 0)
1876 /* TODO: verify that this is reasonable dual-band situation */
1891 if (!eap_is_wps_pbc_enrollee(&ssid->eap))
1896 MAC2STR(selected->bssid));
1897 if (!is_zero_ether_addr(ssid->bssid))
1900 MAC2STR(ssid->bssid));
1914 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
1915 for (i = 0; i < iface->num_wps_ap; i++) {
1916 struct wps_ap_info *ap = &iface->wps_ap[i];
1924 MAC2STR(selected->bssid),
1925 MAC2STR(ap->bssid));
1942 if (wpa_s->disconnected || wpa_s->wpa_state >= WPA_ASSOCIATED)
1945 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1953 else if (wps_is_addr_authorized(ie, wpa_s->own_addr, 0))
1977 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1978 if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && !ssid->disabled)
2005 if (wpa_s->wps_er) {
2006 wps_er_refresh(wpa_s->wps_er);
2009 wpa_s->wps_er = wps_er_init(wpa_s->wps, wpa_s->ifname, filter);
2010 if (wpa_s->wps_er == NULL)
2011 return -1;
2022 wps_er_deinit(wpa_s->wps_er, NULL, NULL);
2023 wpa_s->wps_er = NULL;
2040 use_uuid = wps_er_get_sta_uuid(wpa_s->wps_er, addr_buf);
2042 return -1;
2044 return -1;
2045 return wps_registrar_add_pin(wpa_s->wps->registrar, addr,
2061 return -1;
2062 return wps_er_pbc(wpa_s->wps_er, use_uuid, use_addr);
2077 return -1;
2079 return wps_er_learn(wpa_s->wps_er, use_uuid, use_addr, (const u8 *) pin,
2088 if (ssid->ssid_len > SSID_MAX_LEN)
2089 return -1;
2090 os_memcpy(cred->ssid, ssid->ssid, ssid->ssid_len);
2091 cred->ssid_len = ssid->ssid_len;
2092 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
2093 cred->auth_type = (ssid->proto & WPA_PROTO_RSN) ?
2095 if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)
2096 cred->encr_type = WPS_ENCR_AES;
2098 cred->encr_type = WPS_ENCR_TKIP;
2099 if (ssid->passphrase) {
2100 cred->key_len = os_strlen(ssid->passphrase);
2101 if (cred->key_len >= 64)
2102 return -1;
2103 os_memcpy(cred->key, ssid->passphrase, cred->key_len);
2104 } else if (ssid->psk_set) {
2105 cred->key_len = 32;
2106 os_memcpy(cred->key, ssid->psk, 32);
2108 return -1;
2110 cred->auth_type = WPS_AUTH_OPEN;
2111 cred->encr_type = WPS_ENCR_NONE;
2132 return -1;
2133 ssid = wpa_config_get_network(wpa_s->conf, id);
2134 if (ssid == NULL || ssid->ssid == NULL)
2135 return -1;
2138 return -1;
2139 ret = wps_er_set_config(wpa_s->wps_er, use_uuid, use_addr, &cred);
2158 return -1;
2159 if (settings->ssid_hex == NULL || settings->auth == NULL ||
2160 settings->encr == NULL || settings->key_hex == NULL)
2161 return -1;
2164 len = os_strlen(settings->ssid_hex);
2166 hexstr2bin(settings->ssid_hex, cred.ssid, len / 2))
2167 return -1;
2170 len = os_strlen(settings->key_hex);
2172 hexstr2bin(settings->key_hex, cred.key, len / 2))
2173 return -1;
2176 if (os_strcmp(settings->auth, "OPEN") == 0)
2178 else if (os_strcmp(settings->auth, "WPAPSK") == 0)
2180 else if (os_strcmp(settings->auth, "WPA2PSK") == 0)
2183 return -1;
2185 if (os_strcmp(settings->encr, "NONE") == 0)
2188 else if (os_strcmp(settings->encr, "WEP") == 0)
2191 else if (os_strcmp(settings->encr, "TKIP") == 0)
2193 else if (os_strcmp(settings->encr, "CCMP") == 0)
2196 return -1;
2198 return wps_er_config(wpa_s->wps_er, use_uuid, use_addr,
2211 if (!wpa_s->wps_er)
2221 ret = wps_er_nfc_config_token(wpa_s->wps_er, use_uuid, use_addr);
2241 if (--callbacks_pending <= 0)
2250 if (wpa_s->wps_er) {
2252 wps_er_deinit(wpa_s->wps_er, wpas_wps_terminate_cb, wpa_s);
2253 wpa_s->wps_er = NULL;
2263 struct wps_context *wps = wpa_s->wps;
2268 if (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS) {
2269 wps->config_methods = wps_config_methods_str2bin(
2270 wpa_s->conf->config_methods);
2271 if ((wps->config_methods &
2277 wps->config_methods &= ~WPS_CONFIG_LABEL;
2280 wps->config_methods = wps_fix_config_methods(wps->config_methods);
2281 wps->dev.config_methods = wps->config_methods;
2283 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
2284 os_memcpy(wps->dev.pri_dev_type, wpa_s->conf->device_type,
2287 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE) {
2288 wps->dev.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
2289 os_memcpy(wps->dev.sec_dev_type, wpa_s->conf->sec_device_type,
2290 wps->dev.num_sec_dev_types * WPS_DEV_TYPE_LEN);
2293 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION)
2296 if (wpa_s->conf->changed_parameters & CFG_CHANGED_OS_VERSION)
2297 wps->dev.os_version = WPA_GET_BE32(wpa_s->conf->os_version);
2299 if (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID)
2302 if (wpa_s->conf->changed_parameters &
2305 wps->dev.device_name = wpa_s->conf->device_name;
2306 wps->dev.manufacturer = wpa_s->conf->manufacturer;
2307 wps->dev.model_name = wpa_s->conf->model_name;
2308 wps->dev.model_number = wpa_s->conf->model_number;
2309 wps->dev.serial_number = wpa_s->conf->serial_number;
2318 wps = wpa_s->wps;
2320 os_memcpy(wps->dev.mac_addr, wpa_s->own_addr, ETH_ALEN);
2337 ret = wps_er_config_token_from_cred(wpa_s->wps, &cred);
2366 ssid = wpa_config_get_network(wpa_s->conf, id);
2373 if (wpa_s->ap_iface)
2382 if (wpa_s->conf->wps_nfc_pw_from_config) {
2384 wpa_s->conf->wps_nfc_dev_pw_id,
2385 wpa_s->conf->wps_nfc_dh_pubkey,
2386 wpa_s->conf->wps_nfc_dev_pw);
2389 return wps_nfc_token_gen(ndef, &wpa_s->conf->wps_nfc_dev_pw_id,
2390 &wpa_s->conf->wps_nfc_dh_pubkey,
2391 &wpa_s->conf->wps_nfc_dh_privkey,
2392 &wpa_s->conf->wps_nfc_dev_pw);
2402 struct wps_context *wps = wpa_s->wps;
2406 dev_pw = wpa_s->conf->wps_nfc_dev_pw;
2407 dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
2410 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
2411 wpa_s->conf->wps_nfc_dh_privkey == NULL) {
2412 wpa_printf(MSG_DEBUG, "WPS: Missing DH params - "
2413 "cannot start NFC-triggered connection");
2414 return -1;
2418 wpa_printf(MSG_DEBUG, "WPS: Missing Device Password (id=%u) - "
2419 "cannot start NFC-triggered connection", dev_pw_id);
2420 return -1;
2423 dh5_free(wps->dh_ctx);
2424 wpabuf_free(wps->dh_pubkey);
2425 wpabuf_free(wps->dh_privkey);
2426 wps->dh_privkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
2427 wps->dh_pubkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
2428 if (wps->dh_privkey == NULL || wps->dh_pubkey == NULL) {
2429 wps->dh_ctx = NULL;
2430 wpabuf_free(wps->dh_pubkey);
2431 wps->dh_pubkey = NULL;
2432 wpabuf_free(wps->dh_privkey);
2433 wps->dh_privkey = NULL;
2435 return -1;
2437 wps->dh_ctx = dh5_init_fixed(wps->dh_privkey, wps->dh_pubkey);
2438 if (wps->dh_ctx == NULL) {
2439 wpabuf_free(wps->dh_pubkey);
2440 wps->dh_pubkey = NULL;
2441 wpabuf_free(wps->dh_privkey);
2442 wps->dh_privkey = NULL;
2444 return -1;
2471 if (wps_oob_use_cred(wpa_s->wps, attr) < 0)
2472 return -1;
2474 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
2477 if (attr->ap_channel) {
2478 u16 chan = WPA_GET_BE16(attr->ap_channel);
2489 wpa_printf(MSG_DEBUG, "WPS: Credential container indicated AP channel %u -> %u MHz",
2491 wpa_s->after_wps = 5;
2492 wpa_s->wps_freq = freq;
2498 wpa_s->normal_scans = 0;
2500 wpa_s->disconnected = 0;
2501 wpa_s->reassociate = 1;
2515 wpa_s->wps->registrar, attr->oob_dev_password,
2516 attr->oob_dev_password_len);
2530 return -1;
2542 return -1;
2554 return -1;
2570 return -1;
2586 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
2587 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
2588 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
2591 ret = wps_build_nfc_handover_req(wpa_s->wps,
2592 wpa_s->conf->wps_nfc_dh_pubkey);
2617 struct wps_context *wps = wpa_s->wps;
2631 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL) {
2632 if (wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
2633 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
2638 wps->ap_nfc_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
2639 wps->ap_nfc_dh_pubkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
2640 wps->ap_nfc_dh_privkey = wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
2641 if (!wps->ap_nfc_dh_pubkey || !wps->ap_nfc_dh_privkey) {
2646 ret = wps_er_nfc_handover_sel(wpa_s->wps_er, wpa_s->wps, use_uuid,
2647 use_addr, wpa_s->conf->wps_nfc_dh_pubkey);
2682 int ret = -1;
2693 return -1;
2698 wpa_printf(MSG_DEBUG, "WPS: Too short Wi-Fi Handover Select "
2704 if (wsc_len > wpabuf_len(wps) - 2) {
2706 "in Wi-Fi Handover Select Message", wsc_len);
2712 "WPS: WSC attributes in Wi-Fi Handover Select Message",
2714 if (wsc_len < wpabuf_len(wps) - 2) {
2716 "WPS: Ignore extra data after WSC attributes",
2717 pos + wsc_len, wpabuf_len(wps) - 2 - wsc_len);
2724 "Wi-Fi Handover Select Message");
2730 wpa_printf(MSG_DEBUG, "WPS: No Out-of-Band Device Password "
2731 "included in Wi-Fi Handover Select Message");
2732 ret = -1;
2737 wpa_printf(MSG_DEBUG, "WPS: No SSID included in Wi-Fi Handover "
2739 ret = -1;
2777 "WPS: AP indicated channel %u -> %u MHz",
2782 wpa_hexdump(MSG_DEBUG, "WPS: Out-of-Band Device Password",
2788 "%u in Wi-Fi Handover Select Message", dev_pw_id);
2789 ret = -1;
2821 int ret = -1;
2834 return -1;
2839 wpa_printf(MSG_DEBUG, "WPS: Too short Wi-Fi Handover Request "
2845 if (wsc_len > wpabuf_len(wps) - 2) {
2847 "in rt Wi-Fi Handover Request Message", wsc_len);
2853 "WPS: WSC attributes in Wi-Fi Handover Request Message",
2855 if (wsc_len < wpabuf_len(wps) - 2) {
2857 "WPS: Ignore extra data after WSC attributes",
2858 pos + wsc_len, wpabuf_len(wps) - 2 - wsc_len);
2865 "Wi-Fi Handover Request Message");
2871 wpa_printf(MSG_DEBUG, "WPS: No Out-of-Band Device Password "
2872 "included in Wi-Fi Handover Request Message");
2873 ret = -1;
2878 wpa_printf(MSG_DEBUG, "WPS: No UUID-E included in Wi-Fi "
2880 ret = -1;
2884 wpa_hexdump(MSG_DEBUG, "WPS: UUID-E", attr.uuid_e, WPS_UUID_LEN);
2886 wpa_hexdump(MSG_DEBUG, "WPS: Out-of-Band Device Password",
2892 "%u in Wi-Fi Handover Request Message", dev_pw_id);
2893 ret = -1;
2899 ret = wps_registrar_add_nfc_pw_token(wpa_s->wps->registrar,
2920 if (wpa_s->wps_ap == NULL)
2925 for (i = 0; i < wpa_s->num_wps_ap; i++) {
2926 struct wps_ap_info *ap = &wpa_s->wps_ap[i];
2928 ap->bssid);
2932 (int) i, MAC2STR(ap->bssid), ap->type, ap->tries,
2933 ap->last_attempt.sec > 0 ?
2934 (int) now.sec - (int) ap->last_attempt.sec : -1,
2935 e ? e->count : 0);
2945 if (wpa_s->wps_ap == NULL)
2948 for (i = 0; i < wpa_s->num_wps_ap; i++) {
2949 struct wps_ap_info *ap = &wpa_s->wps_ap[i];
2950 if (ether_addr_equal(ap->bssid, bssid))
2974 r = wps_is_addr_authorized(wps, wpa_s->own_addr, 1);
2985 ap = wpas_wps_get_ap_info(wpa_s, res->bssid);
2987 if (ap->type != type) {
2989 " changed type %d -> %d",
2990 MAC2STR(res->bssid), ap->type, type);
2991 ap->type = type;
2993 wpa_bssid_ignore_del(wpa_s, ap->bssid);
2995 ap->pbc_active = pbc_active;
2997 os_memcpy(ap->uuid, uuid, WPS_UUID_LEN);
3001 ap = os_realloc_array(wpa_s->wps_ap, wpa_s->num_wps_ap + 1,
3006 wpa_s->wps_ap = ap;
3007 ap = &wpa_s->wps_ap[wpa_s->num_wps_ap];
3008 wpa_s->num_wps_ap++;
3011 os_memcpy(ap->bssid, res->bssid, ETH_ALEN);
3012 ap->type = type;
3013 ap->pbc_active = pbc_active;
3015 os_memcpy(ap->uuid, uuid, WPS_UUID_LEN);
3017 MAC2STR(ap->bssid), ap->type);
3029 for (i = 0; i < scan_res->num; i++)
3030 wpas_wps_update_ap_info_bss(wpa_s, scan_res->res[i]);
3038 struct wpa_global *global = wpa_s->global;
3041 for (iface = global->ifaces; iface; iface = iface->next) {
3045 if (!iface->supp_pbc_active)
3052 if (iface->wps_scan_done)
3064 struct wpa_global *global = wpa_s->global;
3067 for (iface = global->ifaces; iface; iface = iface->next) {
3070 if (iface->wps_overlap)
3082 wpa_s->after_wps = 0;
3084 if (!wpa_s->wps_ap_iter)
3089 ap->tries++;
3090 os_get_reltime(&ap->last_attempt);