Lines Matching refs:wpa_s
99 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
101 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s);
102 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq);
104 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
107 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
108 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s);
110 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s);
116 static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
118 static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s);
125 static int wpas_p2p_num_unused_channels(struct wpa_supplicant *wpa_s)
130 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
134 num = get_shared_radio_freqs(wpa_s, freqs,
135 wpa_s->num_multichan_concurrent);
138 return wpa_s->num_multichan_concurrent - num;
146 static int wpas_p2p_valid_oper_freqs(struct wpa_supplicant *wpa_s,
152 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
156 num = get_shared_radio_freqs(wpa_s, freqs,
157 wpa_s->num_multichan_concurrent);
162 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i]))
172 static void wpas_p2p_set_own_freq_preference(struct wpa_supplicant *wpa_s,
175 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
177 if (freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
178 wpas_p2p_num_unused_channels(wpa_s) > 0 &&
179 wpa_s->parent->conf->p2p_ignore_shared_freq)
181 p2p_set_own_freq_preference(wpa_s->global->p2p, freq);
185 static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
190 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
202 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
209 p2p_scan_res_handled(wpa_s->global->p2p);
217 struct wpa_supplicant *wpa_s = ctx;
225 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
228 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
231 wpas_p2p_in_progress(wpa_s) == 2) {
235 wpa_s->global->p2p_cb_on_scan_complete = 1;
248 wpa_s->wps->dev.p2p = 1;
249 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
250 wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
255 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
264 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id);
282 ret = wpa_drv_scan(wpa_s, ¶ms);
287 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
290 wpa_s->global->p2p_cb_on_scan_complete = 1;
296 os_get_time(&wpa_s->scan_trigger_time);
297 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
319 static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s,
325 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
326 for (s = wpa_s->conf->ssid; s; s = s->next) {
332 s != wpa_s->current_ssid)
336 return wpa_s;
344 static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s,
351 ssid = wpa_s->current_ssid;
358 ssid = wpa_s->conf->ssid;
365 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
372 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
374 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
376 wpa_s->reassociate = 0;
377 wpa_s->disconnected = 1;
378 wpa_supplicant_deauthenticate(wpa_s,
383 if (wpa_s->cross_connect_in_use) {
384 wpa_s->cross_connect_in_use = 0;
385 wpa_msg_global(wpa_s->parent, MSG_INFO,
387 wpa_s->ifname, wpa_s->cross_connect_uplink);
418 wpa_msg_global(wpa_s->parent, MSG_INFO,
420 wpa_s->ifname, gtype, reason);
424 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL);
426 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
429 wpa_s->parent, NULL) > 0) {
432 wpa_s->p2p_in_provisioning = 0;
436 wpas_notify_p2p_group_removed(wpa_s, ssid, gtype);
438 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
443 wpa_s->ifname);
444 global = wpa_s->global;
445 ifname = os_strdup(wpa_s->ifname);
446 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
447 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
448 wpa_s = global->ifaces;
449 if (wpa_s && ifname)
450 wpa_drv_if_remove(wpa_s, type, ifname);
460 if (ssid == wpa_s->current_ssid) {
461 wpa_sm_set_config(wpa_s->wpa, NULL);
462 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
463 wpa_s->current_ssid = NULL;
474 wpa_config_remove_network(wpa_s->conf, id);
475 wpa_supplicant_clear_status(wpa_s);
476 wpa_supplicant_cancel_sched_scan(wpa_s);
477 wpa_s->sta_scan_pending = 0;
482 if (wpa_s->ap_iface)
483 wpa_supplicant_ap_deinit(wpa_s);
485 wpa_drv_deinit_p2p_cli(wpa_s);
491 static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
501 if (wpa_s->go_params)
502 bssid = wpa_s->go_params->peer_interface_addr;
504 bssid = wpa_s->bssid;
506 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
509 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
511 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
553 static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
562 for (s = wpa_s->conf->ssid; s; s = s->next) {
582 s = wpa_config_add_network(wpa_s->conf);
594 wpas_notify_persistent_group_added(wpa_s, s);
627 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) {
628 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list);
629 wpa_s->global->add_psk = NULL;
634 if (changed && wpa_s->conf->update_config &&
635 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
644 static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s,
652 ssid = wpa_s->current_ssid;
657 for (s = wpa_s->parent->conf->ssid; s; s = s->next) {
707 if (wpa_s->parent->conf->update_config &&
708 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
714 static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
725 * This callback is likely called for the main interface. Update wpa_s
729 if (wpa_s->global->p2p_group_formation)
730 wpa_s = wpa_s->global->p2p_group_formation;
731 wpa_s->global->p2p_group_formation = NULL;
732 wpa_s->p2p_in_provisioning = 0;
735 wpa_msg_global(wpa_s->parent, MSG_INFO,
737 wpas_p2p_group_delete(wpa_s,
742 wpa_msg_global(wpa_s->parent, MSG_INFO,
745 ssid = wpa_s->current_ssid;
748 p2p_group_notif_formation_done(wpa_s->p2p_group);
749 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
758 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
761 persistent = wpas_p2p_persistent_group(wpa_s,
767 client = wpa_s->p2p_group_interface ==
772 wpa_s->show_group_started = 0;
779 wpa_s->show_group_started = 1;
782 * So we need to restore wpa_s->global->p2p_group_formation */
783 wpa_printf(MSG_INFO, "Restoring back wpa_s->global->p2p_group_formation to wpa_s %p\n", wpa_s);
784 wpa_s->global->p2p_group_formation = wpa_s;
790 wpa_msg_global(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
793 wpa_s->ifname, ssid_txt, ssid->frequency, psk,
796 wpas_p2p_cross_connect_setup(wpa_s);
797 wpas_p2p_set_group_idle_timeout(wpa_s);
799 wpa_msg_global(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
802 wpa_s->ifname, ssid_txt,
807 wpas_p2p_cross_connect_setup(wpa_s);
808 wpas_p2p_set_group_idle_timeout(wpa_s);
812 network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
815 os_free(wpa_s->global->add_psk);
816 wpa_s->global->add_psk = NULL;
821 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
822 os_get_time(&wpa_s->global->p2p_go_wait_client);
827 static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
837 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
839 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
854 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
857 wpa_s->pending_pd_before_join &&
858 (os_memcmp(dst, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
859 os_memcmp(dst, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0) &&
860 wpa_s->p2p_fallback_to_go_neg) {
861 wpa_s->pending_pd_before_join = 0;
862 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req "
864 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
874 struct wpa_supplicant *wpa_s = ctx;
875 return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len,
883 struct wpa_supplicant *wpa_s = ctx;
884 offchannel_send_action_done(wpa_s);
888 static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
891 if (wpa_s->go_params == NULL) {
892 wpa_s->go_params = os_malloc(sizeof(*params));
893 if (wpa_s->go_params == NULL)
896 os_memcpy(wpa_s->go_params, params, sizeof(*params));
901 static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
908 wpa_supplicant_ap_deinit(wpa_s);
909 wpas_copy_go_neg_results(wpa_s, res);
911 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1);
914 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
916 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
917 wpa_s->p2p_pin, 1, dev_pw_id);
922 static void wpas_p2p_add_psk_list(struct wpa_supplicant *wpa_s,
929 if (!wpa_s->ap_iface)
932 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid,
937 hapd = wpa_s->ap_iface->bss[0];
943 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add persistent group PSK entry for "
962 struct wpa_supplicant *wpa_s = ctx;
967 ssid = wpa_s->current_ssid;
970 if (wpa_s->global->p2p_group_formation == wpa_s)
971 wpa_s->global->p2p_group_formation = NULL;
973 wpa_msg_global(wpa_s->parent, MSG_INFO,
977 "%s", wpa_s->ifname,
980 MAC2STR(wpa_s->global->p2p_dev_addr),
987 wpa_msg_global(wpa_s->parent, MSG_INFO,
991 wpa_s->ifname,
994 MAC2STR(wpa_s->global->p2p_dev_addr),
1001 wpa_s->parent, ssid,
1002 wpa_s->global->p2p_dev_addr);
1003 wpas_p2p_add_psk_list(wpa_s, ssid);
1007 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
1008 wpas_p2p_cross_connect_setup(wpa_s);
1009 wpas_p2p_set_group_idle_timeout(wpa_s);
1014 if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
1021 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
1023 else if (wpa_s->p2p_pin[0])
1024 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
1025 wpa_s->p2p_pin, NULL, 0, 0);
1026 os_free(wpa_s->go_params);
1027 wpa_s->go_params = NULL;
1031 static void wpas_start_wps_go(struct wpa_supplicant *wpa_s,
1037 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO");
1038 if (wpas_copy_go_neg_results(wpa_s, params) < 0) {
1039 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation "
1044 ssid = wpa_config_add_network(wpa_s->conf);
1046 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO");
1050 wpa_s->show_group_started = 0;
1072 wpa_msg_global(wpa_s, MSG_ERROR,
1074 wpa_config_remove_network(wpa_s->conf, ssid->id);
1084 ssid->ap_max_inactivity = wpa_s->parent->conf->p2p_go_max_inactivity;
1086 wpa_s->ap_configured_cb = p2p_go_configured;
1087 wpa_s->ap_configured_cb_ctx = wpa_s;
1088 wpa_s->ap_configured_cb_data = wpa_s->go_params;
1089 wpa_s->connect_without_scan = ssid;
1090 wpa_s->reassociate = 1;
1091 wpa_s->disconnected = 0;
1092 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to "
1094 wpa_supplicant_req_scan(wpa_s, 0, 0);
1132 static void wpas_p2p_get_group_ifname(struct wpa_supplicant *wpa_s,
1135 char *ifname_ptr = wpa_s->ifname;
1137 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX,
1139 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1;
1142 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx);
1144 wpa_s->ifname) < IFNAMSIZ) {
1147 wpa_s->p2p_group_idx);
1152 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
1157 if (wpa_s->pending_interface_name[0]) {
1160 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
1163 wpa_s->pending_interface_name);
1169 wpas_p2p_get_group_ifname(wpa_s, ifname, sizeof(ifname));
1174 wpa_s->p2p_group_idx++;
1176 wpa_s->pending_interface_type = type;
1177 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
1178 wpa_s->pending_interface_addr, NULL) < 0) {
1187 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
1188 sizeof(wpa_s->pending_interface_name));
1190 os_strlcpy(wpa_s->pending_interface_name, ifname,
1191 sizeof(wpa_s->pending_interface_name));
1193 MACSTR, wpa_s->pending_interface_name,
1194 MAC2STR(wpa_s->pending_interface_addr));
1201 struct wpa_supplicant *wpa_s)
1203 if (!wpa_s->pending_interface_name[0] ||
1204 is_zero_ether_addr(wpa_s->pending_interface_addr))
1208 wpa_s->pending_interface_name);
1209 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
1210 wpa_s->pending_interface_name);
1211 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
1212 wpa_s->pending_interface_name[0] = '\0';
1217 wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
1222 if (!wpa_s->pending_interface_name[0]) {
1224 if (!wpas_p2p_create_iface(wpa_s))
1231 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
1237 iface.ifname = wpa_s->pending_interface_name;
1238 iface.driver = wpa_s->driver->name;
1239 if (wpa_s->conf->ctrl_interface == NULL &&
1240 wpa_s->parent != wpa_s &&
1241 wpa_s->p2p_mgmt &&
1242 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE))
1243 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface;
1245 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
1246 iface.driver_param = wpa_s->conf->driver_param;
1247 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
1253 wpa_s->pending_interface_name[0] = '\0';
1254 group_wpa_s->parent = wpa_s;
1257 wpa_s->global->p2p_group_formation = group_wpa_s;
1259 wpas_p2p_clone_config(group_wpa_s, wpa_s);
1268 struct wpa_supplicant *wpa_s = eloop_ctx;
1270 wpas_p2p_group_formation_failed(wpa_s);
1274 void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s)
1277 wpa_s->parent, NULL);
1278 if (wpa_s->global->p2p)
1279 p2p_group_formation_failed(wpa_s->global->p2p);
1280 else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
1281 wpa_drv_p2p_group_formation_failed(wpa_s);
1282 wpas_group_formation_completed(wpa_s, 0);
1286 void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s)
1288 if (wpa_s->global->p2p_group_formation != wpa_s)
1292 wpa_s->parent, NULL);
1294 wpa_s->parent, NULL);
1300 struct wpa_supplicant *wpa_s = ctx;
1302 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
1303 wpa_drv_cancel_remain_on_channel(wpa_s);
1304 wpa_s->off_channel_freq = 0;
1305 wpa_s->roc_waiting_drv_freq = 0;
1309 wpa_msg_global(wpa_s, MSG_INFO,
1312 wpas_notify_p2p_go_neg_completed(wpa_s, res);
1313 wpas_p2p_remove_pending_group_interface(wpa_s);
1317 if (wpa_s->p2p_go_ht40)
1320 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS "role=%s "
1327 wpas_notify_p2p_go_neg_completed(wpa_s, res);
1329 if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
1331 ssid = wpa_config_get_network(wpa_s->conf,
1332 wpa_s->p2p_persistent_id);
1343 if (wpa_s->create_p2p_iface) {
1345 wpas_p2p_init_group_interface(wpa_s, res->role_go);
1347 wpas_p2p_remove_pending_group_interface(wpa_s);
1350 if (group_wpa_s != wpa_s) {
1351 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
1353 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
1355 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
1356 wpa_s->pending_interface_name[0] = '\0';
1364 wpa_s->p2p_in_provisioning = 1;
1365 wpa_s->global->p2p_group_formation = wpa_s;
1368 wpas_start_wps_go(wpa_s, res, 1);
1373 wpa_s->p2p_long_listen = 0;
1374 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
1376 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
1379 wpas_p2p_group_formation_timeout, wpa_s, NULL);
1385 struct wpa_supplicant *wpa_s = ctx;
1386 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
1389 wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id);
1398 struct wpa_supplicant *wpa_s = ctx;
1410 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
1428 struct wpa_supplicant *wpa_s = ctx;
1430 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST
1433 wpas_notify_p2p_device_lost(wpa_s, dev_addr);
1439 struct wpa_supplicant *wpa_s = ctx;
1440 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_FIND_STOPPED);
1448 struct wpa_supplicant *wpa_s = ctx;
1450 wpa_drv_set_ap_wps_ie(wpa_s, NULL, probe_resp_ie, NULL);
1452 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
1458 wpa_s->pending_listen_freq = freq;
1459 wpa_s->pending_listen_duration = duration;
1461 if (wpa_drv_remain_on_channel(wpa_s, freq, duration) < 0) {
1465 wpa_s->pending_listen_freq = 0;
1468 wpa_s->off_channel_freq = 0;
1469 wpa_s->roc_waiting_drv_freq = freq;
1477 struct wpa_supplicant *wpa_s = ctx;
1478 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
1479 wpa_drv_cancel_remain_on_channel(wpa_s);
1480 wpa_s->off_channel_freq = 0;
1481 wpa_s->roc_waiting_drv_freq = 0;
1483 wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL);
1484 wpa_drv_probe_req_report(wpa_s, 0);
1490 struct wpa_supplicant *wpa_s = ctx;
1491 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1);
1625 wpas_p2p_service_get_bonjour(struct wpa_supplicant *wpa_s,
1632 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
1644 wpas_p2p_service_get_upnp(struct wpa_supplicant *wpa_s, u8 version,
1649 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1678 static void wpas_sd_all_bonjour(struct wpa_supplicant *wpa_s,
1686 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
1691 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
1741 static void wpas_sd_req_bonjour(struct wpa_supplicant *wpa_s,
1751 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
1759 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
1763 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
1812 static void wpas_sd_all_upnp(struct wpa_supplicant *wpa_s,
1820 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
1825 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1848 static void wpas_sd_req_upnp(struct wpa_supplicant *wpa_s,
1861 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
1869 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
1888 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1930 static void wpas_sd_req_wfd(struct wpa_supplicant *wpa_s,
1940 if (!wpa_s->global->wifi_display) {
1970 wpa_s->global->wfd_subelem[*pos] &&
1972 wpabuf_len(wpa_s->global->wfd_subelem[*pos])) {
1975 wpabuf_put_buf(resp, wpa_s->global->wfd_subelem[*pos]);
1988 struct wpa_supplicant *wpa_s = ctx;
2004 wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_REQ "%d "
2011 if (wpa_s->p2p_sd_over_ctrl_iface) {
2012 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
2044 if (wpa_s->force_long_sd) {
2047 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
2048 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
2056 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp) &&
2057 dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
2065 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
2066 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
2069 wpas_sd_req_bonjour(wpa_s, resp, srv_trans_id,
2073 wpas_sd_req_upnp(wpa_s, resp, srv_trans_id,
2078 wpas_sd_req_wfd(wpa_s, resp, srv_trans_id,
2094 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
2097 wpas_p2p_sd_response(wpa_s, freq, sa, dialog_token, resp);
2106 struct wpa_supplicant *wpa_s = ctx;
2118 wpa_msg_ctrl(wpa_s, MSG_INFO,
2128 wpa_msg_ctrl(wpa_s, MSG_INFO,
2164 wpas_notify_p2p_sd_response(wpa_s, sa, update_indic, tlvs, tlvs_len);
2168 u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
2171 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
2172 return wpa_drv_p2p_sd_request(wpa_s, dst, tlvs);
2173 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2175 return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
2179 u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,
2193 ret = wpas_p2p_sd_request(wpa_s, dst, tlvs);
2201 static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst,
2204 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
2206 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2208 return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs);
2247 u64 wpas_p2p_sd_request_wifi_display(struct wpa_supplicant *wpa_s,
2273 ret = wpas_p2p_sd_request_wfd(wpa_s, dst, tlvs);
2281 int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req)
2283 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
2284 return wpa_drv_p2p_sd_cancel_request(wpa_s, req);
2285 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2287 return p2p_sd_cancel_request(wpa_s->global->p2p,
2292 void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
2296 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
2297 wpa_drv_p2p_sd_response(wpa_s, freq, dst, dialog_token,
2301 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2303 p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
2308 void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s)
2310 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
2311 wpa_drv_p2p_service_update(wpa_s);
2314 if (wpa_s->global->p2p)
2315 p2p_sd_service_update(wpa_s->global->p2p);
2336 void wpas_p2p_service_flush(struct wpa_supplicant *wpa_s)
2341 dl_list_for_each_safe(bsrv, bn, &wpa_s->global->p2p_srv_bonjour,
2345 dl_list_for_each_safe(usrv, un, &wpa_s->global->p2p_srv_upnp,
2349 wpas_p2p_sd_service_update(wpa_s);
2353 int wpas_p2p_service_add_bonjour(struct wpa_supplicant *wpa_s,
2363 dl_list_add(&wpa_s->global->p2p_srv_bonjour, &bsrv->list);
2365 wpas_p2p_sd_service_update(wpa_s);
2370 int wpas_p2p_service_del_bonjour(struct wpa_supplicant *wpa_s,
2375 wpa_s, query);
2379 wpas_p2p_sd_service_update(wpa_s);
2384 int wpas_p2p_service_add_upnp(struct wpa_supplicant *wpa_s, u8 version,
2389 if (wpas_p2p_service_get_upnp(wpa_s, version, service))
2400 dl_list_add(&wpa_s->global->p2p_srv_upnp, &usrv->list);
2402 wpas_p2p_sd_service_update(wpa_s);
2407 int wpas_p2p_service_del_upnp(struct wpa_supplicant *wpa_s, u8 version,
2412 usrv = wpas_p2p_service_get_upnp(wpa_s, version, service);
2416 wpas_p2p_sd_service_update(wpa_s);
2421 static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
2425 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR
2430 static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
2433 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR
2444 struct wpa_supplicant *wpa_s = ctx;
2452 for (group = wpa_s->global->ifaces; group; group = group->next)
2481 wpas_prov_disc_local_display(wpa_s, peer, params,
2484 wpas_prov_disc_local_keypad(wpa_s, peer, params);
2486 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ
2489 wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */,
2497 struct wpa_supplicant *wpa_s = ctx;
2501 if (wpa_s->pending_pd_before_join &&
2502 (os_memcmp(peer, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
2503 os_memcmp(peer, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
2504 wpa_s->pending_pd_before_join = 0;
2507 wpas_p2p_join_start(wpa_s);
2511 if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
2512 wpa_s->pending_pd_use == AUTO_PD_GO_NEG)
2514 wpa_s->pending_pd_use == AUTO_PD_JOIN);
2519 wpas_prov_disc_local_keypad(wpa_s, peer, params);
2522 wpas_prov_disc_local_display(wpa_s, peer, params,
2525 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP
2528 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2537 struct wpa_supplicant *wpa_s = ctx;
2539 if (wpa_s->p2p_fallback_to_go_neg) {
2540 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
2542 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
2547 wpa_s->pending_pd_before_join = 0;
2551 wpas_p2p_join_start(wpa_s);
2555 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
2559 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2579 struct wpa_supplicant *wpa_s = ctx;
2587 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
2588 (os_memcmp(go_dev_addr, wpa_s->p2p_auth_invite, ETH_ALEN)
2590 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0)) {
2602 grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go);
2611 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
2612 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0) {
2615 } else if (!wpa_s->conf->persistent_reconnect)
2618 for (s = wpa_s->conf->ssid; s; s = s->next) {
2633 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
2635 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2641 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
2644 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
2650 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
2655 wpas_p2p_set_own_freq_preference(wpa_s, 0);
2658 if (wpas_p2p_valid_oper_freqs(wpa_s, &res, 1) > 0) {
2661 wpas_p2p_set_own_freq_preference(wpa_s, res);
2664 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
2665 wpas_p2p_num_unused_channels(wpa_s) > 0) {
2692 struct wpa_supplicant *wpa_s = ctx;
2695 for (s = wpa_s->conf->ssid; s; s = s->next) {
2709 wpa_s, s, go, go ? op_freq : 0, 0, NULL);
2711 wpa_s->user_initiated_pd = 0;
2712 wpas_p2p_join(wpa_s, bssid, go_dev_addr,
2713 wpa_s->p2p_wps_method, 0);
2726 wpa_msg_global(wpa_s, MSG_INFO,
2733 wpa_msg_global(wpa_s, MSG_INFO,
2743 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
2747 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
2754 static void wpas_remove_persistent_peer(struct wpa_supplicant *wpa_s,
2773 wpas_notify_network_removed(wpa_s, ssid);
2774 wpa_config_remove_network(wpa_s->conf, ssid->id);
2789 if (wpa_s->parent->conf->update_config &&
2790 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
2796 static void wpas_remove_persistent_client(struct wpa_supplicant *wpa_s,
2801 wpa_s = wpa_s->global->p2p_invite_group;
2802 if (wpa_s == NULL)
2804 ssid = wpa_s->current_ssid;
2808 ssid = wpas_p2p_get_persistent(wpa_s->parent, peer,
2810 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
2818 struct wpa_supplicant *wpa_s = ctx;
2822 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
2826 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
2829 wpas_notify_p2p_invitation_result(wpa_s, status, bssid);
2833 if (wpa_s->pending_invite_ssid_id == -1) {
2835 wpas_remove_persistent_client(wpa_s, peer);
2848 wpa_s->conf, wpa_s->pending_invite_ssid_id);
2849 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
2851 wpas_p2p_remove_pending_group_interface(wpa_s);
2855 ssid = wpa_config_get_network(wpa_s->conf,
2856 wpa_s->pending_invite_ssid_id);
2872 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before "
2876 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 100 ms wait on current channel before "
2881 wpas_p2p_group_add_persistent(wpa_s, ssid,
2883 wpa_s->p2p_persistent_go_freq,
2884 wpa_s->p2p_go_ht40, channels);
2913 static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s,
2925 wpa_s->global, 2412 + i * 5))
2937 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
2939 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
2941 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
2943 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
2954 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
2956 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
2958 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
2960 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
3037 static int wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s,
3043 if (!has_channel(wpa_s->global, mode, channel, &flag))
3047 !has_channel(wpa_s->global, mode, channel - 4, NULL)))
3051 !has_channel(wpa_s->global, mode, channel + 4, NULL)))
3057 static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
3063 if (wpa_s->hw.modes == NULL) {
3067 return wpas_p2p_default_channels(wpa_s, chan);
3077 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode);
3081 if (wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw) < 1)
3105 int wpas_p2p_get_ht40_mode(struct wpa_supplicant *wpa_s,
3118 ret = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
3134 struct wpa_supplicant *wpa_s = ctx;
3136 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3137 if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0)
3140 if (wpa_s == NULL)
3143 return wpa_drv_get_noa(wpa_s, buf, buf_len);
3149 struct wpa_supplicant *wpa_s = ctx;
3151 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3152 struct wpa_ssid *ssid = wpa_s->current_ssid;
3157 if (wpa_s->wpa_state != WPA_COMPLETED &&
3158 wpa_s->wpa_state != WPA_GROUP_HANDSHAKE)
3160 if (os_memcmp(wpa_s->go_dev_addr, dev_addr, ETH_ALEN) == 0)
3170 struct wpa_supplicant *wpa_s = ctx;
3171 wpa_msg_global(wpa_s, level, "P2P: %s", msg);
3175 int wpas_p2p_add_p2pdev_interface(struct wpa_supplicant *wpa_s)
3184 wpa_s->ifname);
3186 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE;
3187 ret = wpa_drv_if_add(wpa_s, WPA_IF_P2P_DEVICE, ifname, NULL, NULL,
3188 force_name, wpa_s->pending_interface_addr, NULL);
3193 os_strlcpy(wpa_s->pending_interface_name, ifname,
3194 sizeof(wpa_s->pending_interface_name));
3198 iface.ifname = wpa_s->pending_interface_name;
3199 iface.driver = wpa_s->driver->name;
3200 iface.driver_param = wpa_s->conf->driver_param;
3201 iface.confname = wpa_s->confname;
3202 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
3207 p2pdev_wpa_s->parent = wpa_s;
3209 wpa_s->pending_interface_name[0] = '\0';
3217 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
3220 int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
3226 if (wpa_s->conf->p2p_disabled)
3229 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
3235 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
3240 params.dev_name = wpa_s->conf->device_name;
3241 os_memcpy(params.pri_dev_type, wpa_s->conf->device_type,
3243 params.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
3245 wpa_s->conf->sec_device_type,
3248 if (wpa_drv_p2p_set_params(wpa_s, ¶ms) < 0)
3255 p2p.cb_ctx = wpa_s;
3279 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
3280 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
3281 p2p.dev_name = wpa_s->conf->device_name;
3282 p2p.manufacturer = wpa_s->conf->manufacturer;
3283 p2p.model_name = wpa_s->conf->model_name;
3284 p2p.model_number = wpa_s->conf->model_number;
3285 p2p.serial_number = wpa_s->conf->serial_number;
3286 if (wpa_s->wps) {
3287 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
3288 p2p.config_methods = wpa_s->wps->config_methods;
3291 if (wpa_s->conf->p2p_listen_reg_class &&
3292 wpa_s->conf->p2p_listen_channel) {
3293 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
3294 p2p.channel = wpa_s->conf->p2p_listen_channel;
3306 if (wpa_s->conf->p2p_oper_reg_class &&
3307 wpa_s->conf->p2p_oper_channel) {
3308 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
3309 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
3327 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) {
3328 p2p.pref_chan = wpa_s->conf->p2p_pref_chan;
3329 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan;
3332 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3333 os_memcpy(p2p.country, wpa_s->conf->country, 2);
3338 if (wpas_p2p_setup_channels(wpa_s, &p2p.channels)) {
3344 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
3347 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
3348 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
3351 p2p.concurrent_operations = !!(wpa_s->drv_flags &
3356 if (wpa_s->conf->p2p_ssid_postfix) {
3358 os_strlen(wpa_s->conf->p2p_ssid_postfix);
3361 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
3365 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
3367 p2p.max_listen = wpa_s->max_remain_on_chan;
3372 global->p2p_init_wpa_s = wpa_s;
3375 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
3378 global->p2p, wpa_s->conf->wps_vendor_ext[i]);
3387 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
3391 void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
3393 if (wpa_s->driver && wpa_s->drv_priv)
3394 wpa_drv_probe_req_report(wpa_s, 0);
3396 if (wpa_s->go_params) {
3399 wpa_s->global->p2p,
3400 wpa_s->go_params->peer_device_addr);
3403 os_free(wpa_s->go_params);
3404 wpa_s->go_params = NULL;
3406 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL);
3408 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
3409 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
3410 wpa_s->p2p_long_listen = 0;
3411 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
3412 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
3413 wpas_p2p_remove_pending_group_interface(wpa_s);
3415 /* TODO: remove group interface from the driver if this wpa_s instance
3428 struct wpa_supplicant *wpa_s, *tmp;
3430 wpa_s = global->ifaces;
3431 if (wpa_s)
3432 wpas_p2p_service_flush(wpa_s);
3438 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
3439 wpa_s = wpa_s->next;
3440 while (wpa_s) {
3443 (tmp == wpa_s ||
3457 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3458 if (wpa_s->ap_iface)
3459 wpas_p2p_group_deinit(wpa_s);
3468 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
3470 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
3471 wpa_s->conf->p2p_no_group_iface)
3473 if (wpa_s->drv_flags &
3478 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
3480 if (wpa_s->global->ifaces->next)
3482 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3488 static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
3495 if (persistent_group && wpa_s->conf->persistent_reconnect)
3498 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
3499 return wpa_drv_p2p_connect(wpa_s, peer_addr, wps_method,
3508 p2p_set_config_timeout(wpa_s->global->p2p,
3509 wpa_s->p2p_go_ht40 ? 255 : 100, 20);
3511 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
3515 wpa_s->p2p_pd_before_go_neg, pref_freq);
3519 static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
3526 if (persistent_group && wpa_s->conf->persistent_reconnect)
3529 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
3532 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
3539 static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s)
3541 wpa_s->p2p_join_scan_count++;
3543 wpa_s->p2p_join_scan_count);
3544 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
3547 MAC2STR(wpa_s->pending_join_iface_addr));
3548 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
3549 if (wpa_s->p2p_auto_pd) {
3550 wpa_s->p2p_auto_pd = 0;
3551 wpa_msg_global(wpa_s, MSG_INFO,
3554 MAC2STR(wpa_s->pending_join_dev_addr));
3557 wpa_msg_global(wpa_s->parent, MSG_INFO,
3563 static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq)
3567 if (wpas_p2p_num_unused_channels(wpa_s) > 0) {
3572 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
3576 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
3577 wpa_s->num_multichan_concurrent);
3600 static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s,
3606 bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr);
3609 if (bss->last_update_idx < wpa_s->bss_update_idx) {
3615 updated = os_time_before(&wpa_s->p2p_auto_started, &bss->last_update);
3625 static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
3632 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
3634 if (wpa_s->global->p2p_disabled)
3639 wpa_s->p2p_auto_join ? "auto_" : "");
3642 wpas_p2p_scan_res_handler(wpa_s, scan_res);
3644 if (wpa_s->p2p_auto_pd) {
3645 int join = wpas_p2p_peer_go(wpa_s,
3646 wpa_s->pending_join_dev_addr);
3648 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
3649 wpa_s->auto_pd_scan_retry++;
3651 wpa_s, wpa_s->pending_join_dev_addr);
3656 wpa_s->auto_pd_scan_retry,
3657 MAC2STR(wpa_s->
3660 wpas_p2p_join_scan_req(wpa_s, freq);
3668 wpa_s->p2p_auto_pd = 0;
3669 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
3671 MAC2STR(wpa_s->pending_join_dev_addr), join);
3672 if (p2p_prov_disc_req(wpa_s->global->p2p,
3673 wpa_s->pending_join_dev_addr,
3674 wpa_s->pending_pd_config_methods, join,
3675 0, wpa_s->user_initiated_pd) < 0) {
3676 wpa_s->p2p_auto_pd = 0;
3677 wpa_msg_global(wpa_s, MSG_INFO,
3680 MAC2STR(wpa_s->pending_join_dev_addr));
3685 if (wpa_s->p2p_auto_join) {
3686 int join = wpas_p2p_peer_go(wpa_s,
3687 wpa_s->pending_join_dev_addr);
3691 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
3692 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
3693 wpa_s->p2p_persistent_group, 0, 0, 0,
3694 wpa_s->p2p_go_intent,
3695 wpa_s->p2p_connect_freq,
3696 wpa_s->p2p_persistent_id,
3697 wpa_s->p2p_pd_before_go_neg,
3698 wpa_s->p2p_go_ht40);
3706 wpa_s->p2p_fallback_to_go_neg = 1;
3709 freq = p2p_get_oper_freq(wpa_s->global->p2p,
3710 wpa_s->pending_join_iface_addr);
3712 p2p_get_interface_addr(wpa_s->global->p2p,
3713 wpa_s->pending_join_dev_addr,
3715 os_memcmp(iface_addr, wpa_s->pending_join_dev_addr, ETH_ALEN) != 0)
3720 MAC2STR(wpa_s->pending_join_iface_addr),
3722 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
3725 freq = p2p_get_oper_freq(wpa_s->global->p2p,
3726 wpa_s->pending_join_iface_addr);
3732 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->pending_join_iface_addr);
3741 if (wpas_check_freq_conflict(wpa_s, freq) > 0) {
3742 wpa_msg_global(wpa_s->parent, MSG_INFO,
3751 MAC2STR(wpa_s->pending_join_dev_addr), freq);
3752 wpa_s->pending_pd_before_join = 1;
3754 switch (wpa_s->pending_join_wps_method) {
3769 if ((p2p_get_provisioning_info(wpa_s->global->p2p,
3770 wpa_s->pending_join_dev_addr) ==
3779 MAC2STR(wpa_s->pending_join_dev_addr));
3780 wpa_s->pending_pd_before_join = 0;
3784 if (p2p_prov_disc_req(wpa_s->global->p2p,
3785 wpa_s->pending_join_dev_addr, method, 1,
3786 freq, wpa_s->user_initiated_pd) < 0) {
3790 wpa_s->pending_pd_before_join = 0;
3797 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
3798 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
3799 wpas_p2p_check_join_scan_limit(wpa_s);
3804 wpas_p2p_join_start(wpa_s);
3808 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq)
3822 freq = (oper_freq = p2p_get_oper_freq(wpa_s->global->p2p,
3823 wpa_s->pending_join_iface_addr) == -1) ? 0 : oper_freq;
3833 wpa_s->wps->dev.p2p = 1;
3834 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev,
3835 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0,
3838 wpas_p2p_scan_res_join(wpa_s, NULL);
3842 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
3846 wpas_p2p_scan_res_join(wpa_s, NULL);
3852 p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
3866 ret = wpa_drv_scan(wpa_s, ¶ms);
3868 os_get_time(&wpa_s->scan_trigger_time);
3869 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
3877 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
3878 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
3879 wpas_p2p_check_join_scan_limit(wpa_s);
3886 struct wpa_supplicant *wpa_s = eloop_ctx;
3887 wpas_p2p_join_scan_req(wpa_s, 0);
3891 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
3900 wpa_s->p2p_auto_pd = 0;
3901 wpa_s->p2p_auto_join = !!auto_join;
3902 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
3903 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
3904 wpa_s->pending_join_wps_method = wps_method;
3907 wpas_p2p_stop_find(wpa_s);
3909 wpa_s->p2p_join_scan_count = 0;
3910 wpas_p2p_join_scan(wpa_s, NULL);
3915 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s)
3921 group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
3924 if (group != wpa_s) {
3925 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
3927 group->p2p_wps_method = wpa_s->p2p_wps_method;
3936 wpa_s->global->p2p_group_formation = wpa_s;
3940 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
3943 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
3945 res.wps_method = wpa_s->pending_join_wps_method;
3946 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->pending_join_iface_addr);
3953 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
3956 wpa_drv_cancel_remain_on_channel(wpa_s);
3957 wpa_s->off_channel_freq = 0;
3958 wpa_s->roc_waiting_drv_freq = 0;
3967 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
3969 wpa_s, NULL);
3975 static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
3981 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
3985 num = get_shared_radio_freqs(wpa_s, freqs,
3986 wpa_s->num_multichan_concurrent);
3989 freq, wpa_s->num_multichan_concurrent, num);
3992 if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
4005 if (num == wpa_s->num_multichan_concurrent && !freq_in_use) {
4018 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i]))
4027 if (*pref_freq == 0 && num < wpa_s->num_multichan_concurrent) {
4041 if (num < wpa_s->num_multichan_concurrent) {
4061 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4081 int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
4093 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4097 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
4103 os_free(wpa_s->global->add_psk);
4104 wpa_s->global->add_psk = NULL;
4107 go_intent = wpa_s->conf->p2p_go_intent;
4110 wpa_s->p2p_long_listen = 0;
4112 wpa_s->p2p_wps_method = wps_method;
4113 wpa_s->p2p_persistent_group = !!persistent_group;
4114 wpa_s->p2p_persistent_id = persistent_id;
4115 wpa_s->p2p_go_intent = go_intent;
4116 wpa_s->p2p_connect_freq = freq;
4117 wpa_s->p2p_fallback_to_go_neg = 0;
4118 wpa_s->p2p_pd_before_go_neg = !!pd;
4119 wpa_s->p2p_go_ht40 = !!ht40;
4122 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
4125 os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin), "%08d",
4128 wpa_s->p2p_pin);
4130 wpa_s->p2p_pin[0] = '\0';
4138 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
4142 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
4145 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
4149 os_get_time(&wpa_s->p2p_auto_started);
4152 wpa_s->p2p_auto_started.sec,
4153 wpa_s->p2p_auto_started.usec);
4155 wpa_s->user_initiated_pd = 1;
4156 if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method,
4162 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq);
4165 wpas_p2p_set_own_freq_preference(wpa_s, force_freq);
4167 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
4169 if (wpa_s->create_p2p_iface) {
4174 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
4180 if_addr = wpa_s->pending_interface_addr;
4182 if_addr = wpa_s->own_addr;
4185 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
4193 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
4196 if (wpa_s->create_p2p_iface)
4197 wpas_p2p_remove_pending_group_interface(wpa_s);
4206 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4213 void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
4216 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4218 if (wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
4219 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
4220 wpa_s->pending_listen_duration);
4221 wpa_s->pending_listen_freq = 0;
4226 static int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s,
4230 if (timeout > wpa_s->max_remain_on_chan)
4231 timeout = wpa_s->max_remain_on_chan;
4233 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
4234 return wpa_drv_p2p_listen(wpa_s, timeout);
4236 return p2p_listen(wpa_s->global->p2p, timeout);
4242 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4249 void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
4254 wpa_s->p2p_long_listen, offchannel_pending_action_tx(wpa_s));
4255 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4257 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
4259 if (offchannel_pending_action_tx(wpa_s))
4261 if (wpa_s->p2p_long_listen > 0)
4262 wpa_s->p2p_long_listen -= wpa_s->max_remain_on_chan;
4263 if (wpa_s->p2p_long_listen > 0) {
4265 wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen);
4271 p2p_stop_listen(wpa_s->global->p2p);
4278 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4289 int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
4291 struct wpa_global *global = wpa_s->global;
4295 wpa_s = global->ifaces;
4296 while (wpa_s) {
4297 prev = wpa_s;
4298 wpa_s = wpa_s->next;
4308 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4309 if (os_strcmp(wpa_s->ifname, ifname) == 0)
4313 return wpas_p2p_disconnect(wpa_s);
4317 static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq)
4324 if (wpa_s->best_24_freq > 0 &&
4325 p2p_supported_freq(wpa_s->global->p2p,
4326 wpa_s->best_24_freq)) {
4327 freq = wpa_s->best_24_freq;
4341 if (wpa_s->best_5_freq > 0 &&
4342 p2p_supported_freq(wpa_s->global->p2p,
4343 wpa_s->best_5_freq)) {
4344 freq = wpa_s->best_5_freq;
4350 if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
4360 if (freq > 0 && !p2p_supported_freq(wpa_s->global->p2p, freq)) {
4371 static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
4392 } else if (wpa_s->conf->p2p_oper_reg_class == 81 &&
4393 wpa_s->conf->p2p_oper_channel >= 1 &&
4394 wpa_s->conf->p2p_oper_channel <= 11 &&
4396 2407 + 5 * wpa_s->conf->p2p_oper_channel)) {
4397 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
4400 } else if ((wpa_s->conf->p2p_oper_reg_class == 115 ||
4401 wpa_s->conf->p2p_oper_reg_class == 116 ||
4402 wpa_s->conf->p2p_oper_reg_class == 117 ||
4403 wpa_s->conf->p2p_oper_reg_class == 124 ||
4404 wpa_s->conf->p2p_oper_reg_class == 126 ||
4405 wpa_s->conf->p2p_oper_reg_class == 127) &&
4407 5000 + 5 * wpa_s->conf->p2p_oper_channel)) {
4408 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
4411 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
4412 wpa_s->best_overall_freq > 0 &&
4413 p2p_supported_freq(wpa_s->global->p2p,
4414 wpa_s->best_overall_freq) &&
4415 freq_included(channels, wpa_s->best_overall_freq)) {
4416 params->freq = wpa_s->best_overall_freq;
4419 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
4420 wpa_s->best_24_freq > 0 &&
4421 p2p_supported_freq(wpa_s->global->p2p,
4422 wpa_s->best_24_freq) &&
4423 freq_included(channels, wpa_s->best_24_freq)) {
4424 params->freq = wpa_s->best_24_freq;
4427 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
4428 wpa_s->best_5_freq > 0 &&
4429 p2p_supported_freq(wpa_s->global->p2p,
4430 wpa_s->best_5_freq) &&
4431 freq_included(channels, wpa_s->best_5_freq)) {
4432 params->freq = wpa_s->best_5_freq;
4435 } else if ((pref_freq = p2p_get_pref_freq(wpa_s->global->p2p,
4444 if (!wpas_p2p_disallowed_freq(wpa_s->global,
4458 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
4462 res = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
4463 wpa_s->num_multichan_concurrent);
4481 if (num == wpa_s->num_multichan_concurrent) {
4496 if (num == wpa_s->num_multichan_concurrent) {
4511 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
4516 if (!wpas_p2p_create_iface(wpa_s)) {
4517 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use same interface for group "
4519 return wpa_s;
4522 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
4524 wpa_msg_global(wpa_s, MSG_ERROR,
4528 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
4530 wpa_msg_global(wpa_s, MSG_ERROR,
4532 wpas_p2p_remove_pending_group_interface(wpa_s);
4536 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s",
4544 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4552 int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
4557 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4560 os_free(wpa_s->global->add_psk);
4561 wpa_s->global->add_psk = NULL;
4565 wpas_p2p_stop_find_oper(wpa_s);
4567 freq = wpas_p2p_select_go_freq(wpa_s, freq);
4571 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, ht40, NULL))
4574 !p2p_supported_freq(wpa_s->global->p2p, params.freq)) {
4580 p2p_go_params(wpa_s->global->p2p, ¶ms);
4583 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
4584 if (wpa_s == NULL)
4586 wpas_start_wps_go(wpa_s, ¶ms, 0);
4592 static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
4597 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
4598 if (wpa_s == NULL)
4600 wpa_s->p2p_last_4way_hs_fail = NULL;
4602 wpa_supplicant_ap_deinit(wpa_s);
4604 ssid = wpa_config_add_network(wpa_s->conf);
4615 wpa_config_remove_network(wpa_s->conf, ssid->id);
4629 wpa_supplicant_select_network(wpa_s, ssid);
4631 wpa_s->show_group_started = 1;
4637 int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
4648 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
4655 os_free(wpa_s->global->add_psk);
4656 wpa_s->global->add_psk = NULL;
4659 wpas_p2p_stop_find_oper(wpa_s);
4661 wpa_s->p2p_fallback_to_go_neg = 0;
4664 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated);
4669 freq = wpas_p2p_select_go_freq(wpa_s, freq);
4673 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, ht40, channels))
4693 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
4694 if (wpa_s == NULL)
4697 wpas_start_wps_go(wpa_s, ¶ms, 0);
4706 struct wpa_supplicant *wpa_s = ctx;
4707 if (wpa_s->ap_iface) {
4708 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
4724 wpa_supplicant_ap_update_beacon(wpa_s);
4730 struct wpa_supplicant *wpa_s = ctx;
4731 if (!wpa_s->ap_iface)
4735 wpas_p2p_set_group_idle_timeout(wpa_s);
4737 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
4741 struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
4747 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
4749 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4756 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
4760 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
4761 if (wpa_s->max_stations &&
4762 wpa_s->max_stations < wpa_s->conf->max_num_sta)
4763 cfg->max_clients = wpa_s->max_stations;
4765 cfg->max_clients = wpa_s->conf->max_num_sta;
4768 cfg->cb_ctx = wpa_s;
4772 group = p2p_group_init(wpa_s->global->p2p, cfg);
4777 wpa_s->p2p_group = group;
4782 void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
4785 struct wpa_ssid *ssid = wpa_s->current_ssid;
4787 if (!wpa_s->p2p_in_provisioning) {
4795 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
4796 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
4799 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
4802 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent,
4813 wpa_s->parent, NULL);
4815 if (wpa_s->global->p2p)
4816 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
4817 else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
4818 wpa_drv_wps_success_cb(wpa_s, peer_addr);
4819 wpas_group_formation_completed(wpa_s, 1);
4823 void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s,
4826 if (!wpa_s->p2p_in_provisioning) {
4832 if (wpa_s->go_params) {
4834 wpa_s->global->p2p,
4835 wpa_s->go_params->peer_device_addr);
4838 wpas_notify_p2p_wps_failed(wpa_s, fail);
4842 int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
4848 wpa_s->p2p_fallback_to_go_neg = 0;
4849 wpa_s->pending_pd_use = NORMAL_PD;
4863 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
4864 wpa_s->pending_pd_config_methods = config_methods;
4865 wpa_s->p2p_auto_pd = 1;
4866 wpa_s->p2p_auto_join = 0;
4867 wpa_s->pending_pd_before_join = 0;
4868 wpa_s->auto_pd_scan_retry = 0;
4869 wpas_p2p_stop_find(wpa_s);
4870 wpa_s->p2p_join_scan_count = 0;
4871 os_get_time(&wpa_s->p2p_auto_started);
4873 wpa_s->p2p_auto_started.sec,
4874 wpa_s->p2p_auto_started.usec);
4875 wpas_p2p_join_scan(wpa_s, NULL);
4879 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
4880 return wpa_drv_p2p_prov_disc_req(wpa_s, peer_addr,
4885 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
4888 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr,
4901 static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s)
4903 if (!offchannel_pending_action_tx(wpa_s))
4908 offchannel_clear_pending_action_tx(wpa_s);
4912 int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
4917 wpas_p2p_clear_pending_action_tx(wpa_s);
4918 wpa_s->p2p_long_listen = 0;
4920 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
4921 return wpa_drv_p2p_find(wpa_s, timeout, type);
4923 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
4924 wpa_s->p2p_in_provisioning)
4927 wpa_supplicant_cancel_sched_scan(wpa_s);
4929 return p2p_find(wpa_s->global->p2p, timeout, type,
4935 static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s)
4937 wpas_p2p_clear_pending_action_tx(wpa_s);
4938 wpa_s->p2p_long_listen = 0;
4939 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
4940 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4941 wpa_s->global->p2p_cb_on_scan_complete = 0;
4943 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
4944 wpa_drv_p2p_stop_find(wpa_s);
4948 if (wpa_s->global->p2p)
4949 p2p_stop_find(wpa_s->global->p2p);
4955 void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
4957 if (wpas_p2p_stop_find_oper(wpa_s) > 0)
4959 wpas_p2p_remove_pending_group_interface(wpa_s);
4965 struct wpa_supplicant *wpa_s = eloop_ctx;
4966 wpa_s->p2p_long_listen = 0;
4970 int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
4974 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4977 wpa_supplicant_cancel_sched_scan(wpa_s);
4978 wpas_p2p_clear_pending_action_tx(wpa_s);
4988 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
4989 wpa_s->p2p_long_listen = 0;
4996 if (wpa_s->global->p2p)
4997 p2p_stop_find(wpa_s->global->p2p);
4999 res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
5000 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
5001 wpa_s->p2p_long_listen = timeout * 1000;
5004 wpa_s, NULL);
5011 int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
5017 if (wpa_s->global->p2p_disabled)
5019 if (wpa_s->global->p2p == NULL)
5025 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
5033 int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
5037 if (wpa_s->global->p2p_disabled)
5039 if (wpa_s->global->p2p == NULL)
5042 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
5045 wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len,
5059 void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
5063 if (wpa_s->global->p2p_disabled)
5065 if (wpa_s->global->p2p == NULL)
5068 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
5073 void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
5075 if (wpa_s->global->p2p_disabled)
5077 if (wpa_s->global->p2p == NULL)
5080 p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
5084 void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
5086 p2p_group_deinit(wpa_s->p2p_group);
5087 wpa_s->p2p_group = NULL;
5089 wpa_s->ap_configured_cb = NULL;
5090 wpa_s->ap_configured_cb_ctx = NULL;
5091 wpa_s->ap_configured_cb_data = NULL;
5092 wpa_s->connect_without_scan = NULL;
5096 int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
5098 wpa_s->p2p_long_listen = 0;
5100 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5101 return wpa_drv_p2p_reject(wpa_s, addr);
5103 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5106 return p2p_reject(wpa_s->global->p2p, addr);
5111 int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
5120 wpa_s->global->p2p_invite_group = NULL;
5122 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
5124 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
5126 wpa_s->p2p_persistent_go_freq = freq;
5127 wpa_s->p2p_go_ht40 = !!ht40;
5135 if (wpas_p2p_create_iface(wpa_s)) {
5136 if (wpas_p2p_add_group_interface(wpa_s,
5143 bssid = wpa_s->pending_interface_addr;
5145 bssid = wpa_s->own_addr;
5150 wpa_s->pending_invite_ssid_id = ssid->id;
5152 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq);
5156 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5157 return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
5161 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5164 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
5171 int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
5174 struct wpa_global *global = wpa_s->global;
5182 wpa_s->p2p_persistent_go_freq = 0;
5183 wpa_s->p2p_go_ht40 = 0;
5185 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5186 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5189 if (wpa_s == NULL) {
5194 ssid = wpa_s->current_ssid;
5201 wpa_s->global->p2p_invite_group = wpa_s;
5203 wpas_p2p_get_persistent(wpa_s->parent, peer_addr,
5208 bssid = wpa_s->own_addr;
5210 go_dev_addr = wpa_s->global->p2p_dev_addr;
5213 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
5218 bssid = wpa_s->bssid;
5220 !is_zero_ether_addr(wpa_s->go_dev_addr))
5221 go_dev_addr = wpa_s->go_dev_addr;
5223 wpa_s
5225 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5226 return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
5230 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5233 res = wpas_p2p_setup_freqs(wpa_s, 0, &force_freq, &pref_freq);
5236 wpas_p2p_set_own_freq_preference(wpa_s, force_freq);
5238 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
5244 void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
5246 struct wpa_ssid *ssid = wpa_s->current_ssid;
5255 wpa_s->parent, NULL);
5258 if (!wpa_s->show_group_started || !ssid)
5261 wpa_s->show_group_started = 0;
5267 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
5269 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
5271 if (wpa_s->global->p2p_group_formation == wpa_s)
5272 wpa_s->global->p2p_group_formation = NULL;
5274 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
5275 (int) wpa_s->assoc_freq;
5279 wpa_msg_global(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
5282 wpa_s->ifname, ssid_txt, freq, psk,
5286 wpa_msg_global(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
5289 wpa_s->ifname, ssid_txt, freq,
5296 network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
5300 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 1);
5303 wpas_p2p_continue_after_scan(wpa_s);
5307 int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
5310 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5312 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5315 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
5316 wpa_s->current_ssid == NULL ||
5317 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
5320 return p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
5321 wpa_s->own_addr, wpa_s->assoc_freq,
5326 int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
5329 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5332 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5335 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
5339 static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s)
5341 if (wpa_s->current_ssid == NULL) {
5349 return wpa_s->current_ssid->p2p_group &&
5350 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
5356 struct wpa_supplicant *wpa_s = eloop_ctx;
5358 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
5366 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT);
5370 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s)
5374 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
5377 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
5380 timeout = wpa_s->conf->p2p_group_idle;
5381 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
5389 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
5395 if (wpa_s->p2p_in_provisioning) {
5406 if (wpa_s->show_group_started) {
5422 wpa_s, NULL);
5427 int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
5431 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5433 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5437 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
5441 wpa_s->current_ssid &&
5442 wpa_s->current_ssid->p2p_group &&
5443 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
5446 if (wpas_p2p_group_delete(wpa_s,
5456 void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
5460 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5462 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5466 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
5471 void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
5473 struct p2p_data *p2p = wpa_s->global->p2p;
5478 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
5481 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
5482 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
5484 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
5485 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
5487 if (wpa_s->wps &&
5488 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
5489 p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
5491 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
5492 p2p_set_uuid(p2p, wpa_s->wps->uuid);
5494 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
5495 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
5496 p2p_set_model_name(p2p, wpa_s->conf->model_name);
5497 p2p_set_model_number(p2p, wpa_s->conf->model_number);
5498 p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
5501 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
5503 (void *) wpa_s->conf->sec_device_type,
5504 wpa_s->conf->num_sec_device_types);
5506 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
5510 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
5513 p2p, wpa_s->conf->wps_vendor_ext[i]);
5517 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5518 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5520 country[0] = wpa_s->conf->country[0];
5521 country[1] = wpa_s->conf->country[1];
5526 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
5527 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
5528 wpa_s->conf->p2p_ssid_postfix ?
5529 os_strlen(wpa_s->conf->p2p_ssid_postfix) :
5533 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
5534 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
5536 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
5540 if (wpa_s->conf->p2p_listen_reg_class &&
5541 wpa_s->conf->p2p_listen_channel) {
5542 reg_class = wpa_s->conf->p2p_listen_reg_class;
5543 channel = wpa_s->conf->p2p_listen_channel;
5558 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
5562 if (wpa_s->conf->p2p_oper_reg_class &&
5563 wpa_s->conf->p2p_oper_channel) {
5564 op_reg_class = wpa_s->conf->p2p_oper_reg_class;
5565 op_channel = wpa_s->conf->p2p_oper_channel;
5584 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
5585 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
5586 wpa_s->conf->p2p_pref_chan) < 0) {
5594 int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start,
5597 if (!wpa_s->ap_iface)
5599 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
5604 int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
5606 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5608 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
5611 wpa_s->global->cross_connection = enabled;
5612 p2p_set_cross_connect(wpa_s->global->p2p, enabled);
5617 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
5682 void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s)
5684 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
5685 wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
5686 wpa_s->cross_connect_disallowed)
5687 wpas_p2p_disable_cross_connect(wpa_s);
5689 wpas_p2p_enable_cross_connect(wpa_s);
5690 if (!wpa_s->ap_iface &&
5691 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
5696 void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s)
5698 wpas_p2p_disable_cross_connect(wpa_s);
5699 if (!wpa_s->ap_iface &&
5701 wpa_s, NULL))
5702 wpas_p2p_set_group_idle_timeout(wpa_s);
5706 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s)
5710 if (!wpa_s->global->cross_connection)
5713 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
5714 if (iface == wpa_s)
5722 wpa_s->cross_connect_enabled = 1;
5723 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
5724 sizeof(wpa_s->cross_connect_uplink));
5727 wpa_s->ifname, wpa_s->cross_connect_uplink);
5735 wpa_s->cross_connect_in_use = 1;
5736 wpa_msg_global(wpa_s->parent, MSG_INFO,
5738 wpa_s->ifname, wpa_s->cross_connect_uplink);
5744 int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s)
5746 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
5747 !wpa_s->p2p_in_provisioning)
5752 if (wpa_s != wpa_s->parent)
5753 wpa_msg_ctrl(wpa_s->parent, MSG_INFO, WPS_EVENT_OVERLAP);
5754 wpas_p2p_group_formation_failed(wpa_s);
5759 void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s)
5763 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
5767 if (wpas_p2p_setup_channels(wpa_s, &chan)) {
5773 p2p_update_channel_list(wpa_s->global->p2p, &chan);
5777 static void wpas_p2p_scan_res_ignore(struct wpa_supplicant *wpa_s,
5784 int wpas_p2p_cancel(struct wpa_supplicant *wpa_s)
5786 struct wpa_global *global = wpa_s->global;
5795 if (wpa_s->pending_interface_name[0] &&
5796 !is_zero_ether_addr(wpa_s->pending_interface_addr))
5807 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) {
5809 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore;
5813 if (wpa_s->pending_pd_before_join) {
5815 wpa_s->pending_pd_before_join = 0;
5819 wpas_p2p_stop_find(wpa_s);
5821 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5822 if (wpa_s == global->p2p_group_formation &&
5823 (wpa_s->p2p_in_provisioning ||
5824 wpa_s->parent->pending_interface_type ==
5828 wpa_s->ifname);
5831 wpa_s->parent, NULL);
5832 if (wpa_s->p2p_in_provisioning) {
5833 wpas_group_formation_completed(wpa_s, 0);
5836 wpas_p2p_group_delete(wpa_s,
5851 void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s)
5853 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
5858 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE);
5862 void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
5865 struct p2p_data *p2p = wpa_s->global->p2p;
5866 if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT))
5872 int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
5875 struct p2p_data *p2p = wpa_s->global->p2p;
5877 if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT))
5889 * @wpa_s: Pointer to wpa_supplicant data
5898 int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s)
5901 if (wpa_s == NULL)
5904 return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ?
5909 int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s)
5913 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5916 ret = p2p_in_progress(wpa_s->global->p2p);
5924 if (wpa_s->global->p2p_group_formation &&
5925 wpa_s->global->p2p_group_formation != wpa_s) {
5926 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Another interface (%s) "
5928 wpa_s->global->p2p_group_formation->ifname);
5933 if (!ret && wpa_s->global->p2p_go_wait_client.sec) {
5936 if (now.sec > wpa_s->global->p2p_go_wait_client.sec +
5939 wpa_s->global->p2p_go_wait_client.sec = 0;
5941 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Waiting for initial client connection during group formation");
5950 void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s,
5953 if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
5955 wpa_s->parent, NULL) > 0) {
5967 wpa_s->parent, NULL);
5972 struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s,
5979 for (s = wpa_s->conf->ssid; s; s = s->next) {
6007 void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
6010 wpa_s->global->p2p_go_wait_client.sec = 0;
6013 wpas_p2p_add_persistent_group_client(wpa_s, addr);
6017 static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
6020 struct wpa_supplicant *group = wpa_s;
6021 if (wpa_s->global->p2p_group_formation)
6022 group = wpa_s->global->p2p_group_formation;
6023 wpa_s = wpa_s->parent;
6024 offchannel_send_action_done(wpa_s);
6027 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation");
6028 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
6029 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
6030 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
6031 wpa_s->p2p_persistent_id,
6032 wpa_s->p2p_pd_before_go_neg,
6033 wpa_s->p2p_go_ht40);
6037 int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s)
6039 if (!wpa_s->p2p_fallback_to_go_neg ||
6040 wpa_s->p2p_in_provisioning <= 5)
6043 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
6046 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
6048 wpas_p2p_fallback_to_go_neg(wpa_s, 1);
6054 unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s)
6059 if (wpa_s->wpa_state > WPA_SCANNING) {
6060 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to "
6066 if (!wpa_s->driver->get_radio_name)
6068 rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
6072 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
6073 if (ifs == wpa_s || !ifs->driver->get_radio_name)
6080 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search "
6092 void wpas_p2p_continue_after_scan(struct wpa_supplicant *wpa_s)
6094 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Station mode scan operation not "
6096 "p2p_cb_on_scan_complete=%d)", wpa_s->sta_scan_pending,
6097 wpa_s->global->p2p_cb_on_scan_complete);
6098 wpa_s->sta_scan_pending = 0;
6100 if (!wpa_s->global->p2p_cb_on_scan_complete)
6102 wpa_s->global->p2p_cb_on_scan_complete = 0;
6104 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6107 if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
6108 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
6110 p2p_increase_search_delay(wpa_s->global->p2p,
6111 wpas_p2p_search_delay(wpa_s));
6116 static int wpas_p2p_remove_psk_entry(struct wpa_supplicant *wpa_s,
6129 wpa_dbg(wpa_s, MSG_DEBUG,
6143 void wpas_p2p_new_psk_cb(struct wpa_supplicant *wpa_s, const u8 *mac_addr,
6147 struct wpa_ssid *ssid = wpa_s->current_ssid;
6155 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR
6161 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR,
6166 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: new_psk_cb during group formation");
6168 if (wpa_s->global->add_psk == NULL) {
6169 wpa_s->global->add_psk = os_zalloc(sizeof(*p));
6170 if (wpa_s->global->add_psk == NULL)
6173 p = wpa_s->global->add_psk;
6186 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO");
6190 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid,
6193 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not find persistent group information to store the new PSK");
6213 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove oldest PSK entry for "
6220 wpas_p2p_remove_psk_entry(wpa_s->parent, persistent,
6224 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for p2p_dev_addr="
6227 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for addr=" MACSTR,
6233 if (wpa_s->parent->conf->update_config &&
6234 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
6240 static void wpas_p2p_remove_psk(struct wpa_supplicant *wpa_s,
6246 res = wpas_p2p_remove_psk_entry(wpa_s, s, addr, iface_addr);
6249 if (wpa_s->conf->update_config &&
6250 wpa_config_write(wpa_s->confname, wpa_s->conf))
6251 wpa_dbg(wpa_s, MSG_DEBUG,
6258 static void wpas_p2p_remove_client_go(struct wpa_supplicant *wpa_s,
6265 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL ||
6266 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO)
6270 hapd = wpa_s->ap_iface->bss[0];
6277 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove operating group PSK entry for "
6299 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disconnect peer " MACSTR
6309 void wpas_p2p_remove_client(struct wpa_supplicant *wpa_s, const u8 *peer,
6315 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove client " MACSTR, MAC2STR(peer));
6318 for (s = wpa_s->parent->conf->ssid; s; s = s->next) {
6322 wpas_remove_persistent_peer(wpa_s, s, peer, 0);
6323 wpas_p2p_remove_psk(wpa_s->parent, s, peer, iface_addr);
6327 for (w = wpa_s->global->ifaces; w; w = w->next)
6334 struct wpa_supplicant *wpa_s = eloop_ctx;
6335 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_PSK_FAILURE);
6339 int wpas_p2p_4way_hs_failed(struct wpa_supplicant *wpa_s)
6341 struct wpa_ssid *ssid = wpa_s->current_ssid;
6346 if (wpa_s->p2p_last_4way_hs_fail &&
6347 wpa_s->p2p_last_4way_hs_fail == ssid) {
6351 if (wpas_p2p_persistent_group(wpa_s, go_dev_addr,
6354 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group");
6358 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr="
6360 persistent = wpas_p2p_get_persistent(wpa_s->parent, go_dev_addr,
6364 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No matching persistent group stored");
6367 wpa_msg_global(wpa_s->parent, MSG_INFO,
6371 wpa_s->p2p_last_4way_hs_fail = NULL;
6378 wpa_s, NULL);
6382 wpa_s->p2p_last_4way_hs_fail = ssid;
6389 struct wpa_supplicant *wpa_s = eloop_ctx;
6392 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_FREQ_CONFLICT);
6395 int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s, int freq,
6399 struct p2p_data *p2p = wpa_s->global->p2p;
6401 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
6430 if (wpa_s == iface)
6437 wpa_supplicant_disable_network(wpa_s->global->ifaces, ssid);
6438 wpa_msg(wpa_s->global->ifaces, MSG_INFO, WPA_EVENT_FREQ_CONFLICT
6440 os_memset(wpa_s->global->ifaces->pending_bssid, 0, ETH_ALEN);
6441 if (wpa_s == iface) {
