#define WPA_STA_MFP BIT(3)
/**
+ * struct p2p_params - P2P parameters for driver-based P2P management
+ */
+struct p2p_params {
+ const char *dev_name;
+ u8 pri_dev_type[8];
+#define DRV_MAX_SEC_DEV_TYPES 5
+ u8 sec_dev_type[DRV_MAX_SEC_DEV_TYPES][8];
+ size_t num_sec_dev_types;
+};
+
+/**
* struct wpa_driver_ops - Driver interface API definition
*
* This structure defines the API that each driver interface needs to implement
* to speed up various operations.
*/
const char * (*get_radio_name)(void *priv);
+
+ /**
+ * p2p_find - Start P2P Device Discovery
+ * @priv: Private driver interface data
+ * @timeout: Timeout for find operation in seconds or 0 for no timeout
+ * @type: Device Discovery type (enum p2p_discovery_type)
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_find)(void *priv, unsigned int timeout, int type);
+
+ /**
+ * p2p_stop_find - Stop P2P Device Discovery
+ * @priv: Private driver interface data
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_stop_find)(void *priv);
+
+ /**
+ * p2p_listen - Start P2P Listen state for specified duration
+ * @priv: Private driver interface data
+ * @timeout: Listen state duration in milliseconds
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function can be used to request the P2P module to keep the
+ * device discoverable on the listen channel for an extended set of
+ * time. At least in its current form, this is mainly used for testing
+ * purposes and may not be of much use for normal P2P operations.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_listen)(void *priv, unsigned int timeout);
+
+ /**
+ * p2p_connect - Start P2P group formation (GO negotiation)
+ * @priv: Private driver interface data
+ * @peer_addr: MAC address of the peer P2P client
+ * @wps_method: enum p2p_wps_method value indicating config method
+ * @go_intent: Local GO intent value (1..15)
+ * @own_interface_addr: Intended interface address to use with the
+ * group
+ * @force_freq: The only allowed channel frequency in MHz or 0
+ * @persistent_group: Whether to create persistent group
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_connect)(void *priv, const u8 *peer_addr, int wps_method,
+ int go_intent, const u8 *own_interface_addr,
+ unsigned int force_freq, int persistent_group);
+
+ /**
+ * wps_success_cb - Report successfully completed WPS provisioning
+ * @priv: Private driver interface data
+ * @peer_addr: Peer address
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is used to report successfully completed WPS
+ * provisioning during group formation in both GO/Registrar and
+ * client/Enrollee roles.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*wps_success_cb)(void *priv, const u8 *peer_addr);
+
+ /**
+ * p2p_group_formation_failed - Report failed WPS provisioning
+ * @priv: Private driver interface data
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is used to report failed group formation. This can
+ * happen either due to failed WPS provisioning or due to 15 second
+ * timeout during the provisioning phase.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_group_formation_failed)(void *priv);
+
+ /**
+ * p2p_set_params - Set P2P parameters
+ * @priv: Private driver interface data
+ * @params: P2P parameters
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_set_params)(void *priv, const struct p2p_params *params);
+
+ /**
+ * p2p_prov_disc_req - Send Provision Discovery Request
+ * @priv: Private driver interface data
+ * @peer_addr: MAC address of the peer P2P client
+ * @config_methods: WPS Config Methods value (only one bit set)
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function can be used to request a discovered P2P peer to
+ * display a PIN (config_methods = WPS_CONFIG_DISPLAY) or be prepared
+ * to enter a PIN from us (config_methods = WPS_CONFIG_KEYPAD). The
+ * Provision Discovery Request frame is transmitted once immediately
+ * and if no response is received, the frame will be sent again
+ * whenever the target device is discovered during device dsicovery
+ * (start with a p2p_find() call). Response from the peer is indicated
+ * with the EVENT_P2P_PROV_DISC_RESPONSE event.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_prov_disc_req)(void *priv, const u8 *peer_addr,
+ u16 config_methods);
+
+ /**
+ * p2p_sd_request - Schedule a service discovery query
+ * @priv: Private driver interface data
+ * @dst: Destination peer or %NULL to apply for all peers
+ * @tlvs: P2P Service Query TLV(s)
+ * Returns: Reference to the query or 0 on failure
+ *
+ * Response to the query is indicated with the
+ * EVENT_P2P_SD_RESPONSE driver event.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ u64 (*p2p_sd_request)(void *priv, const u8 *dst,
+ const struct wpabuf *tlvs);
+
+ /**
+ * p2p_sd_cancel_request - Cancel a pending service discovery query
+ * @priv: Private driver interface data
+ * @req: Query reference from p2p_sd_request()
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_sd_cancel_request)(void *priv, u64 req);
+
+ /**
+ * p2p_sd_response - Send response to a service discovery query
+ * @priv: Private driver interface data
+ * @freq: Frequency from EVENT_P2P_SD_REQUEST event
+ * @dst: Destination address from EVENT_P2P_SD_REQUEST event
+ * @dialog_token: Dialog token from EVENT_P2P_SD_REQUEST event
+ * @resp_tlvs: P2P Service Response TLV(s)
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is called as a response to the request indicated with
+ * the EVENT_P2P_SD_REQUEST driver event.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_sd_response)(void *priv, int freq, const u8 *dst,
+ u8 dialog_token,
+ const struct wpabuf *resp_tlvs);
+
+ /**
+ * p2p_service_update - Indicate a change in local services
+ * @priv: Private driver interface data
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function needs to be called whenever there is a change in
+ * availability of the local services. This will increment the
+ * Service Update Indicator value which will be used in SD Request and
+ * Response frames.
+ *
+ * This function is only used if the driver implements P2P management,
+ * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in
+ * struct wpa_driver_capa.
+ */
+ int (*p2p_service_update)(void *priv);
+
+ /**
+ * p2p_reject - Reject peer device (explicitly block connections)
+ * @priv: Private driver interface data
+ * @addr: MAC address of the peer
+ * Returns: 0 on success, -1 on failure
+ */
+ int (*p2p_reject)(void *priv, const u8 *addr);
+
+ /**
+ * p2p_invite - Invite a P2P Device into a group
+ * @priv: Private driver interface data
+ * @peer: Device Address of the peer P2P Device
+ * @role: Local role in the group
+ * @bssid: Group BSSID or %NULL if not known
+ * @ssid: Group SSID
+ * @ssid_len: Length of ssid in octets
+ * @go_dev_addr: Forced GO Device Address or %NULL if none
+ * @persistent_group: Whether this is to reinvoke a persistent group
+ * Returns: 0 on success, -1 on failure
+ */
+ int (*p2p_invite)(void *priv, const u8 *peer, int role,
+ const u8 *bssid, const u8 *ssid, size_t ssid_len,
+ const u8 *go_dev_addr, int persistent_group);
};
* station was lost. Detection can be through massive transmission
* failures for example.
*/
- EVENT_STATION_LOW_ACK
+ EVENT_STATION_LOW_ACK,
+
+ /**
+ * EVENT_P2P_DEV_FOUND - Report a discovered P2P device
+ *
+ * This event is used only if the driver implements P2P management
+ * internally. Event data is stored in
+ * union wpa_event_data::p2p_dev_found.
+ */
+ EVENT_P2P_DEV_FOUND,
+
+ /**
+ * EVENT_P2P_GO_NEG_REQ_RX - Report reception of GO Negotiation Request
+ *
+ * This event is used only if the driver implements P2P management
+ * internally. Event data is stored in
+ * union wpa_event_data::p2p_go_neg_req_rx.
+ */
+ EVENT_P2P_GO_NEG_REQ_RX,
+
+ /**
+ * EVENT_P2P_GO_NEG_COMPLETED - Report completion of GO Negotiation
+ *
+ * This event is used only if the driver implements P2P management
+ * internally. Event data is stored in
+ * union wpa_event_data::p2p_go_neg_completed.
+ */
+ EVENT_P2P_GO_NEG_COMPLETED,
+
+ EVENT_P2P_PROV_DISC_REQUEST,
+ EVENT_P2P_PROV_DISC_RESPONSE,
+ EVENT_P2P_SD_REQUEST,
+ EVENT_P2P_SD_RESPONSE
};
struct low_ack {
u8 addr[ETH_ALEN];
} low_ack;
+
+ /**
+ * struct p2p_dev_found - Data for EVENT_P2P_DEV_FOUND
+ */
+ struct p2p_dev_found {
+ const u8 *addr;
+ const u8 *dev_addr;
+ const u8 *pri_dev_type;
+ const char *dev_name;
+ u16 config_methods;
+ u8 dev_capab;
+ u8 group_capab;
+ } p2p_dev_found;
+
+ /**
+ * struct p2p_go_neg_req_rx - Data for EVENT_P2P_GO_NEG_REQ_RX
+ */
+ struct p2p_go_neg_req_rx {
+ const u8 *src;
+ u16 dev_passwd_id;
+ } p2p_go_neg_req_rx;
+
+ /**
+ * struct p2p_go_neg_completed - Data for EVENT_P2P_GO_NEG_COMPLETED
+ */
+ struct p2p_go_neg_completed {
+ struct p2p_go_neg_results *res;
+ } p2p_go_neg_completed;
+
+ struct p2p_prov_disc_req {
+ const u8 *peer;
+ u16 config_methods;
+ const u8 *dev_addr;
+ const u8 *pri_dev_type;
+ const char *dev_name;
+ u16 supp_config_methods;
+ u8 dev_capab;
+ u8 group_capab;
+ } p2p_prov_disc_req;
+
+ struct p2p_prov_disc_resp {
+ const u8 *peer;
+ u16 config_methods;
+ } p2p_prov_disc_resp;
+
+ struct p2p_sd_req {
+ int freq;
+ const u8 *sa;
+ u8 dialog_token;
+ u16 update_indic;
+ const u8 *tlvs;
+ size_t tlvs_len;
+ } p2p_sd_req;
+
+ struct p2p_sd_resp {
+ const u8 *sa;
+ u16 update_indic;
+ const u8 *tlvs;
+ size_t tlvs_len;
+ } p2p_sd_resp;
};
/**
NULL /* set_p2p_powersave */,
NULL /* ampdu */,
NULL /* set_intra_bss */,
- NULL /* get_radio_name */
+ NULL /* get_radio_name */,
+ NULL /* p2p_find */,
+ NULL /* p2p_stop_find */,
+ NULL /* p2p_listen */,
+ NULL /* p2p_connect */,
+ NULL /* wps_success_cb */,
+ NULL /* p2p_group_formation_failed */,
+ NULL /* p2p_set_params */,
+ NULL /* p2p_prov_disc_req */,
+ NULL /* p2p_sd_request */,
+ NULL /* p2p_sd_cancel_request */,
+ NULL /* p2p_sd_response */,
+ NULL /* p2p_service_update */,
+ NULL /* p2p_reject */,
+ NULL /* p2p_invite */
};
#include "common/ieee802_11_defs.h"
#include "crypto/sha1.h"
#include "l2_packet/l2_packet.h"
+#include "p2p/p2p.h"
+#include "wps/wps.h"
#include "driver.h"
unsigned int remain_on_channel_duration;
int current_freq;
+
+ struct p2p_data *p2p;
+ unsigned int off_channel_freq;
+ struct wpabuf *pending_action_tx;
+ u8 pending_action_src[ETH_ALEN];
+ u8 pending_action_dst[ETH_ALEN];
+ u8 pending_action_bssid[ETH_ALEN];
+ unsigned int pending_action_freq;
+ unsigned int pending_listen_freq;
+ unsigned int pending_listen_duration;
+ int pending_p2p_scan;
+ struct sockaddr *probe_from;
+ socklen_t probe_from_len;
};
static void wpa_driver_test_close_test_socket(
struct wpa_driver_test_data *drv);
static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx);
+static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv);
static void test_driver_free_bss(struct test_driver_bss *bss)
event.tx_status.ack = ret >= 0;
wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
+#ifdef CONFIG_P2P
+ if (drv->p2p &&
+ WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
+ WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
+ if (drv->pending_action_tx == NULL) {
+ wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - "
+ "no pending operation");
+ return ret;
+ }
+
+ if (os_memcmp(hdr->addr1, drv->pending_action_dst, ETH_ALEN) !=
+ 0) {
+ wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - "
+ "unknown destination address");
+ return ret;
+ }
+
+ wpabuf_free(drv->pending_action_tx);
+ drv->pending_action_tx = NULL;
+
+ p2p_send_action_cb(drv->p2p, drv->pending_action_freq,
+ drv->pending_action_dst,
+ drv->pending_action_src,
+ drv->pending_action_bssid,
+ ret >= 0);
+ }
+#endif /* CONFIG_P2P */
+
return ret;
}
event.rx_probe_req.ie = ie;
event.rx_probe_req.ie_len = ielen;
wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event);
+#ifdef CONFIG_P2P
+ if (drv->p2p)
+ p2p_probe_req_rx(drv->p2p, sa, ie, ielen);
+#endif /* CONFIG_P2P */
}
dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) {
static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx)
{
+ struct wpa_driver_test_data *drv = eloop_ctx;
wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
+ if (drv->pending_p2p_scan && drv->p2p) {
+#ifdef CONFIG_P2P
+ size_t i;
+ for (i = 0; i < drv->num_scanres; i++) {
+ struct wpa_scan_res *bss = drv->scanres[i];
+ if (p2p_scan_res_handler(drv->p2p, bss->bssid,
+ bss->freq, bss->level,
+ (const u8 *) (bss + 1),
+ bss->ie_len) > 0)
+ return;
+ }
+ p2p_scan_res_handled(drv->p2p);
+#endif /* CONFIG_P2P */
+ return;
+ }
wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
}
{
int freq = 0, own_freq;
union wpa_event_data event;
+ const struct ieee80211_mgmt *mgmt;
+ u16 fc;
struct test_driver_bss *bss;
bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
event.mlme_rx.freq = freq;
wpa_supplicant_event(drv->ctx, EVENT_MLME_RX, &event);
- if (drv->probe_req_report && data_len >= 24) {
- const struct ieee80211_mgmt *mgmt;
- u16 fc;
+ mgmt = (const struct ieee80211_mgmt *) data;
+ fc = le_to_host16(mgmt->frame_control);
- mgmt = (const struct ieee80211_mgmt *) data;
- fc = le_to_host16(mgmt->frame_control);
+ if (drv->probe_req_report && data_len >= 24) {
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ) {
os_memset(&event, 0, sizeof(event));
data_len - (mgmt->u.probe_req.variable - data);
wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ,
&event);
+#ifdef CONFIG_P2P
+ if (drv->p2p)
+ p2p_probe_req_rx(drv->p2p, mgmt->sa,
+ event.rx_probe_req.ie,
+ event.rx_probe_req.ie_len);
+#endif /* CONFIG_P2P */
}
}
+
+#ifdef CONFIG_P2P
+ if (drv->p2p &&
+ WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
+ WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
+ size_t hdr_len;
+ hdr_len = (const u8 *)
+ &mgmt->u.action.u.vs_public_action.action - data;
+ p2p_rx_action(drv->p2p, mgmt->da, mgmt->sa, mgmt->bssid,
+ mgmt->u.action.category,
+ &mgmt->u.action.u.vs_public_action.action,
+ data_len - hdr_len, freq);
+ }
+#endif /* CONFIG_P2P */
+
}
bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
/* data: optional [ STA-addr | ' ' | IEs(hex) ] */
+#ifdef CONFIG_P2P
+ if (drv->probe_req_report && drv->p2p && data_len) {
+ const char *d = (const char *) data;
+ u8 sa[ETH_ALEN];
+ u8 ie[512];
+ size_t ielen;
+
+ if (hwaddr_aton(d, sa))
+ return;
+ d += 18;
+ while (*d == ' ')
+ d++;
+ ielen = os_strlen(d) / 2;
+ if (ielen > sizeof(ie))
+ ielen = sizeof(ie);
+ if (hexstr2bin(d, ie, ielen) < 0)
+ ielen = 0;
+ drv->probe_from = from;
+ drv->probe_from_len = fromlen;
+ p2p_probe_req_rx(drv->p2p, sa, ie, ielen);
+ drv->probe_from = NULL;
+ }
+#endif /* CONFIG_P2P */
if (!drv->ibss)
return;
struct test_client_socket *cli, *prev;
int i;
+#ifdef CONFIG_P2P
+ if (drv->p2p)
+ p2p_deinit(drv->p2p);
+ wpabuf_free(drv->pending_action_tx);
+#endif /* CONFIG_P2P */
+
cli = drv->cli;
while (cli) {
prev = cli;
}
#endif /* CONFIG_CLIENT_MLME */
+ if (os_strstr(param, "p2p_mgmt=1")) {
+ wpa_printf(MSG_DEBUG, "test_driver: Use internal P2P "
+ "management");
+ if (wpa_driver_test_init_p2p(drv) < 0)
+ return -1;
+ }
+
return 0;
}
WPA_DRIVER_AUTH_LEAP;
if (drv->use_mlme)
capa->flags |= WPA_DRIVER_FLAGS_USER_SPACE_MLME;
+ if (drv->p2p)
+ capa->flags |= WPA_DRIVER_FLAGS_P2P_MGMT;
capa->flags |= WPA_DRIVER_FLAGS_AP;
capa->flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
capa->flags |= WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE;
}
+#ifdef CONFIG_P2P
+static void test_send_action_cb(void *eloop_ctx, void *timeout_ctx)
+{
+ struct wpa_driver_test_data *drv = eloop_ctx;
+ int res;
+
+ if (drv->pending_action_tx == NULL)
+ return;
+
+ if (drv->off_channel_freq != drv->pending_action_freq) {
+ wpa_printf(MSG_DEBUG, "P2P: Pending Action frame TX "
+ "waiting for another freq=%u",
+ drv->pending_action_freq);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "P2P: Sending pending Action frame to "
+ MACSTR, MAC2STR(drv->pending_action_dst));
+ res = wpa_driver_test_send_action(drv, drv->pending_action_freq, 0,
+ drv->pending_action_dst,
+ drv->pending_action_src,
+ drv->pending_action_bssid,
+ wpabuf_head(drv->pending_action_tx),
+ wpabuf_len(drv->pending_action_tx));
+}
+#endif /* CONFIG_P2P */
+
+
static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx)
{
struct wpa_driver_test_data *drv = eloop_ctx;
os_memset(&data, 0, sizeof(data));
data.remain_on_channel.freq = drv->remain_on_channel_freq;
data.remain_on_channel.duration = drv->remain_on_channel_duration;
- wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data);
+
+ if (drv->p2p)
+ drv->off_channel_freq = 0;
drv->remain_on_channel_freq = 0;
+
+ wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data);
}
data.remain_on_channel.duration = duration;
wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &data);
+#ifdef CONFIG_P2P
+ if (drv->p2p) {
+ drv->off_channel_freq = drv->remain_on_channel_freq;
+ test_send_action_cb(drv, NULL);
+ if (drv->off_channel_freq == drv->pending_listen_freq) {
+ p2p_listen_cb(drv->p2p, drv->pending_listen_freq,
+ drv->pending_listen_duration);
+ drv->pending_listen_freq = 0;
+ }
+ }
+#endif /* CONFIG_P2P */
+
return 0;
}
}
+#ifdef CONFIG_P2P
+
+static int wpa_driver_test_p2p_find(void *priv, unsigned int timeout, int type)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s(timeout=%u)", __func__, timeout);
+ if (!drv->p2p)
+ return -1;
+ return p2p_find(drv->p2p, timeout, type);
+}
+
+
+static int wpa_driver_test_p2p_stop_find(void *priv)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ if (!drv->p2p)
+ return -1;
+ p2p_stop_find(drv->p2p);
+ return 0;
+}
+
+
+static int wpa_driver_test_p2p_listen(void *priv, unsigned int timeout)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s(timeout=%u)", __func__, timeout);
+ if (!drv->p2p)
+ return -1;
+ return p2p_listen(drv->p2p, timeout);
+}
+
+
+static int wpa_driver_test_p2p_connect(void *priv, const u8 *peer_addr,
+ int wps_method, int go_intent,
+ const u8 *own_interface_addr,
+ unsigned int force_freq,
+ int persistent_group)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s(peer_addr=" MACSTR " wps_method=%d "
+ "go_intent=%d "
+ "own_interface_addr=" MACSTR " force_freq=%u "
+ "persistent_group=%d)",
+ __func__, MAC2STR(peer_addr), wps_method, go_intent,
+ MAC2STR(own_interface_addr), force_freq, persistent_group);
+ if (!drv->p2p)
+ return -1;
+ return p2p_connect(drv->p2p, peer_addr, wps_method, go_intent,
+ own_interface_addr, force_freq, persistent_group);
+}
+
+
+static int wpa_driver_test_wps_success_cb(void *priv, const u8 *peer_addr)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s(peer_addr=" MACSTR ")",
+ __func__, MAC2STR(peer_addr));
+ if (!drv->p2p)
+ return -1;
+ p2p_wps_success_cb(drv->p2p, peer_addr);
+ return 0;
+}
+
+
+static int wpa_driver_test_p2p_group_formation_failed(void *priv)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ if (!drv->p2p)
+ return -1;
+ p2p_group_formation_failed(drv->p2p);
+ return 0;
+}
+
+
+static int wpa_driver_test_p2p_set_params(void *priv,
+ const struct p2p_params *params)
+{
+ struct wpa_driver_test_data *drv = priv;
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ if (!drv->p2p)
+ return -1;
+ if (p2p_set_dev_name(drv->p2p, params->dev_name) < 0 ||
+ p2p_set_pri_dev_type(drv->p2p, params->pri_dev_type) < 0 ||
+ p2p_set_sec_dev_types(drv->p2p, params->sec_dev_type,
+ params->num_sec_dev_types) < 0)
+ return -1;
+ return 0;
+}
+
+
+static int test_p2p_scan(void *ctx, enum p2p_scan_type type, int freq)
+{
+ struct wpa_driver_test_data *drv = ctx;
+ struct wpa_driver_scan_params params;
+ int ret;
+ struct wpabuf *wps_ie, *ies;
+ int social_channels[] = { 2412, 2437, 2462, 0, 0 };
+
+ wpa_printf(MSG_DEBUG, "%s(type=%d freq=%d)",
+ __func__, type, freq);
+
+ os_memset(¶ms, 0, sizeof(params));
+
+ /* P2P Wildcard SSID */
+ params.num_ssids = 1;
+ params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
+ params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
+
+#if 0 /* TODO: WPS IE */
+ wpa_s->wps->dev.p2p = 1;
+ wps_ie = wps_build_probe_req_ie(0, &wpa_s->wps->dev, wpa_s->wps->uuid,
+ WPS_REQ_ENROLLEE);
+#else
+ wps_ie = wpabuf_alloc(1);
+#endif
+ if (wps_ie == NULL)
+ return -1;
+
+ ies = wpabuf_alloc(wpabuf_len(wps_ie) + 100);
+ if (ies == NULL) {
+ wpabuf_free(wps_ie);
+ return -1;
+ }
+ wpabuf_put_buf(ies, wps_ie);
+ wpabuf_free(wps_ie);
+
+ p2p_scan_ie(drv->p2p, ies);
+
+ params.extra_ies = wpabuf_head(ies);
+ params.extra_ies_len = wpabuf_len(ies);
+
+ switch (type) {
+ case P2P_SCAN_SOCIAL:
+ params.freqs = social_channels;
+ break;
+ case P2P_SCAN_FULL:
+ break;
+ case P2P_SCAN_SPECIFIC:
+ social_channels[0] = freq;
+ social_channels[1] = 0;
+ params.freqs = social_channels;
+ break;
+ case P2P_SCAN_SOCIAL_PLUS_ONE:
+ social_channels[3] = freq;
+ params.freqs = social_channels;
+ break;
+ }
+
+ drv->pending_p2p_scan = 1;
+ ret = wpa_driver_test_scan(drv, ¶ms);
+
+ wpabuf_free(ies);
+
+ return ret;
+}
+
+
+static int test_send_action(void *ctx, unsigned int freq, const u8 *dst,
+ const u8 *src, const u8 *bssid, const u8 *buf,
+ size_t len, unsigned int wait_time)
+{
+ struct wpa_driver_test_data *drv = ctx;
+
+ wpa_printf(MSG_DEBUG, "%s(freq=%u dst=" MACSTR " src=" MACSTR
+ " bssid=" MACSTR " len=%d",
+ __func__, freq, MAC2STR(dst), MAC2STR(src), MAC2STR(bssid),
+ (int) len);
+ if (freq <= 0) {
+ wpa_printf(MSG_WARNING, "P2P: No frequency specified for "
+ "action frame TX");
+ return -1;
+ }
+
+ if (drv->pending_action_tx) {
+ wpa_printf(MSG_DEBUG, "P2P: Dropped pending Action frame TX "
+ "to " MACSTR, MAC2STR(drv->pending_action_dst));
+ wpabuf_free(drv->pending_action_tx);
+ }
+ drv->pending_action_tx = wpabuf_alloc(len);
+ if (drv->pending_action_tx == NULL)
+ return -1;
+ wpabuf_put_data(drv->pending_action_tx, buf, len);
+ os_memcpy(drv->pending_action_src, src, ETH_ALEN);
+ os_memcpy(drv->pending_action_dst, dst, ETH_ALEN);
+ os_memcpy(drv->pending_action_bssid, bssid, ETH_ALEN);
+ drv->pending_action_freq = freq;
+
+ if (drv->off_channel_freq == freq) {
+ /* Already on requested channel; send immediately */
+ /* TODO: Would there ever be need to extend the current
+ * duration on the channel? */
+ eloop_cancel_timeout(test_send_action_cb, drv, NULL);
+ eloop_register_timeout(0, 0, test_send_action_cb, drv, NULL);
+ return 0;
+ }
+
+ wpa_printf(MSG_DEBUG, "P2P: Schedule Action frame to be transmitted "
+ "once the driver gets to the requested channel");
+ if (wpa_driver_test_remain_on_channel(drv, freq, wait_time) < 0) {
+ wpa_printf(MSG_DEBUG, "P2P: Failed to request driver "
+ "to remain on channel (%u MHz) for Action "
+ "Frame TX", freq);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static void test_send_action_done(void *ctx)
+{
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ /* TODO */
+}
+
+
+static void test_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
+{
+ struct wpa_driver_test_data *drv = ctx;
+ union wpa_event_data event;
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ os_memset(&event, 0, sizeof(event));
+ event.p2p_go_neg_completed.res = res;
+ wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_COMPLETED, &event);
+}
+
+
+static void test_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id)
+{
+ struct wpa_driver_test_data *drv = ctx;
+ union wpa_event_data event;
+ wpa_printf(MSG_DEBUG, "%s(src=" MACSTR ")", __func__, MAC2STR(src));
+ os_memset(&event, 0, sizeof(event));
+ event.p2p_go_neg_req_rx.src = src;
+ event.p2p_go_neg_req_rx.dev_passwd_id = dev_passwd_id;
+ wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_REQ_RX, &event);
+}
+
+
+static void test_dev_found(void *ctx, const u8 *addr, const u8 *dev_addr,
+ const u8 *pri_dev_type, const char *dev_name,
+ u16 config_methods, u8 dev_capab, u8 group_capab)
+{
+ struct wpa_driver_test_data *drv = ctx;
+ union wpa_event_data event;
+ char devtype[WPS_DEV_TYPE_BUFSIZE];
+ wpa_printf(MSG_DEBUG, "%s(" MACSTR " p2p_dev_addr=" MACSTR
+ " pri_dev_type=%s name='%s' config_methods=0x%x "
+ "dev_capab=0x%x group_capab=0x%x)",
+ __func__, MAC2STR(addr), MAC2STR(dev_addr),
+ wps_dev_type_bin2str(pri_dev_type, devtype,
+ sizeof(devtype)),
+ dev_name, config_methods, dev_capab, group_capab);
+
+ os_memset(&event, 0, sizeof(event));
+ event.p2p_dev_found.addr = addr;
+ event.p2p_dev_found.dev_addr = dev_addr;
+ event.p2p_dev_found.pri_dev_type = pri_dev_type;
+ event.p2p_dev_found.dev_name = dev_name;
+ event.p2p_dev_found.config_methods = config_methods;
+ event.p2p_dev_found.dev_capab = dev_capab;
+ event.p2p_dev_found.group_capab = group_capab;
+ wpa_supplicant_event(drv->ctx, EVENT_P2P_DEV_FOUND, &event);
+}
+
+
+static int test_start_listen(void *ctx, unsigned int freq,
+ unsigned int duration,
+ const struct wpabuf *probe_resp_ie)
+{
+ struct wpa_driver_test_data *drv = ctx;
+
+ wpa_printf(MSG_DEBUG, "%s(freq=%u duration=%u)",
+ __func__, freq, duration);
+
+ if (wpa_driver_test_probe_req_report(drv, 1) < 0)
+ return -1;
+
+ drv->pending_listen_freq = freq;
+ drv->pending_listen_duration = duration;
+
+ if (wpa_driver_test_remain_on_channel(drv, freq, duration) < 0) {
+ drv->pending_listen_freq = 0;
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static void test_stop_listen(void *ctx)
+{
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ /* TODO */
+}
+
+
+static int test_send_probe_resp(void *ctx, const struct wpabuf *buf)
+{
+ struct wpa_driver_test_data *drv = ctx;
+ char resp[512], *pos, *end;
+ int ret;
+ const struct ieee80211_mgmt *mgmt;
+ const u8 *ie, *ie_end;
+
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ wpa_hexdump_buf(MSG_MSGDUMP, "Probe Response", buf);
+ if (wpabuf_len(buf) < 24)
+ return -1;
+ if (!drv->probe_from) {
+ wpa_printf(MSG_DEBUG, "%s: probe_from not set", __func__);
+ return -1;
+ }
+
+ pos = resp;
+ end = resp + sizeof(resp);
+
+ mgmt = wpabuf_head(buf);
+
+ /* reply: SCANRESP BSSID SSID IEs */
+ ret = os_snprintf(pos, end - pos, "SCANRESP " MACSTR " ",
+ MAC2STR(mgmt->bssid));
+ if (ret < 0 || ret >= end - pos)
+ return -1;
+ pos += ret;
+
+ ie = mgmt->u.probe_resp.variable;
+ ie_end = wpabuf_head_u8(buf) + wpabuf_len(buf);
+ if (ie_end - ie < 2 || ie[0] != WLAN_EID_SSID ||
+ ie + 2 + ie[1] > ie_end)
+ return -1;
+ pos += wpa_snprintf_hex(pos, end - pos, ie + 2, ie[1]);
+
+ ret = os_snprintf(pos, end - pos, " ");
+ if (ret < 0 || ret >= end - pos)
+ return -1;
+ pos += ret;
+ pos += wpa_snprintf_hex(pos, end - pos, ie, ie_end - ie);
+
+ sendto(drv->test_socket, resp, pos - resp, 0,
+ drv->probe_from, drv->probe_from_len);
+
+ return 0;
+}
+
+
+static void test_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
+ u16 update_indic, const u8 *tlvs, size_t tlvs_len)
+{
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ /* TODO */
+}
+
+
+static void test_sd_response(void *ctx, const u8 *sa, u16 update_indic,
+ const u8 *tlvs, size_t tlvs_len)
+{
+ wpa_printf(MSG_DEBUG, "%s", __func__);
+ /* TODO */
+}
+
+
+static void test_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
+ const u8 *dev_addr, const u8 *pri_dev_type,
+ const char *dev_name, u16 supp_config_methods,
+ u8 dev_capab, u8 group_capab)
+{
+ wpa_printf(MSG_DEBUG, "%s(peer=" MACSTR " config_methods=0x%x)",
+ __func__, MAC2STR(peer), config_methods);
+ /* TODO */
+}
+
+
+static void test_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
+{
+ wpa_printf(MSG_DEBUG, "%s(peer=" MACSTR " config_methods=0x%x)",
+ __func__, MAC2STR(peer), config_methods);
+ /* TODO */
+}
+
+#endif /* CONFIG_P2P */
+
+
+static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv)
+{
+#ifdef CONFIG_P2P
+ struct p2p_config p2p;
+ unsigned int r;
+ int i;
+
+ os_memset(&p2p, 0, sizeof(p2p));
+ p2p.msg_ctx = drv->ctx;
+ p2p.cb_ctx = drv;
+ p2p.p2p_scan = test_p2p_scan;
+ p2p.send_action = test_send_action;
+ p2p.send_action_done = test_send_action_done;
+ p2p.go_neg_completed = test_go_neg_completed;
+ p2p.go_neg_req_rx = test_go_neg_req_rx;
+ p2p.dev_found = test_dev_found;
+ p2p.start_listen = test_start_listen;
+ p2p.stop_listen = test_stop_listen;
+ p2p.send_probe_resp = test_send_probe_resp;
+ p2p.sd_request = test_sd_request;
+ p2p.sd_response = test_sd_response;
+ p2p.prov_disc_req = test_prov_disc_req;
+ p2p.prov_disc_resp = test_prov_disc_resp;
+
+ os_memcpy(p2p.dev_addr, drv->own_addr, ETH_ALEN);
+
+ p2p.reg_class = 12; /* TODO: change depending on location */
+ /*
+ * Pick one of the social channels randomly as the listen
+ * channel.
+ */
+ os_get_random((u8 *) &r, sizeof(r));
+ p2p.channel = 1 + (r % 3) * 5;
+
+ /* TODO: change depending on location */
+ p2p.op_reg_class = 12;
+ /*
+ * For initial tests, pick the operation channel randomly.
+ * TODO: Use scan results (etc.) to select the best channel.
+ */
+ p2p.op_channel = 1 + r % 11;
+
+ os_memcpy(p2p.country, "US ", 3);
+
+ /* FIX: fetch available channels from the driver */
+ p2p.channels.reg_classes = 1;
+ p2p.channels.reg_class[0].reg_class = 12; /* US/12 = 2.4 GHz band */
+ p2p.channels.reg_class[0].channels = 11;
+ for (i = 0; i < 11; i++)
+ p2p.channels.reg_class[0].channel[i] = i + 1;
+
+ p2p.max_peers = 100;
+
+ drv->p2p = p2p_init(&p2p);
+ if (drv->p2p == NULL)
+ return -1;
+ return 0;
+#else /* CONFIG_P2P */
+ wpa_printf(MSG_INFO, "driver_test: P2P support not included");
+ return -1;
+#endif /* CONFIG_P2P */
+}
+
+
const struct wpa_driver_ops wpa_driver_test_ops = {
"test",
"wpa_supplicant test driver",
.remain_on_channel = wpa_driver_test_remain_on_channel,
.cancel_remain_on_channel = wpa_driver_test_cancel_remain_on_channel,
.probe_req_report = wpa_driver_test_probe_req_report,
+#ifdef CONFIG_P2P
+ .p2p_find = wpa_driver_test_p2p_find,
+ .p2p_stop_find = wpa_driver_test_p2p_stop_find,
+ .p2p_listen = wpa_driver_test_p2p_listen,
+ .p2p_connect = wpa_driver_test_p2p_connect,
+ .wps_success_cb = wpa_driver_test_wps_success_cb,
+ .p2p_group_formation_failed =
+ wpa_driver_test_p2p_group_formation_failed,
+ .p2p_set_params = wpa_driver_test_p2p_set_params,
+#endif /* CONFIG_P2P */
};
return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
}
+static inline int wpa_drv_p2p_find(struct wpa_supplicant *wpa_s,
+ unsigned int timeout, int type)
+{
+ if (!wpa_s->driver->p2p_find)
+ return -1;
+ return wpa_s->driver->p2p_find(wpa_s->drv_priv, timeout, type);
+}
+
+static inline int wpa_drv_p2p_stop_find(struct wpa_supplicant *wpa_s)
+{
+ if (!wpa_s->driver->p2p_stop_find)
+ return -1;
+ return wpa_s->driver->p2p_stop_find(wpa_s->drv_priv);
+}
+
+static inline int wpa_drv_p2p_listen(struct wpa_supplicant *wpa_s,
+ unsigned int timeout)
+{
+ if (!wpa_s->driver->p2p_listen)
+ return -1;
+ return wpa_s->driver->p2p_listen(wpa_s->drv_priv, timeout);
+}
+
+static inline int wpa_drv_p2p_connect(struct wpa_supplicant *wpa_s,
+ const u8 *peer_addr, int wps_method,
+ int go_intent,
+ const u8 *own_interface_addr,
+ unsigned int force_freq,
+ int persistent_group)
+{
+ if (!wpa_s->driver->p2p_connect)
+ return -1;
+ return wpa_s->driver->p2p_connect(wpa_s->drv_priv, peer_addr,
+ wps_method, go_intent,
+ own_interface_addr, force_freq,
+ persistent_group);
+}
+
+static inline int wpa_drv_wps_success_cb(struct wpa_supplicant *wpa_s,
+ const u8 *peer_addr)
+{
+ if (!wpa_s->driver->wps_success_cb)
+ return -1;
+ return wpa_s->driver->wps_success_cb(wpa_s->drv_priv, peer_addr);
+}
+
+static inline int
+wpa_drv_p2p_group_formation_failed(struct wpa_supplicant *wpa_s)
+{
+ if (!wpa_s->driver->p2p_group_formation_failed)
+ return -1;
+ return wpa_s->driver->p2p_group_formation_failed(wpa_s->drv_priv);
+}
+
+static inline int wpa_drv_p2p_set_params(struct wpa_supplicant *wpa_s,
+ const struct p2p_params *params)
+{
+ if (!wpa_s->driver->p2p_set_params)
+ return -1;
+ return wpa_s->driver->p2p_set_params(wpa_s->drv_priv, params);
+}
+
+static inline int wpa_drv_p2p_prov_disc_req(struct wpa_supplicant *wpa_s,
+ const u8 *peer_addr,
+ u16 config_methods)
+{
+ if (!wpa_s->driver->p2p_prov_disc_req)
+ return -1;
+ return wpa_s->driver->p2p_prov_disc_req(wpa_s->drv_priv, peer_addr,
+ config_methods);
+}
+
+static inline u64 wpa_drv_p2p_sd_request(struct wpa_supplicant *wpa_s,
+ const u8 *dst,
+ const struct wpabuf *tlvs)
+{
+ if (!wpa_s->driver->p2p_sd_request)
+ return 0;
+ return wpa_s->driver->p2p_sd_request(wpa_s->drv_priv, dst, tlvs);
+}
+
+static inline int wpa_drv_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s,
+ u64 req)
+{
+ if (!wpa_s->driver->p2p_sd_cancel_request)
+ return -1;
+ return wpa_s->driver->p2p_sd_cancel_request(wpa_s->drv_priv, req);
+}
+
+static inline int wpa_drv_p2p_sd_response(struct wpa_supplicant *wpa_s,
+ int freq, const u8 *dst,
+ u8 dialog_token,
+ const struct wpabuf *resp_tlvs)
+{
+ if (!wpa_s->driver->p2p_sd_response)
+ return -1;
+ return wpa_s->driver->p2p_sd_response(wpa_s->drv_priv, freq, dst,
+ dialog_token, resp_tlvs);
+}
+
+static inline int wpa_drv_p2p_service_update(struct wpa_supplicant *wpa_s)
+{
+ if (!wpa_s->driver->p2p_service_update)
+ return -1;
+ return wpa_s->driver->p2p_service_update(wpa_s->drv_priv);
+}
+
+static inline int wpa_drv_p2p_reject(struct wpa_supplicant *wpa_s,
+ const u8 *addr)
+{
+ if (!wpa_s->driver->p2p_reject)
+ return -1;
+ return wpa_s->driver->p2p_reject(wpa_s->drv_priv, addr);
+}
+
+static inline int wpa_drv_p2p_invite(struct wpa_supplicant *wpa_s,
+ const u8 *peer, int role, const u8 *bssid,
+ const u8 *ssid, size_t ssid_len,
+ const u8 *go_dev_addr,
+ int persistent_group)
+{
+ if (!wpa_s->driver->p2p_invite)
+ return -1;
+ return wpa_s->driver->p2p_invite(wpa_s->drv_priv, peer, role, bssid,
+ ssid, ssid_len, go_dev_addr,
+ persistent_group);
+}
+
+
#endif /* DRIVER_I_H */
data->rx_probe_req.ie,
data->rx_probe_req.ie_len);
break;
+ case EVENT_P2P_DEV_FOUND:
+ wpas_dev_found(wpa_s, data->p2p_dev_found.addr,
+ data->p2p_dev_found.dev_addr,
+ data->p2p_dev_found.pri_dev_type,
+ data->p2p_dev_found.dev_name,
+ data->p2p_dev_found.config_methods,
+ data->p2p_dev_found.dev_capab,
+ data->p2p_dev_found.group_capab);
+ break;
+ case EVENT_P2P_GO_NEG_REQ_RX:
+ wpas_go_neg_req_rx(wpa_s, data->p2p_go_neg_req_rx.src,
+ data->p2p_go_neg_req_rx.dev_passwd_id);
+ break;
+ case EVENT_P2P_GO_NEG_COMPLETED:
+ wpas_go_neg_completed(wpa_s, data->p2p_go_neg_completed.res);
+ break;
+ case EVENT_P2P_PROV_DISC_REQUEST:
+ wpas_prov_disc_req(wpa_s, data->p2p_prov_disc_req.peer,
+ data->p2p_prov_disc_req.config_methods,
+ data->p2p_prov_disc_req.dev_addr,
+ data->p2p_prov_disc_req.pri_dev_type,
+ data->p2p_prov_disc_req.dev_name,
+ data->p2p_prov_disc_req.supp_config_methods,
+ data->p2p_prov_disc_req.dev_capab,
+ data->p2p_prov_disc_req.group_capab);
+ break;
+ case EVENT_P2P_PROV_DISC_RESPONSE:
+ wpas_prov_disc_resp(wpa_s, data->p2p_prov_disc_resp.peer,
+ data->p2p_prov_disc_resp.config_methods);
+ break;
+ case EVENT_P2P_SD_REQUEST:
+ wpas_sd_request(wpa_s, data->p2p_sd_req.freq,
+ data->p2p_sd_req.sa,
+ data->p2p_sd_req.dialog_token,
+ data->p2p_sd_req.update_indic,
+ data->p2p_sd_req.tlvs,
+ data->p2p_sd_req.tlvs_len);
+ break;
+ case EVENT_P2P_SD_RESPONSE:
+ wpas_sd_response(wpa_s, data->p2p_sd_resp.sa,
+ data->p2p_sd_resp.update_indic,
+ data->p2p_sd_resp.tlvs,
+ data->p2p_sd_resp.tlvs_len);
+ break;
#endif /* CONFIG_P2P */
#ifdef CONFIG_CLIENT_MLME
case EVENT_MLME_RX: {
{
if (wpa_s->global->p2p_disabled)
return;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return;
if (wpa_s->pending_action_tx == NULL) {
wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - no "
wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out");
if (wpa_s->global->p2p)
p2p_group_formation_failed(wpa_s->global->p2p);
+ else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ wpa_drv_p2p_group_formation_failed(wpa_s);
wpas_group_formation_completed(wpa_s, 0);
}
void * wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
const struct wpabuf *tlvs)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return (void *) wpa_drv_p2p_sd_request(wpa_s, dst, tlvs);
return p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
}
int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, void *req)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_sd_cancel_request(wpa_s, (u64) req);
return p2p_sd_cancel_request(wpa_s->global->p2p, req);
}
const u8 *dst, u8 dialog_token,
const struct wpabuf *resp_tlvs)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ wpa_drv_p2p_sd_response(wpa_s, freq, dst, dialog_token,
+ resp_tlvs);
+ return;
+ }
p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
resp_tlvs);
}
void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ wpa_drv_p2p_service_update(wpa_s);
+ return;
+ }
p2p_sd_service_update(wpa_s->global->p2p);
}
if (global->p2p)
return 0;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ struct p2p_params params;
+
+ wpa_printf(MSG_DEBUG, "P2P: Use driver-based P2P management");
+ os_memset(¶ms, 0, sizeof(params));
+ params.dev_name = wpa_s->conf->device_name;
+ if (wpa_s->conf->device_type &&
+ wps_dev_type_str2bin(wpa_s->conf->device_type,
+ params.pri_dev_type) < 0) {
+ wpa_printf(MSG_ERROR, "P2P: Invalid device_type");
+ return -1;
+ }
+ for (i = 0; i < MAX_SEC_DEVICE_TYPES; i++) {
+ if (wpa_s->conf->sec_device_type[i] == NULL)
+ continue;
+ if (wps_dev_type_str2bin(
+ wpa_s->conf->sec_device_type[i],
+ params.sec_dev_type[
+ params.num_sec_dev_types]) < 0) {
+ wpa_printf(MSG_ERROR, "P2P: Invalid "
+ "sec_device_type");
+ return -1;
+ }
+ params.num_sec_dev_types++;
+ if (params.num_sec_dev_types == DRV_MAX_SEC_DEV_TYPES)
+ break;
+ }
+ if (wpa_drv_p2p_set_params(wpa_s, ¶ms) < 0)
+ return -1;
+
+ return 0;
+ }
+
os_memset(&p2p, 0, sizeof(p2p));
p2p.msg_ctx = wpa_s;
p2p.cb_ctx = wpa_s;
int go_intent, const u8 *own_interface_addr,
unsigned int force_freq, int persistent_group)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ return wpa_drv_p2p_connect(wpa_s, peer_addr, wps_method,
+ go_intent, own_interface_addr,
+ force_freq, persistent_group);
+ }
+
return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
go_intent, own_interface_addr, force_freq,
persistent_group);
int go_intent, const u8 *own_interface_addr,
unsigned int force_freq, int persistent_group)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return -1;
+
return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
go_intent, own_interface_addr, force_freq,
persistent_group);
if (timeout > wpa_s->max_remain_on_chan)
timeout = wpa_s->max_remain_on_chan;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_listen(wpa_s, timeout);
+
return p2p_listen(wpa_s->global->p2p, timeout);
}
struct p2p_group *group;
struct p2p_group_config *cfg;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return NULL;
+
cfg = os_zalloc(sizeof(*cfg));
if (cfg == NULL)
return NULL;
NULL);
if (wpa_s->global->p2p)
p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
+ else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ wpa_drv_wps_success_cb(wpa_s, peer_addr);
wpas_group_formation_completed(wpa_s, 1);
}
else
return -1;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ return wpa_drv_p2p_prov_disc_req(wpa_s, peer_addr,
+ config_methods);
+ }
+
if (wpa_s->global->p2p == NULL)
return -1;
wpas_p2p_clear_pending_action_tx(wpa_s);
wpa_s->p2p_long_listen = 0;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_find(wpa_s, timeout, type);
+
return p2p_find(wpa_s->global->p2p, timeout, type);
}
eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
+ wpa_drv_p2p_stop_find(wpa_s);
+ return;
+ }
+
p2p_stop_find(wpa_s->global->p2p);
wpas_p2p_remove_pending_group_interface(wpa_s);
{
wpa_s->p2p_long_listen = 0;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_reject(wpa_s, addr);
+
return p2p_reject(wpa_s->global->p2p, addr);
}
}
wpa_s->pending_invite_ssid_id = ssid->id;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
+ ssid->ssid, ssid->ssid_len,
+ go_dev_addr, 1);
+
return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
ssid->ssid, ssid->ssid_len, 0, go_dev_addr, 1);
}
}
wpa_s->parent->pending_invite_ssid_id = -1;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
+ ssid->ssid, ssid->ssid_len,
+ go_dev_addr, 0);
+
return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
ssid->ssid, ssid->ssid_len, wpa_s->assoc_freq,
go_dev_addr, 0);
int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
u32 interval1, u32 duration2, u32 interval2)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return -1;
+
if (wpa_s->wpa_state < WPA_ASSOCIATED ||
wpa_s->current_ssid == NULL ||
wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
unsigned int interval)
{
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return -1;
+
return p2p_ext_listen(wpa_s->global->p2p, period, interval);
}
{
if (wpa_s->global->p2p_disabled)
return;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return;
p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie, ie_len);
}
{
if (wpa_s->global->p2p_disabled)
return;
+ if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
+ return;
p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie, ie_len);
}
projects / mech_eap.git / commitdiff