DGNum/hostapd
6
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

P2P: Remove WPA_DRIVER_FLAGS_P2P_MGMT option

Browse source 
The option of handling upper layer P2P management operations within the
driver/firmware was originally planned to be used with wpa_supplicant,
but this has not really happened and there is no clear sign of this
being needed in the near term either. This functionality has not been
completed and it is certainly not being kept up-to-date or tested. As
such, it is best to remove it for now and if this or something similar
is needed in the future, it can be brought back once a clear need for it
has been demonstrated first.

Signed-hostap: Jouni Malinen <j@w1.fi>
This commit is contained in:
Jouni Malinen 2013-12-29 18:20:47 +02:00
parent 538d6f4b54
commit 152cff6ba6
8 changed files with 18 additions and 1313 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
doc/p2p.doxygen
View file

@ -178,30 +178,6 @@ the standard station/AP mode events when the P2P module resides within
- wpa_event_type::EVENT_CANCEL_REMAIN_ON_CHANNEL - wpa_event_type::EVENT_CANCEL_REMAIN_ON_CHANNEL
- wpa_event_type::EVENT_RX_PROBE_REQ - wpa_event_type::EVENT_RX_PROBE_REQ
The following driver wrapper functions are needed for P2P in addition
to the standard station/AP mode operations when the P2P module resides
in the driver or firmware:
- wpa_driver_ops::if_add()
- wpa_driver_ops::if_remove()
- wpa_driver_ops::alloc_interface_addr()
- wpa_driver_ops::release_interface_addr()
- wpa_driver_ops::disable_11b_rates()
- wpa_driver_ops::p2p_find()
- wpa_driver_ops::p2p_stop_find()
- wpa_driver_ops::p2p_listen()
- wpa_driver_ops::p2p_connect()
- wpa_driver_ops::p2p_reject()
- wpa_driver_ops::wps_success_cb()
- wpa_driver_ops::p2p_group_formation_failed()
- wpa_driver_ops::p2p_set_params()
The following driver wrapper events are needed for P2P in addition to
the standard station/AP mode events when the P2P module resides in the
driver or firmware:
- wpa_event_type::EVENT_P2P_DEV_FOUND
- wpa_event_type::EVENT_P2P_GO_NEG_REQ_RX
- wpa_event_type::EVENT_P2P_GO_NEG_COMPLETED
\section p2p_go_neg P2P device discovery and group formation \section p2p_go_neg P2P device discovery and group formation

322
src/drivers/driver.h
View file

@ -862,8 +862,7 @@ struct wpa_driver_capa {
#define WPA_DRIVER_FLAGS_AP 0x00000040 #define WPA_DRIVER_FLAGS_AP 0x00000040
/* Driver needs static WEP key setup after association has been completed */ /* Driver needs static WEP key setup after association has been completed */
#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE 0x00000080 #define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE 0x00000080
/* Driver takes care of P2P management operations */ /* unused: 0x00000100 */
#define WPA_DRIVER_FLAGS_P2P_MGMT 0x00000100
/* Driver supports concurrent P2P operations */ /* Driver supports concurrent P2P operations */
#define WPA_DRIVER_FLAGS_P2P_CONCURRENT 0x00000200 #define WPA_DRIVER_FLAGS_P2P_CONCURRENT 0x00000200
/* /*
@ -1107,17 +1106,6 @@ struct wpa_bss_params {
#define WPA_STA_MFP BIT(3) #define WPA_STA_MFP BIT(3)
#define WPA_STA_TDLS_PEER BIT(4) #define WPA_STA_TDLS_PEER BIT(4)
/**
* 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;
};
enum tdls_oper { enum tdls_oper {
TDLS_DISCOVERY_REQ, TDLS_DISCOVERY_REQ,
TDLS_SETUP, TDLS_SETUP,
@ -2397,222 +2385,6 @@ struct wpa_driver_ops {
*/ */
const char * (*get_radio_name)(void *priv); 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, int join);
/**
* 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);
/** /**
* send_tdls_mgmt - for sending TDLS management packets * send_tdls_mgmt - for sending TDLS management packets
* @priv: private driver interface data * @priv: private driver interface data
@ -3247,38 +3019,6 @@ enum wpa_event_type {
*/ */
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,
/** /**
* EVENT_IBSS_PEER_LOST - IBSS peer not reachable anymore * EVENT_IBSS_PEER_LOST - IBSS peer not reachable anymore
*/ */
@ -3903,66 +3643,6 @@ union wpa_event_data {
u8 addr[ETH_ALEN]; u8 addr[ETH_ALEN];
} low_ack; } 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;
/** /**
* struct ibss_peer_lost - Data for EVENT_IBSS_PEER_LOST * struct ibss_peer_lost - Data for EVENT_IBSS_PEER_LOST
*/ */

7
src/drivers/driver_common.c
View file

@ -64,13 +64,6 @@ const char * event_to_string(enum wpa_event_type event)
E2S(UNPROT_DEAUTH); E2S(UNPROT_DEAUTH);
E2S(UNPROT_DISASSOC); E2S(UNPROT_DISASSOC);
E2S(STATION_LOW_ACK); E2S(STATION_LOW_ACK);
E2S(P2P_DEV_FOUND);
E2S(P2P_GO_NEG_REQ_RX);
E2S(P2P_GO_NEG_COMPLETED);
E2S(P2P_PROV_DISC_REQUEST);
E2S(P2P_PROV_DISC_RESPONSE);
E2S(P2P_SD_REQUEST);
E2S(P2P_SD_RESPONSE);
E2S(IBSS_PEER_LOST); E2S(IBSS_PEER_LOST);
E2S(DRIVER_GTK_REKEY); E2S(DRIVER_GTK_REKEY);
E2S(SCHED_SCAN_STOPPED); E2S(SCHED_SCAN_STOPPED);

644
src/drivers/driver_test.c
View file

@ -28,7 +28,6 @@
#include "common/ieee802_11_defs.h" #include "common/ieee802_11_defs.h"
#include "crypto/sha1.h" #include "crypto/sha1.h"
#include "l2_packet/l2_packet.h" #include "l2_packet/l2_packet.h"
#include "p2p/p2p.h"
#include "wps/wps.h" #include "wps/wps.h"
#include "driver.h" #include "driver.h"
@ -102,20 +101,6 @@ struct wpa_driver_test_data {
unsigned int remain_on_channel_duration; unsigned int remain_on_channel_duration;
int current_freq; 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_action_no_cck;
unsigned int pending_listen_freq;
unsigned int pending_listen_duration;
int pending_p2p_scan;
struct sockaddr *probe_from;
socklen_t probe_from_len;
}; };
@ -125,7 +110,6 @@ static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
static void wpa_driver_test_close_test_socket( static void wpa_driver_test_close_test_socket(
struct wpa_driver_test_data *drv); struct wpa_driver_test_data *drv);
static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx); 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) static void test_driver_free_bss(struct test_driver_bss *bss)
@ -479,34 +463,6 @@ static int wpa_driver_test_send_mlme(void *priv, const u8 *data,
event.tx_status.ack = ret >= 0; event.tx_status.ack = ret >= 0;
wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event); 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; return ret;
} }
@ -553,10 +509,6 @@ static void test_driver_scan(struct wpa_driver_test_data *drv,
event.rx_probe_req.ie = ie; event.rx_probe_req.ie = ie;
event.rx_probe_req.ie_len = ielen; event.rx_probe_req.ie_len = ielen;
wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event); wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event);
#ifdef CONFIG_P2P
if (drv->p2p)
p2p_probe_req_rx(drv->p2p, sa, NULL, NULL, ie, ielen);
#endif /* CONFIG_P2P */
} }
dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) { dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) {
@ -1313,25 +1265,7 @@ static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx)
static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx) 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"); wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
if (drv->pending_p2p_scan && drv->p2p) {
#ifdef CONFIG_P2P
size_t i;
struct os_reltime now;
os_get_reltime(&now);
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, &now, 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); wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
} }
@ -1949,30 +1883,8 @@ static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv,
data_len - (mgmt->u.probe_req.variable - data); data_len - (mgmt->u.probe_req.variable - data);
wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ,
&event); &event);
#ifdef CONFIG_P2P
if (drv->p2p)
p2p_probe_req_rx(drv->p2p, mgmt->sa,
mgmt->da, mgmt->bssid,
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 */
} }
@ -1988,29 +1900,6 @@ static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv,
bss = dl_list_first(&drv->bss, struct test_driver_bss, list); bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
/* data: optional [ STA-addr | ' ' | IEs(hex) ] */ /* 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, NULL, NULL, ie, ielen);
drv->probe_from = NULL;
}
#endif /* CONFIG_P2P */
if (!drv->ibss) if (!drv->ibss)
return; return;
@ -2167,12 +2056,6 @@ static void wpa_driver_test_deinit(void *priv)
struct test_client_socket *cli, *prev; struct test_client_socket *cli, *prev;
int i; int i;
#ifdef CONFIG_P2P
if (drv->p2p)
p2p_deinit(drv->p2p);
wpabuf_free(drv->pending_action_tx);
#endif /* CONFIG_P2P */
cli = drv->cli; cli = drv->cli;
while (cli) { while (cli) {
prev = cli; prev = cli;
@ -2369,13 +2252,6 @@ static int wpa_driver_test_set_param(void *priv, const char *param)
drv->use_associnfo = 1; drv->use_associnfo = 1;
} }
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; return 0;
} }
@ -2465,8 +2341,6 @@ static int wpa_driver_test_send_eapol(void *priv, const u8 *dest, u16 proto,
static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa) static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa)
{ {
struct test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
os_memset(capa, 0, sizeof(*capa)); os_memset(capa, 0, sizeof(*capa));
capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
@ -2482,8 +2356,6 @@ static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa)
capa->auth = WPA_DRIVER_AUTH_OPEN | capa->auth = WPA_DRIVER_AUTH_OPEN |
WPA_DRIVER_AUTH_SHARED | WPA_DRIVER_AUTH_SHARED |
WPA_DRIVER_AUTH_LEAP; WPA_DRIVER_AUTH_LEAP;
if (drv->p2p)
capa->flags |= WPA_DRIVER_FLAGS_P2P_MGMT;
capa->flags |= WPA_DRIVER_FLAGS_AP; capa->flags |= WPA_DRIVER_FLAGS_AP;
capa->flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT; capa->flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
capa->flags |= WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE; capa->flags |= WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE;
@ -2691,33 +2563,6 @@ static int wpa_driver_test_send_action(void *priv, unsigned int freq,
} }
#ifdef CONFIG_P2P
static void test_send_action_cb(void *eloop_ctx, void *timeout_ctx)
{
struct wpa_driver_test_data *drv = eloop_ctx;
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));
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),
drv->pending_action_no_cck);
}
#endif /* CONFIG_P2P */
static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx) static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx)
{ {
struct wpa_driver_test_data *drv = eloop_ctx; struct wpa_driver_test_data *drv = eloop_ctx;
@ -2729,9 +2574,6 @@ static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx)
data.remain_on_channel.freq = drv->remain_on_channel_freq; data.remain_on_channel.freq = drv->remain_on_channel_freq;
data.remain_on_channel.duration = drv->remain_on_channel_duration; data.remain_on_channel.duration = drv->remain_on_channel_duration;
if (drv->p2p)
drv->off_channel_freq = 0;
drv->remain_on_channel_freq = 0; drv->remain_on_channel_freq = 0;
wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data); wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data);
@ -2765,18 +2607,6 @@ static int wpa_driver_test_remain_on_channel(void *priv, unsigned int freq,
data.remain_on_channel.duration = duration; data.remain_on_channel.duration = duration;
wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &data); 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; return 0;
} }
@ -2804,470 +2634,6 @@ static int wpa_driver_test_probe_req_report(void *priv, int report)
} }
#ifdef CONFIG_P2P
static int wpa_driver_test_p2p_find(void *priv, unsigned int timeout, int type)
{
struct test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
wpa_printf(MSG_DEBUG, "%s(timeout=%u)", __func__, timeout);
if (!drv->p2p)
return -1;
return p2p_find(drv->p2p, timeout, type, 0, NULL, NULL, 0);
}
static int wpa_driver_test_p2p_stop_find(void *priv)
{
struct test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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 test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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 test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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,
NULL, 0, 0, 0);
}
static int wpa_driver_test_wps_success_cb(void *priv, const u8 *peer_addr)
{
struct test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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 test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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 test_driver_bss *dbss = priv;
struct wpa_driver_test_data *drv = dbss->drv;
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,
unsigned int num_req_dev_types,
const u8 *req_dev_types, const u8 *dev_id, u16 pw_id)
{
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 };
size_t ielen;
wpa_printf(MSG_DEBUG, "%s(type=%d freq=%d)",
__func__, type, freq);
os_memset(&params, 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(pw_id, &wpa_s->wps->dev,
wpa_s->wps->uuid, WPS_REQ_ENROLLEE);
#else
wps_ie = wpabuf_alloc(1);
#endif
if (wps_ie == NULL)
return -1;
ielen = p2p_scan_ie_buf_len(drv->p2p);
ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
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, dev_id);
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_SOCIAL_PLUS_ONE:
social_channels[3] = freq;
params.freqs = social_channels;
break;
}
drv->pending_p2p_scan = 1;
ret = wpa_driver_test_scan(drv, &params);
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;
drv->pending_action_no_cck = 1;
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 struct p2p_peer_info *info, int new_device)
{
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(info->p2p_device_addr),
wps_dev_type_bin2str(info->pri_dev_type, devtype,
sizeof(devtype)),
info->device_name, info->config_methods, info->dev_capab,
info->group_capab);
os_memset(&event, 0, sizeof(event));
event.p2p_dev_found.addr = addr;
event.p2p_dev_found.dev_addr = info->p2p_device_addr;
event.p2p_dev_found.pri_dev_type = info->pri_dev_type;
event.p2p_dev_found.dev_name = info->device_name;
event.p2p_dev_found.config_methods = info->config_methods;
event.p2p_dev_found.dev_capab = info->dev_capab;
event.p2p_dev_found.group_capab = info->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,
const u8 *group_id, size_t group_id_len)
{
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 */
}
static void test_p2p_debug_print(void *ctx, int level, const char *msg)
{
wpa_printf(level, "P2P: %s", msg);
}
#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.cb_ctx = drv;
p2p.debug_print = test_p2p_debug_print;
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 = { const struct wpa_driver_ops wpa_driver_test_ops = {
"test", "test",
"wpa_supplicant test driver", "wpa_supplicant test driver",
@ -3309,14 +2675,4 @@ const struct wpa_driver_ops wpa_driver_test_ops = {
.remain_on_channel = wpa_driver_test_remain_on_channel, .remain_on_channel = wpa_driver_test_remain_on_channel,
.cancel_remain_on_channel = wpa_driver_test_cancel_remain_on_channel, .cancel_remain_on_channel = wpa_driver_test_cancel_remain_on_channel,
.probe_req_report = wpa_driver_test_probe_req_report, .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 */
}; };

128
wpa_supplicant/driver_i.h
View file

@ -516,134 +516,6 @@ static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu); 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, int join)
{
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, join);
}
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);
}
static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s, static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
const u8 *dst, u8 action_code, const u8 *dst, u8 action_code,
u8 dialog_token, u16 status_code, u8 dialog_token, u16 status_code,

65
wpa_supplicant/events.c
View file

@ -3148,71 +3148,6 @@ void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
wpa_s, data->remain_on_channel.freq); wpa_s, data->remain_on_channel.freq);
#endif /* CONFIG_P2P */ #endif /* CONFIG_P2P */
break; break;
#ifdef CONFIG_P2P
case EVENT_P2P_DEV_FOUND: {
struct p2p_peer_info peer_info;
os_memset(&peer_info, 0, sizeof(peer_info));
if (data->p2p_dev_found.dev_addr)
os_memcpy(peer_info.p2p_device_addr,
data->p2p_dev_found.dev_addr, ETH_ALEN);
if (data->p2p_dev_found.pri_dev_type)
os_memcpy(peer_info.pri_dev_type,
data->p2p_dev_found.pri_dev_type,
sizeof(peer_info.pri_dev_type));
if (data->p2p_dev_found.dev_name)
os_strlcpy(peer_info.device_name,
data->p2p_dev_found.dev_name,
sizeof(peer_info.device_name));
peer_info.config_methods = data->p2p_dev_found.config_methods;
peer_info.dev_capab = data->p2p_dev_found.dev_capab;
peer_info.group_capab = data->p2p_dev_found.group_capab;
/*
* FIX: new_device=1 is not necessarily correct. We should
* maintain a P2P peer database in wpa_supplicant and update
* this information based on whether the peer is truly new.
*/
wpas_dev_found(wpa_s, data->p2p_dev_found.addr, &peer_info, 1);
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,
NULL, 0);
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 */
case EVENT_EAPOL_RX: case EVENT_EAPOL_RX:
wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src, wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src,
data->eapol_rx.data, data->eapol_rx.data,

110
wpa_supplicant/p2p_supplicant.c
View file

@ -871,8 +871,6 @@ static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
return; return;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return;
switch (result) { switch (result) {
case OFFCHANNEL_SEND_ACTION_SUCCESS: case OFFCHANNEL_SEND_ACTION_SUCCESS:
@ -1329,8 +1327,6 @@ void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s)
wpa_s->parent, NULL); wpa_s->parent, NULL);
if (wpa_s->global->p2p) if (wpa_s->global->p2p)
p2p_group_formation_failed(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); wpas_group_formation_completed(wpa_s, 0);
} }
@ -1347,7 +1343,7 @@ void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s)
} }
void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res) static void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
{ {
struct wpa_supplicant *wpa_s = ctx; struct wpa_supplicant *wpa_s = ctx;
@ -1434,7 +1430,7 @@ void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
} }
void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id) static void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id)
{ {
struct wpa_supplicant *wpa_s = ctx; struct wpa_supplicant *wpa_s = ctx;
wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
@ -1444,7 +1440,7 @@ void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id)
} }
void wpas_dev_found(void *ctx, const u8 *addr, static void wpas_dev_found(void *ctx, const u8 *addr,
const struct p2p_peer_info *info, const struct p2p_peer_info *info,
int new_device) int new_device)
{ {
@ -2036,7 +2032,7 @@ static void wpas_sd_req_wfd(struct wpa_supplicant *wpa_s,
#endif /* CONFIG_WIFI_DISPLAY */ #endif /* CONFIG_WIFI_DISPLAY */
void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token, static void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
u16 update_indic, const u8 *tlvs, size_t tlvs_len) u16 update_indic, const u8 *tlvs, size_t tlvs_len)
{ {
struct wpa_supplicant *wpa_s = ctx; struct wpa_supplicant *wpa_s = ctx;
@ -2154,7 +2150,7 @@ done:
} }
void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic, static void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
const u8 *tlvs, size_t tlvs_len) const u8 *tlvs, size_t tlvs_len)
{ {
struct wpa_supplicant *wpa_s = ctx; struct wpa_supplicant *wpa_s = ctx;
@ -2222,8 +2218,6 @@ void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst, u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
const struct wpabuf *tlvs) const struct wpabuf *tlvs)
{ {
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return wpa_drv_p2p_sd_request(wpa_s, dst, tlvs);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return 0; return 0;
return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs); return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
@ -2255,8 +2249,6 @@ u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,
static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst, static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst,
const struct wpabuf *tlvs) const struct wpabuf *tlvs)
{ {
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return 0;
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return 0; return 0;
return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs); return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs);
@ -2334,8 +2326,6 @@ u64 wpas_p2p_sd_request_wifi_display(struct wpa_supplicant *wpa_s,
int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req) int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req)
{ {
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return wpa_drv_p2p_sd_cancel_request(wpa_s, req);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
return p2p_sd_cancel_request(wpa_s->global->p2p, return p2p_sd_cancel_request(wpa_s->global->p2p,
@ -2347,11 +2337,6 @@ void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
const u8 *dst, u8 dialog_token, const u8 *dst, u8 dialog_token,
const struct wpabuf *resp_tlvs) 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;
}
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return; return;
p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token, p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
@ -2361,10 +2346,6 @@ void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s) 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;
}
if (wpa_s->global->p2p) if (wpa_s->global->p2p)
p2p_sd_service_update(wpa_s->global->p2p); p2p_sd_service_update(wpa_s->global->p2p);
} }
@ -2489,7 +2470,7 @@ static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
} }
void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods, static void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
const u8 *dev_addr, const u8 *pri_dev_type, const u8 *dev_addr, const u8 *pri_dev_type,
const char *dev_name, u16 supp_config_methods, const char *dev_name, u16 supp_config_methods,
u8 dev_capab, u8 group_capab, const u8 *group_id, u8 dev_capab, u8 group_capab, const u8 *group_id,
@ -2546,7 +2527,7 @@ void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
} }
void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods) static void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
{ {
struct wpa_supplicant *wpa_s = ctx; struct wpa_supplicant *wpa_s = ctx;
unsigned int generated_pin = 0; unsigned int generated_pin = 0;
@ -3404,25 +3385,6 @@ int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
if (global->p2p) if (global->p2p)
return 0; 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(&params, 0, sizeof(params));
params.dev_name = wpa_s->conf->device_name;
os_memcpy(params.pri_dev_type, wpa_s->conf->device_type,
WPS_DEV_TYPE_LEN);
params.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
os_memcpy(params.sec_dev_type,
wpa_s->conf->sec_device_type,
params.num_sec_dev_types * WPS_DEV_TYPE_LEN);
if (wpa_drv_p2p_set_params(wpa_s, &params) < 0)
return -1;
return 0;
}
os_memset(&p2p, 0, sizeof(p2p)); os_memset(&p2p, 0, sizeof(p2p));
p2p.cb_ctx = wpa_s; p2p.cb_ctx = wpa_s;
p2p.debug_print = wpas_p2p_debug_print; p2p.debug_print = wpas_p2p_debug_print;
@ -3667,12 +3629,6 @@ static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
if (persistent_group && wpa_s->conf->persistent_reconnect) if (persistent_group && wpa_s->conf->persistent_reconnect)
persistent_group = 2; persistent_group = 2;
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);
}
/* /*
* Increase GO config timeout if HT40 is used since it takes some time * Increase GO config timeout if HT40 is used since it takes some time
* to scan channels for coex purposes before the BSS can be started. * to scan channels for coex purposes before the BSS can be started.
@ -3698,9 +3654,6 @@ static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
if (persistent_group && wpa_s->conf->persistent_reconnect) if (persistent_group && wpa_s->conf->persistent_reconnect)
persistent_group = 2; persistent_group = 2;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return -1;
return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method, return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
go_intent, own_interface_addr, force_freq, go_intent, own_interface_addr, force_freq,
persistent_group, ssid ? ssid->ssid : NULL, persistent_group, ssid ? ssid->ssid : NULL,
@ -4404,9 +4357,6 @@ static int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s,
if (timeout > wpa_s->max_remain_on_chan) if (timeout > wpa_s->max_remain_on_chan)
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); return p2p_listen(wpa_s->global->p2p, timeout);
} }
@ -4916,8 +4866,6 @@ struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
struct p2p_group *group; struct p2p_group *group;
struct p2p_group_config *cfg; struct p2p_group_config *cfg;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return NULL;
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return NULL; return NULL;
@ -5006,8 +4954,6 @@ void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
} }
if (wpa_s->global->p2p) if (wpa_s->global->p2p)
p2p_wps_success_cb(wpa_s->global->p2p, peer_addr); 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); wpas_group_formation_completed(wpa_s, 1);
} }
@ -5068,12 +5014,6 @@ int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
return 0; return 0;
} }
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
return wpa_drv_p2p_prov_disc_req(wpa_s, peer_addr,
config_methods,
use == WPAS_P2P_PD_FOR_JOIN);
}
if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
return -1; return -1;
@ -5109,9 +5049,6 @@ int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
wpas_p2p_clear_pending_action_tx(wpa_s); wpas_p2p_clear_pending_action_tx(wpa_s);
wpa_s->p2p_long_listen = 0; 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);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL || if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
wpa_s->p2p_in_provisioning) wpa_s->p2p_in_provisioning)
return -1; return -1;
@ -5132,11 +5069,6 @@ static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s)
eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
wpa_s->global->p2p_cb_on_scan_complete = 0; wpa_s->global->p2p_cb_on_scan_complete = 0;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
wpa_drv_p2p_stop_find(wpa_s);
return 1;
}
if (wpa_s->global->p2p) if (wpa_s->global->p2p)
p2p_stop_find(wpa_s->global->p2p); p2p_stop_find(wpa_s->global->p2p);
@ -5289,9 +5221,6 @@ int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
{ {
wpa_s->p2p_long_listen = 0; wpa_s->p2p_long_listen = 0;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return wpa_drv_p2p_reject(wpa_s, addr);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
@ -5347,11 +5276,6 @@ int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
if (res) if (res)
return res; return res;
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);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
@ -5429,11 +5353,6 @@ int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
} }
wpa_s->parent->pending_invite_ssid_id = -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, persistent);
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
@ -5515,8 +5434,6 @@ done:
int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1, int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
u32 interval1, u32 duration2, u32 interval2) u32 interval1, u32 duration2, u32 interval2)
{ {
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return -1;
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
@ -5534,9 +5451,6 @@ int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period, int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
unsigned int interval) unsigned int interval)
{ {
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return -1;
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
@ -5638,8 +5552,6 @@ int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
{ {
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return 0; return 0;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return 0;
if (!locally_generated) if (!locally_generated)
p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie, p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
@ -5667,8 +5579,6 @@ void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
{ {
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return; return;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return;
if (!locally_generated) if (!locally_generated)
p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie, p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
@ -5818,8 +5728,6 @@ int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
{ {
if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
return -1; return -1;
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
return -1;
wpa_s->global->cross_connection = enabled; wpa_s->global->cross_connection = enabled;
p2p_set_cross_connect(wpa_s->global->p2p, enabled); p2p_set_cross_connect(wpa_s->global->p2p, enabled);
@ -6077,7 +5985,7 @@ void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
int freq_24, int freq_5, int freq_overall) int freq_24, int freq_5, int freq_overall)
{ {
struct p2p_data *p2p = wpa_s->global->p2p; struct p2p_data *p2p = wpa_s->global->p2p;
if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)) if (p2p == NULL)
return; return;
p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall); p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall);
} }
@ -6088,7 +5996,7 @@ int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
u8 peer[ETH_ALEN]; u8 peer[ETH_ALEN];
struct p2p_data *p2p = wpa_s->global->p2p; struct p2p_data *p2p = wpa_s->global->p2p;
if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)) if (p2p == NULL)
return -1; return -1;
if (hwaddr_aton(addr, peer)) if (hwaddr_aton(addr, peer))

15
wpa_supplicant/p2p_supplicant.h
View file

@ -74,22 +74,7 @@ void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
u8 category, const u8 *data, size_t len, int freq); u8 category, const u8 *data, size_t len, int freq);
void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies); void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies);
void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s); void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s);
void wpas_dev_found(void *ctx, const u8 *addr,
const struct p2p_peer_info *info,
int new_device);
void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s); void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s);
void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res);
void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id);
void wpas_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, const u8 *group_id,
size_t group_id_len);
void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods);
void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
u16 update_indic, const u8 *tlvs, size_t tlvs_len);
void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
const u8 *tlvs, size_t tlvs_len);
u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst, u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
const struct wpabuf *tlvs); const struct wpabuf *tlvs);
u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst, u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,