}
-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)
+static void test_dev_found(void *ctx, const u8 *addr,
+ const struct p2p_peer_info *info)
{
struct wpa_driver_test_data *drv = ctx;
union wpa_event_data event;
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,
+ __func__, MAC2STR(addr), MAC2STR(info->p2p_device_addr),
+ wps_dev_type_bin2str(info->pri_dev_type, devtype,
sizeof(devtype)),
- dev_name, config_methods, dev_capab, group_capab);
+ 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 = 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;
+ 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);
}
if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
continue;
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Expiring old peer "
- "entry " MACSTR, MAC2STR(dev->p2p_device_addr));
+ "entry " MACSTR, MAC2STR(dev->info.p2p_device_addr));
dl_list_del(&dev->list);
p2p_device_free(p2p, dev);
}
os_memset(&res, 0, sizeof(res));
res.status = status;
if (peer) {
- os_memcpy(res.peer_device_addr, peer->p2p_device_addr,
+ os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr,
ETH_ALEN);
os_memcpy(res.peer_interface_addr, peer->intended_addr,
ETH_ALEN);
{
struct p2p_device *dev;
dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
- if (os_memcmp(dev->p2p_device_addr, addr, ETH_ALEN) == 0)
+ if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0)
return dev;
}
return NULL;
if (dev == NULL)
return NULL;
dl_list_add(&p2p->devices, &dev->list);
- os_memcpy(dev->p2p_device_addr, addr, ETH_ALEN);
+ os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
return dev;
}
static void p2p_copy_client_info(struct p2p_device *dev,
struct p2p_client_info *cli)
{
- os_memcpy(dev->device_name, cli->dev_name, cli->dev_name_len);
- dev->device_name[cli->dev_name_len] = '\0';
- dev->dev_capab = cli->dev_capab;
- dev->config_methods = cli->config_methods;
- os_memcpy(dev->pri_dev_type, cli->pri_dev_type, 8);
+ os_memcpy(dev->info.device_name, cli->dev_name, cli->dev_name_len);
+ dev->info.device_name[cli->dev_name_len] = '\0';
+ dev->info.dev_capab = cli->dev_capab;
+ dev->info.config_methods = cli->config_methods;
+ os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
}
dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
p2p_copy_client_info(dev, cli);
dev->oper_freq = freq;
- p2p->cfg->dev_found(
- p2p->cfg->cb_ctx, dev->p2p_device_addr,
- dev->p2p_device_addr, dev->pri_dev_type,
- dev->device_name, dev->config_methods,
- dev->dev_capab, 0);
+ p2p->cfg->dev_found(p2p->cfg->cb_ctx,
+ dev->info.p2p_device_addr,
+ &dev->info);
}
os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Update Listen frequency based on scan "
"results (" MACSTR " %d -> %d MHz (DS param %d)",
- MAC2STR(dev->p2p_device_addr), dev->listen_freq, freq,
- msg.ds_params ? *msg.ds_params : -1);
+ MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
+ freq, msg.ds_params ? *msg.ds_params : -1);
}
dev->listen_freq = freq;
if (msg.group_info)
dev->level = level;
if (msg.pri_dev_type)
- os_memcpy(dev->pri_dev_type, msg.pri_dev_type,
- sizeof(dev->pri_dev_type));
- os_memcpy(dev->device_name, msg.device_name, sizeof(dev->device_name));
- dev->config_methods = msg.config_methods ? msg.config_methods :
+ os_memcpy(dev->info.pri_dev_type, msg.pri_dev_type,
+ sizeof(dev->info.pri_dev_type));
+ os_memcpy(dev->info.device_name, msg.device_name,
+ sizeof(dev->info.device_name));
+ dev->info.config_methods = msg.config_methods ? msg.config_methods :
msg.wps_config_methods;
+
if (msg.capability) {
- dev->dev_capab = msg.capability[0];
- dev->group_capab = msg.capability[1];
+ dev->info.dev_capab = msg.capability[0];
+ dev->info.group_capab = msg.capability[1];
}
if (msg.ext_listen_timing) {
"P2P: Do not report rejected device");
return 0;
}
- p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, dev->p2p_device_addr,
- dev->pri_dev_type, dev->device_name,
- dev->config_methods, dev->dev_capab,
- dev->group_capab);
+ p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info);
dev->flags |= P2P_DEV_REPORTED;
return 0;
}
if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
- if (!(dev->dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
+ if (!(dev->info.dev_capab &
+ P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Cannot connect to P2P Device " MACSTR
" that is in a group and is not discoverable",
os_get_time(&dev->last_seen);
if (msg->pri_dev_type)
- os_memcpy(dev->pri_dev_type, msg->pri_dev_type,
- sizeof(dev->pri_dev_type));
- os_memcpy(dev->device_name, msg->device_name,
- sizeof(dev->device_name));
- dev->config_methods = msg->config_methods ? msg->config_methods :
+ os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
+ sizeof(dev->info.pri_dev_type));
+ os_memcpy(dev->info.device_name, msg->device_name,
+ sizeof(dev->info.device_name));
+ dev->info.config_methods = msg->config_methods ? msg->config_methods :
msg->wps_config_methods;
if (msg->capability) {
- dev->dev_capab = msg->capability[0];
- dev->group_capab = msg->capability[1];
+ dev->info.dev_capab = msg->capability[0];
+ dev->info.group_capab = msg->capability[1];
}
if (msg->listen_channel) {
int freq;
} else {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update "
"peer " MACSTR " Listen channel: %u -> %u MHz",
- MAC2STR(dev->p2p_device_addr),
+ MAC2STR(dev->info.p2p_device_addr),
dev->listen_freq, freq);
dev->listen_freq = freq;
}
"P2P: Created device entry based on GO Neg Req: "
MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' "
"listen_freq=%d",
- MAC2STR(dev->p2p_device_addr), dev->dev_capab,
- dev->group_capab, dev->device_name, dev->listen_freq);
+ MAC2STR(dev->info.p2p_device_addr),
+ dev->info.dev_capab, dev->info.group_capab,
+ dev->info.device_name, dev->listen_freq);
}
dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
return;
}
- p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, dev->p2p_device_addr,
- dev->pri_dev_type, dev->device_name,
- dev->config_methods, dev->dev_capab,
- dev->group_capab);
+ p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info);
}
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: GO Negotiation with " MACSTR " completed (%s will be "
- "GO)", MAC2STR(peer->p2p_device_addr),
+ "GO)", MAC2STR(peer->info.p2p_device_addr),
go ? "local end" : "peer");
os_memset(&res, 0, sizeof(res));
res.role_go = go;
- os_memcpy(res.peer_device_addr, peer->p2p_device_addr, ETH_ALEN);
+ os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
res.wps_method = peer->wps_method;
if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP)
dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
if (msg.capability) {
- dev->dev_capab = msg.capability[0];
- dev->group_capab = msg.capability[1];
+ dev->info.dev_capab = msg.capability[0];
+ dev->info.group_capab = msg.capability[1];
}
if (msg.listen_channel) {
msg.listen_channel[4]);
}
- os_memcpy(dev->device_name, msg.device_name, sizeof(dev->device_name));
+ os_memcpy(dev->info.device_name, msg.device_name,
+ sizeof(dev->info.device_name));
if (msg.wps_pri_dev_type)
- os_memcpy(dev->pri_dev_type, msg.wps_pri_dev_type,
- sizeof(dev->pri_dev_type));
+ os_memcpy(dev->info.pri_dev_type, msg.wps_pri_dev_type,
+ sizeof(dev->info.pri_dev_type));
p2p_parse_free(&msg);
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Created device entry based on Probe Req: " MACSTR
" dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d",
- MAC2STR(dev->p2p_device_addr), dev->dev_capab,
- dev->group_capab, dev->device_name, dev->listen_freq);
+ MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
+ dev->info.group_capab, dev->info.device_name,
+ dev->listen_freq);
}
if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
p2p->go_neg_peer &&
- os_memcmp(addr, p2p->go_neg_peer->p2p_device_addr, ETH_ALEN) == 0)
- {
+ os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)
+ == 0) {
/* Received a Probe Request from GO Negotiation peer */
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Found GO Negotiation peer - try to start GO "
if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
p2p->invite_peer &&
- os_memcmp(addr, p2p->invite_peer->p2p_device_addr, ETH_ALEN) == 0)
- {
+ os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)
+ == 0) {
/* Received a Probe Request from Invite peer */
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Found Invite peer - try to start Invite from "
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send "
"pending Provisioning Discovery Request to "
MACSTR " (config methods 0x%x)",
- MAC2STR(dev->p2p_device_addr),
+ MAC2STR(dev->info.p2p_device_addr),
dev->req_config_methods);
if (p2p_send_prov_disc_req(p2p, dev, 0) == 0)
return;
p2p_set_timeout(p2p, 0, 200000);
}
-
static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
{
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
p2p_add_device(p2p, bssid, freq, level, ies, ies_len);
if (p2p->go_neg_peer && p2p->state == P2P_SEARCH &&
- os_memcmp(p2p->go_neg_peer->p2p_device_addr, bssid, ETH_ALEN) == 0)
- {
+ os_memcmp(p2p->go_neg_peer->info.p2p_device_addr, bssid, ETH_ALEN)
+ == 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Found GO Negotiation peer - try to start GO "
"negotiation");
}
if (!success &&
- (dev->dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
+ (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
!is_zero_ether_addr(dev->member_in_go_dev)) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Peer " MACSTR " did not acknowledge request - "
"try to use device discoverability through its GO",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
p2p_send_dev_disc_req(p2p, dev);
return;
end = buf + buflen;
res = os_snprintf(pos, end - pos, MACSTR "\n",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
if (res < 0 || res >= end - pos)
return pos - buf;
pos += res;
MAC2STR(dev->interface_addr),
MAC2STR(dev->member_in_go_dev),
MAC2STR(dev->member_in_go_iface),
- wps_dev_type_bin2str(dev->pri_dev_type,
+ wps_dev_type_bin2str(dev->info.pri_dev_type,
devtype, sizeof(devtype)),
- dev->device_name,
- dev->config_methods,
- dev->dev_capab,
- dev->group_capab,
+ dev->info.device_name,
+ dev->info.config_methods,
+ dev->info.dev_capab,
+ dev->info.group_capab,
dev->go_neg_req_sent,
p2p_go_state_text(dev->go_state),
dev->dialog_token,
struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
if (dev == NULL)
return -1;
- os_memcpy(dev_addr, dev->p2p_device_addr, ETH_ALEN);
+ os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
return 0;
}
{
if (p2p == NULL || p2p->go_neg_peer == NULL)
return NULL;
- return p2p->go_neg_peer->p2p_device_addr;
+ return p2p->go_neg_peer->info.p2p_device_addr;
}
};
/**
+ * struct p2p_peer_info - P2P peer information
+
+ */
+struct p2p_peer_info {
+ /**
+ * p2p_device_addr - P2P Device Address of the peer
+ */
+ u8 p2p_device_addr[ETH_ALEN];
+
+ /**
+ * pri_dev_type - Primary Device Type
+ */
+ u8 pri_dev_type[8];
+
+ /**
+ * device_name - Device Name
+ */
+ char device_name[33];
+
+ /**
+ * config_methods - WPS Configuration Methods
+ */
+ u16 config_methods;
+
+ /**
+ * dev_capab - Device Capabilities
+ */
+ u8 dev_capab;
+
+ /**
+ * group_capab - Group Capabilities
+ */
+ u8 group_capab;
+};
+
+/**
* struct p2p_config - P2P configuration
*
* This configuration is provided to the P2P module during initialization with
* dev_found - Notification of a found P2P Device
* @ctx: Callback context from cb_ctx
* @addr: Source address of the message triggering this notification
- * @dev_addr: P2P Device Address of the found P2P Device
- * @pri_dev_type: Primary Device Type
- * @dev_name: Device Name
- * @config_methods: Configuration Methods
- * @dev_capab: Device Capabilities
- * @group_capab: Group Capabilities
+ * @info: P2P peer information
*
* This callback is used to notify that a new P2P Device has been
* found. This may happen, e.g., during Search state based on scan
* results or during Listen state based on receive Probe Request and
* Group Owner Negotiation Request.
*/
- void (*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);
+ void (*dev_found)(void *ctx, const u8 *addr,
+ const struct p2p_peer_info *info);
/**
* go_neg_req_rx - Notification of a receive GO Negotiation Request
len = p2p_buf_add_ie_hdr(buf);
p2p_buf_add_device_id(buf, dev_id);
- p2p_buf_add_group_id(buf, go->p2p_device_addr, go->oper_ssid,
+ p2p_buf_add_group_id(buf, go->info.p2p_device_addr, go->oper_ssid,
go->oper_ssid_len);
p2p_buf_update_ie_hdr(buf, len);
return -1;
}
- req = p2p_build_dev_disc_req(p2p, go, dev->p2p_device_addr);
+ req = p2p_build_dev_disc_req(p2p, go, dev->info.p2p_device_addr);
if (req == NULL)
return -1;
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Sending Device Discoverability Request to GO " MACSTR
" for client " MACSTR,
- MAC2STR(go->p2p_device_addr), MAC2STR(dev->p2p_device_addr));
+ MAC2STR(go->info.p2p_device_addr),
+ MAC2STR(dev->info.p2p_device_addr));
p2p->pending_client_disc_go = go;
- os_memcpy(p2p->pending_client_disc_addr, dev->p2p_device_addr,
+ os_memcpy(p2p->pending_client_disc_addr, dev->info.p2p_device_addr,
ETH_ALEN);
p2p->pending_action_state = P2P_PENDING_DEV_DISC_REQUEST;
- if (p2p_send_action(p2p, dev->oper_freq, go->p2p_device_addr,
- p2p->cfg->dev_addr, go->p2p_device_addr,
+ if (p2p_send_action(p2p, dev->oper_freq, go->info.p2p_device_addr,
+ p2p->cfg->dev_addr, go->info.p2p_device_addr,
wpabuf_head(req), wpabuf_len(req), 1000) < 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Failed to send Action frame");
MAC2STR(sa));
go = p2p->pending_client_disc_go;
- if (go == NULL || os_memcmp(sa, go->p2p_device_addr, ETH_ALEN) != 0) {
+ if (go == NULL ||
+ os_memcmp(sa, go->info.p2p_device_addr, ETH_ALEN) != 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Ignore unexpected "
"Device Discoverability Response");
return;
if (p2p->go_neg_peer == NULL ||
os_memcmp(p2p->pending_client_disc_addr,
- p2p->go_neg_peer->p2p_device_addr, ETH_ALEN) != 0 ||
- os_memcmp(p2p->go_neg_peer->member_in_go_dev, go->p2p_device_addr,
- ETH_ALEN) != 0) {
+ p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN) != 0 ||
+ os_memcmp(p2p->go_neg_peer->member_in_go_dev,
+ go->info.p2p_device_addr, ETH_ALEN) != 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: No pending "
"operation with the client discoverability peer "
"anymore");
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: No Listen/Operating frequency known for the "
"peer " MACSTR " to send GO Negotiation Request",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
return -1;
}
p2p->go_neg_peer = dev;
dev->flags |= P2P_DEV_WAIT_GO_NEG_RESPONSE;
dev->connect_reqs++;
- if (p2p_send_action(p2p, freq, dev->p2p_device_addr,
- p2p->cfg->dev_addr, dev->p2p_device_addr,
+ if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
+ p2p->cfg->dev_addr, dev->info.p2p_device_addr,
wpabuf_head(req), wpabuf_len(req), 200) < 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Failed to send Action frame");
int level;
enum p2p_wps_method wps_method;
- u8 p2p_device_addr[ETH_ALEN]; /* P2P Device Address of the peer */
- u8 pri_dev_type[8];
- char device_name[33];
- u16 config_methods;
- u8 dev_capab;
- u8 group_capab;
+ struct p2p_peer_info info;
/*
* If the peer was discovered based on an interface address (e.g., GO
if (go_dev_addr)
dev_addr = go_dev_addr;
else if (p2p->inv_role == P2P_INVITE_ROLE_CLIENT)
- dev_addr = peer->p2p_device_addr;
+ dev_addr = peer->info.p2p_device_addr;
else
dev_addr = p2p->cfg->dev_addr;
p2p_buf_add_group_id(buf, dev_addr, p2p->inv_ssid, p2p->inv_ssid_len);
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: No Listen/Operating frequency known for the "
"peer " MACSTR " to send Invitation Request",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
return -1;
}
p2p->pending_action_state = P2P_PENDING_INVITATION_REQUEST;
p2p->invite_peer = dev;
dev->invitation_reqs++;
- if (p2p_send_action(p2p, freq, dev->p2p_device_addr,
- p2p->cfg->dev_addr, dev->p2p_device_addr,
+ if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
+ p2p->cfg->dev_addr, dev->info.p2p_device_addr,
wpabuf_head(req), wpabuf_len(req), 200) < 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Failed to send Action frame");
}
if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
- if (!(dev->dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
+ if (!(dev->info.dev_capab &
+ P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Cannot invite a P2P Device " MACSTR
" that is in a group and is not discoverable",
p2p_buf_add_capability(buf, p2p->dev_capab, 0);
p2p_buf_add_device_info(buf, p2p, NULL);
if (go) {
- p2p_buf_add_group_id(buf, go->p2p_device_addr, go->oper_ssid,
- go->oper_ssid_len);
+ p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
+ go->oper_ssid, go->oper_ssid_len);
}
p2p_buf_update_ie_hdr(buf, len);
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: No Listen/Operating frequency known for the "
"peer " MACSTR " to send Provision Discovery Request",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
return -1;
}
if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
- if (!(dev->dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
+ if (!(dev->info.dev_capab &
+ P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Cannot use PD with P2P Device " MACSTR
" that is in a group and is not discoverable",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
return -1;
}
/* TODO: use device discoverability request through GO */
return -1;
p2p->pending_action_state = P2P_PENDING_PD;
- if (p2p_send_action(p2p, freq, dev->p2p_device_addr,
- p2p->cfg->dev_addr, dev->p2p_device_addr,
+ if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
+ p2p->cfg->dev_addr, dev->info.p2p_device_addr,
wpabuf_head(req), wpabuf_len(req), 200) < 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Failed to send Action frame");
{
struct p2p_sd_query *q;
- if (!(dev->dev_capab & P2P_DEV_CAPAB_SERVICE_DISCOVERY))
+ if (!(dev->info.dev_capab & P2P_DEV_CAPAB_SERVICE_DISCOVERY))
return 0; /* peer does not support SD */
for (q = p2p->sd_queries; q; q = q->next) {
if (q->for_all_peers && !(dev->flags & P2P_DEV_SD_INFO))
return q;
if (!q->for_all_peers &&
- os_memcmp(q->peer, dev->p2p_device_addr, ETH_ALEN) == 0)
+ os_memcmp(q->peer, dev->info.p2p_device_addr, ETH_ALEN) ==
+ 0)
return q;
}
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: No Listen/Operating frequency known for the "
"peer " MACSTR " to send SD Request",
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
return -1;
}
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Start Service Discovery with " MACSTR,
- MAC2STR(dev->p2p_device_addr));
+ MAC2STR(dev->info.p2p_device_addr));
req = p2p_build_sd_query(p2p->srv_update_indic, query->tlvs);
if (req == NULL)
p2p->sd_query = query;
p2p->pending_action_state = P2P_PENDING_SD;
- if (p2p_send_action(p2p, freq, dev->p2p_device_addr,
- p2p->cfg->dev_addr, dev->p2p_device_addr,
+ if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
+ p2p->cfg->dev_addr, dev->info.p2p_device_addr,
wpabuf_head(req), wpabuf_len(req), 5000) < 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Failed to send Action frame");
u16 update_indic;
if (p2p->state != P2P_SD_DURING_FIND || p2p->sd_peer == NULL ||
- os_memcmp(sa, p2p->sd_peer->p2p_device_addr, ETH_ALEN) != 0) {
+ os_memcmp(sa, p2p->sd_peer->info.p2p_device_addr, ETH_ALEN) != 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Ignore unexpected GAS Initial Response from "
MACSTR, MAC2STR(sa));
wpa_hexdump(MSG_DEBUG, "P2P: RX GAS Comeback Response", data, len);
if (p2p->state != P2P_SD_DURING_FIND || p2p->sd_peer == NULL ||
- os_memcmp(sa, p2p->sd_peer->p2p_device_addr, ETH_ALEN) != 0) {
+ os_memcmp(sa, p2p->sd_peer->info.p2p_device_addr, ETH_ALEN) != 0) {
wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
"P2P: Ignore unexpected GAS Comeback Response from "
MACSTR, MAC2STR(sa));
wpas_p2p_cancel_remain_on_channel_cb(
wpa_s, data->remain_on_channel.freq);
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);
+ 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;
+
+ wpas_dev_found(wpa_s, data->p2p_dev_found.addr, &peer_info);
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);
}
-void wpas_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)
+void wpas_dev_found(void *ctx, const u8 *addr,
+ const struct p2p_peer_info *info)
{
struct wpa_supplicant *wpa_s = ctx;
char devtype[WPS_DEV_TYPE_BUFSIZE];
+
wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
" p2p_dev_addr=" MACSTR
" pri_dev_type=%s name='%s' config_methods=0x%x "
"dev_capab=0x%x group_capab=0x%x",
- MAC2STR(addr), MAC2STR(dev_addr),
- wps_dev_type_bin2str(pri_dev_type, devtype, sizeof(devtype)),
- dev_name, config_methods, dev_capab, group_capab);
+ 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);
}
enum p2p_wps_method;
struct p2p_go_neg_results;
enum p2p_send_action_result;
+struct p2p_peer_info;
int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s);
void wpas_p2p_deinit(struct wpa_supplicant *wpa_s);
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_group_deinit(struct wpa_supplicant *wpa_s);
-void wpas_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);
+void wpas_dev_found(void *ctx, const u8 *addr,
+ const struct p2p_peer_info *info);
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,
projects / mech_eap.git / commitdiff