Lines Matching refs:wpa_s
123 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
125 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
127 static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
131 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
134 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
138 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
139 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s);
141 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s);
145 static int wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
147 static void wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s);
150 static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s);
151 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
153 static void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s,
155 static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s,
159 static int wpas_p2p_go_is_peer_freq(struct wpa_supplicant *wpa_s, int freq);
161 wpas_p2p_consider_moving_gos(struct wpa_supplicant *wpa_s,
171 static int wpas_p2p_num_unused_channels(struct wpa_supplicant *wpa_s)
176 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
180 num = get_shared_radio_freqs(wpa_s, freqs,
181 wpa_s->num_multichan_concurrent);
184 unused = wpa_s->num_multichan_concurrent - num;
185 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: num_unused_channels: %d", unused);
195 wpas_p2p_valid_oper_freqs(struct wpa_supplicant *wpa_s,
202 freqs = os_calloc(wpa_s->num_multichan_concurrent,
207 num = get_shared_radio_freqs_data(wpa_s, freqs,
208 wpa_s->num_multichan_concurrent);
213 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
219 dump_freq_data(wpa_s, "valid for P2P", p2p_freqs, j);
225 static void wpas_p2p_set_own_freq_preference(struct wpa_supplicant *wpa_s,
228 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
231 /* Use the wpa_s used to control the P2P Device operation */
232 wpa_s = wpa_s->global->p2p_init_wpa_s;
234 if (wpa_s->conf->p2p_ignore_shared_freq &&
235 freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
236 wpas_p2p_num_unused_channels(wpa_s) > 0) {
241 p2p_set_own_freq_preference(wpa_s->global->p2p, freq);
245 static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
250 if (wpa_s->p2p_scan_work) {
251 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
252 wpa_s->p2p_scan_work = NULL;
256 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
284 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
290 p2p_scan_res_handled(wpa_s->global->p2p);
296 struct wpa_supplicant *wpa_s = work->wpa_s;
306 wpa_s->p2p_scan_work = NULL;
310 if (wpa_s->clear_driver_scan_cache) {
315 ret = wpa_drv_scan(wpa_s, params);
317 wpa_s->curr_scan_cookie = params->scan_cookie;
322 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
326 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
327 os_get_reltime(&wpa_s->scan_trigger_time);
328 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
329 wpa_s->own_scan_requested = 1;
330 wpa_s->clear_driver_scan_cache = 0;
331 wpa_s->p2p_scan_work = work;
335 static int wpas_p2p_search_social_channel(struct wpa_supplicant *wpa_s,
338 if (wpa_s->global->p2p_24ghz_social_channels &&
347 return p2p_supported_freq(wpa_s->global->p2p, freq);
355 struct wpa_supplicant *wpa_s = ctx;
364 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
367 if (wpa_s->p2p_scan_work) {
368 wpa_dbg(wpa_s, MSG_INFO, "P2P: Reject scan trigger since one is already pending");
385 wpa_s->wps->dev.p2p = 1;
386 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
387 wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
400 wpa_s, social_channels_freq[i]))
422 wpa_s, social_channels_freq[i]))
426 if (p2p_supported_freq(wpa_s->global->p2p, freq))
432 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
441 bands = wpas_get_bands(wpa_s, params->freqs);
442 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id, bands);
455 radio_remove_works(wpa_s, "p2p-scan", 0);
456 if (radio_add_work(wpa_s, 0, "p2p-scan", 0, wpas_p2p_trigger_scan_cb,
482 static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s,
488 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
489 for (s = wpa_s->conf->ssid; s; s = s->next) {
495 s != wpa_s->current_ssid)
499 return wpa_s;
509 struct wpa_supplicant *wpa_s = eloop_ctx;
512 wpa_s->ifname);
513 wpas_p2p_disconnect(wpa_s);
517 static int wpas_p2p_disconnect_safely(struct wpa_supplicant *wpa_s,
520 if (calling_wpa_s == wpa_s && wpa_s &&
521 wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
523 * The calling wpa_s instance is going to be removed. Do that
529 wpa_s, NULL) < 0)
534 return wpas_p2p_disconnect(wpa_s);
539 static unsigned int p2p_group_go_member_count(struct wpa_supplicant *wpa_s)
544 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
545 for (s = wpa_s->conf->ssid; s; s = s->next) {
548 wpa_s, s, s->disabled, s->p2p_group,
553 wpa_s->p2p_group);
562 static unsigned int p2p_is_active_persistent_group(struct wpa_supplicant *wpa_s)
564 return !wpa_s->p2p_mgmt && wpa_s->current_ssid &&
565 !wpa_s->current_ssid->disabled &&
566 wpa_s->current_ssid->p2p_group &&
567 wpa_s->current_ssid->p2p_persistent_group;
571 static unsigned int p2p_is_active_persistent_go(struct wpa_supplicant *wpa_s)
573 return p2p_is_active_persistent_group(wpa_s) &&
574 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO;
580 wpas_p2p_get_go_group(struct wpa_supplicant *wpa_s)
584 if (!wpa_s)
587 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
588 if (!p2p_is_active_persistent_go(wpa_s))
592 if (p2p_get_group_num_members(wpa_s->p2p_group))
593 return wpa_s;
594 save = wpa_s;
602 static unsigned int p2p_is_active_persistent_cli(struct wpa_supplicant *wpa_s)
604 return p2p_is_active_persistent_group(wpa_s) &&
605 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
611 wpas_p2p_get_cli_group(struct wpa_supplicant *wpa_s)
613 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
614 if (p2p_is_active_persistent_cli(wpa_s))
615 return wpa_s;
624 wpas_p2p_get_persistent_go(struct wpa_supplicant *wpa_s)
628 for (s = wpa_s->conf->ssid; s; s = s->next) {
641 struct wpa_supplicant *wpa_s = ctx;
659 !wpas_p2p_setup_freqs(wpa_s, 0, (int *) force_freq,
661 wpas_p2p_set_own_freq_preference(wpa_s,
671 go_wpa_s = wpas_p2p_get_go_group(wpa_s);
674 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
675 p2p_no_group_iface = !wpas_p2p_create_iface(wpa_s);
676 cli_wpa_s = wpas_p2p_get_cli_group(wpa_s);
811 s = wpas_p2p_get_persistent_go(wpa_s);
813 p2p_set_intended_addr(wpa_s->global->p2p,
814 wpa_s->p2p_mgmt ?
815 wpa_s->parent->own_addr :
816 wpa_s->own_addr);
818 if (wpas_p2p_add_group_interface(wpa_s,
824 wpa_s->global->pending_group_iface_for_p2ps = 1;
825 p2p_set_intended_addr(wpa_s->global->p2p,
826 wpa_s->pending_interface_addr);
834 static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s,
841 ssid = wpa_s->current_ssid;
848 ssid = wpa_s->conf->ssid;
855 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
862 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
864 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
866 wpa_s->reassociate = 0;
867 wpa_s->disconnected = 1;
873 wpas_notify_p2p_group_removed(wpa_s, ssid, gtype);
876 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
878 wpa_s, NULL)) {
883 wpa_s, NULL);
887 if (wpa_s->cross_connect_in_use) {
888 wpa_s->cross_connect_in_use = 0;
889 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
891 wpa_s->ifname, wpa_s->cross_connect_uplink);
920 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
922 wpa_s->ifname, gtype, reason);
925 if (eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL) > 0)
927 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
930 wpa_s->p2pdev, NULL) > 0) {
933 wpa_s->p2p_in_provisioning = 0;
934 wpas_p2p_group_formation_failed(wpa_s, 1);
937 wpa_s->p2p_in_invitation = 0;
938 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
939 eloop_cancel_timeout(wpas_p2p_reconsider_moving_go, wpa_s, NULL);
945 wpa_s->global->p2p_go_wait_client.sec = 0;
947 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
952 wpa_s->ifname);
953 global = wpa_s->global;
954 ifname = os_strdup(wpa_s->ifname);
955 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
956 eloop_cancel_timeout(run_wpas_p2p_disconnect, wpa_s, NULL);
957 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
958 wpa_s = global->ifaces;
959 if (wpa_s && ifname)
960 wpa_drv_if_remove(wpa_s, type, ifname);
969 wpa_s->p2pdev = wpa_s->parent;
971 if (!wpa_s->p2p_go_group_formation_completed) {
972 wpa_s->global->p2p_group_formation = NULL;
973 wpa_s->p2p_in_provisioning = 0;
976 wpa_s->show_group_started = 0;
977 os_free(wpa_s->go_params);
978 wpa_s->go_params = NULL;
980 os_free(wpa_s->p2p_group_common_freqs);
981 wpa_s->p2p_group_common_freqs = NULL;
982 wpa_s->p2p_group_common_freqs_num = 0;
983 wpa_s->p2p_go_do_acs = 0;
985 wpa_s->waiting_presence_resp = 0;
992 if (ssid == wpa_s->current_ssid) {
993 wpa_sm_set_config(wpa_s->wpa, NULL);
994 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
995 wpa_s->current_ssid = NULL;
1006 wpa_config_remove_network(wpa_s->conf, id);
1007 wpa_supplicant_clear_status(wpa_s);
1008 wpa_supplicant_cancel_sched_scan(wpa_s);
1013 if (wpa_s->ap_iface)
1014 wpa_supplicant_ap_deinit(wpa_s);
1016 wpa_drv_deinit_p2p_cli(wpa_s);
1018 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
1024 static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
1034 if (wpa_s->go_params)
1035 bssid = wpa_s->go_params->peer_interface_addr;
1037 bssid = wpa_s->bssid;
1039 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
1040 if (bss == NULL && wpa_s->go_params &&
1041 !is_zero_ether_addr(wpa_s->go_params->peer_device_addr))
1043 wpa_s, wpa_s->go_params->peer_device_addr);
1046 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
1048 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
1093 static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
1102 for (s = wpa_s->conf->ssid; s; s = s->next) {
1122 s = wpa_config_add_network(wpa_s->conf);
1134 wpas_notify_persistent_group_added(wpa_s, s);
1168 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) {
1169 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list);
1170 wpa_s->global->add_psk = NULL;
1174 if (changed && wpa_s->conf->update_config &&
1175 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
1183 static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s,
1190 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
1192 ssid = wpa_s->current_ssid;
1262 static void wpas_p2p_group_started(struct wpa_supplicant *wpa_s,
1288 wpa_msg_global_ctrl(wpa_s->p2pdev, MSG_INFO,
1292 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1301 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1307 static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
1316 * This callback is likely called for the main interface. Update wpa_s
1320 if (wpa_s->global->p2p_group_formation)
1321 wpa_s = wpa_s->global->p2p_group_formation;
1322 if (wpa_s->p2p_go_group_formation_completed) {
1323 wpa_s->global->p2p_group_formation = NULL;
1324 wpa_s->p2p_in_provisioning = 0;
1325 } else if (wpa_s->p2p_in_provisioning && !success) {
1326 wpa_msg(wpa_s, MSG_DEBUG,
1328 wpa_s->p2p_in_provisioning = 0;
1330 wpa_s->p2p_in_invitation = 0;
1331 wpa_s->group_formation_reported = 1;
1334 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1336 wpas_notify_p2p_group_formation_failure(wpa_s, "");
1339 wpas_p2p_group_delete(wpa_s,
1344 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1347 ssid = wpa_s->current_ssid;
1350 p2p_group_notif_formation_done(wpa_s->p2p_group);
1351 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
1359 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
1362 persistent = wpas_p2p_persistent_group(wpa_s,
1367 client = wpa_s->p2p_group_interface ==
1372 wpa_s->show_group_started = 0;
1379 wpa_s->show_group_started = 1;
1381 wpas_p2p_group_started(wpa_s, 1, ssid,
1387 wpas_p2p_cross_connect_setup(wpa_s);
1388 wpas_p2p_set_group_idle_timeout(wpa_s);
1392 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
1395 os_free(wpa_s->global->add_psk);
1396 wpa_s->global->add_psk = NULL;
1400 wpas_notify_p2p_group_started(wpa_s, ssid, persistent, 0, NULL);
1401 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
1417 static void wpas_p2p_free_send_action_work(struct wpa_supplicant *wpa_s)
1419 struct send_action_work *awork = wpa_s->p2p_send_action_work->ctx;
1424 wpa_s->p2p_send_action_work, awork->freq,
1430 wpa_s->p2p_send_action_work->ctx = NULL;
1431 radio_work_done(wpa_s->p2p_send_action_work);
1432 wpa_s->p2p_send_action_work = NULL;
1439 struct wpa_supplicant *wpa_s = eloop_ctx;
1441 if (!wpa_s->p2p_send_action_work)
1445 wpas_p2p_free_send_action_work(wpa_s);
1449 static void wpas_p2p_action_tx_clear(struct wpa_supplicant *wpa_s)
1451 if (wpa_s->p2p_send_action_work) {
1454 awork = wpa_s->p2p_send_action_work->ctx;
1457 wpa_s->p2p_send_action_work, awork->wait_time);
1459 wpas_p2p_free_send_action_work(wpa_s);
1468 wpa_s, NULL);
1472 wpa_s, NULL);
1478 static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
1488 wpas_p2p_action_tx_clear(wpa_s);
1490 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
1505 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
1508 wpa_s->pending_pd_before_join &&
1509 (os_memcmp(dst, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
1510 os_memcmp(dst, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0) &&
1511 wpa_s->p2p_fallback_to_go_neg) {
1512 wpa_s->pending_pd_before_join = 0;
1513 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req "
1515 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1518 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
1526 struct wpa_supplicant *wpa_s = work->wpa_s;
1532 wpa_s, NULL);
1533 wpa_s->p2p_send_action_work = NULL;
1534 offchannel_send_action_done(wpa_s);
1540 if (offchannel_send_action(wpa_s, awork->freq, awork->dst, awork->src,
1548 wpa_s->p2p_send_action_work = work;
1552 static int wpas_send_action_work(struct wpa_supplicant *wpa_s,
1559 if (radio_work_pending(wpa_s, "p2p-send-action")) {
1576 if (radio_add_work(wpa_s, freq, "p2p-send-action", 1,
1590 struct wpa_supplicant *wpa_s = ctx;
1595 if (wpa_s->p2p_listen_work)
1596 listen_freq = wpa_s->p2p_listen_work->freq;
1597 if (wpa_s->p2p_send_action_work)
1598 send_freq = wpa_s->p2p_send_action_work->freq;
1604 res = wpas_send_action_work(wpa_s, freq, dst, src, bssid, buf,
1612 return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len,
1620 struct wpa_supplicant *wpa_s = ctx;
1622 if (wpa_s->p2p_send_action_work) {
1624 wpa_s, NULL);
1625 os_free(wpa_s->p2p_send_action_work->ctx);
1626 radio_work_done(wpa_s->p2p_send_action_work);
1627 wpa_s->p2p_send_action_work = NULL;
1630 offchannel_send_action_done(wpa_s);
1634 static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
1637 if (wpa_s->go_params == NULL) {
1638 wpa_s->go_params = os_malloc(sizeof(*params));
1639 if (wpa_s->go_params == NULL)
1642 os_memcpy(wpa_s->go_params, params, sizeof(*params));
1647 static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
1650 wpa_s->group_formation_reported = 0;
1657 wpa_supplicant_ap_deinit(wpa_s);
1658 wpas_copy_go_neg_results(wpa_s, res);
1660 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1, 0);
1663 wpas_wps_start_nfc(wpa_s, res->peer_device_addr,
1665 wpa_s->p2pdev->p2p_oob_dev_pw,
1666 wpa_s->p2pdev->p2p_oob_dev_pw_id, 1,
1667 wpa_s->p2pdev->p2p_oob_dev_pw_id ==
1669 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash :
1675 if (wpa_s->p2p_wps_method == WPS_P2PS)
1677 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
1679 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
1680 wpa_s->p2p_pin, 1, dev_pw_id);
1685 static void wpas_p2p_add_psk_list(struct wpa_supplicant *wpa_s,
1692 if (!wpa_s->ap_iface)
1695 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
1700 hapd = wpa_s->ap_iface->bss[0];
1706 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add persistent group PSK entry for "
1723 static void p2p_go_dump_common_freqs(struct wpa_supplicant *wpa_s)
1732 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
1734 wpa_s->p2p_group_common_freqs[i]);
1741 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Common group frequencies:%s", buf);
1745 static void p2p_go_save_group_common_freqs(struct wpa_supplicant *wpa_s,
1748 unsigned int i, len = int_array_len(wpa_s->go_params->freq_list);
1750 wpa_s->p2p_group_common_freqs_num = 0;
1751 os_free(wpa_s->p2p_group_common_freqs);
1752 wpa_s->p2p_group_common_freqs = os_calloc(len, sizeof(int));
1753 if (!wpa_s->p2p_group_common_freqs)
1757 if (!wpa_s->go_params->freq_list[i])
1759 wpa_s->p2p_group_common_freqs[i] =
1760 wpa_s->go_params->freq_list[i];
1762 wpa_s->p2p_group_common_freqs_num = i;
1766 static void p2p_config_write(struct wpa_supplicant *wpa_s)
1769 if (wpa_s->p2pdev->conf->update_config &&
1770 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
1778 struct wpa_supplicant *wpa_s = ctx;
1782 wpa_s->ap_configured_cb = NULL;
1783 wpa_s->ap_configured_cb_ctx = NULL;
1784 wpa_s->ap_configured_cb_data = NULL;
1785 if (!wpa_s->go_params) {
1787 "P2P: p2p_go_configured() called with wpa_s->go_params == NULL");
1791 p2p_go_save_group_common_freqs(wpa_s, params);
1792 p2p_go_dump_common_freqs(wpa_s);
1794 ssid = wpa_s->current_ssid;
1797 if (wpa_s->global->p2p_group_formation == wpa_s)
1798 wpa_s->global->p2p_group_formation = NULL;
1799 wpas_p2p_group_started(wpa_s, 1, ssid, ssid->frequency,
1803 wpa_s->global->p2p_dev_addr,
1805 wpa_s->group_formation_reported = 1;
1807 if (wpa_s->p2pdev->p2ps_method_config_any) {
1808 if (is_zero_ether_addr(wpa_s->p2pdev->p2ps_join_addr)) {
1809 wpa_dbg(wpa_s, MSG_DEBUG,
1811 wpa_supplicant_ap_wps_pin(wpa_s, NULL,
1815 wpa_dbg(wpa_s, MSG_DEBUG,
1817 MAC2STR(wpa_s->p2pdev->p2ps_join_addr));
1819 wpa_s, wpa_s->p2pdev->p2ps_join_addr,
1822 wpa_s->p2pdev->p2ps_method_config_any = 0;
1825 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
1828 wpa_s->p2pdev, ssid,
1829 wpa_s->global->p2p_dev_addr);
1830 wpas_p2p_add_psk_list(wpa_s, ssid);
1833 wpas_notify_p2p_group_started(wpa_s, ssid,
1836 wpas_p2p_cross_connect_setup(wpa_s);
1837 wpas_p2p_set_group_idle_timeout(wpa_s);
1839 if (wpa_s->p2p_first_connection_timeout) {
1840 wpa_dbg(wpa_s, MSG_DEBUG,
1842 wpa_s->p2p_first_connection_timeout);
1843 wpa_s->p2p_go_group_formation_completed = 0;
1844 wpa_s->global->p2p_group_formation = wpa_s;
1846 wpa_s->p2pdev, NULL);
1848 wpa_s->p2p_first_connection_timeout, 0,
1850 wpa_s->p2pdev, NULL);
1857 if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
1864 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
1868 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
1870 !wpa_s->p2pdev->p2p_oob_dev_pw) {
1875 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
1876 wpa_s->p2pdev->p2p_oob_dev_pw,
1877 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
1878 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
1880 } else if (wpa_s->p2p_pin[0])
1881 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
1882 wpa_s->p2p_pin, NULL, 0, 0);
1883 os_free(wpa_s->go_params);
1884 wpa_s->go_params = NULL;
1888 static void wpas_start_wps_go(struct wpa_supplicant *wpa_s,
1894 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO");
1895 if (wpas_copy_go_neg_results(wpa_s, params) < 0) {
1896 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation "
1901 ssid = wpa_config_add_network(wpa_s->conf);
1903 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO");
1907 wpa_s->show_group_started = 0;
1908 wpa_s->p2p_go_group_formation_completed = 0;
1909 wpa_s->group_formation_reported = 0;
1910 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
1947 wpa_msg_global(wpa_s, MSG_ERROR,
1949 wpa_config_remove_network(wpa_s->conf, ssid->id);
1959 ssid->ap_max_inactivity = wpa_s->p2pdev->conf->p2p_go_max_inactivity;
1961 wpa_s->ap_configured_cb = p2p_go_configured;
1962 wpa_s->ap_configured_cb_ctx = wpa_s;
1963 wpa_s->ap_configured_cb_data = wpa_s->go_params;
1964 wpa_s->scan_req = NORMAL_SCAN_REQ;
1965 wpa_s->connect_without_scan = ssid;
1966 wpa_s->reassociate = 1;
1967 wpa_s->disconnected = 0;
1968 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to "
1970 wpa_supplicant_req_scan(wpa_s, 0, 0);
2032 static void wpas_p2p_get_group_ifname(struct wpa_supplicant *wpa_s,
2035 char *ifname_ptr = wpa_s->ifname;
2037 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX,
2039 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1;
2042 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx);
2044 os_strlen(wpa_s->ifname) < IFNAMSIZ) {
2048 res = os_snprintf(ifname, len, "p2p-%d", wpa_s->p2p_group_idx);
2055 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
2060 if (wpa_s->pending_interface_name[0]) {
2063 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
2066 wpa_s->pending_interface_name);
2072 wpas_p2p_get_group_ifname(wpa_s, ifname, sizeof(ifname));
2077 wpa_s->p2p_group_idx++;
2079 wpa_s->pending_interface_type = type;
2080 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
2081 wpa_s->pending_interface_addr, NULL) < 0) {
2087 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2088 random_mac_addr(wpa_s->pending_interface_addr);
2091 MAC2STR(wpa_s->pending_interface_addr));
2097 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
2098 sizeof(wpa_s->pending_interface_name));
2100 os_strlcpy(wpa_s->pending_interface_name, ifname,
2101 sizeof(wpa_s->pending_interface_name));
2103 MACSTR, wpa_s->pending_interface_name,
2104 MAC2STR(wpa_s->pending_interface_addr));
2111 struct wpa_supplicant *wpa_s)
2113 if (!wpa_s->pending_interface_name[0] ||
2114 is_zero_ether_addr(wpa_s->pending_interface_addr))
2118 wpa_s->pending_interface_name);
2119 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
2120 wpa_s->pending_interface_name);
2121 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
2122 wpa_s->pending_interface_name[0] = '\0';
2123 wpa_s->global->pending_group_iface_for_p2ps = 0;
2128 wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
2133 if (!wpa_s->pending_interface_name[0]) {
2135 if (!wpas_p2p_create_iface(wpa_s))
2142 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
2148 iface.ifname = wpa_s->pending_interface_name;
2149 iface.driver = wpa_s->driver->name;
2150 if (wpa_s->conf->ctrl_interface == NULL &&
2151 wpa_s->parent != wpa_s &&
2152 wpa_s->p2p_mgmt &&
2153 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE))
2154 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface;
2156 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
2157 iface.driver_param = wpa_s->conf->driver_param;
2158 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
2164 wpa_s->pending_interface_name[0] = '\0';
2167 wpa_s->global->p2p_group_formation = group_wpa_s;
2168 wpa_s->global->pending_group_iface_for_p2ps = 0;
2170 wpas_p2p_clone_config(group_wpa_s, wpa_s);
2172 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2174 wpa_s->pending_interface_addr) < 0) {
2177 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2185 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2192 MAC2STR(wpa_s->pending_interface_addr));
2202 struct wpa_supplicant *wpa_s = eloop_ctx;
2204 wpas_p2p_group_formation_failed(wpa_s, 0);
2208 static void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s,
2212 wpa_s->p2pdev, NULL);
2213 if (wpa_s->global->p2p)
2214 p2p_group_formation_failed(wpa_s->global->p2p);
2215 wpas_group_formation_completed(wpa_s, 0, already_deleted);
2219 static void wpas_p2p_grpform_fail_after_wps(struct wpa_supplicant *wpa_s)
2223 wpa_s->p2pdev, NULL);
2225 wpa_s->p2pdev, NULL);
2226 wpa_s->global->p2p_fail_on_wps_complete = 0;
2230 void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s)
2232 if (wpa_s->global->p2p_group_formation != wpa_s)
2236 wpa_s->p2pdev, NULL);
2238 wpa_s->p2pdev, NULL);
2244 struct wpa_supplicant *wpa_s = ctx;
2247 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
2248 wpa_drv_cancel_remain_on_channel(wpa_s);
2249 wpa_s->off_channel_freq = 0;
2250 wpa_s->roc_waiting_drv_freq = 0;
2254 wpa_msg_global(wpa_s, MSG_INFO,
2257 wpas_notify_p2p_go_neg_completed(wpa_s, res);
2258 wpas_p2p_remove_pending_group_interface(wpa_s);
2264 wpa_drv_set_prob_oper_freq(wpa_s, res->freq);
2267 if (wpa_s->p2p_go_ht40)
2269 if (wpa_s->p2p_go_vht)
2271 if (wpa_s->p2p_go_he)
2273 res->max_oper_chwidth = wpa_s->p2p_go_max_oper_chwidth;
2274 res->vht_center_freq2 = wpa_s->p2p_go_vht_center_freq2;
2276 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS "role=%s "
2283 wpas_notify_p2p_go_neg_completed(wpa_s, res);
2285 if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
2287 ssid = wpa_config_get_network(wpa_s->conf,
2288 wpa_s->p2p_persistent_id);
2299 if (wpa_s->create_p2p_iface) {
2301 wpas_p2p_init_group_interface(wpa_s, res->role_go);
2303 wpas_p2p_remove_pending_group_interface(wpa_s);
2305 wpa_s, NULL);
2306 wpas_p2p_group_formation_failed(wpa_s, 1);
2309 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
2310 wpa_s->pending_interface_name[0] = '\0';
2312 group_wpa_s = wpa_s->parent;
2313 wpa_s->global->p2p_group_formation = group_wpa_s;
2314 if (group_wpa_s != wpa_s)
2315 wpas_p2p_clone_config(group_wpa_s, wpa_s);
2319 group_wpa_s->p2pdev = wpa_s;
2320 if (group_wpa_s != wpa_s) {
2321 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
2323 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
2332 wpa_s->p2p_long_listen = 0;
2333 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
2335 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
2338 wpas_p2p_group_formation_timeout, wpa_s, NULL);
2345 struct wpa_supplicant *wpa_s = ctx;
2346 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
2350 wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id, go_intent);
2359 struct wpa_supplicant *wpa_s = ctx;
2392 wpa_msg_global(wpa_s, MSG_INFO,
2414 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
2438 struct wpa_supplicant *wpa_s = ctx;
2440 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST
2443 wpas_notify_p2p_device_lost(wpa_s, dev_addr);
2449 struct wpa_supplicant *wpa_s = ctx;
2451 if (wpa_s->p2p_scan_work && wpas_abort_ongoing_scan(wpa_s) < 0)
2454 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_FIND_STOPPED);
2455 wpas_notify_p2p_find_stopped(wpa_s);
2475 static void wpas_p2p_listen_work_done(struct wpa_supplicant *wpa_s)
2479 if (!wpa_s->p2p_listen_work)
2482 lwork = wpa_s->p2p_listen_work->ctx;
2484 radio_work_done(wpa_s->p2p_listen_work);
2485 wpa_s->p2p_listen_work = NULL;
2491 struct wpa_supplicant *wpa_s = work->wpa_s;
2497 wpa_s->p2p_listen_work = NULL;
2498 wpas_stop_listen(wpa_s);
2504 wpa_s->p2p_listen_work = work;
2506 wpa_drv_set_ap_wps_ie(wpa_s, NULL, lwork->probe_resp_ie, NULL);
2508 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
2511 wpas_p2p_listen_work_done(wpa_s);
2515 wpa_s->pending_listen_freq = lwork->freq;
2516 wpa_s->pending_listen_duration = lwork->duration;
2520 if (wpa_s->extra_roc_dur) {
2522 duration, duration + wpa_s->extra_roc_dur);
2523 duration += wpa_s->extra_roc_dur;
2527 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, duration) < 0) {
2531 wpas_p2p_listen_work_done(wpa_s);
2532 wpa_s->pending_listen_freq = 0;
2535 wpa_s->off_channel_freq = 0;
2536 wpa_s->roc_waiting_drv_freq = lwork->freq;
2544 struct wpa_supplicant *wpa_s = ctx;
2547 if (wpa_s->p2p_listen_work) {
2565 if (radio_add_work(wpa_s, freq, "p2p-listen", 0, wpas_start_listen_cb,
2577 struct wpa_supplicant *wpa_s = ctx;
2578 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
2579 wpa_drv_cancel_remain_on_channel(wpa_s);
2580 wpa_s->off_channel_freq = 0;
2581 wpa_s->roc_waiting_drv_freq = 0;
2583 wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL);
2589 if (!wpa_s->p2p_cli_probe)
2590 wpa_drv_probe_req_report(wpa_s, 0);
2592 wpas_p2p_listen_work_done(wpa_s);
2599 struct wpa_supplicant *wpa_s = ctx;
2600 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1,
2605 static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
2609 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR
2614 static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
2617 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR
2628 struct wpa_supplicant *wpa_s = ctx;
2637 for (group = wpa_s->global->ifaces; group; group = group->next)
2670 wpa_s, peer, 0 /* response */,
2674 wpas_prov_disc_local_display(wpa_s, peer, params,
2677 wpas_prov_disc_local_keypad(wpa_s, peer, params);
2679 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ
2682 wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */,
2690 struct wpa_supplicant *wpa_s = ctx;
2694 if (wpa_s->pending_pd_before_join &&
2695 (os_memcmp(peer, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
2696 os_memcmp(peer, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
2697 wpa_s->pending_pd_before_join = 0;
2700 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
2704 if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
2705 wpa_s->pending_pd_use == AUTO_PD_GO_NEG) {
2709 wpa_s->pending_pd_use == AUTO_PD_JOIN);
2716 wpas_prov_disc_local_keypad(wpa_s, peer, params);
2721 wpa_s, peer, 0 /* response */,
2725 wpas_prov_disc_local_display(wpa_s, peer, params,
2728 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP
2731 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2742 struct wpa_supplicant *wpa_s = ctx;
2744 if (wpa_s->p2p_fallback_to_go_neg) {
2745 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
2747 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
2750 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
2755 wpa_s->pending_pd_before_join = 0;
2759 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
2764 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
2770 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
2774 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
2779 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2784 static int freq_included(struct wpa_supplicant *wpa_s,
2789 wpas_p2p_go_is_peer_freq(wpa_s, freq))
2795 static void wpas_p2p_go_update_common_freqs(struct wpa_supplicant *wpa_s)
2801 p2p_go_dump_common_freqs(wpa_s);
2806 ret = p2p_group_get_common_freqs(wpa_s->p2p_group, common_freqs, &num);
2808 wpa_dbg(wpa_s, MSG_DEBUG,
2814 os_free(wpa_s->p2p_group_common_freqs);
2815 wpa_s->p2p_group_common_freqs = common_freqs;
2816 wpa_s->p2p_group_common_freqs_num = num;
2817 p2p_go_dump_common_freqs(wpa_s);
2825 static int wpas_p2p_go_is_peer_freq(struct wpa_supplicant *wpa_s, int freq)
2829 p2p_go_dump_common_freqs(wpa_s);
2832 if (!wpa_s->p2p_group_common_freqs_num)
2835 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
2836 if (wpa_s->p2p_group_common_freqs[i] == freq)
2855 static int wpas_p2p_go_clients_support_ecsa(struct wpa_supplicant *wpa_s)
2859 ap_for_each_sta(wpa_s->ap_iface->bss[0], wpas_sta_check_ecsa,
2869 static int wpas_p2p_pick_best_used_freq(struct wpa_supplicant *wpa_s,
2877 if (p2p_supported_freq(wpa_s->global->p2p, freqs[c].freq))
2885 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
2912 struct wpa_supplicant *wpa_s = ctx;
2922 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
2923 (os_memcmp(go_dev_addr, wpa_s->p2p_auth_invite, ETH_ALEN)
2925 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0)) {
2932 if (dev_pw_id >= 0 && wpa_s->p2p_nfc_tag_enabled &&
2933 dev_pw_id == wpa_s->p2p_oob_dev_pw_id) {
2935 wpa_s->p2p_wps_method = WPS_NFC;
2936 wpa_s->pending_join_wps_method = WPS_NFC;
2937 os_memcpy(wpa_s->pending_join_dev_addr,
2939 os_memcpy(wpa_s->pending_join_iface_addr,
2952 grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go);
2961 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
2962 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0) {
2965 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
2966 } else if (!wpa_s->conf->persistent_reconnect)
2969 for (s = wpa_s->conf->ssid; s; s = s->next) {
2984 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
2986 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2992 if (wpa_s->p2p_mgmt)
2993 os_memcpy(group_bssid, wpa_s->parent->own_addr,
2996 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
2999 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
3005 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
3010 wpas_p2p_set_own_freq_preference(wpa_s, 0);
3013 freqs = os_calloc(wpa_s->num_multichan_concurrent,
3016 int num_channels = wpa_s->num_multichan_concurrent;
3017 int num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, num_channels);
3018 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
3025 wpas_p2p_set_own_freq_preference(wpa_s, best_freq);
3027 if (wpa_s->num_multichan_concurrent < 2 ||
3028 wpas_p2p_num_unused_channels(wpa_s) < 1) {
3034 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
3035 wpas_p2p_num_unused_channels(wpa_s) > 0) {
3042 } else if (!freq_included(wpa_s, channels, *force_freq)) {
3062 struct wpa_supplicant *wpa_s = ctx;
3065 for (s = wpa_s->conf->ssid; s; s = s->next) {
3079 wpa_msg_global(wpa_s, MSG_INFO,
3085 wpa_msg_global(wpa_s, MSG_INFO,
3092 wpa_s, s, go, 0, op_freq, 0, 0, 0, 0, 0, NULL,
3096 wpa_s->user_initiated_pd = 0;
3097 wpa_msg_global(wpa_s, MSG_INFO,
3103 wpas_p2p_join(wpa_s, bssid, go_dev_addr,
3104 wpa_s->p2p_wps_method, 0, op_freq,
3118 wpa_msg_global(wpa_s, MSG_INFO,
3125 wpa_msg_global(wpa_s, MSG_INFO,
3131 wpas_notify_p2p_invitation_received(wpa_s, sa, go_dev_addr,
3137 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3141 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3145 wpas_notify_p2p_invitation_received(wpa_s, sa, go_dev_addr, bssid,
3150 static void wpas_remove_persistent_peer(struct wpa_supplicant *wpa_s,
3155 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
3170 wpas_notify_network_removed(wpa_s, ssid);
3171 wpa_config_remove_network(wpa_s->conf, ssid->id);
3191 static void wpas_remove_persistent_client(struct wpa_supplicant *wpa_s,
3196 wpa_s = wpa_s->global->p2p_invite_group;
3197 if (wpa_s == NULL)
3199 ssid = wpa_s->current_ssid;
3203 ssid = wpas_p2p_get_persistent(wpa_s->p2pdev, peer,
3205 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
3214 struct wpa_supplicant *wpa_s = ctx;
3219 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
3223 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
3226 wpas_notify_p2p_invitation_result(wpa_s, status, bssid);
3230 if (wpa_s->pending_invite_ssid_id == -1) {
3232 wpa_s->global->p2p_invite_group;
3235 wpas_remove_persistent_client(wpa_s, peer);
3246 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
3253 wpa_s, NULL);
3257 wpa_s, NULL);
3273 wpa_s->conf, wpa_s->pending_invite_ssid_id);
3274 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
3276 wpas_p2p_remove_pending_group_interface(wpa_s);
3280 ssid = wpa_config_get_network(wpa_s->conf,
3281 wpa_s->pending_invite_ssid_id);
3296 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before "
3301 freq_included(wpa_s, channels, neg_freq))
3304 freq_included(wpa_s, channels, peer_oper_freq))
3311 wpas_p2p_group_add_persistent(wpa_s, ssid,
3313 wpa_s->p2p_persistent_go_freq,
3315 wpa_s->p2p_go_vht_center_freq2,
3316 wpa_s->p2p_go_ht40, wpa_s->p2p_go_vht,
3317 wpa_s->p2p_go_max_oper_chwidth,
3318 wpa_s->p2p_go_he,
3342 static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s,
3348 wpa_s->global->p2p_24ghz_social_channels = 1;
3359 if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5))
3371 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
3373 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
3375 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
3377 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
3388 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
3390 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
3392 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
3394 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
3433 static int wpas_p2p_get_center_80mhz(struct wpa_supplicant *wpa_s,
3456 static enum chan_allowed wpas_p2p_verify_80mhz(struct wpa_supplicant *wpa_s,
3464 center_chan = wpas_p2p_get_center_80mhz(wpa_s, mode, channel);
3474 res = has_channel(wpa_s->global, mode, adj_chan, &flags);
3494 static int wpas_p2p_get_center_160mhz(struct wpa_supplicant *wpa_s,
3517 static enum chan_allowed wpas_p2p_verify_160mhz(struct wpa_supplicant *wpa_s,
3525 center_chan = wpas_p2p_get_center_160mhz(wpa_s, mode, channel);
3534 res = has_channel(wpa_s->global, mode, adj_chan, &flags);
3563 static enum chan_allowed wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s,
3570 res2 = res = has_channel(wpa_s->global, mode, channel, &flag);
3574 res2 = has_channel(wpa_s->global, mode, channel - 4, NULL);
3578 res2 = has_channel(wpa_s->global, mode, channel + 4, NULL);
3580 res2 = wpas_p2p_verify_80mhz(wpa_s, mode, channel, bw);
3582 res2 = wpas_p2p_verify_160mhz(wpa_s, mode, channel, bw);
3593 static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
3600 if (wpa_s->hw.modes == NULL) {
3604 return wpas_p2p_default_channels(wpa_s, chan, cli_chan);
3617 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode);
3621 wpa_s->global->p2p_24ghz_social_channels = 1;
3624 res = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
3636 wpa_s->conf->p2p_add_cli_chan) {
3665 int wpas_p2p_get_ht40_mode(struct wpa_supplicant *wpa_s,
3683 ret = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
3692 int wpas_p2p_get_vht80_center(struct wpa_supplicant *wpa_s,
3695 if (!wpas_p2p_verify_channel(wpa_s, mode, channel, BW80))
3698 return wpas_p2p_get_center_80mhz(wpa_s, mode, channel);
3702 int wpas_p2p_get_vht160_center(struct wpa_supplicant *wpa_s,
3705 if (!wpas_p2p_verify_channel(wpa_s, mode, channel, BW160))
3707 return wpas_p2p_get_center_160mhz(wpa_s, mode, channel);
3714 struct wpa_supplicant *wpa_s = ctx;
3716 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3717 if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0)
3720 if (wpa_s == NULL)
3723 return wpa_drv_get_noa(wpa_s, buf, buf_len);
3727 struct wpa_supplicant * wpas_get_p2p_go_iface(struct wpa_supplicant *wpa_s,
3730 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3731 struct wpa_ssid *s = wpa_s->current_ssid;
3741 return wpa_s;
3749 struct wpa_supplicant * wpas_get_p2p_client_iface(struct wpa_supplicant *wpa_s,
3752 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3753 struct wpa_ssid *ssid = wpa_s->current_ssid;
3756 if (os_memcmp(wpa_s->go_dev_addr, peer_dev_addr, ETH_ALEN) == 0)
3757 return wpa_s;
3766 struct wpa_supplicant *wpa_s = ctx;
3768 return wpas_get_p2p_client_iface(wpa_s, dev_addr) != NULL;
3774 struct wpa_supplicant *wpa_s = ctx;
3777 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
3778 if (ifs == wpa_s)
3789 struct wpa_supplicant *wpa_s = ctx;
3790 wpa_msg_global(wpa_s, level, "P2P: %s", msg);
3794 int wpas_p2p_add_p2pdev_interface(struct wpa_supplicant *wpa_s,
3804 wpa_s->ifname);
3808 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE;
3809 ret = wpa_drv_if_add(wpa_s, WPA_IF_P2P_DEVICE, ifname, NULL, NULL,
3810 force_name, wpa_s->pending_interface_addr, NULL);
3815 os_strlcpy(wpa_s->pending_interface_name, ifname,
3816 sizeof(wpa_s->pending_interface_name));
3820 iface.ifname = wpa_s->pending_interface_name;
3821 iface.driver = wpa_s->driver->name;
3822 iface.driver_param = wpa_s->conf->driver_param;
3832 iface.confname = wpa_s->confname;
3833 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
3836 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
3843 wpa_s->pending_interface_name[0] = '\0';
3851 struct wpa_supplicant *wpa_s, *intf = ctx;
3854 for (wpa_s = intf->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3855 if (wpa_s->waiting_presence_resp)
3858 if (!wpa_s) {
3859 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No group interface was waiting for presence response");
3862 wpa_s->waiting_presence_resp = 0;
3865 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PRESENCE_RESPONSE "src=" MACSTR
3875 struct wpa_supplicant *wpa_s = ctx;
3878 s = wpas_p2p_get_persistent(wpa_s, addr, ssid, ssid_len);
3886 } else if (wpas_p2p_create_iface(wpa_s)) {
3887 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO))
3891 wpa_s->pending_interface_addr, ETH_ALEN);
3893 os_memcpy(intended_iface_addr, wpa_s->own_addr,
3907 struct wpa_supplicant *wpa_s = ctx;
3923 go = wpas_p2p_get_go_group(wpa_s);
3925 s = wpas_p2p_get_persistent_go(wpa_s);
3926 *group_iface = wpas_p2p_create_iface(wpa_s);
3948 struct wpa_supplicant *wpa_s = ctx;
3954 while ((s = wpas_p2p_get_persistent(wpa_s, peer, NULL, 0))) {
3963 wpa_dbg(wpa_s, MSG_DEBUG,
3966 wpas_notify_persistent_group_removed(wpa_s, s);
3967 wpa_config_remove_network(wpa_s->conf, s->id);
3987 p2p_config_write(wpa_s);
4033 struct wpa_supplicant *wpa_s = ctx;
4056 wpa_msg_global(wpa_s, MSG_INFO,
4067 wpa_msg_global(wpa_s, MSG_INFO,
4081 go_wpa_s = wpas_p2p_get_go_group(wpa_s);
4082 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
4085 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
4086 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4090 wpa_dbg(wpa_s, MSG_DEBUG,
4093 wpas_notify_persistent_group_removed(wpa_s,
4095 wpa_config_remove_network(wpa_s->conf,
4099 wpa_msg_global(wpa_s, MSG_INFO,
4112 s = wpas_p2p_get_persistent(wpa_s, dev, persist_ssid,
4117 wpa_dbg(wpa_s, MSG_ERROR,
4123 stale = wpas_p2p_get_persistent(wpa_s, dev, NULL, 0);
4135 wpa_dbg(wpa_s, MSG_DEBUG,
4138 wpas_notify_persistent_group_removed(wpa_s, stale);
4139 wpa_config_remove_network(wpa_s->conf, stale->id);
4162 p2p_config_write(wpa_s);
4165 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
4166 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4171 wpa_dbg(wpa_s, MSG_DEBUG,
4174 wpas_notify_persistent_group_removed(wpa_s,
4176 wpa_config_remove_network(wpa_s->conf,
4181 wpa_msg_global(wpa_s, MSG_INFO,
4193 wpa_s->global->pending_p2ps_group = 0;
4194 wpa_s->global->pending_p2ps_group_freq = 0;
4207 wpa_s->global->pending_p2ps_group = 1;
4208 wpa_s->global->pending_p2ps_group_freq = freq;
4211 if (!wpas_p2p_create_iface(wpa_s))
4212 os_memcpy(go_ifname, wpa_s->ifname,
4214 else if (wpa_s->pending_interface_name[0])
4216 wpa_s->pending_interface_name,
4221 wpa_s, P2P_SC_FAIL_UNKNOWN_GROUP,
4232 wpa_s, persistent_go,
4239 wpas_p2p_group_add(wpa_s, 1, freq,
4244 os_memcpy(wpa_s->p2ps_join_addr, grp_mac,
4246 wpa_s->p2ps_method_config_any = 1;
4267 os_memcpy(wpa_s->p2ps_join_addr, grp_mac, ETH_ALEN);
4268 wpa_s->p2ps_method_config_any = 1;
4271 wpa_msg_global(wpa_s, MSG_INFO,
4284 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
4285 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4289 wpa_dbg(wpa_s, MSG_DEBUG,
4292 wpas_notify_persistent_group_removed(wpa_s, persistent_go);
4293 wpa_config_remove_network(wpa_s->conf, persistent_go->id);
4304 wpa_msg_global(wpa_s, MSG_INFO,
4316 wpa_msg_global(wpa_s, MSG_INFO,
4332 struct wpa_supplicant *wpa_s = ctx;
4333 return wpas_p2p_in_progress(wpa_s);
4339 struct wpa_supplicant *wpa_s = ctx;
4343 if (!wpa_s->global->pending_p2ps_group)
4346 freq = wpa_s->global->pending_p2ps_group_freq;
4347 wpa_s->global->pending_p2ps_group_freq = 0;
4348 wpa_s->global->pending_p2ps_group = 0;
4350 if (wpas_p2p_get_go_group(wpa_s))
4352 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
4356 wpa_s, persistent_go, 0, 0, 0, 0, 0, 0, 0, 0, NULL,
4360 wpas_p2p_group_add(wpa_s, 1, freq, 0, 0, 0, 0, 0);
4371 struct wpa_supplicant *wpa_s = ctx;
4373 return wpa_drv_get_pref_freq_list(wpa_s, go ? WPA_IF_P2P_GO :
4378 int wpas_p2p_mac_setup(struct wpa_supplicant *wpa_s)
4382 if (wpa_s->conf->p2p_device_random_mac_addr == 0)
4385 if (!wpa_s->conf->ssid) {
4387 wpa_msg(wpa_s, MSG_INFO,
4393 os_memcpy(wpa_s->conf->p2p_device_persistent_mac_addr, addr,
4400 wpa_s->conf->p2p_device_persistent_mac_addr))
4402 os_memcpy(addr, wpa_s->conf->p2p_device_persistent_mac_addr,
4404 wpa_msg(wpa_s, MSG_DEBUG, "Restore last used MAC address.");
4407 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
4408 wpa_msg(wpa_s, MSG_INFO,
4413 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
4414 wpa_msg(wpa_s, MSG_INFO,
4419 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
4429 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4432 int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
4437 if (wpa_s->conf->p2p_disabled)
4440 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
4446 if (wpas_p2p_mac_setup(wpa_s) < 0) {
4447 wpa_msg(wpa_s, MSG_ERROR,
4453 p2p.cb_ctx = wpa_s;
4487 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
4488 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
4489 p2p.dev_name = wpa_s->conf->device_name;
4490 p2p.manufacturer = wpa_s->conf->manufacturer;
4491 p2p.model_name = wpa_s->conf->model_name;
4492 p2p.model_number = wpa_s->conf->model_number;
4493 p2p.serial_number = wpa_s->conf->serial_number;
4494 if (wpa_s->wps) {
4495 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
4496 p2p.config_methods = wpa_s->wps->config_methods;
4499 if (wpas_p2p_setup_channels(wpa_s, &p2p.channels, &p2p.cli_channels)) {
4505 if (wpa_s->conf->p2p_listen_reg_class &&
4506 wpa_s->conf->p2p_listen_channel) {
4507 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
4508 p2p.channel = wpa_s->conf->p2p_listen_channel;
4529 if (wpa_s->conf->p2p_oper_reg_class &&
4530 wpa_s->conf->p2p_oper_channel) {
4531 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
4532 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
4558 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) {
4559 p2p.pref_chan = wpa_s->conf->p2p_pref_chan;
4560 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan;
4563 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4564 os_memcpy(p2p.country, wpa_s->conf->country, 2);
4569 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
4572 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
4573 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
4576 p2p.concurrent_operations = !!(wpa_s->drv_flags &
4581 if (wpa_s->conf->p2p_ssid_postfix) {
4583 os_strlen(wpa_s->conf->p2p_ssid_postfix);
4586 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
4590 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
4592 p2p.max_listen = wpa_s->max_remain_on_chan;
4594 if (wpa_s->conf->p2p_passphrase_len >= 8 &&
4595 wpa_s->conf->p2p_passphrase_len <= 63)
4596 p2p.passphrase_len = wpa_s->conf->p2p_passphrase_len;
4603 global->p2p_init_wpa_s = wpa_s;
4606 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
4609 global->p2p, wpa_s->conf->wps_vendor_ext[i]);
4612 p2p_set_no_go_freq(global->p2p, &wpa_s->conf->p2p_no_go_freq);
4620 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4624 void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
4626 if (wpa_s->driver && wpa_s->drv_priv)
4627 wpa_drv_probe_req_report(wpa_s, 0);
4629 if (wpa_s->go_params) {
4632 wpa_s->global->p2p,
4633 wpa_s->go_params->peer_device_addr);
4636 os_free(wpa_s->go_params);
4637 wpa_s->go_params = NULL;
4638 eloop_cancel_timeout(wpas_p2p_psk_failure_removal, wpa_s, NULL);
4639 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
4640 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4641 wpa_s->p2p_long_listen = 0;
4642 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
4643 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
4644 wpas_p2p_remove_pending_group_interface(wpa_s);
4645 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL);
4646 wpas_p2p_listen_work_done(wpa_s);
4647 if (wpa_s->p2p_send_action_work) {
4648 os_free(wpa_s->p2p_send_action_work->ctx);
4649 radio_work_done(wpa_s->p2p_send_action_work);
4650 wpa_s->p2p_send_action_work = NULL;
4652 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, wpa_s, NULL);
4654 wpabuf_free(wpa_s->p2p_oob_dev_pw);
4655 wpa_s->p2p_oob_dev_pw = NULL;
4657 os_free(wpa_s->p2p_group_common_freqs);
4658 wpa_s->p2p_group_common_freqs = NULL;
4659 wpa_s->p2p_group_common_freqs_num = 0;
4661 /* TODO: remove group interface from the driver if this wpa_s instance
4674 struct wpa_supplicant *wpa_s, *tmp;
4676 wpa_s = global->ifaces;
4681 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
4682 wpa_s = wpa_s->next;
4683 while (wpa_s) {
4686 (tmp == wpa_s ||
4700 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4701 if (wpa_s->ap_iface)
4702 wpas_p2p_group_deinit(wpa_s);
4711 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
4713 if (wpa_s->conf->p2p_no_group_iface)
4715 if (wpa_s->drv_flags &
4720 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
4722 if (wpa_s->global->ifaces->next)
4724 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4730 static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
4737 if (persistent_group && wpa_s->conf->persistent_reconnect)
4744 p2p_set_config_timeout(wpa_s->global->p2p,
4745 wpa_s->p2p_go_ht40 ? 255 : 100, 20);
4747 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
4751 wpa_s->p2p_pd_before_go_neg, pref_freq,
4752 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
4757 static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
4764 if (persistent_group && wpa_s->conf->persistent_reconnect)
4767 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
4771 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
4776 static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s)
4778 wpa_s->p2p_join_scan_count++;
4780 wpa_s->p2p_join_scan_count);
4781 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
4784 MAC2STR(wpa_s->pending_join_iface_addr));
4785 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4786 if (wpa_s->p2p_auto_pd) {
4787 wpa_s->p2p_auto_pd = 0;
4788 wpa_msg_global(wpa_s, MSG_INFO,
4791 MAC2STR(wpa_s->pending_join_dev_addr));
4794 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
4796 wpas_notify_p2p_group_formation_failure(wpa_s, "");
4801 static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq)
4807 if (wpas_p2p_num_unused_channels(wpa_s) > 0) {
4812 freqs = os_calloc(wpa_s->num_multichan_concurrent,
4817 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
4818 wpa_s->num_multichan_concurrent);
4838 static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s,
4844 bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr);
4847 if (bss->last_update_idx < wpa_s->bss_update_idx) {
4853 updated = os_reltime_before(&wpa_s->p2p_auto_started,
4864 static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
4871 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4873 if (wpa_s->global->p2p_disabled)
4878 wpa_s->p2p_auto_join ? "auto_" : "");
4881 wpas_p2p_scan_res_handler(wpa_s, scan_res);
4883 if (wpa_s->p2p_auto_pd) {
4884 int join = wpas_p2p_peer_go(wpa_s,
4885 wpa_s->pending_join_dev_addr);
4887 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
4888 wpa_s->auto_pd_scan_retry++;
4890 wpa_s, wpa_s->pending_join_dev_addr);
4895 wpa_s->auto_pd_scan_retry,
4896 MAC2STR(wpa_s->
4899 wpas_p2p_join_scan_req(wpa_s, freq, NULL, 0);
4907 wpa_s->p2p_auto_pd = 0;
4908 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
4910 MAC2STR(wpa_s->pending_join_dev_addr), join);
4911 if (p2p_prov_disc_req(wpa_s->global->p2p,
4912 wpa_s->pending_join_dev_addr, NULL,
4913 wpa_s->pending_pd_config_methods, join,
4914 0, wpa_s->user_initiated_pd) < 0) {
4915 wpa_s->p2p_auto_pd = 0;
4916 wpa_msg_global(wpa_s, MSG_INFO,
4919 MAC2STR(wpa_s->pending_join_dev_addr));
4924 if (wpa_s->p2p_auto_join) {
4925 int join = wpas_p2p_peer_go(wpa_s,
4926 wpa_s->pending_join_dev_addr);
4930 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
4933 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
4934 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
4935 wpa_s->p2p_persistent_group, 0, 0, 0,
4936 wpa_s->p2p_go_intent,
4937 wpa_s->p2p_connect_freq,
4938 wpa_s->p2p_go_vht_center_freq2,
4939 wpa_s->p2p_persistent_id,
4940 wpa_s->p2p_pd_before_go_neg,
4941 wpa_s->p2p_go_ht40,
4942 wpa_s->p2p_go_vht,
4943 wpa_s->p2p_go_max_oper_chwidth,
4944 wpa_s->p2p_go_he,
4953 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
4955 wpa_s->p2p_fallback_to_go_neg = 1;
4959 freq = p2p_get_oper_freq(wpa_s->global->p2p,
4960 wpa_s->pending_join_iface_addr);
4962 p2p_get_interface_addr(wpa_s->global->p2p,
4963 wpa_s->pending_join_dev_addr,
4965 os_memcmp(iface_addr, wpa_s->pending_join_dev_addr, ETH_ALEN) != 0
4966 && !wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr)) {
4970 MAC2STR(wpa_s->pending_join_iface_addr),
4972 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
4975 freq = p2p_get_oper_freq(wpa_s->global->p2p,
4976 wpa_s->pending_join_iface_addr);
4982 if (wpa_s->p2p_join_ssid_len) {
4985 MAC2STR(wpa_s->pending_join_iface_addr),
4986 wpa_ssid_txt(wpa_s->p2p_join_ssid,
4987 wpa_s->p2p_join_ssid_len));
4988 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
4989 wpa_s->p2p_join_ssid,
4990 wpa_s->p2p_join_ssid_len);
4993 MACSTR, MAC2STR(wpa_s->pending_join_iface_addr));
4994 bss = wpa_bss_get_bssid_latest(wpa_s,
4995 wpa_s->pending_join_iface_addr);
5006 os_memcmp(wpa_s->pending_join_dev_addr,
5007 wpa_s->pending_join_iface_addr, ETH_ALEN) == 0 &&
5008 os_memcmp(dev_addr, wpa_s->pending_join_dev_addr,
5013 MAC2STR(wpa_s->pending_join_dev_addr));
5014 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr,
5021 if (wpas_check_freq_conflict(wpa_s, freq) > 0) {
5022 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5026 wpa_s, "FREQ_CONFLICT");
5033 MAC2STR(wpa_s->pending_join_dev_addr), freq);
5034 wpa_s->pending_pd_before_join = 1;
5036 switch (wpa_s->pending_join_wps_method) {
5054 if ((p2p_get_provisioning_info(wpa_s->global->p2p,
5055 wpa_s->pending_join_dev_addr) ==
5064 MAC2STR(wpa_s->pending_join_dev_addr));
5065 wpa_s->pending_pd_before_join = 0;
5069 if (p2p_prov_disc_req(wpa_s->global->p2p,
5070 wpa_s->pending_join_dev_addr,
5072 freq, wpa_s->user_initiated_pd) < 0) {
5076 wpa_s->pending_pd_before_join = 0;
5083 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
5084 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
5085 wpas_p2p_check_join_scan_limit(wpa_s);
5090 wpas_p2p_join_start(wpa_s, 0, wpa_s->p2p_join_ssid,
5091 wpa_s->p2p_join_ssid_len);
5095 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
5112 os_memcpy(wpa_s->p2p_join_ssid, ssid, ssid_len);
5113 wpa_s->p2p_join_ssid_len = ssid_len;
5117 wpa_s->p2p_join_ssid_len = 0;
5120 wpa_s->wps->dev.p2p = 1;
5121 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev,
5122 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0,
5125 wpas_p2p_scan_res_join(wpa_s, NULL);
5135 oper_freq = p2p_get_oper_freq(wpa_s->global->p2p,
5136 wpa_s->pending_join_iface_addr);
5145 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
5149 wpas_p2p_scan_res_join(wpa_s, NULL);
5155 bands = wpas_get_bands(wpa_s, freqs);
5156 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
5162 if (wpa_s->clear_driver_scan_cache) {
5172 ret = wpa_drv_scan(wpa_s, ¶ms);
5174 os_get_reltime(&wpa_s->scan_trigger_time);
5175 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
5176 wpa_s->own_scan_requested = 1;
5177 wpa_s->clear_driver_scan_cache = 0;
5185 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
5186 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
5187 wpas_p2p_check_join_scan_limit(wpa_s);
5194 struct wpa_supplicant *wpa_s = eloop_ctx;
5195 wpas_p2p_join_scan_req(wpa_s, 0, NULL, 0);
5199 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
5213 wpa_s->p2p_auto_pd = 0;
5214 wpa_s->p2p_auto_join = !!auto_join;
5215 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
5216 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
5217 wpa_s->pending_join_wps_method = wps_method;
5220 wpas_p2p_stop_find(wpa_s);
5222 wpa_s->p2p_join_scan_count = 0;
5223 wpas_p2p_join_scan_req(wpa_s, op_freq, ssid, ssid_len);
5228 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
5235 group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
5238 if (group != wpa_s) {
5239 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
5241 group->p2p_wps_method = wpa_s->p2p_wps_method;
5251 if (group == wpa_s->parent)
5252 wpa_s->global->p2p_group_formation = group;
5255 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
5258 os_memcpy(res.peer_device_addr, wpa_s->pending_join_dev_addr, ETH_ALEN);
5259 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
5261 res.wps_method = wpa_s->pending_join_wps_method;
5268 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
5272 wpa_s, wpa_s->pending_join_iface_addr);
5289 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
5292 wpa_drv_cancel_remain_on_channel(wpa_s);
5293 wpa_s->off_channel_freq = 0;
5294 wpa_s->roc_waiting_drv_freq = 0;
5303 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
5305 wpa_s, NULL);
5311 static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
5323 freqs = os_calloc(wpa_s->num_multichan_concurrent,
5328 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
5329 wpa_s->num_multichan_concurrent);
5336 num_unused = wpas_p2p_num_unused_channels(wpa_s);
5340 freq, wpa_s->num_multichan_concurrent, num, num_unused);
5345 ret = p2p_supported_freq(wpa_s->global->p2p, freq);
5347 ret = p2p_supported_freq_cli(wpa_s->global->p2p, freq);
5349 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
5350 ieee80211_is_dfs(freq, wpa_s->hw.modes,
5351 wpa_s->hw.num_modes)) {
5385 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
5387 if (!wpa_s->conf->num_p2p_pref_chan && *pref_freq == 0) {
5398 res = wpa_drv_get_pref_freq_list(wpa_s, iface_type,
5405 (!p2p_supported_freq(wpa_s->global->p2p,
5407 wpas_p2p_disallowed_freq(wpa_s->global,
5462 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5488 int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
5503 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5507 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
5513 os_free(wpa_s->global->add_psk);
5514 wpa_s->global->add_psk = NULL;
5516 wpa_s->global->p2p_fail_on_wps_complete = 0;
5517 wpa_s->global->pending_p2ps_group = 0;
5518 wpa_s->global->pending_p2ps_group_freq = 0;
5519 wpa_s->p2ps_method_config_any = 0;
5522 go_intent = wpa_s->conf->p2p_go_intent;
5525 wpa_s->p2p_long_listen = 0;
5527 wpa_s->p2p_wps_method = wps_method;
5528 wpa_s->p2p_persistent_group = !!persistent_group;
5529 wpa_s->p2p_persistent_id = persistent_id;
5530 wpa_s->p2p_go_intent = go_intent;
5531 wpa_s->p2p_connect_freq = freq;
5532 wpa_s->p2p_fallback_to_go_neg = 0;
5533 wpa_s->p2p_pd_before_go_neg = !!pd;
5534 wpa_s->p2p_go_ht40 = !!ht40;
5535 wpa_s->p2p_go_vht = !!vht;
5536 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
5537 wpa_s->p2p_go_max_oper_chwidth = vht_chwidth;
5538 wpa_s->p2p_go_he = !!he;
5541 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
5545 res = os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin),
5547 if (os_snprintf_error(sizeof(wpa_s->p2p_pin), res))
5548 wpa_s->p2p_pin[sizeof(wpa_s->p2p_pin) - 1] = '\0';
5550 wpa_s->p2p_pin);
5553 os_strlcpy(wpa_s->p2p_pin, "12345670", sizeof(wpa_s->p2p_pin));
5555 wpa_s->p2p_pin[0] = '\0';
5563 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
5567 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
5570 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
5574 os_get_reltime(&wpa_s->p2p_auto_started);
5577 wpa_s->p2p_auto_started.sec,
5578 wpa_s->p2p_auto_started.usec);
5580 wpa_s->user_initiated_pd = 1;
5581 if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method,
5589 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
5593 wpas_p2p_set_own_freq_preference(wpa_s,
5596 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
5598 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
5600 if (wpa_s->create_p2p_iface) {
5605 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
5611 if_addr = wpa_s->pending_interface_addr;
5613 if (wpa_s->p2p_mgmt)
5614 if_addr = wpa_s->parent->own_addr;
5616 if_addr = wpa_s->own_addr;
5617 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
5621 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
5629 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
5632 if (wpa_s->create_p2p_iface)
5633 wpas_p2p_remove_pending_group_interface(wpa_s);
5642 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5649 void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
5652 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5655 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
5656 wpa_s->roc_waiting_drv_freq, freq, duration);
5657 if (wpa_s->off_channel_freq &&
5658 wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
5659 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
5660 wpa_s->pending_listen_duration);
5661 wpa_s->pending_listen_freq = 0;
5664 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
5670 int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s, unsigned int timeout)
5673 if (timeout > wpa_s->max_remain_on_chan)
5674 timeout = wpa_s->max_remain_on_chan;
5676 return p2p_listen(wpa_s->global->p2p, timeout);
5682 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5689 void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
5694 wpa_s->p2p_long_listen, offchannel_pending_action_tx(wpa_s));
5695 wpas_p2p_listen_work_done(wpa_s);
5696 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5698 if (wpa_s->p2p_long_listen > 0)
5699 wpa_s->p2p_long_listen -= wpa_s->max_remain_on_chan;
5700 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
5702 if (offchannel_pending_action_tx(wpa_s))
5704 if (wpa_s->p2p_long_listen > 0) {
5706 wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen);
5712 p2p_stop_listen(wpa_s->global->p2p);
5719 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5730 int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
5732 struct wpa_global *global = wpa_s->global;
5733 struct wpa_supplicant *calling_wpa_s = wpa_s;
5737 wpa_s = global->ifaces;
5738 while (wpa_s) {
5739 prev = wpa_s;
5740 wpa_s = wpa_s->next;
5750 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5751 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5755 return wpas_p2p_disconnect_safely(wpa_s, calling_wpa_s);
5759 static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq)
5763 if (!wpa_s->conf->num_p2p_pref_chan && !freq) {
5768 res = wpa_drv_get_pref_freq_list(wpa_s, WPA_IF_P2P_GO,
5773 (!p2p_supported_freq(wpa_s->global->p2p,
5775 wpas_p2p_disallowed_freq(wpa_s->global,
5800 if (wpa_s->best_24_freq > 0 &&
5801 p2p_supported_freq_go(wpa_s->global->p2p,
5802 wpa_s->best_24_freq)) {
5803 freq = wpa_s->best_24_freq;
5818 if (wpa_s->best_5_freq > 0 &&
5819 p2p_supported_freq_go(wpa_s->global->p2p,
5820 wpa_s->best_5_freq)) {
5821 freq = wpa_s->best_5_freq;
5828 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
5838 if (freq > 0 && !p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
5839 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
5840 ieee80211_is_dfs(freq, wpa_s->hw.modes,
5841 wpa_s->hw.num_modes)) {
5861 static int wpas_p2p_supported_freq_go(struct wpa_supplicant *wpa_s,
5865 if (!wpas_p2p_disallowed_freq(wpa_s->global, freq) &&
5866 p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
5867 freq_included(wpa_s, channels, freq))
5873 static void wpas_p2p_select_go_freq_no_pref(struct wpa_supplicant *wpa_s,
5882 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5883 freq_included(wpa_s, channels, params->freq) &&
5884 p2p_supported_freq(wpa_s->global->p2p, params->freq))
5891 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5892 freq_included(wpa_s, channels, params->freq) &&
5893 p2p_supported_freq(wpa_s->global->p2p, params->freq))
5899 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5900 freq_included(wpa_s, channels, params->freq) &&
5901 p2p_supported_freq(wpa_s->global->p2p, params->freq))
5907 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5908 freq_included(wpa_s, channels, params->freq) &&
5909 p2p_supported_freq(wpa_s->global->p2p, params->freq))
5919 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
5933 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
5959 static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
5969 int unused_channels = wpas_p2p_num_unused_channels(wpa_s) > 0;
5979 freqs = os_calloc(wpa_s->num_multichan_concurrent,
5984 num = get_shared_radio_freqs_data(wpa_s, freqs,
5985 wpa_s->num_multichan_concurrent);
5987 if (wpa_s->current_ssid &&
5988 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO &&
5989 wpa_s->wpa_state == WPA_COMPLETED) {
6000 if (freqs[i].freq == wpa_s->current_ssid->frequency &&
6010 if (wpas_p2p_disallowed_freq(wpa_s->global, freq) ||
6011 !freq_included(wpa_s, channels, freq)) {
6017 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
6018 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
6019 ieee80211_is_dfs(freq, wpa_s->hw.modes,
6020 wpa_s->hw.num_modes)) {
6062 (!wpa_s->conf->p2p_ignore_shared_freq || !unused_channels)) {
6063 cand = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
6064 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6074 if (wpas_p2p_supported_freq_go(wpa_s, channels,
6092 if (wpa_s->conf->p2p_oper_reg_class == 81 &&
6093 wpa_s->conf->p2p_oper_channel >= 1 &&
6094 wpa_s->conf->p2p_oper_channel <= 11 &&
6096 wpa_s, channels,
6097 2407 + 5 * wpa_s->conf->p2p_oper_channel)) {
6098 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
6104 if ((wpa_s->conf->p2p_oper_reg_class == 115 ||
6105 wpa_s->conf->p2p_oper_reg_class == 116 ||
6106 wpa_s->conf->p2p_oper_reg_class == 117 ||
6107 wpa_s->conf->p2p_oper_reg_class == 124 ||
6108 wpa_s->conf->p2p_oper_reg_class == 125 ||
6109 wpa_s->conf->p2p_oper_reg_class == 126 ||
6110 wpa_s->conf->p2p_oper_reg_class == 127) &&
6111 wpas_p2p_supported_freq_go(wpa_s, channels,
6113 5 * wpa_s->conf->p2p_oper_channel)) {
6114 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
6121 if (wpa_s->conf->p2p_oper_channel == 0 &&
6122 wpa_s->best_overall_freq > 0 &&
6123 wpas_p2p_supported_freq_go(wpa_s, channels,
6124 wpa_s->best_overall_freq)) {
6125 params->freq = wpa_s->best_overall_freq;
6131 if (wpa_s->conf->p2p_oper_channel == 0 &&
6132 wpa_s->best_24_freq > 0 &&
6133 wpas_p2p_supported_freq_go(wpa_s, channels,
6134 wpa_s->best_24_freq)) {
6135 params->freq = wpa_s->best_24_freq;
6141 if (wpa_s->conf->p2p_oper_channel == 0 &&
6142 wpa_s->best_5_freq > 0 &&
6143 wpas_p2p_supported_freq_go(wpa_s, channels,
6144 wpa_s->best_5_freq)) {
6145 params->freq = wpa_s->best_5_freq;
6152 cand = p2p_get_pref_freq(wpa_s->global->p2p, channels);
6153 if (cand && wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6161 if (wpa_s->hw.modes && wpa_s->p2p_group_common_freqs) {
6162 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6167 cand = wpa_s->p2p_group_common_freqs[i];
6169 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
6172 wpas_p2p_verify_channel(wpa_s, hwmode, chan,
6175 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6187 if (wpa_s->current_ssid && wpa_s->hw.modes &&
6188 wpa_s->p2p_group_common_freqs) {
6189 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6194 cand = wpa_s->p2p_group_common_freqs[i];
6196 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
6198 if (!wpas_same_band(wpa_s->current_ssid->frequency,
6201 (wpas_p2p_verify_channel(wpa_s, hwmode, chan,
6203 wpas_p2p_verify_channel(wpa_s, hwmode, chan,
6206 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6218 if (wpa_s->current_ssid && wpa_s->p2p_group_common_freqs) {
6219 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6220 cand = wpa_s->p2p_group_common_freqs[i];
6221 if (!wpas_same_band(wpa_s->current_ssid->frequency,
6224 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6235 if (wpa_s->p2p_group_common_freqs) {
6236 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6237 cand = wpa_s->p2p_group_common_freqs[i];
6238 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
6249 wpas_p2p_select_go_freq_no_pref(wpa_s, params, channels);
6266 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
6271 if (!wpas_p2p_create_iface(wpa_s)) {
6272 if (wpa_s->p2p_mgmt) {
6278 wpa_s->parent->p2pdev = wpa_s;
6279 wpa_s = wpa_s->parent;
6281 wpa_dbg(wpa_s, MSG_DEBUG,
6283 wpa_s->p2p_first_connection_timeout = 0;
6284 if (wpa_s != wpa_s->p2pdev)
6285 wpas_p2p_clone_config(wpa_s, wpa_s->p2pdev);
6286 return wpa_s;
6289 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
6291 wpa_msg_global(wpa_s, MSG_ERROR,
6295 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
6297 wpa_msg_global(wpa_s, MSG_ERROR,
6299 wpas_p2p_remove_pending_group_interface(wpa_s);
6303 if (go && wpa_s->p2p_go_do_acs) {
6304 group_wpa_s->p2p_go_do_acs = wpa_s->p2p_go_do_acs;
6305 group_wpa_s->p2p_go_acs_band = wpa_s->p2p_go_acs_band;
6306 wpa_s->p2p_go_do_acs = 0;
6309 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s",
6318 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
6330 int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
6336 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6339 os_free(wpa_s->global->add_psk);
6340 wpa_s->global->add_psk = NULL;
6344 wpas_p2p_stop_find_oper(wpa_s);
6346 if (!wpa_s->p2p_go_do_acs) {
6347 freq = wpas_p2p_select_go_freq(wpa_s, freq);
6352 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, vht_center_freq2,
6356 p2p_go_params(wpa_s->global->p2p, ¶ms);
6359 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
6360 if (wpa_s == NULL)
6362 wpas_start_wps_go(wpa_s, ¶ms, 0);
6368 static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
6374 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
6375 if (wpa_s == NULL)
6378 os_get_reltime(&wpa_s->scan_min_time);
6379 wpa_s->p2p_last_4way_hs_fail = NULL;
6381 wpa_supplicant_ap_deinit(wpa_s);
6383 ssid = wpa_config_add_network(wpa_s->conf);
6386 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
6397 wpa_config_remove_network(wpa_s->conf, ssid->id);
6411 wpa_s->show_group_started = 1;
6412 wpa_s->p2p_in_invitation = 1;
6413 wpa_s->p2p_invite_go_freq = freq;
6414 wpa_s->p2p_go_group_formation_completed = 0;
6415 wpa_s->global->p2p_group_formation = wpa_s;
6417 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
6421 wpa_s->p2pdev, NULL);
6422 wpa_supplicant_select_network(wpa_s, ssid);
6428 int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
6442 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
6448 wpa_s->p2pdev, NULL)) {
6461 wpa_s->p2pdev, NULL);
6466 os_free(wpa_s->global->add_psk);
6467 wpa_s->global->add_psk = NULL;
6470 wpas_p2p_stop_find_oper(wpa_s);
6472 wpa_s->p2p_fallback_to_go_neg = 0;
6476 freq = wpas_p2p_select_go_freq(wpa_s, force_freq);
6480 freq = wpas_p2p_select_go_freq(wpa_s, neg_freq);
6482 (freq > 0 && !freq_included(wpa_s, channels, freq)))
6487 if (freq <= 0 || !freq_included(wpa_s, channels, freq)) {
6490 wpa_bss_get_p2p_dev_addr(wpa_s, ssid->bssid);
6495 freq_included(wpa_s, channels, bss->freq))
6501 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated, freq,
6507 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, vht_center_freq2,
6528 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
6529 if (wpa_s == NULL)
6534 wpa_s->p2p_first_connection_timeout = connection_timeout;
6535 wpas_start_wps_go(wpa_s, ¶ms, 0);
6544 struct wpa_supplicant *wpa_s = ctx;
6545 if (wpa_s->ap_iface) {
6546 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
6562 wpa_supplicant_ap_update_beacon(wpa_s);
6568 struct wpa_supplicant *wpa_s = ctx;
6569 if (!wpa_s->ap_iface)
6573 if (wpa_s->global->p2p_fail_on_wps_complete &&
6574 wpa_s->p2p_in_provisioning) {
6575 wpas_p2p_grpform_fail_after_wps(wpa_s);
6578 wpas_p2p_set_group_idle_timeout(wpa_s);
6580 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
6584 struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
6590 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
6598 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
6602 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
6603 if (wpa_s->max_stations &&
6604 wpa_s->max_stations < wpa_s->conf->max_num_sta)
6605 cfg->max_clients = wpa_s->max_stations;
6607 cfg->max_clients = wpa_s->conf->max_num_sta;
6611 cfg->cb_ctx = wpa_s;
6614 cfg->ip_addr_alloc = WPA_GET_BE32(wpa_s->p2pdev->conf->ip_addr_start)
6617 group = p2p_group_init(wpa_s->global->p2p, cfg);
6622 wpa_s->p2p_group = group;
6627 void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
6630 struct wpa_ssid *ssid = wpa_s->current_ssid;
6632 if (!wpa_s->p2p_in_provisioning) {
6640 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
6641 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
6644 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
6647 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
6649 wpa_s->p2p_go_group_formation_completed = 1;
6657 wpa_dbg(wpa_s, MSG_DEBUG,
6662 wpa_s->p2pdev, NULL);
6664 wpa_s->p2p_go_group_formation_completed = 0;
6671 wpa_dbg(wpa_s, MSG_DEBUG,
6676 wpa_s->p2pdev, NULL);
6680 wpa_s->p2p_go_group_formation_completed = 0;
6682 if (wpa_s->global->p2p)
6683 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
6684 wpas_group_formation_completed(wpa_s, 1, 0);
6688 void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s,
6691 if (!wpa_s->p2p_in_provisioning) {
6697 if (wpa_s->go_params) {
6699 wpa_s->global->p2p,
6700 wpa_s->go_params->peer_device_addr);
6703 wpas_notify_p2p_wps_failed(wpa_s, fail);
6705 if (wpa_s == wpa_s->global->p2p_group_formation) {
6712 wpa_s->global->p2p_fail_on_wps_complete = 1;
6715 wpa_s->p2pdev, NULL);
6720 int wpas_p2p_wps_eapol_cb(struct wpa_supplicant *wpa_s)
6722 if (!wpa_s->global->p2p_fail_on_wps_complete ||
6723 !wpa_s->p2p_in_provisioning)
6726 wpas_p2p_grpform_fail_after_wps(wpa_s);
6732 int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
6739 wpa_s->global->pending_p2ps_group = 0;
6740 wpa_s->global->pending_p2ps_group_freq = 0;
6741 wpa_s->p2p_fallback_to_go_neg = 0;
6742 wpa_s->pending_pd_use = NORMAL_PD;
6745 wpa_s, P2PS_SETUP_NONE, p2ps_prov->role,
6769 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
6770 wpa_s->pending_pd_config_methods = config_methods;
6771 wpa_s->p2p_auto_pd = 1;
6772 wpa_s->p2p_auto_join = 0;
6773 wpa_s->pending_pd_before_join = 0;
6774 wpa_s->auto_pd_scan_retry = 0;
6775 wpas_p2p_stop_find(wpa_s);
6776 wpa_s->p2p_join_scan_count = 0;
6777 os_get_reltime(&wpa_s->p2p_auto_started);
6779 wpa_s->p2p_auto_started.sec,
6780 wpa_s->p2p_auto_started.usec);
6781 wpas_p2p_join_scan(wpa_s, NULL);
6785 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) {
6790 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr, p2ps_prov,
6803 static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s)
6805 if (!offchannel_pending_action_tx(wpa_s))
6808 if (wpa_s->p2p_send_action_work) {
6809 wpas_p2p_free_send_action_work(wpa_s);
6811 wpa_s, NULL);
6812 offchannel_send_action_done(wpa_s);
6817 offchannel_clear_pending_action_tx(wpa_s);
6821 int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
6827 wpas_p2p_clear_pending_action_tx(wpa_s);
6828 wpa_s->p2p_long_listen = 0;
6830 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
6831 wpa_s->p2p_in_provisioning) {
6832 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Reject p2p_find operation%s%s",
6833 (wpa_s->global->p2p_disabled || !wpa_s->global->p2p) ?
6835 wpa_s->p2p_in_provisioning ?
6840 wpa_supplicant_cancel_sched_scan(wpa_s);
6842 return p2p_find(wpa_s->global->p2p, timeout, type,
6848 static void wpas_p2p_scan_res_ignore_search(struct wpa_supplicant *wpa_s,
6853 if (wpa_s->p2p_scan_work) {
6854 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
6855 wpa_s->p2p_scan_work = NULL;
6859 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6866 p2p_scan_res_handled(wpa_s->global->p2p);
6870 static void wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s)
6872 wpas_p2p_clear_pending_action_tx(wpa_s);
6873 wpa_s->p2p_long_listen = 0;
6874 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
6875 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6877 if (wpa_s->global->p2p)
6878 p2p_stop_find(wpa_s->global->p2p);
6880 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_handler) {
6883 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore_search;
6888 void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
6890 wpas_p2p_stop_find_oper(wpa_s);
6891 if (!wpa_s->global->pending_group_iface_for_p2ps)
6892 wpas_p2p_remove_pending_group_interface(wpa_s);
6898 struct wpa_supplicant *wpa_s = eloop_ctx;
6899 wpa_s->p2p_long_listen = 0;
6903 int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
6907 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6910 if (wpa_s->p2p_lo_started) {
6916 wpa_supplicant_cancel_sched_scan(wpa_s);
6917 wpas_p2p_clear_pending_action_tx(wpa_s);
6927 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
6928 wpa_s->p2p_long_listen = 0;
6935 if (wpa_s->global->p2p)
6936 p2p_stop_find(wpa_s->global->p2p);
6938 res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
6939 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
6940 wpa_s->p2p_long_listen = timeout * 1000;
6943 wpa_s, NULL);
6950 int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
6956 if (wpa_s->global->p2p_disabled)
6962 if (wpa_s->conf->p2p_disabled && p2p_group)
6964 if (wpa_s->global->p2p == NULL)
6970 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
6978 int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
6983 if (wpa_s->global->p2p_disabled)
6985 if (wpa_s->global->p2p == NULL)
6988 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
6989 ie, ie_len, rx_freq, wpa_s->p2p_lo_started)) {
6991 wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len,
7005 void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
7009 if (wpa_s->global->p2p_disabled)
7011 if (wpa_s->global->p2p == NULL)
7014 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
7019 void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
7023 if (wpa_s->global->p2p_disabled)
7025 if (wpa_s->global->p2p == NULL)
7028 bands = wpas_get_bands(wpa_s, NULL);
7029 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
7033 static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
7035 p2p_group_deinit(wpa_s->p2p_group);
7036 wpa_s->p2p_group = NULL;
7038 wpa_s->ap_configured_cb = NULL;
7039 wpa_s->ap_configured_cb_ctx = NULL;
7040 wpa_s->ap_configured_cb_data = NULL;
7041 wpa_s->connect_without_scan = NULL;
7045 int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
7047 wpa_s->p2p_long_listen = 0;
7049 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7052 return p2p_reject(wpa_s->global->p2p, addr);
7057 int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
7069 wpa_s->global->p2p_invite_group = NULL;
7071 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
7073 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
7075 wpa_s->p2p_persistent_go_freq = freq;
7076 wpa_s->p2p_go_ht40 = !!ht40;
7077 wpa_s->p2p_go_vht = !!vht;
7078 wpa_s->p2p_go_he = !!he;
7079 wpa_s->p2p_go_max_oper_chwidth = max_chwidth;
7080 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
7088 if (wpas_p2p_create_iface(wpa_s)) {
7089 if (wpas_p2p_add_group_interface(wpa_s,
7096 bssid = wpa_s->pending_interface_addr;
7097 } else if (wpa_s->p2p_mgmt)
7098 bssid = wpa_s->parent->own_addr;
7100 bssid = wpa_s->own_addr;
7105 wpa_s->pending_invite_ssid_id = ssid->id;
7108 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
7114 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7117 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
7119 if (wpa_s->parent->conf->p2p_ignore_shared_freq &&
7121 wpa_s->num_multichan_concurrent > 1 &&
7122 wpas_p2p_num_unused_channels(wpa_s) > 0) {
7132 wpas_p2p_stop_find_oper(wpa_s);
7134 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
7141 int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
7144 struct wpa_global *global = wpa_s->global;
7153 wpa_s->p2p_persistent_go_freq = 0;
7154 wpa_s->p2p_go_ht40 = 0;
7155 wpa_s->p2p_go_vht = 0;
7156 wpa_s->p2p_go_vht_center_freq2 = 0;
7157 wpa_s->p2p_go_max_oper_chwidth = 0;
7159 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7160 if (os_strcmp(wpa_s->ifname, ifname) == 0)
7163 if (wpa_s == NULL) {
7168 ssid = wpa_s->current_ssid;
7175 wpa_s->global->p2p_invite_group = wpa_s;
7177 wpas_p2p_get_persistent(wpa_s->p2pdev, peer_addr,
7182 bssid = wpa_s->own_addr;
7184 go_dev_addr = wpa_s->global->p2p_dev_addr;
7188 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
7193 bssid = wpa_s->bssid;
7195 !is_zero_ether_addr(wpa_s->go_dev_addr))
7196 go_dev_addr = wpa_s->go_dev_addr;
7197 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
7198 (int) wpa_s->assoc_freq;
7200 wpa_s->p2pdev->pending_invite_ssid_id = -1;
7202 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7206 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
7211 wpas_p2p_set_own_freq_preference(wpa_s, force_freq);
7213 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
7219 void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
7221 struct wpa_ssid *ssid = wpa_s->current_ssid;
7230 wpa_s->p2pdev, NULL);
7233 if (!wpa_s->show_group_started || !ssid)
7236 wpa_s->show_group_started = 0;
7237 if (!wpa_s->p2p_go_group_formation_completed &&
7238 wpa_s->global->p2p_group_formation == wpa_s) {
7239 wpa_dbg(wpa_s, MSG_DEBUG,
7241 wpa_s->p2p_go_group_formation_completed = 1;
7242 wpa_s->global->p2p_group_formation = NULL;
7243 wpa_s->p2p_in_provisioning = 0;
7244 wpa_s->p2p_in_invitation = 0;
7250 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
7252 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
7254 if (wpa_s->global->p2p_group_formation == wpa_s)
7255 wpa_s->global->p2p_group_formation = NULL;
7257 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
7258 (int) wpa_s->assoc_freq;
7261 if (wpa_sm_get_p2p_ip_addr(wpa_s->wpa, ip) == 0) {
7275 wpas_p2p_group_started(wpa_s, 0, ssid, freq,
7282 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
7285 wpas_notify_p2p_group_started(wpa_s, ssid, persistent, 1, ip_ptr);
7289 int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
7294 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7297 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
7298 wpa_s->current_ssid == NULL ||
7299 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
7302 ret = p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
7303 wpa_s->own_addr, wpa_s->assoc_freq,
7306 wpa_s->waiting_presence_resp = 1;
7312 int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
7315 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7318 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
7322 static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s)
7324 if (wpa_s->current_ssid == NULL) {
7332 return wpa_s->current_ssid->p2p_group &&
7333 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
7339 struct wpa_supplicant *wpa_s = eloop_ctx;
7341 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
7349 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT);
7353 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s)
7357 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
7360 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
7363 timeout = wpa_s->conf->p2p_group_idle;
7364 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
7372 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
7378 if (wpa_s->p2p_in_provisioning) {
7389 if (wpa_s->show_group_started) {
7405 wpa_s, NULL);
7410 int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
7414 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7418 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
7422 wpa_s->current_ssid &&
7423 wpa_s->current_ssid->p2p_group &&
7424 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
7427 if (wpas_p2p_group_delete(wpa_s,
7437 void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
7441 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7445 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
7450 void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
7452 struct p2p_data *p2p = wpa_s->global->p2p;
7457 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
7460 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
7461 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
7463 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
7464 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
7466 if (wpa_s->wps &&
7467 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
7468 p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
7470 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
7471 p2p_set_uuid(p2p, wpa_s->wps->uuid);
7473 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
7474 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
7475 p2p_set_model_name(p2p, wpa_s->conf->model_name);
7476 p2p_set_model_number(p2p, wpa_s->conf->model_number);
7477 p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
7480 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
7482 (void *) wpa_s->conf->sec_device_type,
7483 wpa_s->conf->num_sec_device_types);
7485 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
7489 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
7492 p2p, wpa_s->conf->wps_vendor_ext[i]);
7496 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
7497 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
7499 country[0] = wpa_s->conf->country[0];
7500 country[1] = wpa_s->conf->country[1];
7505 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
7506 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
7507 wpa_s->conf->p2p_ssid_postfix ?
7508 os_strlen(wpa_s->conf->p2p_ssid_postfix) :
7512 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
7513 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
7515 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
7521 if (wpa_s->conf->p2p_listen_reg_class &&
7522 wpa_s->conf->p2p_listen_channel) {
7523 reg_class = wpa_s->conf->p2p_listen_reg_class;
7524 channel = wpa_s->conf->p2p_listen_channel;
7544 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
7548 if (wpa_s->conf->p2p_oper_reg_class &&
7549 wpa_s->conf->p2p_oper_channel) {
7550 op_reg_class = wpa_s->conf->p2p_oper_reg_class;
7551 op_channel = wpa_s->conf->p2p_oper_channel;
7572 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
7573 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
7574 wpa_s->conf->p2p_pref_chan) < 0) {
7579 if (p2p_set_no_go_freq(p2p, &wpa_s->conf->p2p_no_go_freq) < 0) {
7585 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN)
7586 p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len);
7590 int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start,
7593 if (!wpa_s->ap_iface)
7595 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
7600 int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
7602 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7605 wpa_s->global->cross_connection = enabled;
7606 p2p_set_cross_connect(wpa_s->global->p2p, enabled);
7611 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
7676 void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s)
7678 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
7679 wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
7680 wpa_s->cross_connect_disallowed)
7681 wpas_p2p_disable_cross_connect(wpa_s);
7683 wpas_p2p_enable_cross_connect(wpa_s);
7684 if (!wpa_s->ap_iface &&
7685 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
7690 void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s)
7692 wpas_p2p_disable_cross_connect(wpa_s);
7693 if (!wpa_s->ap_iface &&
7695 wpa_s, NULL))
7696 wpas_p2p_set_group_idle_timeout(wpa_s);
7700 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s)
7704 if (!wpa_s->global->cross_connection)
7707 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
7708 if (iface == wpa_s)
7714 iface != wpa_s->parent)
7717 wpa_s->cross_connect_enabled = 1;
7718 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
7719 sizeof(wpa_s->cross_connect_uplink));
7722 wpa_s->ifname, wpa_s->cross_connect_uplink);
7730 wpa_s->cross_connect_in_use = 1;
7731 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
7733 wpa_s->ifname, wpa_s->cross_connect_uplink);
7739 int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s)
7741 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
7742 !wpa_s->p2p_in_provisioning)
7747 if (wpa_s != wpa_s->p2pdev)
7748 wpa_msg_ctrl(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_OVERLAP);
7749 wpas_p2p_group_formation_failed(wpa_s, 0);
7756 struct wpa_supplicant *wpa_s = eloop_ctx;
7757 wpas_p2p_notif_pbc_overlap(wpa_s);
7761 void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s,
7766 unsigned int num = wpa_s->num_multichan_concurrent;
7768 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
7775 num = get_shared_radio_freqs_data(wpa_s, freqs, num);
7779 if (wpas_p2p_setup_channels(wpa_s, &chan, &cli_chan)) {
7785 p2p_update_channel_list(wpa_s->global->p2p, &chan, &cli_chan);
7787 wpas_p2p_optimize_listen_channel(wpa_s, freqs, num);
7795 wpas_p2p_consider_moving_gos(wpa_s, freqs, num, trig);
7801 static void wpas_p2p_scan_res_ignore(struct wpa_supplicant *wpa_s,
7808 int wpas_p2p_cancel(struct wpa_supplicant *wpa_s)
7810 struct wpa_global *global = wpa_s->global;
7819 if (wpa_s->pending_interface_name[0] &&
7820 !is_zero_ether_addr(wpa_s->pending_interface_addr))
7831 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) {
7833 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore;
7837 if (wpa_s->pending_pd_before_join) {
7839 wpa_s->pending_pd_before_join = 0;
7843 wpas_p2p_stop_find(wpa_s);
7845 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7846 if (wpa_s == global->p2p_group_formation &&
7847 (wpa_s->p2p_in_provisioning ||
7848 wpa_s->parent->pending_interface_type ==
7852 wpa_s->ifname);
7855 wpa_s->p2pdev, NULL);
7856 if (wpa_s->p2p_in_provisioning) {
7857 wpas_group_formation_completed(wpa_s, 0, 0);
7860 wpas_p2p_group_delete(wpa_s,
7863 } else if (wpa_s->p2p_in_invitation) {
7865 wpa_s->ifname);
7867 wpas_p2p_group_formation_failed(wpa_s, 0);
7881 void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s)
7883 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
7888 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE);
7892 void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
7895 struct p2p_data *p2p = wpa_s->global->p2p;
7902 int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
7905 struct p2p_data *p2p = wpa_s->global->p2p;
7919 * @wpa_s: Pointer to wpa_supplicant data
7928 int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s)
7931 if (wpa_s == NULL)
7934 return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ?
7939 int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s)
7943 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7946 ret = p2p_in_progress(wpa_s->global->p2p);
7954 if (wpa_s->global->p2p_group_formation &&
7955 wpa_s->global->p2p_group_formation != wpa_s) {
7956 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Another interface (%s) "
7958 wpa_s->global->p2p_group_formation->ifname);
7963 if (!ret && wpa_s->global->p2p_go_wait_client.sec) {
7966 if (os_reltime_expired(&now, &wpa_s->global->p2p_go_wait_client,
7969 wpa_s->global->p2p_go_wait_client.sec = 0;
7971 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Waiting for initial client connection during group formation");
7980 void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s,
7983 if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
7985 wpa_s->p2pdev, NULL) > 0) {
7997 wpa_s->p2pdev, NULL);
8002 struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s,
8009 for (s = wpa_s->conf->ssid; s; s = s->next) {
8037 void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
8041 wpa_s->p2pdev, NULL) > 0) {
8053 if (!wpa_s->p2p_go_group_formation_completed &&
8054 !wpa_s->group_formation_reported) {
8062 if (wpa_s->global->p2p)
8063 p2p_wps_success_cb(wpa_s->global->p2p, addr);
8064 wpas_group_formation_completed(wpa_s, 1, 0);
8067 if (!wpa_s->p2p_go_group_formation_completed) {
8068 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Marking group formation completed on GO on first data connection");
8069 wpa_s->p2p_go_group_formation_completed = 1;
8070 wpa_s->global->p2p_group_formation = NULL;
8071 wpa_s->p2p_in_provisioning = 0;
8072 wpa_s->p2p_in_invitation = 0;
8074 wpa_s->global->p2p_go_wait_client.sec = 0;
8077 wpas_p2p_add_persistent_group_client(wpa_s, addr);
8081 static int wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
8084 struct wpa_supplicant *group = wpa_s;
8087 if (wpa_s->global->p2p_group_formation)
8088 group = wpa_s->global->p2p_group_formation;
8089 wpa_s = wpa_s->global->p2p_init_wpa_s;
8090 offchannel_send_action_done(wpa_s);
8093 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation");
8094 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
8095 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
8096 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
8097 wpa_s->p2p_go_vht_center_freq2,
8098 wpa_s->p2p_persistent_id,
8099 wpa_s->p2p_pd_before_go_neg,
8100 wpa_s->p2p_go_ht40,
8101 wpa_s->p2p_go_vht,
8102 wpa_s->p2p_go_max_oper_chwidth,
8103 wpa_s->p2p_go_he, NULL, 0);
8108 int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s)
8112 if (!wpa_s->p2p_fallback_to_go_neg ||
8113 wpa_s->p2p_in_provisioning <= 5)
8116 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
8119 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
8121 wpa_msg_global(wpa_s->p2pdev, MSG_INFO, P2P_EVENT_FALLBACK_TO_GO_NEG
8123 res = wpas_p2p_fallback_to_go_neg(wpa_s, 1);
8129 unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s)
8133 if (wpa_s->wpa_state > WPA_SCANNING) {
8134 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to "
8136 wpa_s->conf->p2p_search_delay);
8137 return wpa_s->conf->p2p_search_delay;
8140 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
8142 if (ifs != wpa_s && ifs->wpa_state > WPA_SCANNING) {
8143 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search "
8146 wpa_s->conf->p2p_search_delay,
8148 return wpa_s->conf->p2p_search_delay;
8156 static int wpas_p2p_remove_psk_entry(struct wpa_supplicant *wpa_s,
8169 wpa_dbg(wpa_s, MSG_DEBUG,
8183 void wpas_p2p_new_psk_cb(struct wpa_supplicant *wpa_s, const u8 *mac_addr,
8187 struct wpa_ssid *ssid = wpa_s->current_ssid;
8195 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR
8201 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR,
8206 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: new_psk_cb during group formation");
8208 if (wpa_s->global->add_psk == NULL) {
8209 wpa_s->global->add_psk = os_zalloc(sizeof(*p));
8210 if (wpa_s->global->add_psk == NULL)
8213 p = wpa_s->global->add_psk;
8226 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO");
8230 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
8233 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not find persistent group information to store the new PSK");
8252 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove oldest PSK entry for "
8259 wpas_p2p_remove_psk_entry(wpa_s->p2pdev, persistent,
8263 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for p2p_dev_addr="
8266 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for addr=" MACSTR,
8271 if (wpa_s->p2pdev->conf->update_config &&
8272 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
8277 static void wpas_p2p_remove_psk(struct wpa_supplicant *wpa_s,
8283 res = wpas_p2p_remove_psk_entry(wpa_s, s, addr, iface_addr);
8284 if (res > 0 && wpa_s->conf->update_config &&
8285 wpa_config_write(wpa_s->confname, wpa_s->conf))
8286 wpa_dbg(wpa_s, MSG_DEBUG,
8291 static void wpas_p2p_remove_client_go(struct wpa_supplicant *wpa_s,
8298 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL ||
8299 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO)
8303 hapd = wpa_s->ap_iface->bss[0];
8310 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove operating group PSK entry for "
8332 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disconnect peer " MACSTR
8342 void wpas_p2p_remove_client(struct wpa_supplicant *wpa_s, const u8 *peer,
8347 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
8349 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove client " MACSTR, MAC2STR(peer));
8361 for (w = wpa_s->global->ifaces; w; w = w->next)
8368 struct wpa_supplicant *wpa_s = eloop_ctx;
8369 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_PSK_FAILURE);
8375 struct wpa_supplicant *wpa_s = eloop_ctx;
8378 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_FREQ_CONFLICT);
8382 int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s, int freq,
8387 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
8404 if (wpa_s == iface)
8411 wpa_supplicant_disable_network(wpa_s->global->ifaces,
8413 wpa_msg(wpa_s->global->ifaces, MSG_INFO,
8415 os_memset(wpa_s->global->ifaces->pending_bssid, 0,
8419 if (wpa_s == iface)
8430 int wpas_p2p_4way_hs_failed(struct wpa_supplicant *wpa_s)
8432 struct wpa_ssid *ssid = wpa_s->current_ssid;
8437 if (wpa_s->p2p_last_4way_hs_fail &&
8438 wpa_s->p2p_last_4way_hs_fail == ssid) {
8442 if (wpas_p2p_persistent_group(wpa_s, go_dev_addr,
8445 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group");
8449 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr="
8451 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, go_dev_addr,
8455 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No matching persistent group stored");
8458 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
8462 wpa_s->p2p_last_4way_hs_fail = NULL;
8469 wpa_s, NULL);
8473 wpa_s->p2p_last_4way_hs_fail = ssid;
8526 static int wpas_p2p_cli_freq(struct wpa_supplicant *wpa_s,
8535 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
8551 struct wpabuf * wpas_p2p_nfc_handover_req(struct wpa_supplicant *wpa_s,
8557 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
8559 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
8564 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
8565 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
8566 &wpa_s->conf->wps_nfc_dh_privkey) < 0) {
8567 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No DH key available for handover request");
8573 wpa_s->parent->wps, wpa_s->conf->wps_nfc_dh_pubkey);
8576 p2p = p2p_build_nfc_handover_req(wpa_s->global->p2p, cli_freq,
8584 struct wpabuf * wpas_p2p_nfc_handover_sel(struct wpa_supplicant *wpa_s,
8590 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
8592 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8595 if (!tag && wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
8596 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
8597 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
8602 wpa_s->parent->wps,
8603 tag ? wpa_s->conf->wps_nfc_dev_pw_id :
8605 wpa_s->conf->wps_nfc_dh_pubkey,
8606 tag ? wpa_s->conf->wps_nfc_dev_pw : NULL);
8609 p2p = p2p_build_nfc_handover_sel(wpa_s->global->p2p, cli_freq,
8617 static int wpas_p2p_nfc_join_group(struct wpa_supplicant *wpa_s,
8625 wpa_s->p2p_wps_method = WPS_NFC;
8626 wpa_s->pending_join_wps_method = WPS_NFC;
8627 os_memset(wpa_s->pending_join_iface_addr, 0, ETH_ALEN);
8628 os_memcpy(wpa_s->pending_join_dev_addr, params->go_dev_addr,
8630 return wpas_p2p_join_start(wpa_s, params->go_freq,
8635 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
8636 WPS_NFC, 0, 0, 1, 0, wpa_s->conf->p2p_go_intent,
8637 params->go_freq, wpa_s->p2p_go_vht_center_freq2,
8638 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
8639 wpa_s->p2p_go_he,
8645 static int wpas_p2p_nfc_auth_join(struct wpa_supplicant *wpa_s,
8653 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
8654 ssid = wpa_s->current_ssid;
8659 if (wpa_s->ap_iface == NULL)
8663 if (wpa_s == NULL) {
8668 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
8670 !wpa_s->p2pdev->p2p_oob_dev_pw) {
8675 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
8676 wpa_s->p2pdev->p2p_oob_dev_pw,
8677 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
8678 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
8694 wpa_s->global->p2p_invite_group = wpa_s;
8696 wpas_p2p_get_persistent(wpa_s->p2pdev,
8699 wpa_s->p2pdev->pending_invite_ssid_id = -1;
8701 return p2p_invite(wpa_s->global->p2p, params->peer->p2p_device_addr,
8702 P2P_INVITE_ROLE_ACTIVE_GO, wpa_s->own_addr,
8704 wpa_s->global->p2p_dev_addr, persistent, 0,
8705 wpa_s->p2pdev->p2p_oob_dev_pw_id);
8709 static int wpas_p2p_nfc_init_go_neg(struct wpa_supplicant *wpa_s,
8715 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
8716 WPS_NFC, 0, 0, 0, 0, wpa_s->conf->p2p_go_intent,
8717 forced_freq, wpa_s->p2p_go_vht_center_freq2,
8718 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
8719 wpa_s->p2p_go_he, NULL, 0);
8723 static int wpas_p2p_nfc_resp_go_neg(struct wpa_supplicant *wpa_s,
8731 res = wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
8732 WPS_NFC, 0, 0, 0, 1, wpa_s->conf->p2p_go_intent,
8733 forced_freq, wpa_s->p2p_go_vht_center_freq2,
8734 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
8735 wpa_s->p2p_go_he, NULL, 0);
8739 res = wpas_p2p_listen(wpa_s, 60);
8741 p2p_unauthorize(wpa_s->global->p2p,
8749 static int wpas_p2p_nfc_connection_handover(struct wpa_supplicant *wpa_s,
8808 res = p2p_process_nfc_connection_handover(wpa_s->global->p2p, ¶ms);
8816 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_BOTH_GO "peer=" MACSTR,
8823 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
8832 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
8840 if (wpas_p2p_cli_freq(wpa_s, NULL, NULL)) {
8841 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_WHILE_CLIENT "peer="
8846 wpabuf_free(wpa_s->p2p_oob_dev_pw);
8847 wpa_s->p2p_oob_dev_pw = NULL;
8859 os_memcpy(wpa_s->p2p_peer_oob_pubkey_hash,
8861 wpa_s->p2p_peer_oob_pk_hash_known = 1;
8875 wpa_s->p2p_oob_dev_pw_id = id;
8876 wpa_s->p2p_oob_dev_pw = wpabuf_alloc_copy(
8880 if (wpa_s->p2p_oob_dev_pw == NULL)
8883 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
8884 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
8885 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
8890 wpa_s->p2p_oob_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
8900 return wpas_p2p_nfc_join_group(wpa_s, ¶ms);
8902 return wpas_p2p_nfc_auth_join(wpa_s, ¶ms, tag);
8904 return wpas_p2p_nfc_init_go_neg(wpa_s, ¶ms, forced_freq);
8907 return wpas_p2p_nfc_resp_go_neg(wpa_s, ¶ms, forced_freq);
8914 int wpas_p2p_nfc_tag_process(struct wpa_supplicant *wpa_s,
8917 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8920 return wpas_p2p_nfc_connection_handover(wpa_s, data, 1, 1, forced_freq);
8924 int wpas_p2p_nfc_report_handover(struct wpa_supplicant *wpa_s, int init,
8931 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8948 ret = wpas_p2p_nfc_connection_handover(wpa_s, tmp, init, 0,
8956 int wpas_p2p_nfc_tag_enabled(struct wpa_supplicant *wpa_s, int enabled)
8959 int go_intent = wpa_s->conf->p2p_go_intent;
8962 if (wpa_s->global->p2p == NULL)
8967 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
8973 p2p_set_authorized_oob_dev_pw_id(wpa_s->global->p2p, 0,
8975 if (wpa_s->p2p_nfc_tag_enabled)
8976 wpas_p2p_remove_pending_group_interface(wpa_s);
8977 wpa_s->p2p_nfc_tag_enabled = 0;
8981 if (wpa_s->global->p2p_disabled)
8984 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
8985 wpa_s->conf->wps_nfc_dh_privkey == NULL ||
8986 wpa_s->conf->wps_nfc_dev_pw == NULL ||
8987 wpa_s->conf->wps_nfc_dev_pw_id < 0x10) {
8995 wpa_s->p2p_oob_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
8996 wpabuf_free(wpa_s->p2p_oob_dev_pw);
8997 wpa_s->p2p_oob_dev_pw = wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
8998 if (wpa_s->p2p_oob_dev_pw == NULL)
9000 wpa_s->p2p_peer_oob_pk_hash_known = 0;
9002 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
9003 wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) {
9008 wpa_s->create_p2p_iface = 0;
9010 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
9013 if (wpa_s->create_p2p_iface) {
9019 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
9025 if_addr = wpa_s->pending_interface_addr;
9026 } else if (wpa_s->p2p_mgmt)
9027 if_addr = wpa_s->parent->own_addr;
9029 if_addr = wpa_s->own_addr;
9031 wpa_s->p2p_nfc_tag_enabled = enabled;
9033 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
9040 wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
9043 wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
9046 wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
9047 hapd->conf->wps_nfc_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
9055 wpa_s->global->p2p, wpa_s->conf->wps_nfc_dev_pw_id, go_intent,
9064 static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s,
9075 if (!wpa_s->conf->p2p_optimize_listen_chan)
9078 if (!wpa_s->current_ssid || wpa_s->wpa_state != WPA_COMPLETED)
9081 curr_chan = p2p_get_listen_channel(wpa_s->global->p2p);
9094 wpa_dbg(wpa_s, MSG_DEBUG,
9097 p2p_set_listen_channel(wpa_s->global->p2p, 81, cand, 0);
9102 static int wpas_p2p_move_go_csa(struct wpa_supplicant *wpa_s)
9107 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
9111 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP_CSA)) {
9112 wpa_dbg(wpa_s, MSG_DEBUG, "CSA is not enabled");
9120 if (wpas_p2p_init_go_params(wpa_s, ¶ms, 0, 0, 0, 0, 0, 0, NULL)) {
9121 wpa_dbg(wpa_s, MSG_DEBUG,
9127 wpa_dbg(wpa_s, MSG_DEBUG,
9134 wpa_dbg(wpa_s, MSG_DEBUG,
9140 if (wpa_supplicant_conf_ap_ht(wpa_s, current_ssid, conf)) {
9141 wpa_dbg(wpa_s, MSG_DEBUG,
9147 if (conf->hw_mode != wpa_s->ap_iface->current_mode->mode) {
9148 wpa_dbg(wpa_s, MSG_DEBUG,
9187 wpa_dbg(wpa_s, MSG_DEBUG,
9208 ret = ap_switch_channel(wpa_s, &csa_settings);
9216 static void wpas_p2p_move_go_no_csa(struct wpa_supplicant *wpa_s)
9219 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
9221 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_REMOVE_AND_REFORM_GROUP);
9223 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Move GO from freq=%d MHz",
9229 wpa_supplicant_ap_deinit(wpa_s);
9232 if (wpas_p2p_init_go_params(wpa_s, ¶ms, 0, 0, 0, 0, 0, 0, NULL)) {
9233 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Failed to reselect freq");
9234 wpas_p2p_group_delete(wpa_s,
9238 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New freq selected for the GO (%u MHz)",
9242 !p2p_supported_freq_go(wpa_s->global->p2p, params.freq)) {
9246 wpas_p2p_group_delete(wpa_s,
9253 wpa_s->connect_without_scan = current_ssid;
9254 wpa_s->reassociate = 1;
9255 wpa_s->disconnected = 0;
9256 wpa_supplicant_req_scan(wpa_s, 0, 0);
9262 struct wpa_supplicant *wpa_s = eloop_ctx;
9264 if (!wpa_s->ap_iface || !wpa_s->current_ssid)
9267 wpas_p2p_go_update_common_freqs(wpa_s);
9270 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
9280 if (wpas_p2p_move_go_csa(wpa_s) < 0)
9281 wpas_p2p_move_go_no_csa(wpa_s);
9287 struct wpa_supplicant *wpa_s = eloop_ctx;
9289 unsigned int num = wpa_s->num_multichan_concurrent;
9295 num = get_shared_radio_freqs_data(wpa_s, freqs, num);
9298 wpas_p2p_consider_moving_gos(wpa_s, freqs, num,
9316 static void wpas_p2p_consider_moving_one_go(struct wpa_supplicant *wpa_s,
9325 wpas_p2p_go_update_common_freqs(wpa_s);
9327 freq = wpa_s->current_ssid->frequency;
9328 dfs_offload = (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
9329 ieee80211_is_dfs(freq, wpa_s->hw.modes, wpa_s->hw.num_modes);
9335 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
9337 wpa_dbg(wpa_s, MSG_DEBUG,
9345 } else if (!p2p_supported_freq(wpa_s->global->p2p,
9349 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
9352 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
9354 wpas_p2p_go_is_peer_freq(wpa_s, freqs[i].freq)) {
9356 } else if ((wpa_s->conf->p2p_go_freq_change_policy ==
9358 wpas_p2p_go_is_peer_freq(wpa_s, freqs[i].freq)) {
9359 if (!p2p_get_group_num_members(wpa_s->p2p_group)) {
9361 } else if ((wpa_s->drv_flags &
9363 wpas_p2p_go_clients_support_ecsa(wpa_s)) {
9370 if (wpa_s->ap_iface->current_mode->mode ==
9378 wpa_dbg(wpa_s, MSG_DEBUG,
9387 wpa_dbg(wpa_s, MSG_DEBUG,
9389 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
9391 if (wpas_p2p_in_progress(wpa_s)) {
9392 wpa_dbg(wpa_s, MSG_DEBUG,
9395 wpa_s, NULL);
9398 wpa_s, NULL);
9404 wpa_dbg(wpa_s, MSG_DEBUG,
9413 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
9414 wpa_dbg(wpa_s, MSG_DEBUG,
9419 if (invalid_freq && !wpas_p2p_disallowed_freq(wpa_s->global, freq))
9424 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Move GO from freq=%d MHz in %d secs",
9426 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
9427 eloop_register_timeout(timeout, 0, wpas_p2p_move_go, wpa_s, NULL);
9431 static void wpas_p2p_consider_moving_gos(struct wpa_supplicant *wpa_s,
9446 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
9456 if (wpa_s == ifs &&
9459 wpa_dbg(wpa_s, MSG_DEBUG,
9463 wpa_s, NULL);
9472 void wpas_p2p_indicate_state_change(struct wpa_supplicant *wpa_s)
9474 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9477 wpas_p2p_update_channel_list(wpa_s,
9482 void wpas_p2p_deinit_iface(struct wpa_supplicant *wpa_s)
9484 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
9485 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
9487 wpas_p2p_deinit_global(wpa_s->global);
9492 void wpas_p2p_ap_deinit(struct wpa_supplicant *wpa_s)
9494 if (wpa_s->ap_iface->bss)
9495 wpa_s->ap_iface->bss[0]->p2p_group = NULL;
9496 wpas_p2p_group_deinit(wpa_s);
9500 int wpas_p2p_lo_start(struct wpa_supplicant *wpa_s, unsigned int freq,
9504 struct p2p_data *p2p = wpa_s->global->p2p;
9510 if (wpa_s->p2p_lo_started) {
9511 wpa_dbg(wpa_s, MSG_DEBUG,
9516 if (wpa_s->global->p2p == NULL ||
9517 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD)) {
9522 if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
9529 dev_types_len = (wpa_s->conf->num_sec_device_types + 1) *
9534 os_memcpy(device_types, wpa_s->conf->device_type, WPS_DEV_TYPE_LEN);
9535 os_memcpy(&device_types[WPS_DEV_TYPE_LEN], wpa_s->conf->sec_device_type,
9536 wpa_s->conf->num_sec_device_types * WPS_DEV_TYPE_LEN);
9545 ret = wpa_drv_p2p_lo_start(wpa_s, freq, period, interval, count,
9549 wpa_dbg(wpa_s, MSG_DEBUG,
9556 wpa_s->p2p_lo_started = 1;
9559 wpas_stop_listen(wpa_s);
9566 int wpas_p2p_lo_stop(struct wpa_supplicant *wpa_s)
9570 if (!wpa_s->p2p_lo_started)
9573 ret = wpa_drv_p2p_lo_stop(wpa_s);
9575 wpa_dbg(wpa_s, MSG_DEBUG,
9578 wpa_s->p2p_lo_started = 0;