3 * Copyright (c) 2009-2010, Atheros Communications
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
19 #include "common/ieee802_11_common.h"
20 #include "common/ieee802_11_defs.h"
21 #include "common/wpa_ctrl.h"
22 #include "wps/wps_i.h"
24 #include "ap/hostapd.h"
25 #include "wpa_supplicant_i.h"
28 #include "config_ssid.h"
34 #include "wps_supplicant.h"
35 #include "p2p_supplicant.h"
38 static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx);
39 static struct wpa_supplicant *
40 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
42 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s);
43 static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx);
44 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
47 static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
48 struct wpa_scan_results *scan_res)
52 if (wpa_s->global->p2p_disabled)
55 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS)",
58 for (i = 0; i < scan_res->num; i++) {
59 struct wpa_scan_res *bss = scan_res->res[i];
60 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
61 bss->freq, bss->level,
62 (const u8 *) (bss + 1),
67 p2p_scan_res_handled(wpa_s->global->p2p);
71 static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int freq)
73 struct wpa_supplicant *wpa_s = ctx;
74 struct wpa_driver_scan_params params;
76 struct wpabuf *wps_ie, *ies;
77 int social_channels[] = { 2412, 2437, 2462, 0, 0 };
79 os_memset(¶ms, 0, sizeof(params));
81 /* P2P Wildcard SSID */
83 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
84 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
86 wpa_s->wps->dev.p2p = 1;
87 wps_ie = wps_build_probe_req_ie(0, &wpa_s->wps->dev, wpa_s->wps->uuid,
92 ies = wpabuf_alloc(wpabuf_len(wps_ie) + 100);
97 wpabuf_put_buf(ies, wps_ie);
100 p2p_scan_ie(wpa_s->global->p2p, ies);
102 params.extra_ies = wpabuf_head(ies);
103 params.extra_ies_len = wpabuf_len(ies);
106 case P2P_SCAN_SOCIAL:
107 params.freqs = social_channels;
111 case P2P_SCAN_SPECIFIC:
112 social_channels[0] = freq;
113 social_channels[1] = 0;
114 params.freqs = social_channels;
116 case P2P_SCAN_SOCIAL_PLUS_ONE:
117 social_channels[3] = freq;
118 params.freqs = social_channels;
122 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
123 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
124 ret = ieee80211_sta_req_scan(wpa_s, ¶ms);
126 ret = wpa_drv_scan(wpa_s, ¶ms);
134 #ifdef CONFIG_CLIENT_MLME
135 static void p2p_rx_action_mlme(void *ctx, const u8 *buf, size_t len, int freq)
137 struct wpa_supplicant *wpa_s = ctx;
138 const struct ieee80211_mgmt *mgmt;
141 if (wpa_s->global->p2p_disabled)
143 mgmt = (const struct ieee80211_mgmt *) buf;
144 hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
147 p2p_rx_action(wpa_s->global->p2p, mgmt->da, mgmt->sa, mgmt->bssid,
148 mgmt->u.action.category,
149 &mgmt->u.action.u.vs_public_action.action,
150 len - hdr_len, freq);
152 #endif /* CONFIG_CLIENT_MLME */
155 static enum wpa_driver_if_type wpas_p2p_if_type(int p2p_group_interface)
157 switch (p2p_group_interface) {
158 case P2P_GROUP_INTERFACE_PENDING:
159 return WPA_IF_P2P_GROUP;
160 case P2P_GROUP_INTERFACE_GO:
161 return WPA_IF_P2P_GO;
162 case P2P_GROUP_INTERFACE_CLIENT:
163 return WPA_IF_P2P_CLIENT;
166 return WPA_IF_P2P_GROUP;
170 static void wpas_p2p_group_delete(struct wpa_supplicant *wpa_s)
172 struct wpa_ssid *ssid;
175 ssid = wpa_s->current_ssid;
178 * The current SSID was not known, but there may still be a
179 * pending P2P group interface waiting for provisioning.
181 ssid = wpa_s->conf->ssid;
183 if (ssid->p2p_group &&
184 (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
185 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)))
190 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
192 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
193 (ssid && ssid->mode == WPAS_MODE_INFRA)) {
194 wpa_s->reassociate = 0;
195 wpa_s->disconnected = 1;
196 wpa_supplicant_deauthenticate(wpa_s,
197 WLAN_REASON_DEAUTH_LEAVING);
201 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_REMOVED "%s %s",
202 wpa_s->ifname, gtype);
203 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
204 struct wpa_global *global;
206 enum wpa_driver_if_type type;
207 wpa_printf(MSG_DEBUG, "P2P: Remove group interface %s",
209 global = wpa_s->global;
210 ifname = os_strdup(wpa_s->ifname);
211 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
212 wpa_supplicant_remove_iface(wpa_s->global, wpa_s);
213 wpa_s = global->ifaces;
215 wpa_drv_if_remove(wpa_s, type, ifname);
220 wpa_printf(MSG_DEBUG, "P2P: Remove temporary group network");
221 if (ssid && (ssid->p2p_group ||
222 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
223 (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) {
225 if (ssid == wpa_s->current_ssid)
226 wpa_s->current_ssid = NULL;
227 wpas_notify_network_removed(wpa_s, ssid);
228 wpa_config_remove_network(wpa_s->conf, id);
229 wpa_supplicant_clear_status(wpa_s);
231 wpa_printf(MSG_DEBUG, "P2P: Temporary group network not "
234 wpa_supplicant_ap_deinit(wpa_s);
238 static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
240 const u8 *ssid, size_t ssid_len)
248 if (wpa_s->go_params)
249 bssid = wpa_s->go_params->peer_interface_addr;
251 bssid = wpa_s->bssid;
253 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
255 u8 iface_addr[ETH_ALEN];
256 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
258 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
261 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
262 "group is persistent - BSS " MACSTR " not found",
267 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
269 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
270 "group is persistent - BSS " MACSTR
271 " did not include P2P IE", MAC2STR(bssid));
272 wpa_hexdump(MSG_DEBUG, "P2P: Probe Response IEs",
273 (u8 *) (bss + 1), bss->ie_len);
274 wpa_hexdump(MSG_DEBUG, "P2P: Beacon IEs",
275 ((u8 *) bss + 1) + bss->ie_len,
280 group_capab = p2p_get_group_capab(p2p);
281 addr = p2p_get_go_dev_addr(p2p);
282 wpa_printf(MSG_DEBUG, "P2P: Checking whether group is persistent: "
283 "group_capab=0x%x", group_capab);
285 os_memcpy(go_dev_addr, addr, ETH_ALEN);
286 wpa_printf(MSG_DEBUG, "P2P: GO Device Address " MACSTR,
289 os_memset(go_dev_addr, 0, ETH_ALEN);
292 wpa_printf(MSG_DEBUG, "P2P: BSS " MACSTR " group_capab=0x%x "
293 "go_dev_addr=" MACSTR,
294 MAC2STR(bssid), group_capab, MAC2STR(go_dev_addr));
296 return group_capab & P2P_GROUP_CAPAB_PERSISTENT_GROUP;
300 static void wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
301 struct wpa_ssid *ssid,
302 const u8 *go_dev_addr)
307 wpa_printf(MSG_DEBUG, "P2P: Storing credentials for a persistent "
308 "group (GO Dev Addr " MACSTR ")", MAC2STR(go_dev_addr));
309 for (s = wpa_s->conf->ssid; s; s = s->next) {
310 if (s->disabled == 2 &&
311 os_memcmp(go_dev_addr, s->bssid, ETH_ALEN) == 0 &&
312 s->ssid_len == ssid->ssid_len &&
313 os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0)
318 wpa_printf(MSG_DEBUG, "P2P: Update existing persistent group "
320 if (ssid->passphrase && !s->passphrase)
322 else if (ssid->passphrase && s->passphrase &&
323 os_strcmp(ssid->passphrase, s->passphrase) != 0)
326 wpa_printf(MSG_DEBUG, "P2P: Create a new persistent group "
329 s = wpa_config_add_network(wpa_s->conf);
332 wpa_config_set_network_defaults(s);
336 s->p2p_persistent_group = 1;
339 os_memcpy(s->bssid, go_dev_addr, ETH_ALEN);
340 s->mode = ssid->mode;
341 s->auth_alg = WPA_AUTH_ALG_OPEN;
342 s->key_mgmt = WPA_KEY_MGMT_PSK;
343 s->proto = WPA_PROTO_RSN;
344 s->pairwise_cipher = WPA_CIPHER_CCMP;
345 if (ssid->passphrase) {
346 os_free(s->passphrase);
347 s->passphrase = os_strdup(ssid->passphrase);
351 os_memcpy(s->psk, ssid->psk, 32);
353 if (s->passphrase && !s->psk_set)
354 wpa_config_update_psk(s);
355 if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) {
357 s->ssid = os_malloc(ssid->ssid_len);
360 s->ssid_len = ssid->ssid_len;
361 os_memcpy(s->ssid, ssid->ssid, s->ssid_len);
364 #ifndef CONFIG_NO_CONFIG_WRITE
365 if (changed && wpa_s->conf->update_config &&
366 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
367 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
369 #endif /* CONFIG_NO_CONFIG_WRITE */
373 static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
376 struct wpa_ssid *ssid;
377 const char *ssid_txt;
380 u8 go_dev_addr[ETH_ALEN];
383 * This callback is likely called for the main interface. Update wpa_s
384 * to use the group interface if a new interface was created for the
387 if (wpa_s->global->p2p_group_formation)
388 wpa_s = wpa_s->global->p2p_group_formation;
389 wpa_s->p2p_in_provisioning = 0;
392 wpa_msg(wpa_s->parent, MSG_INFO,
393 P2P_EVENT_GROUP_FORMATION_FAILURE);
394 wpas_p2p_group_delete(wpa_s);
398 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_FORMATION_SUCCESS);
400 ssid = wpa_s->current_ssid;
401 if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
402 ssid->mode = WPAS_MODE_P2P_GO;
403 p2p_group_notif_formation_done(wpa_s->p2p_group);
404 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
409 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
410 client = ssid->mode == WPAS_MODE_INFRA;
411 if (ssid->mode == WPAS_MODE_P2P_GO) {
412 persistent = ssid->p2p_persistent_group;
413 os_memcpy(go_dev_addr, wpa_s->parent->own_addr,
416 persistent = wpas_p2p_persistent_group(wpa_s,
422 client = wpa_s->p2p_group_interface ==
423 P2P_GROUP_INTERFACE_CLIENT;
426 wpa_s->show_group_started = 0;
429 * Indicate event only after successfully completed 4-way
430 * handshake, i.e., when the interface is ready for data
433 wpa_s->show_group_started = 1;
434 } else if (ssid && ssid->passphrase == NULL && ssid->psk_set) {
436 wpa_snprintf_hex(psk, sizeof(psk), ssid->psk, 32);
437 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
438 "%s GO ssid=\"%s\" psk=%s go_dev_addr=" MACSTR "%s",
439 wpa_s->ifname, ssid_txt, psk, MAC2STR(go_dev_addr),
440 persistent ? " [PERSISTENT]" : "");
442 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
443 "%s GO ssid=\"%s\" passphrase=\"%s\" go_dev_addr="
445 wpa_s->ifname, ssid_txt,
446 ssid && ssid->passphrase ? ssid->passphrase : "",
447 MAC2STR(go_dev_addr),
448 persistent ? " [PERSISTENT]" : "");
452 wpas_p2p_store_persistent_group(wpa_s->parent, ssid,
457 static void wpas_send_action_cb(void *eloop_ctx, void *timeout_ctx)
459 struct wpa_supplicant *wpa_s = eloop_ctx;
460 struct wpa_supplicant *iface;
464 without_roc = wpa_s->pending_action_without_roc;
465 wpa_s->pending_action_without_roc = 0;
467 if (wpa_s->pending_action_tx == NULL)
470 if (wpa_s->off_channel_freq != wpa_s->pending_action_freq &&
471 wpa_s->pending_action_freq != 0) {
472 wpa_printf(MSG_DEBUG, "P2P: Pending Action frame TX "
473 "waiting for another freq=%u (off_channel_freq=%u)",
474 wpa_s->pending_action_freq,
475 wpa_s->off_channel_freq);
476 if (without_roc && wpa_s->off_channel_freq == 0) {
478 * We may get here if wpas_send_action() found us to be
479 * on the correct channel, but remain-on-channel cancel
480 * event was received before getting here.
482 wpa_printf(MSG_DEBUG, "P2P: Schedule "
483 "remain-on-channel to send Action frame");
484 if (wpa_drv_remain_on_channel(
485 wpa_s, wpa_s->pending_action_freq, 200) <
487 wpa_printf(MSG_DEBUG, "P2P: Failed to request "
488 "driver to remain on channel (%u "
489 "MHz) for Action Frame TX",
490 wpa_s->pending_action_freq);
492 wpa_s->roc_waiting_drv_freq =
493 wpa_s->pending_action_freq;
499 * This call is likely going to be on the P2P device instance if the
500 * driver uses a separate interface for that purpose. However, some
501 * Action frames are actually sent within a P2P Group and when that is
502 * the case, we need to follow power saving (e.g., GO buffering the
503 * frame for a client in PS mode or a client following the advertised
504 * NoA from its GO). To make that easier for the driver, select the
505 * correct group interface here.
507 if (os_memcmp(wpa_s->pending_action_src, wpa_s->own_addr, ETH_ALEN) !=
510 * Try to find a group interface that matches with the source
513 iface = wpa_s->global->ifaces;
515 if (os_memcmp(wpa_s->pending_action_src,
516 iface->own_addr, ETH_ALEN) == 0)
521 wpa_printf(MSG_DEBUG, "P2P: Use group interface %s "
522 "instead of interface %s for Action TX",
523 iface->ifname, wpa_s->ifname);
529 wpa_printf(MSG_DEBUG, "P2P: Sending pending Action frame to "
530 MACSTR " using interface %s",
531 MAC2STR(wpa_s->pending_action_dst), iface->ifname);
532 res = wpa_drv_send_action(iface, wpa_s->pending_action_freq,
533 wpa_s->pending_action_dst,
534 wpa_s->pending_action_src,
535 wpa_s->pending_action_bssid,
536 wpabuf_head(wpa_s->pending_action_tx),
537 wpabuf_len(wpa_s->pending_action_tx));
539 wpa_printf(MSG_DEBUG, "P2P: Failed to send the pending "
542 * Use fake TX status event to allow P2P state machine to
545 wpas_send_action_tx_status(
546 wpa_s, wpa_s->pending_action_dst,
547 wpabuf_head(wpa_s->pending_action_tx),
548 wpabuf_len(wpa_s->pending_action_tx), 0);
553 void wpas_send_action_tx_status(struct wpa_supplicant *wpa_s, const u8 *dst,
554 const u8 *data, size_t data_len, int ack)
556 if (wpa_s->global->p2p_disabled)
559 if (wpa_s->pending_action_tx == NULL) {
560 wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - no "
561 "pending operation");
565 if (os_memcmp(dst, wpa_s->pending_action_dst, ETH_ALEN) != 0) {
566 wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - unknown "
567 "destination address");
571 wpabuf_free(wpa_s->pending_action_tx);
572 wpa_s->pending_action_tx = NULL;
574 p2p_send_action_cb(wpa_s->global->p2p, wpa_s->pending_action_freq,
575 wpa_s->pending_action_dst,
576 wpa_s->pending_action_src,
577 wpa_s->pending_action_bssid,
580 if (wpa_s->pending_pd_before_join &&
581 (os_memcmp(wpa_s->pending_action_dst, wpa_s->pending_join_dev_addr,
583 os_memcmp(wpa_s->pending_action_dst,
584 wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
585 wpa_s->pending_pd_before_join = 0;
586 wpa_printf(MSG_DEBUG, "P2P: Starting pending "
587 "join-existing-group operation");
588 wpas_p2p_join_start(wpa_s);
593 static int wpas_send_action(void *ctx, unsigned int freq, const u8 *dst,
594 const u8 *src, const u8 *bssid, const u8 *buf,
595 size_t len, unsigned int wait_time)
597 struct wpa_supplicant *wpa_s = ctx;
599 wpa_printf(MSG_DEBUG, "P2P: Send action frame: freq=%d dst=" MACSTR
600 " src=" MACSTR " bssid=" MACSTR,
601 freq, MAC2STR(dst), MAC2STR(src), MAC2STR(bssid));
603 if (wpa_s->pending_action_tx) {
604 wpa_printf(MSG_DEBUG, "P2P: Dropped pending Action frame TX "
605 "to " MACSTR, MAC2STR(wpa_s->pending_action_dst));
606 wpabuf_free(wpa_s->pending_action_tx);
608 wpa_s->pending_action_tx = wpabuf_alloc(len);
609 if (wpa_s->pending_action_tx == NULL)
611 wpabuf_put_data(wpa_s->pending_action_tx, buf, len);
612 os_memcpy(wpa_s->pending_action_src, src, ETH_ALEN);
613 os_memcpy(wpa_s->pending_action_dst, dst, ETH_ALEN);
614 os_memcpy(wpa_s->pending_action_bssid, bssid, ETH_ALEN);
615 wpa_s->pending_action_freq = freq;
617 if (wpa_s->off_channel_freq == freq || freq == 0) {
618 /* Already on requested channel; send immediately */
619 /* TODO: Would there ever be need to extend the current
620 * duration on the channel? */
621 wpa_s->pending_action_without_roc = 1;
622 eloop_cancel_timeout(wpas_send_action_cb, wpa_s, NULL);
623 eloop_register_timeout(0, 0, wpas_send_action_cb, wpa_s, NULL);
626 wpa_s->pending_action_without_roc = 0;
628 if (wpa_s->roc_waiting_drv_freq == freq) {
629 wpa_printf(MSG_DEBUG, "P2P: Already waiting for driver to get "
630 "to frequency %u MHz; continue waiting to send the "
631 "Action frame", freq);
635 wpa_printf(MSG_DEBUG, "P2P: Schedule Action frame to be transmitted "
636 "once the driver gets to the requested channel");
637 if (wait_time > wpa_s->max_remain_on_chan)
638 wait_time = wpa_s->max_remain_on_chan;
639 if (wpa_drv_remain_on_channel(wpa_s, freq, wait_time) < 0) {
640 wpa_printf(MSG_DEBUG, "P2P: Failed to request driver "
641 "to remain on channel (%u MHz) for Action "
645 wpa_s->roc_waiting_drv_freq = freq;
651 static void wpas_send_action_done(void *ctx)
653 struct wpa_supplicant *wpa_s = ctx;
654 wpa_printf(MSG_DEBUG, "P2P: Action frame sequence done notification");
655 wpabuf_free(wpa_s->pending_action_tx);
656 wpa_s->pending_action_tx = NULL;
657 if (wpa_s->off_channel_freq) {
658 wpa_drv_cancel_remain_on_channel(wpa_s);
659 wpa_s->off_channel_freq = 0;
660 wpa_s->roc_waiting_drv_freq = 0;
665 static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
666 struct p2p_go_neg_results *params)
668 if (wpa_s->go_params == NULL) {
669 wpa_s->go_params = os_malloc(sizeof(*params));
670 if (wpa_s->go_params == NULL)
673 os_memcpy(wpa_s->go_params, params, sizeof(*params));
678 static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
679 struct p2p_go_neg_results *res)
681 wpa_supplicant_ap_deinit(wpa_s);
682 wpas_copy_go_neg_results(wpa_s, res);
683 if (res->wps_method == WPS_PBC)
684 wpas_wps_start_pbc(wpa_s, NULL /* res->peer_interface_addr */,
687 u16 dev_pw_id = DEV_PW_DEFAULT;
688 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
689 dev_pw_id = DEV_PW_REGISTRAR_SPECIFIED;
690 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
691 wpa_s->p2p_pin, 1, dev_pw_id);
696 static void p2p_go_configured(void *ctx, void *data)
698 struct wpa_supplicant *wpa_s = ctx;
699 struct p2p_go_neg_results *params = data;
700 struct wpa_ssid *ssid;
702 ssid = wpa_s->current_ssid;
703 if (ssid && ssid->mode == WPAS_MODE_P2P_GO) {
704 wpa_printf(MSG_DEBUG, "P2P: Group setup without provisioning");
705 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
706 "%s GO ssid=\"%s\" passphrase=\"%s\" go_dev_addr="
709 wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
710 params->passphrase ? params->passphrase : "",
711 MAC2STR(wpa_s->parent->own_addr),
712 params->persistent_group ? " [PERSISTENT]" : "");
713 if (params->persistent_group)
714 wpas_p2p_store_persistent_group(
716 wpa_s->parent->own_addr);
720 wpa_printf(MSG_DEBUG, "P2P: Setting up WPS for GO provisioning");
721 if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
722 params->peer_interface_addr)) {
723 wpa_printf(MSG_DEBUG, "P2P: Failed to setup MAC address "
727 if (params->wps_method == WPS_PBC)
728 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr);
729 else if (wpa_s->p2p_pin[0])
730 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
731 wpa_s->p2p_pin, NULL, 0);
732 os_free(wpa_s->go_params);
733 wpa_s->go_params = NULL;
737 static void wpas_start_wps_go(struct wpa_supplicant *wpa_s,
738 struct p2p_go_neg_results *params,
741 struct wpa_ssid *ssid;
743 if (wpas_copy_go_neg_results(wpa_s, params) < 0)
746 ssid = wpa_config_add_network(wpa_s->conf);
750 wpa_config_set_network_defaults(ssid);
753 ssid->p2p_persistent_group = params->persistent_group;
754 ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION :
756 ssid->frequency = params->freq;
757 ssid->ssid = os_zalloc(params->ssid_len + 1);
759 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
760 ssid->ssid_len = params->ssid_len;
762 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
763 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
764 ssid->proto = WPA_PROTO_RSN;
765 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
766 ssid->passphrase = os_strdup(params->passphrase);
768 wpa_s->ap_configured_cb = p2p_go_configured;
769 wpa_s->ap_configured_cb_ctx = wpa_s;
770 wpa_s->ap_configured_cb_data = wpa_s->go_params;
771 wpa_s->connect_without_scan = 1;
772 wpa_s->reassociate = 1;
773 wpa_s->disconnected = 0;
774 wpa_supplicant_req_scan(wpa_s, 0, 0);
778 static void wpas_p2p_clone_config(struct wpa_supplicant *dst,
779 const struct wpa_supplicant *src)
781 struct wpa_config *d;
782 const struct wpa_config *s;
787 #define C(n) if (s->n) d->n = os_strdup(s->n)
799 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
800 enum wpa_driver_if_type type)
802 char ifname[120], force_ifname[120];
804 if (wpa_s->pending_interface_name[0]) {
805 wpa_printf(MSG_DEBUG, "P2P: Pending virtual interface exists "
806 "- skip creation of a new one");
807 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
808 wpa_printf(MSG_DEBUG, "P2P: Pending virtual address "
809 "unknown?! ifname='%s'",
810 wpa_s->pending_interface_name);
816 os_snprintf(ifname, sizeof(ifname), "%s-p2p-%d", wpa_s->ifname,
817 wpa_s->p2p_group_idx);
818 force_ifname[0] = '\0';
820 wpa_printf(MSG_DEBUG, "P2P: Create a new interface %s for the group",
822 wpa_s->p2p_group_idx++;
824 wpa_s->pending_interface_type = type;
825 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
826 wpa_s->pending_interface_addr) < 0) {
827 wpa_printf(MSG_ERROR, "P2P: Failed to create new group "
832 if (force_ifname[0]) {
833 wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s",
835 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
836 sizeof(wpa_s->pending_interface_name));
838 os_strlcpy(wpa_s->pending_interface_name, ifname,
839 sizeof(wpa_s->pending_interface_name));
840 wpa_printf(MSG_DEBUG, "P2P: Created pending virtual interface %s addr "
841 MACSTR, wpa_s->pending_interface_name,
842 MAC2STR(wpa_s->pending_interface_addr));
848 static void wpas_p2p_remove_pending_group_interface(
849 struct wpa_supplicant *wpa_s)
851 if (!wpa_s->pending_interface_name[0] ||
852 is_zero_ether_addr(wpa_s->pending_interface_addr))
853 return; /* No pending virtual interface */
855 wpa_printf(MSG_DEBUG, "P2P: Removing pending group interface %s",
856 wpa_s->pending_interface_name);
857 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
858 wpa_s->pending_interface_name);
859 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
860 wpa_s->pending_interface_name[0] = '\0';
864 static struct wpa_supplicant *
865 wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
867 struct wpa_interface iface;
868 struct wpa_supplicant *group_wpa_s;
870 if (!wpa_s->pending_interface_name[0]) {
871 wpa_printf(MSG_ERROR, "P2P: No pending group interface");
875 os_memset(&iface, 0, sizeof(iface));
876 iface.ifname = wpa_s->pending_interface_name;
877 iface.driver = wpa_s->driver->name;
878 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
879 iface.driver_param = wpa_s->conf->driver_param;
880 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
881 if (group_wpa_s == NULL) {
882 wpa_printf(MSG_ERROR, "P2P: Failed to create new "
883 "wpa_supplicant interface");
886 wpa_s->pending_interface_name[0] = '\0';
887 group_wpa_s->parent = wpa_s;
888 group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO :
889 P2P_GROUP_INTERFACE_CLIENT;
890 wpa_s->global->p2p_group_formation = group_wpa_s;
892 wpas_p2p_clone_config(group_wpa_s, wpa_s);
898 static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
901 struct wpa_supplicant *wpa_s = eloop_ctx;
902 wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out");
903 if (wpa_s->global->p2p)
904 p2p_group_formation_failed(wpa_s->global->p2p);
905 wpas_group_formation_completed(wpa_s, 0);
909 void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
911 struct wpa_supplicant *wpa_s = ctx;
913 if (wpa_s->off_channel_freq) {
914 wpa_drv_cancel_remain_on_channel(wpa_s);
915 wpa_s->off_channel_freq = 0;
916 wpa_s->roc_waiting_drv_freq = 0;
920 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_FAILURE "status=%d",
922 wpas_p2p_remove_pending_group_interface(wpa_s);
926 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS);
928 if (wpa_s->create_p2p_iface) {
929 struct wpa_supplicant *group_wpa_s =
930 wpas_p2p_init_group_interface(wpa_s, res->role_go);
931 if (group_wpa_s == NULL) {
932 wpas_p2p_remove_pending_group_interface(wpa_s);
935 if (group_wpa_s != wpa_s) {
936 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
937 sizeof(group_wpa_s->p2p_pin));
938 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
940 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
941 wpa_s->pending_interface_name[0] = '\0';
942 group_wpa_s->p2p_in_provisioning = 1;
945 wpas_start_wps_go(group_wpa_s, res, 1);
947 wpas_start_wps_enrollee(group_wpa_s, res);
949 wpa_s->p2p_in_provisioning = 1;
950 wpa_s->global->p2p_group_formation = wpa_s;
953 wpas_start_wps_go(wpa_s, res, 1);
955 wpas_start_wps_enrollee(ctx, res);
958 wpa_s->p2p_long_listen = 0;
959 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
961 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
962 /* TODO: add peer Config Timeout */
963 eloop_register_timeout(15, 0, wpas_p2p_group_formation_timeout, wpa_s,
968 void wpas_go_neg_req_rx(void *ctx, const u8 *src)
970 struct wpa_supplicant *wpa_s = ctx;
971 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR,
976 void wpas_dev_found(void *ctx, const u8 *addr, const u8 *dev_addr,
977 const u8 *pri_dev_type, const char *dev_name,
978 u16 config_methods, u8 dev_capab, u8 group_capab)
980 struct wpa_supplicant *wpa_s = ctx;
981 char devtype[WPS_DEV_TYPE_BUFSIZE];
982 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
983 " p2p_dev_addr=" MACSTR
984 " pri_dev_type=%s name='%s' config_methods=0x%x "
985 "dev_capab=0x%x group_capab=0x%x",
986 MAC2STR(addr), MAC2STR(dev_addr),
987 wps_dev_type_bin2str(pri_dev_type, devtype, sizeof(devtype)),
988 dev_name, config_methods, dev_capab, group_capab);
992 static int wpas_start_listen(void *ctx, unsigned int freq,
993 unsigned int duration,
994 const struct wpabuf *probe_resp_ie)
996 struct wpa_supplicant *wpa_s = ctx;
998 wpa_drv_set_ap_wps_ie(wpa_s, NULL, probe_resp_ie);
1000 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
1001 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver to "
1002 "report received Probe Request frames");
1006 wpa_s->pending_listen_freq = freq;
1007 wpa_s->pending_listen_duration = duration;
1009 if (wpa_drv_remain_on_channel(wpa_s, freq, duration) < 0) {
1010 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver "
1011 "to remain on channel (%u MHz) for Listen "
1013 wpa_s->pending_listen_freq = 0;
1016 wpa_s->roc_waiting_drv_freq = freq;
1022 static void wpas_stop_listen(void *ctx)
1024 struct wpa_supplicant *wpa_s = ctx;
1025 if (wpa_s->off_channel_freq) {
1026 wpa_drv_cancel_remain_on_channel(wpa_s);
1027 wpa_s->off_channel_freq = 0;
1028 wpa_s->roc_waiting_drv_freq = 0;
1030 wpa_drv_probe_req_report(wpa_s, 0);
1034 static int wpas_send_probe_resp(void *ctx, const struct wpabuf *buf)
1036 struct wpa_supplicant *wpa_s = ctx;
1037 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf));
1041 static struct p2p_srv_bonjour *
1042 wpas_p2p_service_get_bonjour(struct wpa_supplicant *wpa_s,
1043 const struct wpabuf *query)
1045 struct p2p_srv_bonjour *bsrv;
1048 len = wpabuf_len(query);
1049 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
1050 struct p2p_srv_bonjour, list) {
1051 if (len == wpabuf_len(bsrv->query) &&
1052 os_memcmp(wpabuf_head(query), wpabuf_head(bsrv->query),
1060 static struct p2p_srv_upnp *
1061 wpas_p2p_service_get_upnp(struct wpa_supplicant *wpa_s, u8 version,
1062 const char *service)
1064 struct p2p_srv_upnp *usrv;
1066 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1067 struct p2p_srv_upnp, list) {
1068 if (version == usrv->version &&
1069 os_strcmp(service, usrv->service) == 0)
1076 static void wpas_sd_add_proto_not_avail(struct wpabuf *resp, u8 srv_proto,
1081 if (wpabuf_tailroom(resp) < 5)
1084 /* Length (to be filled) */
1085 len_pos = wpabuf_put(resp, 2);
1086 wpabuf_put_u8(resp, srv_proto);
1087 wpabuf_put_u8(resp, srv_trans_id);
1089 wpabuf_put_u8(resp, P2P_SD_PROTO_NOT_AVAILABLE);
1090 /* Response Data: empty */
1091 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
1095 static void wpas_sd_all_bonjour(struct wpa_supplicant *wpa_s,
1096 struct wpabuf *resp, u8 srv_trans_id)
1098 struct p2p_srv_bonjour *bsrv;
1101 wpa_printf(MSG_DEBUG, "P2P: SD Request for all Bonjour services");
1103 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
1104 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
1108 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
1109 struct p2p_srv_bonjour, list) {
1110 if (wpabuf_tailroom(resp) <
1111 5 + wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp))
1113 /* Length (to be filled) */
1114 len_pos = wpabuf_put(resp, 2);
1115 wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
1116 wpabuf_put_u8(resp, srv_trans_id);
1118 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
1119 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
1120 wpabuf_head(bsrv->resp),
1121 wpabuf_len(bsrv->resp));
1123 wpabuf_put_buf(resp, bsrv->query); /* Key */
1124 wpabuf_put_buf(resp, bsrv->resp); /* Value */
1125 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
1131 static void wpas_sd_req_bonjour(struct wpa_supplicant *wpa_s,
1132 struct wpabuf *resp, u8 srv_trans_id,
1133 const u8 *query, size_t query_len)
1135 struct p2p_srv_bonjour *bsrv;
1139 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for Bonjour",
1141 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
1142 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
1143 wpas_sd_add_proto_not_avail(resp, P2P_SERV_BONJOUR,
1148 if (query_len == 0) {
1149 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
1153 if (wpabuf_tailroom(resp) < 5)
1155 /* Length (to be filled) */
1156 len_pos = wpabuf_put(resp, 2);
1157 wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
1158 wpabuf_put_u8(resp, srv_trans_id);
1160 wpabuf_set(&buf, query, query_len);
1161 bsrv = wpas_p2p_service_get_bonjour(wpa_s, &buf);
1163 wpa_printf(MSG_DEBUG, "P2P: Requested Bonjour service not "
1167 wpabuf_put_u8(resp, P2P_SD_QUERY_DATA_NOT_AVAILABLE);
1168 /* Response Data: empty */
1169 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
1175 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
1176 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
1177 wpabuf_head(bsrv->resp), wpabuf_len(bsrv->resp));
1179 if (wpabuf_tailroom(resp) >=
1180 wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp)) {
1182 wpabuf_put_buf(resp, bsrv->query); /* Key */
1183 wpabuf_put_buf(resp, bsrv->resp); /* Value */
1185 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
1189 static void wpas_sd_all_upnp(struct wpa_supplicant *wpa_s,
1190 struct wpabuf *resp, u8 srv_trans_id)
1192 struct p2p_srv_upnp *usrv;
1195 wpa_printf(MSG_DEBUG, "P2P: SD Request for all UPnP services");
1197 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
1198 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
1202 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1203 struct p2p_srv_upnp, list) {
1204 if (wpabuf_tailroom(resp) < 5 + 1 + os_strlen(usrv->service))
1207 /* Length (to be filled) */
1208 len_pos = wpabuf_put(resp, 2);
1209 wpabuf_put_u8(resp, P2P_SERV_UPNP);
1210 wpabuf_put_u8(resp, srv_trans_id);
1213 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
1215 wpabuf_put_u8(resp, usrv->version);
1216 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
1218 wpabuf_put_str(resp, usrv->service);
1219 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
1225 static void wpas_sd_req_upnp(struct wpa_supplicant *wpa_s,
1226 struct wpabuf *resp, u8 srv_trans_id,
1227 const u8 *query, size_t query_len)
1229 struct p2p_srv_upnp *usrv;
1235 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for UPnP",
1238 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
1239 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
1240 wpas_sd_add_proto_not_avail(resp, P2P_SERV_UPNP,
1245 if (query_len == 0) {
1246 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
1251 str = os_malloc(query_len);
1254 os_memcpy(str, query + 1, query_len - 1);
1255 str[query_len - 1] = '\0';
1257 if (wpabuf_tailroom(resp) < 5)
1260 /* Length (to be filled) */
1261 len_pos = wpabuf_put(resp, 2);
1262 wpabuf_put_u8(resp, P2P_SERV_UPNP);
1263 wpabuf_put_u8(resp, srv_trans_id);
1265 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
1266 struct p2p_srv_upnp, list) {
1267 if (version != usrv->version)
1270 if (os_strcmp(str, "ssdp:all") != 0 &&
1271 os_strstr(usrv->service, str) == NULL)
1274 if (wpabuf_tailroom(resp) < 2)
1278 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
1280 wpabuf_put_u8(resp, version);
1282 wpabuf_put_u8(resp, ',');
1286 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
1288 if (wpabuf_tailroom(resp) < os_strlen(usrv->service))
1290 wpabuf_put_str(resp, usrv->service);
1294 wpa_printf(MSG_DEBUG, "P2P: Requested UPnP service not "
1297 wpabuf_put_u8(resp, P2P_SD_QUERY_DATA_NOT_AVAILABLE);
1298 /* Response Data: empty */
1301 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
1305 void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
1306 u16 update_indic, const u8 *tlvs, size_t tlvs_len)
1308 struct wpa_supplicant *wpa_s = ctx;
1309 const u8 *pos = tlvs;
1310 const u8 *end = tlvs + tlvs_len;
1313 struct wpabuf *resp;
1314 u8 srv_proto, srv_trans_id;
1318 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Request TLVs",
1320 buf_len = 2 * tlvs_len + 1;
1321 buf = os_malloc(buf_len);
1323 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
1324 wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_REQ "%d "
1326 freq, MAC2STR(sa), dialog_token, update_indic,
1331 if (wpa_s->p2p_sd_over_ctrl_iface)
1332 return; /* to be processed by an external program */
1334 resp = wpabuf_alloc(10000);
1338 while (pos + 1 < end) {
1339 wpa_printf(MSG_DEBUG, "P2P: Service Request TLV");
1340 slen = WPA_GET_LE16(pos);
1342 if (pos + slen > end || slen < 2) {
1343 wpa_printf(MSG_DEBUG, "P2P: Unexpected Query Data "
1348 tlv_end = pos + slen;
1351 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
1353 srv_trans_id = *pos++;
1354 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
1357 wpa_hexdump(MSG_MSGDUMP, "P2P: Query Data",
1358 pos, tlv_end - pos);
1360 switch (srv_proto) {
1361 case P2P_SERV_ALL_SERVICES:
1362 wpa_printf(MSG_DEBUG, "P2P: Service Discovery Request "
1363 "for all services");
1364 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp) &&
1365 dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
1366 wpa_printf(MSG_DEBUG, "P2P: No service "
1367 "discovery protocols available");
1368 wpas_sd_add_proto_not_avail(
1369 resp, P2P_SERV_ALL_SERVICES,
1373 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
1374 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
1376 case P2P_SERV_BONJOUR:
1377 wpas_sd_req_bonjour(wpa_s, resp, srv_trans_id,
1378 pos, tlv_end - pos);
1381 wpas_sd_req_upnp(wpa_s, resp, srv_trans_id,
1382 pos, tlv_end - pos);
1385 wpa_printf(MSG_DEBUG, "P2P: Unavailable service "
1386 "protocol %u", srv_proto);
1387 wpas_sd_add_proto_not_avail(resp, srv_proto,
1395 wpas_p2p_sd_response(wpa_s, freq, sa, dialog_token, resp);
1401 void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
1402 const u8 *tlvs, size_t tlvs_len)
1404 struct wpa_supplicant *wpa_s = ctx;
1405 const u8 *pos = tlvs;
1406 const u8 *end = tlvs + tlvs_len;
1412 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Response TLVs",
1414 buf_len = 2 * tlvs_len + 1;
1415 buf = os_malloc(buf_len);
1417 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
1418 wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_RESP MACSTR
1420 MAC2STR(sa), update_indic, buf);
1425 u8 srv_proto, srv_trans_id, status;
1427 wpa_printf(MSG_DEBUG, "P2P: Service Response TLV");
1428 slen = WPA_GET_LE16(pos);
1430 if (pos + slen > end || slen < 3) {
1431 wpa_printf(MSG_DEBUG, "P2P: Unexpected Response Data "
1435 tlv_end = pos + slen;
1438 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
1440 srv_trans_id = *pos++;
1441 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
1444 wpa_printf(MSG_DEBUG, "P2P: Status Code ID %u",
1447 wpa_hexdump(MSG_MSGDUMP, "P2P: Response Data",
1448 pos, tlv_end - pos);
1455 void * wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
1456 const struct wpabuf *tlvs)
1458 return p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
1462 void * wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,
1463 u8 version, const char *query)
1465 struct wpabuf *tlvs;
1468 tlvs = wpabuf_alloc(2 + 1 + 1 + 1 + os_strlen(query));
1471 wpabuf_put_le16(tlvs, 1 + 1 + 1 + os_strlen(query));
1472 wpabuf_put_u8(tlvs, P2P_SERV_UPNP); /* Service Protocol Type */
1473 wpabuf_put_u8(tlvs, 1); /* Service Transaction ID */
1474 wpabuf_put_u8(tlvs, version);
1475 wpabuf_put_str(tlvs, query);
1476 ret = wpas_p2p_sd_request(wpa_s, dst, tlvs);
1482 int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, void *req)
1484 return p2p_sd_cancel_request(wpa_s->global->p2p, req);
1488 void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
1489 const u8 *dst, u8 dialog_token,
1490 const struct wpabuf *resp_tlvs)
1492 p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
1497 void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s)
1499 p2p_sd_service_update(wpa_s->global->p2p);
1503 static void wpas_p2p_srv_bonjour_free(struct p2p_srv_bonjour *bsrv)
1505 dl_list_del(&bsrv->list);
1506 wpabuf_free(bsrv->query);
1507 wpabuf_free(bsrv->resp);
1512 static void wpas_p2p_srv_upnp_free(struct p2p_srv_upnp *usrv)
1514 dl_list_del(&usrv->list);
1515 os_free(usrv->service);
1520 void wpas_p2p_service_flush(struct wpa_supplicant *wpa_s)
1522 struct p2p_srv_bonjour *bsrv, *bn;
1523 struct p2p_srv_upnp *usrv, *un;
1525 dl_list_for_each_safe(bsrv, bn, &wpa_s->global->p2p_srv_bonjour,
1526 struct p2p_srv_bonjour, list)
1527 wpas_p2p_srv_bonjour_free(bsrv);
1529 dl_list_for_each_safe(usrv, un, &wpa_s->global->p2p_srv_upnp,
1530 struct p2p_srv_upnp, list)
1531 wpas_p2p_srv_upnp_free(usrv);
1533 wpas_p2p_sd_service_update(wpa_s);
1537 int wpas_p2p_service_add_bonjour(struct wpa_supplicant *wpa_s,
1538 struct wpabuf *query, struct wpabuf *resp)
1540 struct p2p_srv_bonjour *bsrv;
1542 bsrv = wpas_p2p_service_get_bonjour(wpa_s, query);
1545 wpabuf_free(bsrv->resp);
1550 bsrv = os_zalloc(sizeof(*bsrv));
1553 bsrv->query = query;
1555 dl_list_add(&wpa_s->global->p2p_srv_bonjour, &bsrv->list);
1557 wpas_p2p_sd_service_update(wpa_s);
1562 int wpas_p2p_service_del_bonjour(struct wpa_supplicant *wpa_s,
1563 const struct wpabuf *query)
1565 struct p2p_srv_bonjour *bsrv;
1567 bsrv = wpas_p2p_service_get_bonjour(wpa_s, query);
1570 wpas_p2p_srv_bonjour_free(bsrv);
1571 wpas_p2p_sd_service_update(wpa_s);
1576 int wpas_p2p_service_add_upnp(struct wpa_supplicant *wpa_s, u8 version,
1577 const char *service)
1579 struct p2p_srv_upnp *usrv;
1581 if (wpas_p2p_service_get_upnp(wpa_s, version, service))
1582 return 0; /* Already listed */
1583 usrv = os_zalloc(sizeof(*usrv));
1586 usrv->version = version;
1587 usrv->service = os_strdup(service);
1588 if (usrv->service == NULL) {
1592 dl_list_add(&wpa_s->global->p2p_srv_upnp, &usrv->list);
1594 wpas_p2p_sd_service_update(wpa_s);
1599 int wpas_p2p_service_del_upnp(struct wpa_supplicant *wpa_s, u8 version,
1600 const char *service)
1602 struct p2p_srv_upnp *usrv;
1604 usrv = wpas_p2p_service_get_upnp(wpa_s, version, service);
1607 wpas_p2p_srv_upnp_free(usrv);
1608 wpas_p2p_sd_service_update(wpa_s);
1613 static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
1614 const u8 *peer, const char *params)
1616 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR " %08d%s",
1617 MAC2STR(peer), wps_generate_pin(), params);
1621 static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
1622 const u8 *peer, const char *params)
1624 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR "%s",
1625 MAC2STR(peer), params);
1629 void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
1630 const u8 *dev_addr, const u8 *pri_dev_type,
1631 const char *dev_name, u16 supp_config_methods,
1632 u8 dev_capab, u8 group_capab)
1634 struct wpa_supplicant *wpa_s = ctx;
1635 char devtype[WPS_DEV_TYPE_BUFSIZE];
1637 u8 empty_dev_type[8];
1639 if (pri_dev_type == NULL) {
1640 os_memset(empty_dev_type, 0, sizeof(empty_dev_type));
1641 pri_dev_type = empty_dev_type;
1643 os_snprintf(params, sizeof(params), " p2p_dev_addr=" MACSTR
1644 " pri_dev_type=%s name='%s' config_methods=0x%x "
1645 "dev_capab=0x%x group_capab=0x%x",
1647 wps_dev_type_bin2str(pri_dev_type, devtype,
1649 dev_name, supp_config_methods, dev_capab, group_capab);
1650 params[sizeof(params) - 1] = '\0';
1652 if (config_methods & WPS_CONFIG_DISPLAY)
1653 wpas_prov_disc_local_display(wpa_s, peer, params);
1654 else if (config_methods & WPS_CONFIG_KEYPAD)
1655 wpas_prov_disc_local_keypad(wpa_s, peer, params);
1656 else if (config_methods & WPS_CONFIG_PUSHBUTTON)
1657 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ MACSTR
1658 "%s", MAC2STR(peer), params);
1662 void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
1664 struct wpa_supplicant *wpa_s = ctx;
1665 if (config_methods & WPS_CONFIG_DISPLAY)
1666 wpas_prov_disc_local_keypad(wpa_s, peer, "");
1667 else if (config_methods & WPS_CONFIG_KEYPAD)
1668 wpas_prov_disc_local_display(wpa_s, peer, "");
1669 else if (config_methods & WPS_CONFIG_PUSHBUTTON)
1670 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP MACSTR,
1675 static u8 wpas_invitation_process(void *ctx, const u8 *sa, const u8 *bssid,
1676 const u8 *go_dev_addr, const u8 *ssid,
1677 size_t ssid_len, int *go, u8 *group_bssid,
1678 int *force_freq, int persistent_group)
1680 struct wpa_supplicant *wpa_s = ctx;
1682 u8 cur_bssid[ETH_ALEN];
1685 if (!persistent_group) {
1686 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
1687 " to join an active group", MAC2STR(sa));
1689 * Do not accept the invitation automatically; notify user and
1692 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
1695 if (!wpa_s->conf->persistent_reconnect)
1696 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
1698 for (s = wpa_s->conf->ssid; s; s = s->next) {
1699 if (s->disabled == 2 &&
1700 os_memcmp(s->bssid, go_dev_addr, ETH_ALEN) == 0 &&
1701 s->ssid_len == ssid_len &&
1702 os_memcmp(ssid, s->ssid, ssid_len) == 0)
1707 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
1708 " requested reinvocation of an unknown group",
1710 return P2P_SC_FAIL_UNKNOWN_GROUP;
1713 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
1715 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
1716 wpa_printf(MSG_DEBUG, "P2P: The only available "
1717 "interface is already in use - reject "
1719 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1721 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
1722 } else if (s->mode == WPAS_MODE_P2P_GO) {
1724 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
1726 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
1727 "interface address for the group");
1728 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1730 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
1734 if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, cur_bssid) == 0 &&
1735 wpa_s->assoc_freq) {
1736 wpa_printf(MSG_DEBUG, "P2P: Trying to force channel to match "
1737 "the channel we are already using");
1738 *force_freq = wpa_s->assoc_freq;
1741 res = wpa_drv_shared_freq(wpa_s);
1743 wpa_printf(MSG_DEBUG, "P2P: Trying to force channel to match "
1744 "with the channel we are already using on a "
1745 "shared interface");
1749 return P2P_SC_SUCCESS;
1753 static void wpas_invitation_received(void *ctx, const u8 *sa, const u8 *bssid,
1754 const u8 *ssid, size_t ssid_len,
1755 const u8 *go_dev_addr, u8 status,
1758 struct wpa_supplicant *wpa_s = ctx;
1761 for (s = wpa_s->conf->ssid; s; s = s->next) {
1762 if (s->disabled == 2 &&
1763 s->ssid_len == ssid_len &&
1764 os_memcmp(ssid, s->ssid, ssid_len) == 0)
1768 if (status == P2P_SC_SUCCESS) {
1769 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
1770 " was accepted; op_freq=%d MHz",
1771 MAC2STR(sa), op_freq);
1773 wpas_p2p_group_add_persistent(
1774 wpa_s, s, s->mode == WPAS_MODE_P2P_GO, 0);
1779 if (status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1780 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
1781 " was rejected (status %u)", MAC2STR(sa), status);
1787 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
1788 "sa=" MACSTR " go_dev_addr=" MACSTR
1789 " bssid=" MACSTR " unknown-network",
1790 MAC2STR(sa), MAC2STR(go_dev_addr),
1793 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
1794 "sa=" MACSTR " go_dev_addr=" MACSTR
1796 MAC2STR(sa), MAC2STR(go_dev_addr));
1801 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED "sa=" MACSTR
1802 " persistent=%d", MAC2STR(sa), s->id);
1806 static void wpas_invitation_result(void *ctx, int status, const u8 *bssid)
1808 struct wpa_supplicant *wpa_s = ctx;
1809 struct wpa_ssid *ssid;
1812 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
1813 "status=%d " MACSTR,
1814 status, MAC2STR(bssid));
1816 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
1817 "status=%d ", status);
1820 if (status != P2P_SC_SUCCESS) {
1821 wpas_p2p_remove_pending_group_interface(wpa_s);
1825 ssid = wpa_config_get_network(wpa_s->conf,
1826 wpa_s->pending_invite_ssid_id);
1828 wpa_printf(MSG_ERROR, "P2P: Could not find persistent group "
1829 "data matching with invitation");
1833 wpas_p2p_group_add_persistent(wpa_s, ssid,
1834 ssid->mode == WPAS_MODE_P2P_GO, 0);
1838 static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
1839 struct p2p_config *p2p)
1841 struct hostapd_hw_modes *modes;
1842 u16 num_modes, flags;
1844 int band24 = 0, band5_low = 0, band5_high = 0;
1846 /* TODO: more detailed selection of channels within reg_class based on
1847 * driver capabilities */
1849 modes = wpa_drv_get_hw_feature_data(wpa_s, &num_modes, &flags);
1850 if (modes == NULL) {
1851 wpa_printf(MSG_DEBUG, "P2P: Driver did not support fetching "
1852 "of all supported channels; assume dualband "
1854 band24 = band5_low = band5_high = 1;
1856 for (i = 0; i < num_modes; i++) {
1857 struct hostapd_hw_modes *mode;
1859 if (mode->mode == HOSTAPD_MODE_IEEE80211G) {
1861 } else if (mode->mode == HOSTAPD_MODE_IEEE80211A) {
1863 for (j = 0; j < mode->num_channels; j++) {
1864 struct hostapd_channel_data *ch;
1865 ch = &mode->channels[j];
1868 else if (ch->chan == 157)
1878 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for "
1881 /* Operating class 81 - 2.4 GHz band channels 1..13 */
1882 p2p->channels.reg_class[cla].reg_class = 81;
1883 p2p->channels.reg_class[cla].channels = 13;
1884 for (i = 0; i < 13; i++)
1885 p2p->channels.reg_class[cla].channel[i] = i + 1;
1888 /* Operating class 82 - 2.4 GHz band channel 14 */
1889 p2p->channels.reg_class[cla].reg_class = 82;
1890 p2p->channels.reg_class[cla].channels = 1;
1891 p2p->channels.reg_class[cla].channel[0] = 14;
1895 /* Operating class 83 - 2.4 GHz band channels 1..9; 40 MHz */
1896 p2p->channels.reg_class[cla].reg_class = 83;
1897 p2p->channels.reg_class[cla].channels = 9;
1898 for (i = 0; i < 9; i++)
1899 p2p->channels.reg_class[cla].channel[i] = i + 1;
1902 /* Operating class 84 - 2.4 GHz band channels 5..13; 40 MHz */
1903 p2p->channels.reg_class[cla].reg_class = 84;
1904 p2p->channels.reg_class[cla].channels = 9;
1905 for (i = 0; i < 9; i++)
1906 p2p->channels.reg_class[cla].channel[i] = i + 5;
1912 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for "
1913 "lower 5 GHz band");
1915 /* Operating class 115 - 5 GHz, channels 36-48 */
1916 p2p->channels.reg_class[cla].reg_class = 115;
1917 p2p->channels.reg_class[cla].channels = 4;
1918 p2p->channels.reg_class[cla].channel[0] = 36;
1919 p2p->channels.reg_class[cla].channel[1] = 40;
1920 p2p->channels.reg_class[cla].channel[2] = 44;
1921 p2p->channels.reg_class[cla].channel[3] = 48;
1925 /* Operating class 116 - 5 GHz, channels 36,44; 40 MHz */
1926 p2p->channels.reg_class[cla].reg_class = 116;
1927 p2p->channels.reg_class[cla].channels = 2;
1928 p2p->channels.reg_class[cla].channel[0] = 36;
1929 p2p->channels.reg_class[cla].channel[1] = 44;
1932 /* Operating class 117 - 5 GHz, channels 40,48; 40 MHz */
1933 p2p->channels.reg_class[cla].reg_class = 117;
1934 p2p->channels.reg_class[cla].channels = 2;
1935 p2p->channels.reg_class[cla].channel[0] = 40;
1936 p2p->channels.reg_class[cla].channel[1] = 48;
1942 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for "
1943 "higher 5 GHz band");
1945 /* Operating class 124 - 5 GHz, channels 149,153,157,161 */
1946 p2p->channels.reg_class[cla].reg_class = 124;
1947 p2p->channels.reg_class[cla].channels = 4;
1948 p2p->channels.reg_class[cla].channel[0] = 149;
1949 p2p->channels.reg_class[cla].channel[1] = 153;
1950 p2p->channels.reg_class[cla].channel[2] = 157;
1951 p2p->channels.reg_class[cla].channel[3] = 161;
1955 /* Operating class 126 - 5 GHz, channels 149,157; 40 MHz */
1956 p2p->channels.reg_class[cla].reg_class = 126;
1957 p2p->channels.reg_class[cla].channels = 2;
1958 p2p->channels.reg_class[cla].channel[0] = 149;
1959 p2p->channels.reg_class[cla].channel[1] = 157;
1962 /* Operating class 127 - 5 GHz, channels 153,161; 40 MHz */
1963 p2p->channels.reg_class[cla].reg_class = 127;
1964 p2p->channels.reg_class[cla].channels = 2;
1965 p2p->channels.reg_class[cla].channel[0] = 153;
1966 p2p->channels.reg_class[cla].channel[1] = 161;
1971 p2p->channels.reg_classes = cla;
1974 ieee80211_sta_free_hw_features(modes, num_modes);
1980 static int wpas_get_noa(void *ctx, const u8 *interface_addr, u8 *buf,
1983 struct wpa_supplicant *wpa_s = ctx;
1985 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1986 if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0)
1992 return wpa_drv_get_noa(wpa_s, buf, buf_len);
1997 * wpas_p2p_init - Initialize P2P module for %wpa_supplicant
1998 * @global: Pointer to global data from wpa_supplicant_init()
1999 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2000 * Returns: 0 on success, -1 on failure
2002 int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
2004 struct p2p_config p2p;
2008 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
2011 #ifdef CONFIG_CLIENT_MLME
2012 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)) {
2013 wpa_s->mlme.public_action_cb = p2p_rx_action_mlme;
2014 wpa_s->mlme.public_action_cb_ctx = wpa_s;
2016 #endif /* CONFIG_CLIENT_MLME */
2018 if (wpa_drv_disable_11b_rates(wpa_s, 1) < 0) {
2019 wpa_printf(MSG_DEBUG, "P2P: Failed to disable 11b rates");
2020 /* Continue anyway; this is not really a fatal error */
2026 os_memset(&p2p, 0, sizeof(p2p));
2027 p2p.msg_ctx = wpa_s;
2029 p2p.p2p_scan = wpas_p2p_scan;
2030 p2p.send_action = wpas_send_action;
2031 p2p.send_action_done = wpas_send_action_done;
2032 p2p.go_neg_completed = wpas_go_neg_completed;
2033 p2p.go_neg_req_rx = wpas_go_neg_req_rx;
2034 p2p.dev_found = wpas_dev_found;
2035 p2p.start_listen = wpas_start_listen;
2036 p2p.stop_listen = wpas_stop_listen;
2037 p2p.send_probe_resp = wpas_send_probe_resp;
2038 p2p.sd_request = wpas_sd_request;
2039 p2p.sd_response = wpas_sd_response;
2040 p2p.prov_disc_req = wpas_prov_disc_req;
2041 p2p.prov_disc_resp = wpas_prov_disc_resp;
2042 p2p.invitation_process = wpas_invitation_process;
2043 p2p.invitation_received = wpas_invitation_received;
2044 p2p.invitation_result = wpas_invitation_result;
2045 p2p.get_noa = wpas_get_noa;
2047 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
2048 os_memcpy(p2p.dev_addr, wpa_s->own_addr, ETH_ALEN);
2049 p2p.dev_name = wpa_s->conf->device_name;
2051 if (wpa_s->conf->p2p_listen_reg_class &&
2052 wpa_s->conf->p2p_listen_channel) {
2053 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
2054 p2p.channel = wpa_s->conf->p2p_listen_channel;
2058 * Pick one of the social channels randomly as the listen
2061 os_get_random((u8 *) &r, sizeof(r));
2062 p2p.channel = 1 + (r % 3) * 5;
2065 if (wpa_s->conf->p2p_oper_reg_class &&
2066 wpa_s->conf->p2p_oper_channel) {
2067 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
2068 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
2070 p2p.op_reg_class = 81;
2072 * For initial tests, pick the operation channel randomly.
2073 * TODO: Use scan results (etc.) to select the best channel.
2075 p2p.op_channel = 1 + r % 11;
2077 wpa_printf(MSG_DEBUG, "P2P: Own listen channel: %d "
2078 "Own preferred operation channel: %d",
2079 p2p.channel, p2p.op_channel);
2080 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
2081 os_memcpy(p2p.country, wpa_s->conf->country, 2);
2082 p2p.country[2] = 0x04;
2084 os_memcpy(p2p.country, "US\x04", 3);
2086 if (wpas_p2p_setup_channels(wpa_s, &p2p)) {
2087 wpa_printf(MSG_ERROR, "P2P: Failed to configure supported "
2092 if (wpa_s->conf->device_type &&
2093 wps_dev_type_str2bin(wpa_s->conf->device_type, p2p.pri_dev_type) <
2095 wpa_printf(MSG_ERROR, "P2P: Invalid device_type");
2099 for (i = 0; i < MAX_SEC_DEVICE_TYPES; i++) {
2100 if (wpa_s->conf->sec_device_type[i] == NULL)
2102 if (wps_dev_type_str2bin(
2103 wpa_s->conf->sec_device_type[i],
2104 p2p.sec_dev_type[p2p.num_sec_dev_types]) < 0) {
2105 wpa_printf(MSG_ERROR, "P2P: Invalid sec_device_type");
2108 p2p.num_sec_dev_types++;
2109 if (p2p.num_sec_dev_types == P2P_SEC_DEVICE_TYPES)
2113 p2p.concurrent_operations = !!(wpa_s->drv_flags &
2114 WPA_DRIVER_FLAGS_P2P_CONCURRENT);
2116 p2p.max_peers = 100;
2118 if (wpa_s->conf->p2p_ssid_postfix) {
2119 p2p.ssid_postfix_len =
2120 os_strlen(wpa_s->conf->p2p_ssid_postfix);
2121 if (p2p.ssid_postfix_len > sizeof(p2p.ssid_postfix))
2122 p2p.ssid_postfix_len = sizeof(p2p.ssid_postfix);
2123 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
2124 p2p.ssid_postfix_len);
2127 global->p2p = p2p_init(&p2p);
2128 if (global->p2p == NULL)
2136 * wpas_p2p_deinit - Deinitialize per-interface P2P data
2137 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2139 * This function deinitialize per-interface P2P data.
2141 void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
2143 if (wpa_s->driver && wpa_s->drv_priv)
2144 wpa_drv_probe_req_report(wpa_s, 0);
2145 os_free(wpa_s->go_params);
2146 wpa_s->go_params = NULL;
2147 wpabuf_free(wpa_s->pending_action_tx);
2148 wpa_s->pending_action_tx = NULL;
2149 eloop_cancel_timeout(wpas_send_action_cb, wpa_s, NULL);
2150 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
2151 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
2152 wpa_s->p2p_long_listen = 0;
2153 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
2154 wpas_p2p_remove_pending_group_interface(wpa_s);
2156 /* TODO: remove group interface from the driver if this wpa_s instance
2157 * is on top of a P2P group interface */
2162 * wpas_p2p_deinit_global - Deinitialize global P2P module
2163 * @global: Pointer to global data from wpa_supplicant_init()
2165 * This function deinitializes the global (per device) P2P module.
2167 void wpas_p2p_deinit_global(struct wpa_global *global)
2169 struct wpa_supplicant *wpa_s, *tmp;
2172 if (global->p2p == NULL)
2175 /* Remove remaining P2P group interfaces */
2176 wpa_s = global->ifaces;
2177 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
2178 wpa_s = wpa_s->next;
2180 enum wpa_driver_if_type type;
2181 tmp = global->ifaces;
2184 tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) {
2189 ifname = os_strdup(tmp->ifname);
2190 type = wpas_p2p_if_type(tmp->p2p_group_interface);
2191 wpa_supplicant_remove_iface(global, tmp);
2193 wpa_drv_if_remove(wpa_s, type, ifname);
2197 p2p_deinit(global->p2p);
2202 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
2204 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)
2205 return 1; /* P2P group requires a new interface in every case
2207 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
2208 return 0; /* driver does not support concurrent operations */
2209 if (wpa_s->global->ifaces->next)
2210 return 1; /* more that one interface already in use */
2211 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2212 return 1; /* this interface is already in use */
2217 static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
2218 const u8 *peer_addr,
2219 enum p2p_wps_method wps_method,
2220 int go_intent, const u8 *own_interface_addr,
2221 unsigned int force_freq, int persistent_group)
2223 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
2224 go_intent, own_interface_addr, force_freq,
2229 static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
2230 const u8 *peer_addr,
2231 enum p2p_wps_method wps_method,
2232 int go_intent, const u8 *own_interface_addr,
2233 unsigned int force_freq, int persistent_group)
2235 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
2236 go_intent, own_interface_addr, force_freq,
2241 static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
2242 struct wpa_scan_results *scan_res)
2244 struct wpa_bss *bss;
2246 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
2248 if (wpa_s->global->p2p_disabled)
2251 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS) for join",
2252 scan_res ? (int) scan_res->num : -1);
2255 wpas_p2p_scan_res_handler(wpa_s, scan_res);
2257 bss = wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr);
2261 wpa_printf(MSG_DEBUG, "P2P: Send Provision Discovery Request "
2262 "prior to joining an existing group (GO " MACSTR
2264 MAC2STR(wpa_s->pending_join_dev_addr), bss->freq);
2265 wpa_s->pending_pd_before_join = 1;
2267 switch (wpa_s->pending_join_wps_method) {
2269 case WPS_PIN_DISPLAY:
2270 method = WPS_CONFIG_KEYPAD;
2272 case WPS_PIN_KEYPAD:
2273 method = WPS_CONFIG_DISPLAY;
2276 method = WPS_CONFIG_PUSHBUTTON;
2283 if (p2p_prov_disc_req(wpa_s->global->p2p,
2284 wpa_s->pending_join_dev_addr, method, 1)
2286 wpa_printf(MSG_DEBUG, "P2P: Failed to send Provision "
2287 "Discovery Request before joining an "
2289 wpa_s->pending_pd_before_join = 0;
2294 * Actual join operation will be started from the Action frame
2295 * TX status callback.
2300 wpa_printf(MSG_DEBUG, "P2P: Target BSS/GO not yet in BSS table - "
2301 "cannot send Provision Discovery Request");
2304 /* Start join operation immediately */
2305 wpas_p2p_join_start(wpa_s);
2309 static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx)
2311 struct wpa_supplicant *wpa_s = eloop_ctx;
2313 struct wpa_driver_scan_params params;
2314 struct wpabuf *wps_ie, *ies;
2316 os_memset(¶ms, 0, sizeof(params));
2318 /* P2P Wildcard SSID */
2319 params.num_ssids = 1;
2320 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
2321 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
2323 wpa_s->wps->dev.p2p = 1;
2324 wps_ie = wps_build_probe_req_ie(0, &wpa_s->wps->dev, wpa_s->wps->uuid,
2326 if (wps_ie == NULL) {
2327 wpas_p2p_scan_res_join(wpa_s, NULL);
2331 ies = wpabuf_alloc(wpabuf_len(wps_ie) + 100);
2333 wpabuf_free(wps_ie);
2334 wpas_p2p_scan_res_join(wpa_s, NULL);
2337 wpabuf_put_buf(ies, wps_ie);
2338 wpabuf_free(wps_ie);
2340 p2p_scan_ie(wpa_s->global->p2p, ies);
2342 params.extra_ies = wpabuf_head(ies);
2343 params.extra_ies_len = wpabuf_len(ies);
2346 * Run a scan to update BSS table and start Provision Discovery once
2347 * the new scan results become available.
2349 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
2350 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
2351 ret = ieee80211_sta_req_scan(wpa_s, ¶ms);
2353 ret = wpa_drv_scan(wpa_s, ¶ms);
2358 wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - "
2360 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
2361 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
2366 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
2367 const u8 *dev_addr, enum p2p_wps_method wps_method)
2369 wpa_printf(MSG_DEBUG, "P2P: Request to join existing group (iface "
2370 MACSTR " dev " MACSTR ")",
2371 MAC2STR(iface_addr), MAC2STR(dev_addr));
2373 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
2374 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
2375 wpa_s->pending_join_wps_method = wps_method;
2377 /* Make sure we are not running find during connection establishment */
2378 wpas_p2p_stop_find(wpa_s);
2380 wpas_p2p_join_scan(wpa_s, NULL);
2385 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s)
2387 struct wpa_supplicant *group;
2388 struct p2p_go_neg_results res;
2390 group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
2393 if (group != wpa_s) {
2394 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
2395 sizeof(group->p2p_pin));
2396 group->p2p_wps_method = wpa_s->p2p_wps_method;
2399 group->p2p_in_provisioning = 1;
2401 os_memset(&res, 0, sizeof(res));
2402 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
2404 res.wps_method = wpa_s->pending_join_wps_method;
2405 wpas_start_wps_enrollee(group, &res);
2412 * wpas_p2p_connect - Request P2P Group Formation to be started
2413 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2414 * @peer_addr: Address of the peer P2P Device
2415 * @pin: PIN to use during provisioning or %NULL to indicate PBC mode
2416 * @persistent_group: Whether to create a persistent group
2417 * @join: Whether to join an existing group (as a client) instead of starting
2418 * Group Owner negotiation; @peer_addr is BSSID in that case
2419 * @auth: Whether to only authorize the connection instead of doing that and
2420 * initiating Group Owner negotiation
2421 * @go_intent: GO Intent or -1 to use default
2422 * @freq: Frequency for the group or 0 for auto-selection
2423 * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on failure
2425 int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
2426 const char *pin, enum p2p_wps_method wps_method,
2427 int persistent_group, int join, int auth, int go_intent,
2433 enum wpa_driver_if_type iftype;
2436 go_intent = wpa_s->conf->p2p_go_intent;
2439 wpa_s->p2p_long_listen = 0;
2441 wpa_s->p2p_wps_method = wps_method;
2444 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
2445 else if (wps_method == WPS_PIN_DISPLAY) {
2446 ret = wps_generate_pin();
2447 os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin), "%08d",
2449 wpa_printf(MSG_DEBUG, "P2P: Randomly generated PIN: %s",
2452 wpa_s->p2p_pin[0] = '\0';
2455 u8 iface_addr[ETH_ALEN];
2456 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
2458 os_memcpy(iface_addr, peer_addr, ETH_ALEN);
2459 if (wpas_p2p_join(wpa_s, iface_addr, peer_addr, wps_method) <
2467 else if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, bssid) == 0 &&
2469 force_freq = wpa_s->assoc_freq;
2471 force_freq = wpa_drv_shared_freq(wpa_s);
2476 if (force_freq > 0) {
2477 wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the "
2478 "channel we are already using (%u MHz) on another "
2479 "interface", force_freq);
2482 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
2484 if (!wpa_s->create_p2p_iface) {
2486 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
2487 go_intent, wpa_s->own_addr,
2488 force_freq, persistent_group)
2493 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
2494 go_intent, wpa_s->own_addr,
2495 force_freq, persistent_group) < 0)
2500 /* Prepare to add a new interface for the group */
2501 iftype = WPA_IF_P2P_GROUP;
2503 iftype = WPA_IF_P2P_CLIENT;
2504 else if (go_intent == 15)
2505 iftype = WPA_IF_P2P_GO;
2506 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
2507 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
2508 "interface for the group");
2513 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
2515 wpa_s->pending_interface_addr,
2516 force_freq, persistent_group) < 0)
2520 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method, go_intent,
2521 wpa_s->pending_interface_addr,
2522 force_freq, persistent_group) < 0) {
2523 wpas_p2p_remove_pending_group_interface(wpa_s);
2531 * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start
2532 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2533 * @freq: Frequency of the channel in MHz
2534 * @duration: Duration of the stay on the channel in milliseconds
2536 * This callback is called when the driver indicates that it has started the
2537 * requested remain-on-channel duration.
2539 void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
2540 unsigned int freq, unsigned int duration)
2542 wpa_s->roc_waiting_drv_freq = 0;
2543 wpa_s->off_channel_freq = freq;
2544 wpas_send_action_cb(wpa_s, NULL);
2545 if (wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
2546 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
2547 wpa_s->pending_listen_duration);
2548 wpa_s->pending_listen_freq = 0;
2553 static int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s,
2554 unsigned int timeout)
2556 /* Limit maximum Listen state time based on driver limitation. */
2557 if (timeout > wpa_s->max_remain_on_chan)
2558 timeout = wpa_s->max_remain_on_chan;
2560 return p2p_listen(wpa_s->global->p2p, timeout);
2565 * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout
2566 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2567 * @freq: Frequency of the channel in MHz
2569 * This callback is called when the driver indicates that a remain-on-channel
2570 * operation has been completed, i.e., the duration on the requested channel
2573 void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
2576 wpa_s->off_channel_freq = 0;
2577 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
2578 return; /* P2P module started a new operation */
2579 if (wpa_s->pending_action_tx)
2581 if (wpa_s->p2p_long_listen > 0)
2582 wpa_s->p2p_long_listen -= 5;
2583 if (wpa_s->p2p_long_listen > 0) {
2584 wpa_printf(MSG_DEBUG, "P2P: Continuing long Listen state");
2585 wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen * 1000);
2591 * wpas_p2p_group_remove - Remove a P2P group
2592 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2593 * @ifname: Network interface name of the group interface or "*" to remove all
2595 * Returns: 0 on success, -1 on failure
2597 * This function is used to remove a P2P group. This can be used to disconnect
2598 * from a group in which the local end is a P2P Client or to end a P2P Group in
2599 * case the local end is the Group Owner. If a virtual network interface was
2600 * created for this group, that interface will be removed. Otherwise, only the
2601 * configured P2P group network will be removed from the interface.
2603 int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
2605 struct wpa_global *global = wpa_s->global;
2607 if (os_strcmp(ifname, "*") == 0) {
2608 struct wpa_supplicant *prev;
2609 wpa_s = global->ifaces;
2612 wpa_s = wpa_s->next;
2613 wpas_p2p_group_delete(prev);
2618 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2619 if (os_strcmp(wpa_s->ifname, ifname) == 0)
2626 wpas_p2p_group_delete(wpa_s);
2632 static void wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
2633 struct p2p_go_neg_results *params,
2639 os_memset(params, 0, sizeof(*params));
2640 params->role_go = 1;
2641 params->freq = 2412;
2643 params->freq = freq;
2644 else if (wpa_s->conf->p2p_oper_reg_class == 81 &&
2645 wpa_s->conf->p2p_oper_channel >= 1 &&
2646 wpa_s->conf->p2p_oper_channel <= 11)
2647 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
2648 else if (wpa_s->conf->p2p_oper_reg_class == 115 ||
2649 wpa_s->conf->p2p_oper_reg_class == 118)
2650 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
2651 if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, bssid) == 0 &&
2652 wpa_s->assoc_freq && !freq) {
2653 wpa_printf(MSG_DEBUG, "P2P: Force GO on the channel we are "
2655 params->freq = wpa_s->assoc_freq;
2658 res = wpa_drv_shared_freq(wpa_s);
2659 if (res > 0 && !freq) {
2660 wpa_printf(MSG_DEBUG, "P2P: Force GO on the channel we are "
2661 "already using on a shared interface");
2667 static struct wpa_supplicant *
2668 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
2671 struct wpa_supplicant *group_wpa_s;
2673 if (!wpas_p2p_create_iface(wpa_s))
2676 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
2677 WPA_IF_P2P_CLIENT) < 0)
2679 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
2680 if (group_wpa_s == NULL) {
2681 wpas_p2p_remove_pending_group_interface(wpa_s);
2690 * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner
2691 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
2692 * @persistent_group: Whether to create a persistent group
2693 * @freq: Frequency for the group or 0 to indicate no hardcoding
2694 * Returns: 0 on success, -1 on failure
2696 * This function creates a new P2P group with the local end as the Group Owner,
2697 * i.e., without using Group Owner Negotiation.
2699 int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
2702 struct p2p_go_neg_results params;
2704 wpas_p2p_init_go_params(wpa_s, ¶ms, freq);
2705 p2p_go_params(wpa_s->global->p2p, ¶ms);
2706 params.persistent_group = persistent_group;
2708 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
2711 wpas_start_wps_go(wpa_s, ¶ms, 0);
2717 static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
2718 struct wpa_ssid *params, int addr_allocated)
2720 struct wpa_ssid *ssid;
2722 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
2726 wpa_supplicant_ap_deinit(wpa_s);
2728 ssid = wpa_config_add_network(wpa_s->conf);
2731 wpas_notify_network_added(wpa_s, ssid);
2732 wpa_config_set_network_defaults(ssid);
2733 ssid->temporary = 1;
2734 ssid->proto = WPA_PROTO_RSN;
2735 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
2736 ssid->group_cipher = WPA_CIPHER_CCMP;
2737 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
2738 ssid->ssid = os_malloc(params->ssid_len);
2739 if (ssid->ssid == NULL) {
2740 wpas_notify_network_removed(wpa_s, ssid);
2741 wpa_config_remove_network(wpa_s->conf, ssid->id);
2744 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
2745 ssid->ssid_len = params->ssid_len;
2746 ssid->p2p_group = 1;
2747 if (params->psk_set) {
2748 os_memcpy(ssid->psk, params->psk, 32);
2751 if (params->passphrase)
2752 ssid->passphrase = os_strdup(params->passphrase);
2754 wpa_supplicant_select_network(wpa_s, ssid);
2756 wpa_s->show_group_started = 1;
2762 int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
2763 struct wpa_ssid *ssid, int addr_allocated,
2766 struct p2p_go_neg_results params;
2768 if (ssid->disabled != 2 || ssid->ssid == NULL)
2771 wpa_s->p2p_long_listen = 0;
2772 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
2774 if (ssid->mode == WPAS_MODE_INFRA)
2775 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated);
2777 if (ssid->mode != WPAS_MODE_P2P_GO)
2780 wpas_p2p_init_go_params(wpa_s, ¶ms, freq);
2783 if (ssid->passphrase == NULL ||
2784 os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) {
2785 wpa_printf(MSG_DEBUG, "P2P: Invalid passphrase in persistent "
2789 os_strlcpy(params.passphrase, ssid->passphrase,
2790 sizeof(params.passphrase));
2791 os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len);
2792 params.ssid_len = ssid->ssid_len;
2793 params.persistent_group = 1;
2795 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
2799 wpas_start_wps_go(wpa_s, ¶ms, 0);
2805 static void wpas_p2p_ie_update(void *ctx, struct wpabuf *beacon_ies,
2806 struct wpabuf *proberesp_ies)
2808 struct wpa_supplicant *wpa_s = ctx;
2809 if (wpa_s->ap_iface) {
2810 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
2812 wpabuf_free(hapd->p2p_beacon_ie);
2813 hapd->p2p_beacon_ie = beacon_ies;
2815 wpabuf_free(hapd->p2p_probe_resp_ie);
2816 hapd->p2p_probe_resp_ie = proberesp_ies;
2818 wpabuf_free(beacon_ies);
2819 wpabuf_free(proberesp_ies);
2821 wpa_supplicant_ap_update_beacon(wpa_s);
2825 struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
2826 int persistent_group,
2827 int group_formation)
2829 struct p2p_group *group;
2830 struct p2p_group_config *cfg;
2832 cfg = os_zalloc(sizeof(*cfg));
2836 cfg->persistent_group = persistent_group;
2837 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
2838 cfg->cb_ctx = wpa_s;
2839 cfg->ie_update = wpas_p2p_ie_update;
2841 group = p2p_group_init(wpa_s->global->p2p, cfg);
2844 if (!group_formation)
2845 p2p_group_notif_formation_done(group);
2846 wpa_s->p2p_group = group;
2851 void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
2854 if (!wpa_s->p2p_in_provisioning) {
2855 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P "
2856 "provisioning not in progress");
2860 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent,
2862 if (wpa_s->global->p2p)
2863 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
2864 wpas_group_formation_completed(wpa_s, 1);
2868 int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
2869 const char *config_method)
2873 if (os_strcmp(config_method, "display") == 0)
2874 config_methods = WPS_CONFIG_DISPLAY;
2875 else if (os_strcmp(config_method, "keypad") == 0)
2876 config_methods = WPS_CONFIG_KEYPAD;
2877 else if (os_strcmp(config_method, "pbc") == 0 ||
2878 os_strcmp(config_method, "pushbutton") == 0)
2879 config_methods = WPS_CONFIG_PUSHBUTTON;
2883 if (wpa_s->global->p2p == NULL)
2886 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr,
2891 int wpas_p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
2894 return p2p_scan_result_text(ies, ies_len, buf, end);
2898 int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
2899 enum p2p_discovery_type type)
2901 wpa_s->p2p_long_listen = 0;
2903 return p2p_find(wpa_s->global->p2p, timeout, type);
2907 void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
2909 wpa_s->p2p_long_listen = 0;
2910 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
2912 p2p_stop_find(wpa_s->global->p2p);
2914 wpas_p2p_remove_pending_group_interface(wpa_s);
2918 static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx)
2920 struct wpa_supplicant *wpa_s = eloop_ctx;
2921 wpa_s->p2p_long_listen = 0;
2925 int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
2931 * This is a request for unlimited Listen state. However, at
2932 * least for now, this is mapped to a Listen state for one
2937 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
2938 wpa_s->p2p_long_listen = 0;
2940 res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
2941 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
2942 wpa_s->p2p_long_listen = timeout;
2943 eloop_register_timeout(timeout, 0,
2944 wpas_p2p_long_listen_timeout,
2952 int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, const u8 *bssid,
2953 u8 *buf, size_t len, int p2p_group)
2955 if (wpa_s->global->p2p_disabled)
2957 if (wpa_s->global->p2p == NULL)
2960 return p2p_assoc_req_ie(wpa_s->global->p2p, bssid, buf, len,
2965 int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
2966 const u8 *ie, size_t ie_len)
2968 if (wpa_s->global->p2p_disabled)
2970 if (wpa_s->global->p2p == NULL)
2973 return p2p_probe_req_rx(wpa_s->global->p2p, addr, ie, ie_len);
2977 void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
2978 const u8 *sa, const u8 *bssid,
2979 u8 category, const u8 *data, size_t len, int freq)
2981 if (wpa_s->global->p2p_disabled)
2983 if (wpa_s->global->p2p == NULL)
2986 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
2991 void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
2993 if (wpa_s->global->p2p_disabled)
2995 if (wpa_s->global->p2p == NULL)
2998 p2p_scan_ie(wpa_s->global->p2p, ies);
3002 void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
3004 p2p_group_deinit(wpa_s->p2p_group);
3005 wpa_s->p2p_group = NULL;
3009 int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
3011 wpa_s->p2p_long_listen = 0;
3013 return p2p_reject(wpa_s->global->p2p, addr);
3017 /* Invite to reinvoke a persistent group */
3018 int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
3019 struct wpa_ssid *ssid, const u8 *go_dev_addr)
3021 enum p2p_invite_role role;
3024 if (ssid->mode == WPAS_MODE_P2P_GO) {
3025 role = P2P_INVITE_ROLE_GO;
3026 if (peer_addr == NULL) {
3027 wpa_printf(MSG_DEBUG, "P2P: Missing peer "
3028 "address in invitation command");
3031 if (wpas_p2p_create_iface(wpa_s)) {
3032 if (wpas_p2p_add_group_interface(wpa_s,
3033 WPA_IF_P2P_GO) < 0) {
3034 wpa_printf(MSG_ERROR, "P2P: Failed to "
3035 "allocate a new interface for the "
3039 bssid = wpa_s->pending_interface_addr;
3041 bssid = wpa_s->own_addr;
3043 role = P2P_INVITE_ROLE_CLIENT;
3044 peer_addr = ssid->bssid;
3046 wpa_s->pending_invite_ssid_id = ssid->id;
3048 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
3049 ssid->ssid, ssid->ssid_len, 0, go_dev_addr, 1);
3053 /* Invite to join an active group */
3054 int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
3055 const u8 *peer_addr, const u8 *go_dev_addr)
3057 struct wpa_global *global = wpa_s->global;
3058 enum p2p_invite_role role;
3060 struct wpa_ssid *ssid;
3062 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3063 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3066 if (wpa_s == NULL) {
3067 wpa_printf(MSG_DEBUG, "P2P: Interface '%s' not found", ifname);
3071 ssid = wpa_s->current_ssid;
3073 wpa_printf(MSG_DEBUG, "P2P: No current SSID to use for "
3078 if (ssid->mode == WPAS_MODE_P2P_GO) {
3079 role = P2P_INVITE_ROLE_ACTIVE_GO;
3080 bssid = wpa_s->own_addr;
3081 if (go_dev_addr == NULL)
3082 go_dev_addr = wpa_s->own_addr;
3084 role = P2P_INVITE_ROLE_CLIENT;
3085 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
3086 wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot "
3087 "invite to current group");
3090 bssid = wpa_s->bssid;
3091 if (go_dev_addr == NULL &&
3092 !is_zero_ether_addr(wpa_s->go_dev_addr))
3093 go_dev_addr = wpa_s->go_dev_addr;
3095 wpa_s->pending_invite_ssid_id = -1;
3097 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
3098 ssid->ssid, ssid->ssid_len, 0, go_dev_addr, 0);
3102 void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
3104 struct wpa_ssid *ssid = wpa_s->current_ssid;
3105 const char *ssid_txt;
3106 u8 go_dev_addr[ETH_ALEN];
3109 if (!wpa_s->show_group_started || !ssid)
3112 wpa_s->show_group_started = 0;
3114 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
3115 os_memset(go_dev_addr, 0, ETH_ALEN);
3116 if (ssid->bssid_set)
3117 os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN);
3118 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
3120 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
3122 if (ssid->passphrase == NULL && ssid->psk_set) {
3124 wpa_snprintf_hex(psk, sizeof(psk), ssid->psk, 32);
3125 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
3126 "%s client ssid=\"%s\" psk=%s go_dev_addr=" MACSTR
3128 wpa_s->ifname, ssid_txt, psk, MAC2STR(go_dev_addr),
3129 persistent ? " [PERSISTENT]" : "");
3131 wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
3132 "%s client ssid=\"%s\" passphrase=\"%s\" go_dev_addr="
3134 wpa_s->ifname, ssid_txt,
3135 ssid->passphrase ? ssid->passphrase : "",
3136 MAC2STR(go_dev_addr),
3137 persistent ? " [PERSISTENT]" : "");
3141 wpas_p2p_store_persistent_group(wpa_s->parent, ssid,
3146 int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
3147 u32 interval1, u32 duration2, u32 interval2)
3149 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3150 wpa_s->current_ssid == NULL ||
3151 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
3154 return p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
3155 wpa_s->own_addr, wpa_s->assoc_freq,
3156 duration1, interval1, duration2, interval2);
3160 int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
3161 unsigned int interval)
3163 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
3167 void wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
3168 u16 reason_code, const u8 *ie, size_t ie_len)
3170 if (wpa_s->global->p2p_disabled)
3173 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie, ie_len);
3177 void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
3178 u16 reason_code, const u8 *ie, size_t ie_len)
3180 if (wpa_s->global->p2p_disabled)
3183 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie, ie_len);
3187 void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
3189 struct p2p_data *p2p = wpa_s->global->p2p;
3194 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
3195 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
3197 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE) {
3199 if (wpa_s->conf->device_type) {
3200 if (wps_dev_type_str2bin(wpa_s->conf->device_type,
3201 pri_dev_type) < 0) {
3202 wpa_printf(MSG_ERROR, "P2P: Invalid "
3205 p2p_set_pri_dev_type(p2p, pri_dev_type);
3209 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE) {
3210 u8 sec_dev_type[P2P_SEC_DEVICE_TYPES][8];
3213 for (i = 0; i < MAX_SEC_DEVICE_TYPES; i++) {
3214 if (wpa_s->conf->sec_device_type[i] == NULL)
3216 if (wps_dev_type_str2bin(
3217 wpa_s->conf->sec_device_type[i],
3218 sec_dev_type[num]) < 0) {
3219 wpa_printf(MSG_ERROR, "P2P: Invalid "
3224 if (num == P2P_SEC_DEVICE_TYPES)
3227 p2p_set_sec_dev_types(p2p, (void *) sec_dev_type, num);
3230 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3231 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3233 country[0] = wpa_s->conf->country[0];
3234 country[1] = wpa_s->conf->country[1];
3236 p2p_set_country(p2p, country);
3239 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
3240 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
3241 wpa_s->conf->p2p_ssid_postfix ?
3242 os_strlen(wpa_s->conf->p2p_ssid_postfix) :