Lines Matching +full:adv +full:- +full:extra +full:- +full:delay
2 * Wi-Fi Direct - P2P module
3 * Copyright (c) 2009-2010, Atheros Communications
45 * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer
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) {
73 if (p2p->cfg->go_connected &&
74 p2p->cfg->go_connected(p2p->cfg->cb_ctx,
75 dev->info.p2p_device_addr)) {
80 os_get_reltime(&dev->last_seen);
84 for (i = 0; i < p2p->num_groups; i++) {
86 p2p->groups[i], dev->info.p2p_device_addr))
89 if (i < p2p->num_groups) {
94 os_get_reltime(&dev->last_seen);
99 MAC2STR(dev->info.p2p_device_addr));
100 dl_list_del(&dev->list);
143 return p2p_state_txt(p2p->state);
149 return p2p ? p2p->p2ps_adv_list : NULL;
156 os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN);
169 return dev->wps_prov_info;
184 dev->wps_prov_info = 0;
190 p2p_dbg(p2p, "State %s -> %s",
191 p2p_state_txt(p2p->state), p2p_state_txt(new_state));
192 p2p->state = new_state;
194 if (new_state == P2P_IDLE && p2p->pending_channel) {
196 p2p->cfg->reg_class = p2p->pending_reg_class;
197 p2p->cfg->channel = p2p->pending_channel;
198 p2p->pending_reg_class = 0;
199 p2p->pending_channel = 0;
207 p2p_state_txt(p2p->state), sec, usec);
215 p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state));
223 struct p2p_device *peer = p2p->go_neg_peer;
229 if (p2p->state != P2P_SEARCH) {
238 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
239 peer->wps_method = WPS_NOT_READY;
240 peer->oob_pw_id = 0;
241 wpabuf_free(peer->go_neg_conf);
242 peer->go_neg_conf = NULL;
243 p2p->go_neg_peer = NULL;
247 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
248 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
249 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
260 p2p_state_txt(p2p->state));
262 if (p2p->pending_listen_freq) {
268 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
276 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +
277 p2p->min_disc_int) * 100;
278 if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu)
279 tu = p2p->max_disc_tu;
281 tu = 100; /* Need to wait in non-device discovery use cases */
282 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen)
283 tu = p2p->cfg->max_listen * 1000 / 1024;
295 p2p->pending_listen_freq = freq;
296 p2p->pending_listen_sec = 0;
297 p2p->pending_listen_usec = 1024 * tu;
299 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,
302 p2p->pending_listen_freq = 0;
304 p2p->pending_listen_wait_drv = true;
317 if (p2p->pending_listen_freq) {
320 return -1;
323 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
326 return -1;
329 p2p->pending_listen_sec = timeout / 1000;
330 p2p->pending_listen_usec = (timeout % 1000) * 1000;
332 if (p2p->p2p_scan_running) {
333 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) {
334 p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen");
337 p2p_dbg(p2p, "p2p_scan running - delay start of listen state");
338 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;
344 return -1;
346 p2p->pending_listen_freq = freq;
348 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
350 p2p->pending_listen_freq = 0;
352 return -1;
354 p2p->pending_listen_wait_drv = true;
366 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
367 dev->flags &= ~P2P_DEV_REPORTED;
368 dev->sd_reqs = 0;
374 * p2p_get_device - Fetch a peer entry
382 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
383 if (ether_addr_equal(dev->info.p2p_device_addr, addr))
391 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address
400 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
401 if (ether_addr_equal(dev->interface_addr, addr))
409 * p2p_create_device - Create a peer entry
427 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
430 os_reltime_before(&dev->last_seen, &oldest->last_seen))
433 if (count + 1 > p2p->cfg->max_peers && oldest) {
436 MACSTR, MAC2STR(oldest->info.p2p_device_addr));
437 dl_list_del(&oldest->list);
444 dl_list_add(&p2p->devices, &dev->list);
445 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
446 dev->support_6ghz = false;
455 p2p_copy_filter_devname(dev->info.device_name,
456 sizeof(dev->info.device_name),
457 cli->dev_name, cli->dev_name_len);
458 dev->info.dev_capab = cli->dev_capab;
459 dev->info.config_methods = cli->config_methods;
460 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
461 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
462 if (dev->info.wps_sec_dev_type_list_len > WPS_SEC_DEV_TYPE_MAX_LEN)
463 dev->info.wps_sec_dev_type_list_len = WPS_SEC_DEV_TYPE_MAX_LEN;
464 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
465 dev->info.wps_sec_dev_type_list_len);
482 return -1;
488 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
489 if (ether_addr_equal(dev->member_in_go_iface,
491 os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
492 os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
498 if (ether_addr_equal(cli->p2p_device_addr, p2p->cfg->dev_addr))
500 dev = p2p_get_device(p2p, cli->p2p_device_addr);
502 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
515 dev->info.dev_capab &=
517 dev->info.dev_capab |=
518 cli->dev_capab &
521 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
522 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
525 dev = p2p_create_device(p2p, cli->p2p_device_addr);
528 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
530 dev->oper_freq = freq;
531 p2p->cfg->dev_found(p2p->cfg->cb_ctx,
532 dev->info.p2p_device_addr,
533 &dev->info, 1);
534 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
537 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
539 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
540 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
541 os_memcpy(dev->member_in_go_iface, go_interface_addr,
543 dev->flags |= P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT;
553 os_memcpy(dev->info.device_name, msg->device_name,
554 sizeof(dev->info.device_name));
556 if (msg->manufacturer &&
557 msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
558 os_memset(dev->info.manufacturer, 0,
559 sizeof(dev->info.manufacturer));
560 os_memcpy(dev->info.manufacturer, msg->manufacturer,
561 msg->manufacturer_len);
564 if (msg->model_name &&
565 msg->model_name_len < sizeof(dev->info.model_name)) {
566 os_memset(dev->info.model_name, 0,
567 sizeof(dev->info.model_name));
568 os_memcpy(dev->info.model_name, msg->model_name,
569 msg->model_name_len);
572 if (msg->model_number &&
573 msg->model_number_len < sizeof(dev->info.model_number)) {
574 os_memset(dev->info.model_number, 0,
575 sizeof(dev->info.model_number));
576 os_memcpy(dev->info.model_number, msg->model_number,
577 msg->model_number_len);
580 if (msg->serial_number &&
581 msg->serial_number_len < sizeof(dev->info.serial_number)) {
582 os_memset(dev->info.serial_number, 0,
583 sizeof(dev->info.serial_number));
584 os_memcpy(dev->info.serial_number, msg->serial_number,
585 msg->serial_number_len);
588 if (msg->pri_dev_type)
589 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
590 sizeof(dev->info.pri_dev_type));
591 else if (msg->wps_pri_dev_type)
592 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
593 sizeof(dev->info.pri_dev_type));
595 if (msg->wps_sec_dev_type_list) {
596 os_memcpy(dev->info.wps_sec_dev_type_list,
597 msg->wps_sec_dev_type_list,
598 msg->wps_sec_dev_type_list_len);
599 dev->info.wps_sec_dev_type_list_len =
600 msg->wps_sec_dev_type_list_len;
603 if (msg->capability) {
608 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
609 dev->info.dev_capab |= msg->capability[0] &
611 dev->info.group_capab = msg->capability[1];
616 if (msg->ext_listen_timing) {
617 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
618 dev->ext_listen_interval =
619 WPA_GET_LE16(msg->ext_listen_timing + 2);
624 new_config_methods = msg->config_methods ?
625 msg->config_methods : msg->wps_config_methods;
627 dev->info.config_methods != new_config_methods) {
629 " config_methods 0x%x -> 0x%x",
630 MAC2STR(dev->info.p2p_device_addr),
631 dev->info.config_methods,
633 dev->info.config_methods = new_config_methods;
642 if (msg->capability &&
643 (msg->capability[0] & P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE))
644 dev->support_6ghz = true;
654 wpabuf_free(dev->info.vendor_elems);
655 dev->info.vendor_elems = NULL;
659 for (pos = ies; end - pos > 1; pos += len) {
663 if (len > end - pos)
680 /* Unknown vendor element - make raw IE data available */
681 if (wpabuf_resize(&dev->info.vendor_elems, 2 + len) < 0)
683 wpabuf_put_data(dev->info.vendor_elems, pos - 2, 2 + len);
684 if (wpabuf_size(dev->info.vendor_elems) > 2000)
693 if (dev->info.wfd_subelems && msg->wfd_subelems) {
694 if (dev->info.wfd_subelems->used != msg->wfd_subelems->used)
697 return os_memcmp(dev->info.wfd_subelems->buf,
698 msg->wfd_subelems->buf,
699 dev->info.wfd_subelems->used);
701 if (dev->info.wfd_subelems || msg->wfd_subelems)
709 * p2p_add_device - Add peer entries based on scan results or P2P frames
719 * Returns: 0 on success, -1 on failure
742 return -1;
752 return -1;
755 if (!is_zero_ether_addr(p2p->peer_filter) &&
756 !ether_addr_equal(p2p_dev_addr, p2p->peer_filter)) {
766 return -1;
780 if (dev->last_seen.sec > 0 &&
781 os_reltime_before(rx_time, &dev->last_seen) &&
782 (!(dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT) ||
783 os_reltime_expired(&dev->last_seen, rx_time,
787 (unsigned int) rx_time->sec,
788 (unsigned int) rx_time->usec,
789 (unsigned int) dev->last_seen.sec,
790 (unsigned int) dev->last_seen.usec,
791 dev->flags);
793 return -1;
796 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
798 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY |
802 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
804 msg.ssid[1] <= sizeof(dev->oper_ssid) &&
808 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
809 dev->oper_ssid_len = msg.ssid[1];
812 wpabuf_free(dev->info.p2ps_instance);
813 dev->info.p2ps_instance = NULL;
815 dev->info.p2ps_instance = wpabuf_alloc_copy(
826 p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz",
832 if (dev->listen_freq && dev->listen_freq != freq && scan_res) {
834 MACSTR " %d -> %d MHz (DS param %d)",
835 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
836 freq, msg.ds_params ? *msg.ds_params : -1);
839 dev->listen_freq = freq;
841 dev->oper_freq = freq;
843 dev->info.level = level;
845 dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name,
851 wpabuf_free(dev->info.wps_vendor_ext[i]);
852 dev->info.wps_vendor_ext[i] = NULL;
858 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
860 if (dev->info.wps_vendor_ext[i] == NULL)
867 wpabuf_free(dev->info.wfd_subelems);
869 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
871 dev->info.wfd_subelems = NULL;
884 if (dev->flags & P2P_DEV_REPORTED && !wfd_changed &&
887 (dev->flags & P2P_DEV_P2PS_REPORTED)))
891 freq, (unsigned int) rx_time->sec,
892 (unsigned int) rx_time->usec);
893 if (dev->flags & P2P_DEV_USER_REJECTED) {
898 if (dev->info.config_methods == 0 &&
903 * applications use config_methods value from P2P-DEVICE-FOUND
919 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
920 !(dev->flags & P2P_DEV_REPORTED_ONCE));
921 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
924 dev->flags |= P2P_DEV_P2PS_REPORTED;
934 if (p2p->go_neg_peer == dev) {
938 p2p_go_neg_failed(p2p, -1);
940 if (p2p->invite_peer == dev)
941 p2p->invite_peer = NULL;
942 if (p2p->sd_peer == dev)
943 p2p->sd_peer = NULL;
944 if (p2p->pending_client_disc_go == dev)
945 p2p->pending_client_disc_go = NULL;
948 if (dev->flags & P2P_DEV_REPORTED_ONCE)
949 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
950 dev->info.p2p_device_addr);
953 wpabuf_free(dev->info.wps_vendor_ext[i]);
954 dev->info.wps_vendor_ext[i] = NULL;
957 wpabuf_free(dev->info.wfd_subelems);
958 wpabuf_free(dev->info.vendor_elems);
959 wpabuf_free(dev->go_neg_conf);
960 wpabuf_free(dev->info.p2ps_instance);
976 c = &p2p->cfg->channels;
977 for (cl = 0; cl < c->reg_classes; cl++) {
978 cla = &c->reg_class[cl];
979 if (cla->reg_class != p2p->last_prog_scan_class)
981 for (ch = 0; ch < cla->channels; ch++) {
982 if (cla->channel[ch] == p2p->last_prog_scan_chan) {
993 reg_class = c->reg_class[0].reg_class;
994 channel = c->reg_class[0].channel[0];
998 if (ch == cla->channels) {
1000 if (cl == c->reg_classes)
1004 reg_class = c->reg_class[cl].reg_class;
1005 channel = c->reg_class[cl].channel[ch];
1009 p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz",
1011 p2p->last_prog_scan_class = reg_class;
1012 p2p->last_prog_scan_chan = channel;
1027 if (p2p->drv_in_listen) {
1028 p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing");
1031 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1032 p2p->pending_listen_wait_drv = false;
1034 if (p2p->find_pending_full &&
1035 (p2p->find_type == P2P_FIND_PROGRESSIVE ||
1036 p2p->find_type == P2P_FIND_START_WITH_FULL)) {
1039 p2p->find_pending_full = 0;
1040 } else if ((p2p->find_type == P2P_FIND_PROGRESSIVE &&
1042 (p2p->find_type == P2P_FIND_START_WITH_FULL &&
1043 (freq = p2p->find_specified_freq) > 0)) {
1051 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
1052 p2p->num_req_dev_types, p2p->req_dev_types,
1053 p2p->find_dev_id, pw_id, p2p->include_6ghz);
1064 p2p_dbg(p2p, "Find timeout -> stop");
1077 p2p->p2p_scan_running = 1;
1090 op = p2p->start_after_scan;
1091 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1097 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
1098 p2p->pending_listen_usec / 1000);
1102 MAC2STR(p2p->after_scan_peer));
1103 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1120 p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running);
1121 running = p2p->p2p_scan_running;
1123 p2p->p2p_scan_running = 0;
1132 p2p->num_req_dev_types = 0;
1133 os_free(p2p->req_dev_types);
1134 p2p->req_dev_types = NULL;
1149 os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN);
1160 str_buf[i] = str[i] - 'A' + 'a';
1183 if (p2p->p2p_scan_running) {
1189 p2p->req_dev_types = os_memdup(req_dev_types,
1192 if (p2p->req_dev_types == NULL)
1193 return -1;
1194 p2p->num_req_dev_types = num_req_dev_types;
1198 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);
1199 p2p->find_dev_id = p2p->find_dev_id_buf;
1201 p2p->find_dev_id = NULL;
1202 p2p->include_6ghz = p2p_wfd_enabled(p2p) && include_6ghz;
1205 p2p->p2ps_seek = 0;
1212 p2p->p2ps_seek_count = 0;
1213 p2p->p2ps_seek = 1;
1224 os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN],
1229 p2p->p2ps_seek_count = count;
1230 p2p->p2ps_seek = 1;
1232 p2p->p2ps_seek_count = 0;
1233 p2p->p2ps_seek = 1;
1237 if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) {
1238 p2p->p2ps_seek_count = 1;
1239 os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash,
1243 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1245 if (p2p->pending_listen_freq) {
1247 p2p->pending_listen_freq = 0;
1249 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1250 p2p->pending_listen_wait_drv = false;
1251 p2p->find_pending_full = 0;
1252 p2p->find_type = type;
1254 p2p->find_specified_freq = freq;
1256 p2p->find_specified_freq = 0;
1258 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
1260 p2p->search_delay = search_delay;
1261 p2p->in_search_delay = 0;
1263 p2p->last_p2p_find_timeout = timeout;
1275 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx,
1277 p2p->num_req_dev_types,
1278 p2p->req_dev_types, dev_id,
1280 p2p->include_6ghz);
1285 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
1286 p2p->num_req_dev_types,
1287 p2p->req_dev_types, dev_id,
1288 DEV_PW_DEFAULT, p2p->include_6ghz);
1291 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
1292 p2p->num_req_dev_types,
1293 p2p->req_dev_types, dev_id,
1294 DEV_PW_DEFAULT, p2p->include_6ghz);
1297 return -1;
1301 p2p->find_start = start;
1303 if (res != 0 && p2p->p2p_scan_running) {
1304 p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running");
1308 p2p->find_pending_full = 1;
1325 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
1326 p2p->cfg->find_stopped(p2p->cfg->cb_ctx);
1328 p2p->p2ps_seek_count = 0;
1332 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1333 if (p2p->go_neg_peer)
1334 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
1335 p2p->go_neg_peer = NULL;
1336 p2p->sd_peer = NULL;
1337 p2p->invite_peer = NULL;
1339 p2p->send_action_in_progress = 0;
1347 __func__, freq, p2p->pending_listen_freq, p2p->in_listen,
1348 p2p->drv_in_listen);
1350 ((p2p->drv_in_listen == freq && p2p->in_listen) ||
1351 p2p->pending_listen_freq == (unsigned int) freq)) {
1355 if (p2p->in_listen) {
1356 p2p->in_listen = 0;
1359 if (p2p->drv_in_listen) {
1365 p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen);
1366 p2p->drv_in_listen = 0;
1368 if (p2p->pending_listen_freq &&
1369 p2p->pending_listen_freq != (unsigned int) freq &&
1370 !p2p->drv_in_listen && p2p->pending_listen_wait_drv) {
1373 p2p->pending_listen_freq = 0;
1375 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1376 p2p->pending_listen_wait_drv = false;
1382 if (p2p->state != P2P_LISTEN_ONLY) {
1394 p2p->pending_listen_freq = 0;
1406 p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d",
1410 return -1;
1413 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) &&
1414 (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class,
1418 return -1;
1421 p2p->op_reg_class = op_class;
1422 p2p->op_channel = op_channel;
1425 p2p->channels.reg_classes = 1;
1426 p2p->channels.reg_class[0].channels = 1;
1427 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
1428 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
1430 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels,
1431 p2p->allow_6ghz);
1449 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
1450 p2p_supported_freq(p2p, p2p->best_freq_overall) &&
1451 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel)
1454 p2p->op_reg_class = op_class;
1455 p2p->op_channel = op_channel;
1456 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
1457 p2p_supported_freq(p2p, p2p->best_freq_5) &&
1458 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel)
1461 p2p->op_reg_class = op_class;
1462 p2p->op_channel = op_channel;
1463 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 &&
1464 p2p_supported_freq(p2p, p2p->best_freq_24) &&
1465 p2p_freq_to_channel(p2p->best_freq_24, &op_class,
1468 p2p->op_reg_class = op_class;
1469 p2p->op_channel = op_channel;
1470 } else if (p2p->cfg->num_pref_chan > 0 &&
1471 p2p_channels_includes(&p2p->cfg->channels,
1472 p2p->cfg->pref_chan[0].op_class,
1473 p2p->cfg->pref_chan[0].chan)) {
1475 p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class;
1476 p2p->op_channel = p2p->cfg->pref_chan[0].chan;
1477 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_edmg,
1478 &p2p->op_reg_class, &p2p->op_channel) ==
1481 p2p->op_reg_class, p2p->op_channel);
1482 } else if (p2p->allow_6ghz &&
1483 (p2p_channel_select(&p2p->cfg->channels, op_classes_6ghz,
1484 &p2p->op_reg_class, &p2p->op_channel) ==
1487 p2p->op_reg_class, p2p->op_channel);
1488 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht,
1489 &p2p->op_reg_class, &p2p->op_channel) ==
1492 p2p->op_reg_class, p2p->op_channel);
1493 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40,
1494 &p2p->op_reg_class, &p2p->op_channel) ==
1497 p2p->op_reg_class, p2p->op_channel);
1498 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz,
1499 &p2p->op_reg_class, &p2p->op_channel) ==
1502 p2p->op_reg_class, p2p->op_channel);
1503 } else if (p2p_channels_includes(&p2p->cfg->channels,
1504 p2p->cfg->op_reg_class,
1505 p2p->cfg->op_channel)) {
1506 p2p_dbg(p2p, "Select pre-configured channel as operating channel preference");
1507 p2p->op_reg_class = p2p->cfg->op_reg_class;
1508 p2p->op_channel = p2p->cfg->op_channel;
1509 } else if (p2p_channel_random_social(&p2p->cfg->channels,
1510 &p2p->op_reg_class,
1511 &p2p->op_channel,
1514 p2p->op_reg_class, p2p->op_channel);
1518 if (p2p_channel_select(&p2p->cfg->channels, NULL,
1519 &p2p->op_reg_class,
1520 &p2p->op_channel) == 0)
1523 p2p->op_channel, p2p->op_reg_class);
1526 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, p2p->allow_6ghz);
1531 * p2p_prepare_channel - Select operating channel for GO Negotiation or P2PS PD
1537 * Returns: 0 on success, -1 on failure (channel not supported for P2P)
1547 p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d",
1552 return -1;
1556 p2p_channels_dump(p2p, "prepared channels", &p2p->channels);
1558 p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq);
1560 p2p_channels_union_inplace(&p2p->channels,
1561 &p2p->cfg->cli_channels);
1562 p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels);
1565 p2p->op_reg_class, p2p->op_channel,
1569 dev->flags |= P2P_DEV_FORCE_FREQ;
1571 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1582 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP |
1586 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1587 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN;
1590 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP |
1606 p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR
1612 p2p->allow_6ghz);
1615 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1618 return -1;
1623 return -1;
1625 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1626 if (!(dev->info.dev_capab &
1631 return -1;
1633 if (dev->oper_freq <= 0) {
1637 return -1;
1647 p2p->ssid_set = 0;
1651 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1652 p2p->ssid_len = force_ssid_len;
1653 p2p->ssid_set = 1;
1656 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1657 dev->flags &= ~P2P_DEV_USER_REJECTED;
1658 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1659 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1661 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG;
1663 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1668 dev->dialog_token++;
1669 if (dev->dialog_token == 0)
1670 dev->dialog_token = 1;
1671 dev->tie_breaker = p2p->next_tie_breaker;
1672 p2p->next_tie_breaker = !p2p->next_tie_breaker;
1674 dev->connect_reqs = 0;
1675 dev->go_neg_req_sent = 0;
1676 dev->go_state = UNKNOWN_GO;
1678 p2p->go_intent = go_intent;
1679 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1681 if (p2p->state != P2P_IDLE)
1684 dev->wps_method = wps_method;
1685 dev->oob_pw_id = oob_pw_id;
1686 dev->status = P2P_SC_SUCCESS;
1688 if (p2p->p2p_scan_running) {
1689 p2p_dbg(p2p, "p2p_scan running - delay connect send");
1690 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1691 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1708 p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR
1712 wps_method, persistent_group, oob_pw_id, p2p->allow_6ghz);
1718 return -1;
1723 return -1;
1725 p2p->ssid_set = 0;
1729 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1730 p2p->ssid_len = force_ssid_len;
1731 p2p->ssid_set = 1;
1734 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1735 dev->flags &= ~P2P_DEV_USER_REJECTED;
1736 dev->go_neg_req_sent = 0;
1737 dev->go_state = UNKNOWN_GO;
1739 p2p->go_intent = go_intent;
1740 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1742 dev->wps_method = wps_method;
1743 dev->oob_pw_id = oob_pw_id;
1744 dev->status = P2P_SC_SUCCESS;
1753 os_get_reltime(&dev->last_seen);
1757 if (msg->listen_channel) {
1759 freq = p2p_channel_to_freq(msg->listen_channel[3],
1760 msg->listen_channel[4]);
1764 msg->listen_channel[0],
1765 msg->listen_channel[1],
1766 msg->listen_channel[2],
1767 msg->listen_channel[3],
1768 msg->listen_channel[4]);
1771 " Listen channel: %u -> %u MHz",
1772 MAC2STR(dev->info.p2p_device_addr),
1773 dev->listen_freq, freq);
1774 dev->listen_freq = freq;
1778 if (msg->wfd_subelems) {
1779 wpabuf_free(dev->info.wfd_subelems);
1780 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1783 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1784 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1790 MAC2STR(dev->info.p2p_device_addr),
1791 dev->info.dev_capab, dev->info.group_capab,
1792 dev->info.device_name, dev->listen_freq);
1795 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1797 if (dev->flags & P2P_DEV_USER_REJECTED) {
1802 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1803 !(dev->flags & P2P_DEV_REPORTED_ONCE));
1804 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
1813 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1814 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1820 if (p2p->ssid_set) {
1821 os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len);
1822 params->ssid_len = p2p->ssid_len;
1824 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len);
1826 p2p->ssid_set = 0;
1828 p2p_random(params->passphrase, p2p->cfg->passphrase_len);
1829 params->passphrase[p2p->cfg->passphrase_len] = '\0';
1837 int go = peer->go_state == LOCAL_GO;
1841 MAC2STR(peer->info.p2p_device_addr), go ? "local end" : "peer");
1845 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
1846 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
1847 res.wps_method = peer->wps_method;
1848 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
1849 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
1857 res.freq = p2p_channel_to_freq(p2p->op_reg_class,
1858 p2p->op_channel);
1859 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1860 res.ssid_len = p2p->ssid_len;
1861 p2p_random(res.passphrase, p2p->cfg->passphrase_len);
1862 res.passphrase[p2p->cfg->passphrase_len] = '\0';
1864 res.freq = peer->oper_freq;
1865 if (p2p->ssid_len) {
1866 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1867 res.ssid_len = p2p->ssid_len;
1871 p2p_channels_dump(p2p, "own channels", &p2p->channels);
1872 p2p_channels_dump(p2p, "peer channels", &peer->channels);
1873 p2p_channels_intersect(&p2p->channels, &peer->channels,
1876 p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq);
1877 p2p_channels_dump(p2p, "intersection after no-GO removal",
1884 res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout;
1887 p2p->ssid_set = 0;
1888 peer->go_neg_req_sent = 0;
1889 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
1890 peer->wps_method = WPS_NOT_READY;
1891 peer->oob_pw_id = 0;
1892 wpabuf_free(peer->go_neg_conf);
1893 peer->go_neg_conf = NULL;
1896 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
1911 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
1914 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
1917 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
1920 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
1924 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
1927 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1930 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
1933 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1936 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
1956 len--;
1963 len -= 4;
1968 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
1971 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
1974 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
1977 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
2001 len -= 4;
2011 p2p_dbg(p2p, "Received P2P Action - Notice of Absence");
2015 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
2018 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
2021 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
2024 p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]);
2033 if (p2p->go_neg_peer == NULL)
2035 if (p2p->pending_listen_freq) {
2037 p2p->pending_listen_freq = 0;
2039 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
2040 p2p->pending_listen_wait_drv = false;
2041 p2p->go_neg_peer->status = P2P_SC_SUCCESS;
2047 p2p_connect_send(p2p, p2p->go_neg_peer);
2054 if (p2p->invite_peer == NULL)
2056 if (p2p->pending_listen_freq) {
2058 p2p->pending_listen_freq = 0;
2060 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
2061 p2p->pending_listen_wait_drv = false;
2062 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr,
2063 p2p->invite_dev_pw_id);
2097 if (dev->country[0] == 0)
2098 os_memcpy(dev->country, msg.listen_channel, 3);
2103 if (freq > 0 && dev->listen_freq != freq) {
2105 "Updated peer " MACSTR " Listen channel (Probe Request): %d -> %d MHz",
2106 MAC2STR(addr), dev->listen_freq, freq);
2107 dev->listen_freq = freq;
2112 os_get_reltime(&dev->last_seen);
2123 os_get_reltime(&dev->last_seen);
2124 dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
2127 os_memcpy(dev->country, msg.listen_channel, 3);
2128 dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3],
2135 wpabuf_free(dev->info.wfd_subelems);
2136 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
2143 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
2144 dev->info.group_capab, dev->info.device_name,
2145 dev->listen_freq);
2157 os_get_reltime(&dev->last_seen);
2178 return 1; /* Category match with wildcard OUI/sub-category */
2196 * p2p_match_dev_type - Match local device type with requested type
2214 return 1; /* no Requested Device Type attributes -> match */
2216 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
2220 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) {
2221 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
2238 int pw_id = -1;
2239 size_t extra = 0;
2242 if (p2p->wfd_ie_probe_resp)
2243 extra = wpabuf_len(p2p->wfd_ie_probe_resp);
2246 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2247 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2250 extra += MAX_SVC_ADV_IE_LEN;
2252 buf = wpabuf_alloc(1000 + extra);
2256 if (p2p->go_neg_peer) {
2258 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
2268 if (p2p->wfd_ie_probe_resp)
2269 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp);
2272 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2274 p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2278 p2p_buf_add_capability(buf, p2p->dev_capab &
2280 if (p2p->ext_listen_interval)
2281 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
2282 p2p->ext_listen_interval);
2288 p2p->p2ps_adv_list);
2304 resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) |
2306 os_memcpy(resp->da, addr, ETH_ALEN);
2307 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
2308 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
2309 resp->u.probe_resp.beacon_int = host_to_le16(100);
2310 /* hardware or low-level driver will setup seq_ctrl and timestamp */
2311 resp->u.probe_resp.capab_info =
2332 channel = p2p->cfg->channel;
2335 return -1;
2352 p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list);
2354 /* Wildcard org.wi-fi.wfds matches any WFA spec defined service */
2355 any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0;
2357 adv_data = p2p->p2ps_adv_list;
2359 if (os_memcmp(hash, adv_data->hash, P2PS_HASH_LEN) == 0)
2362 os_strncmp(adv_data->svc_name, P2PS_WILD_HASH_STR,
2365 adv_data = adv_data->next;
2385 p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it");
2390 /* not a P2P probe - ignore it */
2391 p2p_dbg(p2p, "Not a P2P probe - ignore it");
2396 !ether_addr_equal(dst, p2p->cfg->dev_addr)) {
2399 p2p_dbg(p2p, "Probe Req DA " MACSTR " not ours - ignore it",
2406 p2p_dbg(p2p, "Probe Req BSSID " MACSTR " not wildcard - ignore it",
2414 /* not using P2P Wildcard SSID - ignore */
2415 p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it");
2421 p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it");
2428 p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it");
2438 p2p->in_listen, p2p->drv_in_listen, rx_freq,
2439 p2p->cfg->channel, p2p->pending_listen_freq);
2441 if (!p2p->in_listen && !p2p->drv_in_listen &&
2442 p2p->pending_listen_freq && rx_freq &&
2443 rx_freq != p2p->pending_listen_freq) {
2445 rx_freq, p2p->pending_listen_freq);
2470 if (!p2p->in_listen || !p2p->drv_in_listen) {
2471 /* not in Listen state - ignore Probe Request */
2472 p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request",
2473 p2p->in_listen, p2p->drv_in_listen);
2480 !ether_addr_equal(msg.device_id, p2p->cfg->dev_addr)) {
2482 p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR " did not match - ignore it",
2492 p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it");
2497 if (!p2p->cfg->send_probe_resp) {
2499 p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response");
2532 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq);
2562 * same address for P2P and non-P2P STA running simultaneously. The
2567 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
2568 p2p->go_neg_peer &&
2569 ether_addr_equal(addr, p2p->go_neg_peer->info.p2p_device_addr) &&
2570 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
2572 p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout");
2578 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
2579 p2p->invite_peer &&
2580 (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) &&
2581 ether_addr_equal(addr, p2p->invite_peer->info.p2p_device_addr)) {
2583 p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout");
2617 * (Re)Association Request - P2P IE
2624 return -1;
2628 if (p2p->num_groups > 0) {
2630 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2631 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
2632 p2p->cross_connect)
2635 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
2636 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2637 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
2643 res = -1;
2662 size_t extra = 0;
2668 if (p2p->wfd_ie_assoc_req)
2669 extra = wpabuf_len(p2p->wfd_ie_assoc_req);
2672 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2673 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2676 * (Re)Association Request - P2P IE
2681 tmp = wpabuf_alloc(200 + extra);
2683 return -1;
2686 if (p2p->wfd_ie_assoc_req)
2687 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req);
2690 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2692 p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2697 p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
2698 if (p2p->ext_listen_interval)
2699 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
2700 p2p->ext_listen_interval);
2706 res = -1;
2740 adv_data = p2p->p2ps_adv_list;
2742 if (adv_data->id == adv_id)
2744 adv_data = adv_data->next;
2757 return -1;
2759 adv_data = p2p->p2ps_adv_list;
2760 prior = &p2p->p2ps_adv_list;
2762 if (adv_data->id == adv_id) {
2764 *prior = adv_data->next;
2768 prior = &adv_data->next;
2769 adv_data = adv_data->next;
2772 return -1;
2786 return -1;
2788 if (!(config_methods & p2p->cfg->config_methods)) {
2790 config_methods, p2p->cfg->config_methods);
2791 return -1;
2795 return -1;
2805 return -1;
2807 os_memcpy(adv_data->hash, buf, P2PS_HASH_LEN);
2808 adv_data->id = adv_id;
2809 adv_data->state = svc_state;
2810 adv_data->config_methods = config_methods & p2p->cfg->config_methods;
2811 adv_data->auto_accept = (u8) auto_accept;
2812 os_memcpy(adv_data->svc_name, adv_str, adv_len);
2815 adv_data->cpt_priority[i] = cpt_priority[i];
2816 adv_data->cpt_mask |= cpt_priority[i];
2820 adv_data->svc_info = &adv_data->svc_name[adv_len + 1];
2821 os_memcpy(adv_data->svc_info, svc_info, info_len);
2828 tmp = p2p->p2ps_adv_list;
2829 prev = &p2p->p2ps_adv_list;
2831 if (tmp->id == adv_data->id) {
2832 if (os_strcmp(tmp->svc_name, adv_data->svc_name) != 0) {
2834 return -1;
2836 adv_data->next = tmp->next;
2841 if (os_strcmp(tmp->svc_name, adv_data->svc_name) == 0) {
2842 adv_data->next = tmp->next;
2843 tmp->next = adv_data;
2847 prev = &tmp->next;
2848 tmp = tmp->next;
2852 adv_data->next = p2p->p2ps_adv_list;
2853 p2p->p2ps_adv_list = adv_data;
2858 adv_id, adv_data->config_methods, svc_state, adv_str,
2859 adv_data->cpt_mask);
2867 struct p2ps_advertisement *adv, *prev;
2872 adv = p2p->p2ps_adv_list;
2873 while (adv) {
2874 prev = adv;
2875 adv = adv->next;
2879 p2p->p2ps_adv_list = NULL;
2891 return -1;
2900 return -1;
2912 return -1;
2921 p2p->go_neg_peer = NULL;
2929 if (p2p->go_neg_peer == NULL) {
2930 p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification");
2934 if (!ether_addr_equal(mac_addr, p2p->go_neg_peer->intended_addr)) {
2938 MAC2STR(p2p->go_neg_peer->intended_addr));
2951 if (p2p->go_neg_peer == NULL) {
2952 p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification");
2957 MAC2STR(p2p->go_neg_peer->intended_addr));
2966 return p2p->cfg->p2p_6ghz_disable;
2975 if (cfg->max_peers < 1 ||
2976 cfg->passphrase_len < 8 || cfg->passphrase_len > 63)
2982 p2p->cfg = (struct p2p_config *) (p2p + 1);
2983 os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
2984 if (cfg->dev_name)
2985 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
2986 if (cfg->manufacturer)
2987 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
2988 if (cfg->model_name)
2989 p2p->cfg->model_name = os_strdup(cfg->model_name);
2990 if (cfg->model_number)
2991 p2p->cfg->model_number = os_strdup(cfg->model_number);
2992 if (cfg->serial_number)
2993 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
2994 if (cfg->pref_chan) {
2995 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *
2997 if (p2p->cfg->pref_chan) {
2998 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,
2999 cfg->num_pref_chan *
3002 p2p->cfg->num_pref_chan = 0;
3005 p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash);
3007 p2p->min_disc_int = 1;
3008 p2p->max_disc_int = 3;
3009 p2p->max_disc_tu = -1;
3011 if (os_get_random(&p2p->next_tie_breaker, 1) < 0)
3012 p2p->next_tie_breaker = 0;
3013 p2p->next_tie_breaker &= 0x01;
3014 if (cfg->sd_request)
3015 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
3016 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
3017 if (cfg->concurrent_operations)
3018 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
3019 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3021 dl_list_init(&p2p->devices);
3023 p2p->go_timeout = 100;
3024 p2p->client_timeout = 20;
3025 p2p->num_p2p_sd_queries = 0;
3028 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
3029 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
3038 wpabuf_free(p2p->wfd_ie_beacon);
3039 wpabuf_free(p2p->wfd_ie_probe_req);
3040 wpabuf_free(p2p->wfd_ie_probe_resp);
3041 wpabuf_free(p2p->wfd_ie_assoc_req);
3042 wpabuf_free(p2p->wfd_ie_invitation);
3043 wpabuf_free(p2p->wfd_ie_prov_disc_req);
3044 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
3045 wpabuf_free(p2p->wfd_ie_go_neg);
3046 wpabuf_free(p2p->wfd_dev_info);
3047 wpabuf_free(p2p->wfd_assoc_bssid);
3048 wpabuf_free(p2p->wfd_coupled_sink_info);
3049 wpabuf_free(p2p->wfd_r2_dev_info);
3057 os_free(p2p->cfg->dev_name);
3058 os_free(p2p->cfg->manufacturer);
3059 os_free(p2p->cfg->model_name);
3060 os_free(p2p->cfg->model_number);
3061 os_free(p2p->cfg->serial_number);
3062 os_free(p2p->cfg->pref_chan);
3063 os_free(p2p->groups);
3065 wpabuf_free(p2p->sd_resp);
3067 os_free(p2p->no_go_freq.range);
3080 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
3082 dl_list_del(&dev->list);
3086 p2p->ssid_set = 0;
3089 p2p->override_pref_op_class = 0;
3090 p2p->override_pref_channel = 0;
3100 return -1;
3104 if (p2p->go_neg_peer == dev) {
3106 p2p->go_neg_peer = NULL;
3109 dev->wps_method = WPS_NOT_READY;
3110 dev->oob_pw_id = 0;
3111 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
3112 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
3120 os_free(p2p->cfg->dev_name);
3122 p2p->cfg->dev_name = os_strdup(dev_name);
3123 if (p2p->cfg->dev_name == NULL)
3124 return -1;
3126 p2p->cfg->dev_name = NULL;
3133 os_free(p2p->cfg->manufacturer);
3134 p2p->cfg->manufacturer = NULL;
3136 p2p->cfg->manufacturer = os_strdup(manufacturer);
3137 if (p2p->cfg->manufacturer == NULL)
3138 return -1;
3147 os_free(p2p->cfg->model_name);
3148 p2p->cfg->model_name = NULL;
3150 p2p->cfg->model_name = os_strdup(model_name);
3151 if (p2p->cfg->model_name == NULL)
3152 return -1;
3161 os_free(p2p->cfg->model_number);
3162 p2p->cfg->model_number = NULL;
3164 p2p->cfg->model_number = os_strdup(model_number);
3165 if (p2p->cfg->model_number == NULL)
3166 return -1;
3175 os_free(p2p->cfg->serial_number);
3176 p2p->cfg->serial_number = NULL;
3178 p2p->cfg->serial_number = os_strdup(serial_number);
3179 if (p2p->cfg->serial_number == NULL)
3180 return -1;
3189 p2p->cfg->config_methods = config_methods;
3195 os_memcpy(p2p->cfg->uuid, uuid, 16);
3201 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
3211 p2p->cfg->num_sec_dev_types = num_dev_types;
3212 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
3222 wpabuf_free(p2p->wps_vendor_ext[i]);
3223 p2p->wps_vendor_ext[i] = NULL;
3234 return -1;
3237 if (p2p->wps_vendor_ext[i] == NULL)
3241 return -1;
3243 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
3244 if (p2p->wps_vendor_ext[i] == NULL)
3245 return -1;
3253 os_memcpy(p2p->cfg->country, country, 3);
3262 if (dev->sd_pending_bcast_queries == 0) {
3265 dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries;
3269 if (res == -2)
3270 return -2;
3274 if (dev->req_config_methods &&
3275 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
3278 MAC2STR(dev->info.p2p_device_addr),
3279 dev->req_config_methods);
3297 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3298 if (dev == p2p->last_p2p_find_oper) {
3306 p2p->last_p2p_find_oper = dev;
3309 if (res == -2)
3317 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3320 p2p->last_p2p_find_oper = dev;
3323 if (res == -2)
3325 if (dev == p2p->last_p2p_find_oper)
3330 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
3339 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3342 if (p2p->sd_peer) {
3343 if (is_zero_ether_addr(p2p->sd_query_no_ack)) {
3344 os_memcpy(p2p->sd_query_no_ack,
3345 p2p->sd_peer->info.p2p_device_addr,
3348 "First SD Query no-ACK in this search iteration: "
3349 MACSTR, MAC2STR(p2p->sd_query_no_ack));
3351 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3353 p2p->sd_peer = NULL;
3354 if (p2p->state != P2P_IDLE)
3359 if (p2p->sd_peer == NULL) {
3361 if (p2p->state != P2P_IDLE)
3366 if (p2p->sd_query && p2p->sd_query->for_all_peers) {
3369 p2p->sd_peer->sd_pending_bcast_queries--;
3373 * mark it as done (-1).
3375 if (p2p->sd_peer->sd_pending_bcast_queries == 0)
3376 p2p->sd_peer->sd_pending_bcast_queries = -1;
3386 * p2p_retry_pd - Retry any pending provision disc requests in IDLE state
3398 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3399 if (!ether_addr_equal(p2p->pending_pd_devaddr,
3400 dev->info.p2p_device_addr))
3402 if (!dev->req_config_methods)
3407 MAC2STR(dev->info.p2p_device_addr),
3408 dev->req_config_methods);
3410 dev->flags & P2P_DEV_PD_FOR_JOIN,
3411 p2p->pd_force_freq);
3433 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3435 if (p2p->user_initiated_pd &&
3436 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY))
3439 p2p->pending_action_state = P2P_PENDING_PD;
3441 } else if (p2p->state != P2P_IDLE)
3443 else if (p2p->user_initiated_pd) {
3444 p2p->pending_action_state = P2P_PENDING_PD;
3453 * happens only on the advertiser side sending the follow-on PD Request
3456 if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker &&
3457 p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) {
3458 p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK");
3460 if (p2p->send_action_in_progress) {
3461 p2p->send_action_in_progress = 0;
3462 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3465 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3467 if (p2p->cfg->p2ps_prov_complete) {
3468 p2p->cfg->p2ps_prov_complete(
3469 p2p->cfg->cb_ctx,
3470 p2p->p2ps_prov->status,
3471 p2p->p2ps_prov->adv_mac,
3472 p2p->p2ps_prov->adv_mac,
3473 p2p->p2ps_prov->session_mac,
3474 NULL, p2p->p2ps_prov->adv_id,
3475 p2p->p2ps_prov->session_id,
3480 if (p2p->user_initiated_pd)
3491 if (p2p->user_initiated_pd)
3492 p2p->pending_action_state = P2P_PENDING_PD;
3494 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3497 if (p2p->state == P2P_SEARCH)
3508 if (p2p->send_action_in_progress) {
3509 p2p->send_action_in_progress = 0;
3510 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3513 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3516 if (p2p->state == P2P_SEARCH)
3521 if (!p2p->cfg->prov_disc_resp_cb ||
3522 p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1) {
3523 if (p2p->state == P2P_SEARCH)
3529 "Post-Provision Discovery operations started - do not try to continue other P2P operations");
3537 if (os_reltime_before(rx_time, &p2p->find_start)) {
3547 MAC2STR(bssid), (unsigned int) rx_time->sec,
3548 (unsigned int) rx_time->usec,
3549 (unsigned int) p2p->find_start.sec,
3550 (unsigned int) p2p->find_start.usec);
3560 void p2p_scan_res_handled(struct p2p_data *p2p, unsigned int delay)
3562 if (!p2p->p2p_scan_running) {
3565 p2p->p2p_scan_running = 0;
3567 /* Use this delay only when p2p_find doesn't set it */
3568 if (!p2p->search_delay)
3569 p2p->search_delay = delay;
3575 if (p2p->state == P2P_SEARCH)
3587 if (p2p->wfd_ie_probe_req)
3588 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req);
3591 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3593 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3597 dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3600 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3607 if (p2p->cfg->reg_class && p2p->cfg->channel)
3608 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
3609 p2p->cfg->reg_class,
3610 p2p->cfg->channel);
3611 if (p2p->ext_listen_interval)
3612 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
3613 p2p->ext_listen_interval);
3618 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3631 if (p2p && p2p->wfd_ie_probe_req)
3632 len += wpabuf_len(p2p->wfd_ie_probe_req);
3635 if (p2p && p2p->vendor_elem &&
3636 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3637 len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3651 struct p2p_device *dev = p2p->go_neg_peer;
3662 if (dev->flags & P2P_DEV_USER_REJECTED) {
3666 } else if (dev->go_neg_req_sent) {
3668 dev->go_neg_req_sent--;
3672 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
3673 !is_zero_ether_addr(dev->member_in_go_dev)) {
3674 p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability through its GO",
3675 MAC2STR(dev->info.p2p_device_addr));
3676 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3687 if (!success && p2p->go_neg_peer &&
3688 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {
3708 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
3709 p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore");
3721 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
3722 p2p_go_neg_failed(p2p, p2p->go_neg_peer->status);
3730 dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
3731 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE;
3734 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
3746 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3747 p2p_go_neg_failed(p2p, -1);
3751 dev = p2p->go_neg_peer;
3759 if (dev && dev->go_neg_conf &&
3760 dev->go_neg_conf_sent <= P2P_GO_NEG_CNF_MAX_RETRY_COUNT) {
3762 dev->go_neg_conf_sent);
3763 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
3764 if (p2p_send_action(p2p, dev->go_neg_conf_freq,
3765 dev->info.p2p_device_addr,
3766 p2p->cfg->dev_addr,
3767 dev->info.p2p_device_addr,
3768 wpabuf_head(dev->go_neg_conf),
3769 wpabuf_len(dev->go_neg_conf), 0) >=
3771 dev->go_neg_conf_sent++;
3774 p2p_dbg(p2p, "Failed to re-send Action frame");
3795 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3813 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),
3814 MAC2STR(bssid), result, p2p_state_txt(p2p->state));
3816 state = p2p->pending_action_state;
3817 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3820 if (p2p->send_action_in_progress) {
3821 p2p->send_action_in_progress = 0;
3822 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3868 if (freq == p2p->pending_client_disc_freq) {
3869 p2p_dbg(p2p, "Client discoverability remain-awake completed");
3870 p2p->pending_client_disc_freq = 0;
3874 if (freq != p2p->pending_listen_freq) {
3876 freq, duration, p2p->pending_listen_freq);
3881 p2p->pending_listen_sec, p2p->pending_listen_usec,
3882 p2p->pending_listen_freq);
3883 p2p->pending_listen_wait_drv = false;
3884 p2p->in_listen = 1;
3885 p2p->drv_in_listen = freq;
3886 if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
3888 * Add 20 msec extra wait to avoid race condition with driver
3889 * remain-on-channel end event, i.e., give driver more time to
3892 p2p_set_timeout(p2p, p2p->pending_listen_sec,
3893 p2p->pending_listen_usec + 20000);
3896 p2p->pending_listen_freq = 0;
3903 p2p->drv_in_listen = 0;
3904 if (p2p->in_listen)
3907 if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer &&
3908 p2p->pending_listen_freq) {
3915 "Listen operation did not seem to start - delay idle phase to avoid busy loop");
3920 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
3921 if (p2p->go_neg_peer->connect_reqs >= 120) {
3923 p2p_go_neg_failed(p2p, -1);
3928 p2p_connect_send(p2p, p2p->go_neg_peer);
3930 } else if (p2p->state == P2P_SEARCH) {
3931 if (p2p->p2p_scan_running) {
3935 * the end of a remain-on-channel operation and the
3940 p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one");
3943 if (p2p->pending_listen_freq) {
3949 p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop");
3953 if (p2p->search_delay) {
3954 p2p_dbg(p2p, "Delay search operation by %u ms",
3955 p2p->search_delay);
3956 p2p_set_timeout(p2p, p2p->search_delay / 1000,
3957 (p2p->search_delay % 1000) * 1000);
3970 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3971 if (p2p->go_neg_peer &&
3972 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
3973 p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed");
3974 p2p_go_neg_failed(p2p, -1);
3977 if (p2p->go_neg_peer &&
3978 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) &&
3979 p2p->go_neg_peer->connect_reqs < 120) {
3980 p2p_dbg(p2p, "Peer expected to wait our response - skip listen");
3981 p2p_connect_send(p2p, p2p->go_neg_peer);
3984 if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) {
3985 p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)");
3997 if (p2p->go_neg_peer) {
3998 if (p2p->drv_in_listen) {
4003 if (p2p->go_neg_peer->connect_reqs >= 120) {
4005 p2p_go_neg_failed(p2p, -1);
4010 p2p_connect_send(p2p, p2p->go_neg_peer);
4020 if (p2p->cfg->is_concurrent_session_active &&
4021 p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx))
4030 struct p2p_device *dev = p2p->go_neg_peer;
4033 p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait");
4038 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
4039 p2p->pending_listen_wait_drv = false;
4040 if (p2p->pending_listen_freq) {
4042 p2p->pending_listen_freq = 0;
4052 if (p2p->sd_peer) {
4053 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4054 p2p->sd_peer = NULL;
4063 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4073 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4080 if (!p2p->user_initiated_pd)
4085 if (p2p->pd_retries) {
4086 p2p->pd_retries--;
4092 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
4093 if (!ether_addr_equal(p2p->pending_pd_devaddr,
4094 dev->info.p2p_device_addr))
4096 if (dev->req_config_methods &&
4097 (dev->flags & P2P_DEV_PD_FOR_JOIN))
4101 if (p2p->p2ps_prov) {
4102 adv_id = p2p->p2ps_prov->adv_id;
4103 adv_mac = p2p->p2ps_prov->adv_mac;
4106 if (p2p->cfg->prov_disc_fail)
4107 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
4108 p2p->pending_pd_devaddr,
4120 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4122 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
4129 p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel");
4139 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
4141 p2p_invite_send(p2p, p2p->invite_peer,
4142 p2p->invite_go_dev_addr, p2p->invite_dev_pw_id);
4144 if (p2p->invite_peer) {
4146 if (p2p->cfg->invitation_result)
4147 p2p->cfg->invitation_result(
4148 p2p->cfg->cb_ctx, -1, NULL, NULL,
4149 p2p->invite_peer->info.p2p_device_addr,
4161 p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state));
4163 p2p->in_listen = 0;
4164 if (p2p->drv_in_listen) {
4165 p2p_dbg(p2p, "Driver is still in listen state - stop it");
4166 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
4167 p2p->pending_listen_wait_drv = false;
4170 switch (p2p->state) {
4173 if (p2p->pending_action_state == P2P_PENDING_PD)
4178 if (p2p->pending_action_state == P2P_PENDING_PD)
4180 if (p2p->search_delay && !p2p->in_search_delay) {
4181 p2p_dbg(p2p, "Delay search operation by %u ms",
4182 p2p->search_delay);
4183 p2p->in_search_delay = 1;
4184 p2p_set_timeout(p2p, p2p->search_delay / 1000,
4185 (p2p->search_delay % 1000) * 1000);
4188 p2p->in_search_delay = 0;
4201 if (p2p->pending_action_state == P2P_PENDING_PD)
4204 if (p2p->ext_listen_only) {
4205 p2p_dbg(p2p, "Extended Listen Timing - Listen State completed");
4206 p2p->ext_listen_only = 0;
4243 return -1;
4245 dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
4246 dev->flags |= P2P_DEV_USER_REJECTED;
4255 return "not-ready";
4295 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4298 dev = dl_list_first(&dev->list, struct p2p_device, list);
4299 if (&dev->list == &p2p->devices)
4306 return &dev->info;
4319 return -1;
4321 dev = (struct p2p_device *) (((u8 *) info) -
4328 res = os_snprintf(pos, end - pos,
4345 (int) (now.sec - dev->last_seen.sec),
4346 dev->listen_freq,
4347 p2p_wps_method_text(dev->wps_method),
4348 MAC2STR(dev->interface_addr),
4349 MAC2STR(dev->member_in_go_dev),
4350 MAC2STR(dev->member_in_go_iface),
4351 dev->go_neg_req_sent,
4352 p2p_go_state_text(dev->go_state),
4353 dev->dialog_token,
4354 MAC2STR(dev->intended_addr),
4355 dev->country[0] ? dev->country[0] : '_',
4356 dev->country[1] ? dev->country[1] : '_',
4357 dev->oper_freq,
4358 dev->req_config_methods,
4359 dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
4361 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
4362 dev->flags & P2P_DEV_NOT_YET_READY ?
4364 dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
4366 dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
4368 dev->flags & P2P_DEV_PD_PEER_P2PS ?
4370 dev->flags & P2P_DEV_USER_REJECTED ?
4372 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
4374 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
4376 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
4378 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
4380 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
4382 dev->flags & P2P_DEV_FORCE_FREQ ?
4384 dev->flags & P2P_DEV_PD_FOR_JOIN ?
4386 dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT ?
4388 dev->status,
4389 dev->invitation_reqs);
4390 if (os_snprintf_error(end - pos, res))
4391 return pos - buf;
4394 if (dev->ext_listen_period) {
4395 res = os_snprintf(pos, end - pos,
4398 dev->ext_listen_period,
4399 dev->ext_listen_interval);
4400 if (os_snprintf_error(end - pos, res))
4401 return pos - buf;
4405 if (dev->oper_ssid_len) {
4406 res = os_snprintf(pos, end - pos,
4408 wpa_ssid_txt(dev->oper_ssid,
4409 dev->oper_ssid_len));
4410 if (os_snprintf_error(end - pos, res))
4411 return pos - buf;
4416 if (dev->info.wfd_subelems) {
4417 res = os_snprintf(pos, end - pos, "wfd_subelems=");
4418 if (os_snprintf_error(end - pos, res))
4419 return pos - buf;
4422 pos += wpa_snprintf_hex(pos, end - pos,
4423 wpabuf_head(dev->info.wfd_subelems),
4424 wpabuf_len(dev->info.wfd_subelems));
4426 res = os_snprintf(pos, end - pos, "\n");
4427 if (os_snprintf_error(end - pos, res))
4428 return pos - buf;
4433 return pos - buf;
4447 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4450 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4507 return -1;
4509 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4559 p2p_dbg(p2p, "Received P2P Action - P2P Presence Request");
4561 for (g = 0; g < p2p->num_groups; g++) {
4563 da, p2p_group_get_interface_addr(p2p->groups[g]))) {
4564 group = p2p->groups[g];
4590 if (p2p->cfg->get_noa)
4591 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
4594 noa_len = -1;
4603 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4617 p2p_dbg(p2p, "Received P2P Action - P2P Presence Response");
4630 if (p2p->cfg->presence_resp) {
4631 p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status,
4643 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA",
4654 if (p2p->ext_listen_interval) {
4656 eloop_register_timeout(p2p->ext_listen_interval_sec,
4657 p2p->ext_listen_interval_usec,
4661 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
4668 p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");
4669 p2p->ext_listen_only = 0;
4673 if ((p2p->cfg->is_p2p_in_progress &&
4674 p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) ||
4675 (p2p->pending_action_state == P2P_PENDING_PD &&
4676 p2p->pd_retries > 0)) {
4677 p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)",
4678 p2p_state_txt(p2p->state));
4682 if (p2p->state != P2P_IDLE) {
4683 p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state));
4688 p2p->ext_listen_only = 1;
4689 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
4691 p2p->ext_listen_only = 0;
4703 return -1;
4710 p2p->ext_listen_period = 0;
4711 p2p->ext_listen_interval = 0;
4717 p2p->ext_listen_period = period;
4718 p2p->ext_listen_interval = interval;
4719 p2p->ext_listen_interval_sec = interval / 1000;
4720 p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
4722 eloop_register_timeout(p2p->ext_listen_interval_sec,
4723 p2p->ext_listen_interval_usec,
4782 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
4785 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
4795 return p2p_channel_random_social(&p2p->channels, op_class, op_channel,
4804 return -1;
4810 if (p2p->cfg->channel_forced && forced == 0) {
4812 "Listen channel was previously configured - do not override based on optimization");
4813 return -1;
4819 if (p2p->state == P2P_IDLE) {
4820 p2p->cfg->reg_class = reg_class;
4821 p2p->cfg->channel = channel;
4822 p2p->cfg->channel_forced = forced;
4825 p2p->pending_reg_class = reg_class;
4826 p2p->pending_channel = channel;
4827 p2p->pending_channel_forced = forced;
4836 return p2p->cfg->channel;
4844 p2p->cfg->ssid_postfix_len = 0;
4847 if (len > sizeof(p2p->cfg->ssid_postfix))
4848 return -1;
4849 os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
4850 p2p->cfg->ssid_postfix_len = len;
4859 return -1;
4863 p2p->cfg->op_reg_class = op_reg_class;
4864 p2p->cfg->op_channel = op_channel;
4865 p2p->cfg->cfg_op_channel = cfg_op_channel;
4879 return -1;
4883 os_free(p2p->cfg->pref_chan);
4884 p2p->cfg->pref_chan = n;
4885 p2p->cfg->num_pref_chan = num_pref_chan;
4896 if (list == NULL || list->num == 0) {
4897 os_free(p2p->no_go_freq.range);
4898 p2p->no_go_freq.range = NULL;
4899 p2p->no_go_freq.num = 0;
4903 tmp = os_calloc(list->num, sizeof(struct wpa_freq_range));
4905 return -1;
4906 os_memcpy(tmp, list->range, list->num * sizeof(struct wpa_freq_range));
4907 os_free(p2p->no_go_freq.range);
4908 p2p->no_go_freq.range = tmp;
4909 p2p->no_go_freq.num = list->num;
4920 if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
4921 return -1;
4922 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
4932 return -1;
4933 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
4940 os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
4941 if (is_zero_ether_addr(p2p->peer_filter))
4945 MAC2STR(p2p->peer_filter));
4952 if (p2p->cross_connect == enabled)
4954 p2p->cross_connect = enabled;
4963 return -1;
4964 if (dev->oper_freq <= 0)
4965 return -1;
4966 return dev->oper_freq;
4974 p2p->cfg->p2p_intra_bss = enabled;
4983 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
4984 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
4985 os_memcpy(&p2p->cfg->cli_channels, cli_chan,
4987 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
4997 res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
4999 if (res == 0 && scheduled && p2p->in_listen && freq > 0 &&
5000 p2p->drv_in_listen > 0 &&
5001 (unsigned int) p2p->drv_in_listen != freq) {
5004 p2p->drv_in_listen, freq);
5016 p2p->best_freq_24 = freq_24;
5017 p2p->best_freq_5 = freq_5;
5018 p2p->best_freq_overall = freq_overall;
5025 p2p->own_freq_preference = freq;
5031 if (p2p == NULL || p2p->go_neg_peer == NULL)
5033 return p2p->go_neg_peer->info.p2p_device_addr;
5048 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
5051 return &dev->info;
5054 dev = dl_list_first(&dev->list,
5057 if (!dev || &dev->list == &p2p->devices)
5059 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
5062 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
5065 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
5066 dev = dl_list_first(&dev->list,
5069 if (!dev || &dev->list == &p2p->devices)
5074 return &dev->info;
5082 if (p2p->state == P2P_SEARCH)
5084 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;
5092 p2p->go_timeout = go_timeout;
5093 p2p->client_timeout = client_timeout;
5105 for (g = 0; g < p2p->num_groups; g++) {
5106 group = p2p->groups[g];
5114 wpabuf_free(p2p->wfd_ie_beacon);
5115 p2p->wfd_ie_beacon = ie;
5123 wpabuf_free(p2p->wfd_ie_probe_req);
5124 p2p->wfd_ie_probe_req = ie;
5131 wpabuf_free(p2p->wfd_ie_probe_resp);
5132 p2p->wfd_ie_probe_resp = ie;
5140 wpabuf_free(p2p->wfd_ie_assoc_req);
5141 p2p->wfd_ie_assoc_req = ie;
5148 wpabuf_free(p2p->wfd_ie_invitation);
5149 p2p->wfd_ie_invitation = ie;
5156 wpabuf_free(p2p->wfd_ie_prov_disc_req);
5157 p2p->wfd_ie_prov_disc_req = ie;
5164 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
5165 p2p->wfd_ie_prov_disc_resp = ie;
5172 wpabuf_free(p2p->wfd_ie_go_neg);
5173 p2p->wfd_ie_go_neg = ie;
5180 wpabuf_free(p2p->wfd_dev_info);
5182 p2p->wfd_dev_info = wpabuf_dup(elem);
5183 if (p2p->wfd_dev_info == NULL)
5184 return -1;
5186 p2p->wfd_dev_info = NULL;
5194 wpabuf_free(p2p->wfd_r2_dev_info);
5196 p2p->wfd_r2_dev_info = wpabuf_dup(elem);
5197 if (p2p->wfd_r2_dev_info == NULL)
5198 return -1;
5200 p2p->wfd_r2_dev_info = NULL;
5208 wpabuf_free(p2p->wfd_assoc_bssid);
5210 p2p->wfd_assoc_bssid = wpabuf_dup(elem);
5211 if (p2p->wfd_assoc_bssid == NULL)
5212 return -1;
5214 p2p->wfd_assoc_bssid = NULL;
5223 wpabuf_free(p2p->wfd_coupled_sink_info);
5225 p2p->wfd_coupled_sink_info = wpabuf_dup(elem);
5226 if (p2p->wfd_coupled_sink_info == NULL)
5227 return -1;
5229 p2p->wfd_coupled_sink_info = NULL;
5241 return -1;
5243 p2p->min_disc_int = min_disc_int;
5244 p2p->max_disc_int = max_disc_int;
5245 p2p->max_disc_tu = max_disc_tu;
5258 if (!p2p->cfg->debug_print)
5263 buf[sizeof(buf) - 1] = '\0';
5265 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf);
5274 if (!p2p->cfg->debug_print)
5279 buf[sizeof(buf) - 1] = '\0';
5281 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf);
5290 if (!p2p->cfg->debug_print)
5295 buf[sizeof(buf) - 1] = '\0';
5297 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf);
5308 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
5309 peer_callback(&dev->info, user_data);
5329 op_class = p2p->cfg->reg_class;
5330 channel = p2p->cfg->channel;
5332 p2p_buf_add_capability(buf, p2p->dev_capab &
5336 if (p2p->num_groups > 0) {
5337 int freq = p2p_group_get_freq(p2p->groups[0]);
5357 p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class,
5360 if (p2p->num_groups > 0) {
5362 p2p_buf_add_group_info(p2p->groups[0], buf, 5);
5363 p2p_group_buf_add_id(p2p->groups[0], buf);
5407 params->next_step = NO_ACTION;
5409 if (p2p_parse_ies_separate(params->wsc_attr, params->wsc_len,
5410 params->p2p_attr, params->p2p_len, &msg)) {
5413 return -1;
5423 return -1;
5427 os_memcpy(params->oob_dev_pw, msg.oob_dev_password,
5429 params->oob_dev_pw_len = msg.oob_dev_password_len;
5435 return -1;
5438 params->peer = &dev->info;
5440 os_get_reltime(&dev->last_seen);
5441 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
5447 return -1;
5459 return -1;
5465 params->go_freq = freq;
5469 params->go_freq = freq;
5472 dev->oob_go_neg_freq = freq;
5474 if (!params->sel && role != P2P_GO_IN_A_GROUP) {
5475 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
5476 p2p->cfg->channel);
5480 return -1;
5483 dev->oob_go_neg_freq = freq;
5487 os_memcpy(params->go_dev_addr, msg.group_id, ETH_ALEN);
5488 params->go_ssid_len = msg.group_id_len - ETH_ALEN;
5489 os_memcpy(params->go_ssid, msg.group_id + ETH_ALEN,
5490 params->go_ssid_len);
5493 if (dev->flags & P2P_DEV_USER_REJECTED) {
5499 if (!(dev->flags & P2P_DEV_REPORTED)) {
5500 p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info,
5501 !(dev->flags & P2P_DEV_REPORTED_ONCE));
5502 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
5506 if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0)
5507 params->next_step = BOTH_GO;
5509 params->next_step = JOIN_GROUP;
5511 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
5512 params->next_step = PEER_CLIENT;
5513 } else if (p2p->num_groups > 0)
5514 params->next_step = AUTH_JOIN;
5515 else if (params->sel)
5516 params->next_step = INIT_GO_NEG;
5518 params->next_step = RESP_GO_NEG;
5529 p2p->authorized_oob_dev_pw_id = dev_pw_id;
5538 p2p->go_intent = go_intent;
5539 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
5548 return -1;
5549 p2p->cfg->passphrase_len = len;
5556 p2p->vendor_elem = vendor_elem;
5566 p2p_go_neg_failed(p2p, -1);
5578 p2p->num_pref_freq = size;
5579 os_memcpy(p2p->pref_freq_list, pref_freq_list,
5583 i, p2p->pref_freq_list[i].freq);
5591 p2p->override_pref_op_class = op_class;
5592 p2p->override_pref_channel = chan;
5635 return dev->support_6ghz;
5641 p2p->p2p_6ghz_capable = allow_6ghz;
5642 p2p->allow_6ghz = allow_6ghz;
5646 p2p->dev_capab |= P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE;
5648 p2p->dev_capab &= ~P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE;
5654 return p2p->p2p_6ghz_capable;
5661 return p2p->wfd_ie_probe_req != NULL;
5674 return dev && dev->info.wfd_subelems != NULL;
5683 return p2p->allow_6ghz;
5689 p2p->allow_6ghz = value;