Lines Matching defs:dev
25 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
55 struct p2p_device *dev, *n;
60 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
61 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
64 if (dev == p2p->go_neg_peer) {
75 dev->info.p2p_device_addr)) {
80 os_get_reltime(&dev->last_seen);
86 p2p->groups[i], dev->info.p2p_device_addr))
94 os_get_reltime(&dev->last_seen);
99 MAC2STR(dev->info.p2p_device_addr));
100 dl_list_del(&dev->list);
101 p2p_device_free(p2p, dev);
162 struct p2p_device *dev = NULL;
167 dev = p2p_get_device(p2p, addr);
168 if (dev)
169 return dev->wps_prov_info;
177 struct p2p_device *dev = NULL;
182 dev = p2p_get_device(p2p, addr);
183 if (dev)
184 dev->wps_prov_info = 0;
362 struct p2p_device *dev;
363 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
364 dev->flags &= ~P2P_DEV_REPORTED;
365 dev->sd_reqs = 0;
378 struct p2p_device *dev;
379 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
380 if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0)
381 return dev;
396 struct p2p_device *dev;
397 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
398 if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0)
399 return dev;
417 struct p2p_device *dev, *oldest = NULL;
420 dev = p2p_get_device(p2p, addr);
421 if (dev)
422 return dev;
424 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
427 os_reltime_before(&dev->last_seen, &oldest->last_seen))
428 oldest = dev;
436 dev = os_zalloc(sizeof(*dev));
437 if (dev == NULL)
439 dl_list_add(&p2p->devices, &dev->list);
440 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
442 return dev;
446 static void p2p_copy_client_info(struct p2p_device *dev,
449 p2p_copy_filter_devname(dev->info.device_name,
450 sizeof(dev->info.device_name),
452 dev->info.dev_capab = cli->dev_capab;
453 dev->info.config_methods = cli->config_methods;
454 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
455 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
456 if (dev->info.wps_sec_dev_type_list_len > WPS_SEC_DEV_TYPE_MAX_LEN)
457 dev->info.wps_sec_dev_type_list_len = WPS_SEC_DEV_TYPE_MAX_LEN;
458 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
459 dev->info.wps_sec_dev_type_list_len);
470 struct p2p_device *dev;
482 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
483 if (os_memcmp(dev->member_in_go_iface, go_interface_addr,
485 os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
486 os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
495 dev = p2p_get_device(p2p, cli->p2p_device_addr);
496 if (dev) {
497 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
503 p2p_copy_client_info(dev, cli);
510 dev->info.dev_capab &=
512 dev->info.dev_capab |=
516 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
517 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
520 dev = p2p_create_device(p2p, cli->p2p_device_addr);
521 if (dev == NULL)
523 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
524 p2p_copy_client_info(dev, cli);
525 dev->oper_freq = freq;
527 dev->info.p2p_device_addr,
528 &dev->info, 1);
529 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
532 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
534 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
535 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
536 os_memcpy(dev->member_in_go_iface, go_interface_addr,
538 dev->flags |= P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT;
545 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev,
548 os_memcpy(dev->info.device_name, msg->device_name,
549 sizeof(dev->info.device_name));
552 msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
553 os_memset(dev->info.manufacturer, 0,
554 sizeof(dev->info.manufacturer));
555 os_memcpy(dev->info.manufacturer, msg->manufacturer,
560 msg->model_name_len < sizeof(dev->info.model_name)) {
561 os_memset(dev->info.model_name, 0,
562 sizeof(dev->info.model_name));
563 os_memcpy(dev->info.model_name, msg->model_name,
568 msg->model_number_len < sizeof(dev->info.model_number)) {
569 os_memset(dev->info.model_number, 0,
570 sizeof(dev->info.model_number));
571 os_memcpy(dev->info.model_number, msg->model_number,
576 msg->serial_number_len < sizeof(dev->info.serial_number)) {
577 os_memset(dev->info.serial_number, 0,
578 sizeof(dev->info.serial_number));
579 os_memcpy(dev->info.serial_number, msg->serial_number,
584 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
585 sizeof(dev->info.pri_dev_type));
587 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
588 sizeof(dev->info.pri_dev_type));
591 os_memcpy(dev->info.wps_sec_dev_type_list,
594 dev->info.wps_sec_dev_type_list_len =
603 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
604 dev->info.dev_capab |= msg->capability[0] &
606 dev->info.group_capab = msg->capability[1];
610 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
611 dev->ext_listen_interval =
620 dev->info.config_methods != new_config_methods) {
623 MAC2STR(dev->info.p2p_device_addr),
624 dev->info.config_methods,
626 dev->info.config_methods = new_config_methods;
632 static void p2p_update_peer_vendor_elems(struct p2p_device *dev, const u8 *ies,
638 wpabuf_free(dev->info.vendor_elems);
639 dev->info.vendor_elems = NULL;
665 if (wpabuf_resize(&dev->info.vendor_elems, 2 + len) < 0)
667 wpabuf_put_data(dev->info.vendor_elems, pos - 2, 2 + len);
672 static int p2p_compare_wfd_info(struct p2p_device *dev,
675 if (dev->info.wfd_subelems && msg->wfd_subelems) {
676 if (dev->info.wfd_subelems->used != msg->wfd_subelems->used)
679 return os_memcmp(dev->info.wfd_subelems->buf,
681 dev->info.wfd_subelems->used);
683 if (dev->info.wfd_subelems || msg->wfd_subelems)
712 struct p2p_device *dev;
745 dev = p2p_create_device(p2p, p2p_dev_addr);
746 if (dev == NULL) {
762 if (dev->last_seen.sec > 0 &&
763 os_reltime_before(rx_time, &dev->last_seen) &&
764 (!(dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT) ||
765 os_reltime_expired(&dev->last_seen, rx_time,
771 (unsigned int) dev->last_seen.sec,
772 (unsigned int) dev->last_seen.usec,
773 dev->flags);
778 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
780 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY |
784 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
786 msg.ssid[1] <= sizeof(dev->oper_ssid) &&
790 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
791 dev->oper_ssid_len = msg.ssid[1];
794 wpabuf_free(dev->info.p2ps_instance);
795 dev->info.p2ps_instance = NULL;
797 dev->info.p2ps_instance = wpabuf_alloc_copy(
814 if (dev->listen_freq && dev->listen_freq != freq && scan_res) {
817 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
821 dev->listen_freq = freq;
823 dev->oper_freq = freq;
825 dev->info.level = level;
827 dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name,
830 p2p_copy_wps_info(p2p, dev, 0, &msg);
833 wpabuf_free(dev->info.wps_vendor_ext[i]);
834 dev->info.wps_vendor_ext[i] = NULL;
840 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
842 if (dev->info.wps_vendor_ext[i] == NULL)
846 wfd_changed = p2p_compare_wfd_info(dev, &msg);
849 wpabuf_free(dev->info.wfd_subelems);
851 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
853 dev->info.wfd_subelems = NULL;
864 p2p_update_peer_vendor_elems(dev, ies, ies_len);
866 if (dev->flags & P2P_DEV_REPORTED && !wfd_changed &&
869 (dev->flags & P2P_DEV_P2PS_REPORTED)))
875 if (dev->flags & P2P_DEV_USER_REJECTED) {
880 if (dev->info.config_methods == 0 &&
901 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
902 !(dev->flags & P2P_DEV_REPORTED_ONCE));
903 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
906 dev->flags |= P2P_DEV_P2PS_REPORTED;
912 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
916 if (p2p->go_neg_peer == dev) {
922 if (p2p->invite_peer == dev)
924 if (p2p->sd_peer == dev)
926 if (p2p->pending_client_disc_go == dev)
930 if (dev->flags & P2P_DEV_REPORTED_ONCE)
932 dev->info.p2p_device_addr);
935 wpabuf_free(dev->info.wps_vendor_ext[i]);
936 dev->info.wps_vendor_ext[i] = NULL;
939 wpabuf_free(dev->info.wfd_subelems);
940 wpabuf_free(dev->info.vendor_elems);
941 wpabuf_free(dev->go_neg_conf);
942 wpabuf_free(dev->info.p2ps_instance);
944 os_free(dev);
1068 struct p2p_device *dev;
1084 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1085 if (dev == NULL) {
1089 p2p_connect_send(p2p, dev);
1485 * @dev: Selected peer device
1496 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,
1521 dev->flags |= P2P_DEV_FORCE_FREQ;
1523 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1529 static void p2p_set_dev_persistent(struct p2p_device *dev,
1534 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP |
1538 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1539 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN;
1542 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP |
1556 struct p2p_device *dev;
1565 dev = p2p_get_device(p2p, peer_addr);
1566 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1572 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq,
1576 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1577 if (!(dev->info.dev_capab &
1584 if (dev->oper_freq <= 0) {
1607 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1608 dev->flags &= ~P2P_DEV_USER_REJECTED;
1609 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1610 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1612 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG;
1614 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1619 dev->dialog_token++;
1620 if (dev->dialog_token == 0)
1621 dev->dialog_token = 1;
1622 dev->tie_breaker = p2p->next_tie_breaker;
1625 dev->connect_reqs = 0;
1626 dev->go_neg_req_sent = 0;
1627 dev->go_state = UNKNOWN_GO;
1628 p2p_set_dev_persistent(dev, persistent_group);
1635 dev->wps_method = wps_method;
1636 dev->oob_pw_id = oob_pw_id;
1637 dev->status = P2P_SC_SUCCESS;
1646 return p2p_connect_send(p2p, dev);
1657 struct p2p_device *dev;
1665 dev = p2p_get_device(p2p, peer_addr);
1666 if (dev == NULL) {
1672 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent ==
1685 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1686 dev->flags &= ~P2P_DEV_USER_REJECTED;
1687 dev->go_neg_req_sent = 0;
1688 dev->go_state = UNKNOWN_GO;
1689 p2p_set_dev_persistent(dev, persistent_group);
1693 dev->wps_method = wps_method;
1694 dev->oob_pw_id = oob_pw_id;
1695 dev->status = P2P_SC_SUCCESS;
1702 struct p2p_device *dev, struct p2p_message *msg)
1704 os_get_reltime(&dev->last_seen);
1706 p2p_copy_wps_info(p2p, dev, 0, msg);
1723 MAC2STR(dev->info.p2p_device_addr),
1724 dev->listen_freq, freq);
1725 dev->listen_freq = freq;
1730 wpabuf_free(dev->info.wfd_subelems);
1731 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1734 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1735 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1741 MAC2STR(dev->info.p2p_device_addr),
1742 dev->info.dev_capab, dev->info.group_capab,
1743 dev->info.device_name, dev->listen_freq);
1746 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1748 if (dev->flags & P2P_DEV_USER_REJECTED) {
1753 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1754 !(dev->flags & P2P_DEV_REPORTED_ONCE));
1755 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
2018 struct p2p_device *dev;
2039 dev = p2p_get_device(p2p, addr);
2040 if (dev) {
2044 if (dev->country[0] == 0)
2045 os_memcpy(dev->country, msg.listen_channel, 3);
2050 if (freq > 0 && dev->listen_freq != freq) {
2053 MAC2STR(addr), dev->listen_freq, freq);
2054 dev->listen_freq = freq;
2058 os_get_reltime(&dev->last_seen);
2063 dev = p2p_create_device(p2p, addr);
2064 if (dev == NULL) {
2069 os_get_reltime(&dev->last_seen);
2070 dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
2073 os_memcpy(dev->country, msg.listen_channel, 3);
2074 dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3],
2078 p2p_copy_wps_info(p2p, dev, 1, &msg);
2081 wpabuf_free(dev->info.wfd_subelems);
2082 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
2089 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
2090 dev->info.group_capab, dev->info.device_name,
2091 dev->listen_freq);
2099 struct p2p_device *dev;
2101 dev = p2p_get_device(p2p, addr);
2102 if (dev) {
2103 os_get_reltime(&dev->last_seen);
2104 return dev; /* already known */
2107 dev = p2p_create_device(p2p, addr);
2108 if (dev == NULL)
2111 p2p_add_dev_info(p2p, addr, dev, msg);
2113 return dev;
2737 p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x",
3017 struct p2p_device *dev, *prev;
3021 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
3023 dl_list_del(&dev->list);
3024 p2p_device_free(p2p, dev);
3037 struct p2p_device *dev;
3039 dev = p2p_get_device(p2p, addr);
3040 if (dev == NULL)
3045 if (p2p->go_neg_peer == dev) {
3050 dev->wps_method = WPS_NOT_READY;
3051 dev->oob_pw_id = 0;
3052 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
3053 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
3199 static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev)
3203 if (dev->sd_pending_bcast_queries == 0) {
3206 dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries;
3209 res = p2p_start_sd(p2p, dev);
3215 if (dev->req_config_methods &&
3216 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
3219 MAC2STR(dev->info.p2p_device_addr),
3220 dev->req_config_methods);
3221 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
3231 struct p2p_device *dev;
3238 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3239 if (dev == p2p->last_p2p_find_oper) {
3245 res = p2p_pre_find_operation(p2p, dev);
3247 p2p->last_p2p_find_oper = dev;
3258 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3259 res = p2p_pre_find_operation(p2p, dev);
3261 p2p->last_p2p_find_oper = dev;
3266 if (dev == p2p->last_p2p_find_oper)
3332 struct p2p_device *dev;
3339 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3341 dev->info.p2p_device_addr, ETH_ALEN) != 0)
3343 if (!dev->req_config_methods)
3348 MAC2STR(dev->info.p2p_device_addr),
3349 dev->req_config_methods);
3350 p2p_send_prov_disc_req(p2p, dev,
3351 dev->flags & P2P_DEV_PD_FOR_JOIN,
3581 struct p2p_device *dev = p2p->go_neg_peer;
3586 if (dev == NULL) {
3592 if (dev->flags & P2P_DEV_USER_REJECTED) {
3596 } else if (dev->go_neg_req_sent) {
3598 dev->go_neg_req_sent--;
3602 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
3603 !is_zero_ether_addr(dev->member_in_go_dev)) {
3605 MAC2STR(dev->info.p2p_device_addr));
3607 p2p_send_dev_disc_req(p2p, dev);
3661 struct p2p_device *dev;
3662 dev = p2p_get_device(p2p, addr);
3663 if (dev &&
3664 dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
3665 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE;
3676 struct p2p_device *dev;
3685 dev = p2p->go_neg_peer;
3693 if (dev && dev->go_neg_conf &&
3694 dev->go_neg_conf_sent <= P2P_GO_NEG_CNF_MAX_RETRY_COUNT) {
3696 dev->go_neg_conf_sent);
3698 if (p2p_send_action(p2p, dev->go_neg_conf_freq,
3699 dev->info.p2p_device_addr,
3701 dev->info.p2p_device_addr,
3702 wpabuf_head(dev->go_neg_conf),
3703 wpabuf_len(dev->go_neg_conf), 0) >=
3705 dev->go_neg_conf_sent++;
3731 if (dev == NULL)
3734 p2p_go_complete(p2p, dev);
3963 struct p2p_device *dev = p2p->go_neg_peer;
3965 if (dev == NULL) {
4016 struct p2p_device *dev;
4019 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
4021 dev->info.p2p_device_addr, ETH_ALEN) != 0)
4023 if (dev->req_config_methods &&
4024 (dev->flags & P2P_DEV_PD_FOR_JOIN))
4160 struct p2p_device *dev;
4162 dev = p2p_get_device(p2p, peer_addr);
4165 if (dev == NULL) {
4169 dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
4170 dev->flags |= P2P_DEV_USER_REJECTED;
4214 struct p2p_device *dev;
4217 dev = p2p_get_device(p2p, addr);
4219 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4221 if (dev && next) {
4222 dev = dl_list_first(&dev->list, struct p2p_device, list);
4223 if (&dev->list == &p2p->devices)
4224 dev = NULL;
4227 if (dev == NULL)
4230 return &dev->info;
4237 struct p2p_device *dev;
4245 dev = (struct p2p_device *) (((u8 *) info) -
4269 (int) (now.sec - dev->last_seen.sec),
4270 dev->listen_freq,
4271 p2p_wps_method_text(dev->wps_method),
4272 MAC2STR(dev->interface_addr),
4273 MAC2STR(dev->member_in_go_dev),
4274 MAC2STR(dev->member_in_go_iface),
4275 dev->go_neg_req_sent,
4276 p2p_go_state_text(dev->go_state),
4277 dev->dialog_token,
4278 MAC2STR(dev->intended_addr),
4279 dev->country[0] ? dev->country[0] : '_',
4280 dev->country[1] ? dev->country[1] : '_',
4281 dev->oper_freq,
4282 dev->req_config_methods,
4283 dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
4285 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
4286 dev->flags & P2P_DEV_NOT_YET_READY ?
4288 dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
4290 dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
4292 dev->flags & P2P_DEV_PD_PEER_P2PS ?
4294 dev->flags & P2P_DEV_USER_REJECTED ?
4296 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
4298 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
4300 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
4302 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
4304 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
4306 dev->flags & P2P_DEV_FORCE_FREQ ?
4308 dev->flags & P2P_DEV_PD_FOR_JOIN ?
4310 dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT ?
4312 dev->status,
4313 dev->invitation_reqs);
4318 if (dev->ext_listen_period) {
4322 dev->ext_listen_period,
4323 dev->ext_listen_interval);
4329 if (dev->oper_ssid_len) {
4332 wpa_ssid_txt(dev->oper_ssid,
4333 dev->oper_ssid_len));
4340 if (dev->info.wfd_subelems) {
4347 wpabuf_head(dev->info.wfd_subelems),
4348 wpabuf_len(dev->info.wfd_subelems));
4843 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
4844 if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
4846 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
4854 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4855 if (dev == NULL)
4857 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
4885 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4886 if (dev == NULL)
4888 if (dev->oper_freq <= 0)
4890 return dev->oper_freq;
4963 struct p2p_device *dev;
4966 dev = p2p_get_device(p2p, addr);
4967 if (!dev)
4971 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
4974 return &dev->info;
4977 dev = dl_list_first(&dev->list,
4980 if (!dev || &dev->list == &p2p->devices)
4982 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
4985 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4986 if (!dev)
4988 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
4989 dev = dl_list_first(&dev->list,
4992 if (!dev || &dev->list == &p2p->devices)
4997 return &dev->info;
5229 struct p2p_device *dev, *n;
5231 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
5232 peer_callback(&dev->info, user_data);
5325 struct p2p_device *dev;
5355 dev = p2p_create_device(p2p, p2p_dev_addr);
5356 if (dev == NULL) {
5361 params->peer = &dev->info;
5363 os_get_reltime(&dev->last_seen);
5364 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
5365 p2p_copy_wps_info(p2p, dev, 0, &msg);
5395 dev->oob_go_neg_freq = freq;
5406 dev->oob_go_neg_freq = freq;
5416 if (dev->flags & P2P_DEV_USER_REJECTED) {
5422 if (!(dev->flags & P2P_DEV_REPORTED)) {
5423 p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info,
5424 !(dev->flags & P2P_DEV_REPORTED_ONCE));
5425 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
5434 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;