Lines Matching refs:p2p
21 #include "p2p.h"
25 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
26 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
29 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
53 void p2p_expire_peers(struct p2p_data *p2p)
60 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
64 if (dev == p2p->go_neg_peer) {
73 if (p2p->cfg->go_connected &&
74 p2p->cfg->go_connected(p2p->cfg->cb_ctx,
84 for (i = 0; i < p2p->num_groups; i++) {
86 p2p->groups[i], dev->info.p2p_device_addr))
89 if (i < p2p->num_groups) {
98 p2p_dbg(p2p, "Expiring old peer entry " MACSTR,
101 p2p_device_free(p2p, dev);
141 const char * p2p_get_state_txt(struct p2p_data *p2p)
143 return p2p_state_txt(p2p->state);
147 struct p2ps_advertisement * p2p_get_p2ps_adv_list(struct p2p_data *p2p)
149 return p2p ? p2p->p2ps_adv_list : NULL;
153 void p2p_set_intended_addr(struct p2p_data *p2p, const u8 *intended_addr)
155 if (p2p && intended_addr)
156 os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN);
160 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr)
164 if (!addr || !p2p)
167 dev = p2p_get_device(p2p, addr);
175 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr)
179 if (!addr || !p2p)
182 dev = p2p_get_device(p2p, addr);
188 void p2p_set_state(struct p2p_data *p2p, int new_state)
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) {
195 p2p_dbg(p2p, "Apply change in listen 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;
204 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)
206 p2p_dbg(p2p, "Set timeout (state=%s): %u.%06u sec",
207 p2p_state_txt(p2p->state), sec, usec);
208 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
209 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);
213 void p2p_clear_timeout(struct p2p_data *p2p)
215 p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state));
216 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
220 void p2p_go_neg_failed(struct p2p_data *p2p, int status)
223 struct p2p_device *peer = p2p->go_neg_peer;
228 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
229 if (p2p->state != P2P_SEARCH) {
234 p2p_clear_timeout(p2p);
235 p2p_set_state(p2p, P2P_IDLE);
243 p2p->go_neg_peer = NULL;
249 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
253 static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc)
259 p2p_dbg(p2p, "Starting short listen state (state=%s)",
260 p2p_state_txt(p2p->state));
262 if (p2p->pending_listen_freq) {
264 p2p_dbg(p2p, "p2p_listen command pending already");
268 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
270 p2p_dbg(p2p, "Unknown regulatory class/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;
282 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen)
283 tu = p2p->cfg->max_listen * 1000 / 1024;
286 p2p_dbg(p2p, "Skip listen state since duration was 0 TU");
287 p2p_set_timeout(p2p, 0, 0);
291 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
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,
301 p2p_dbg(p2p, "Failed to start listen mode");
302 p2p->pending_listen_freq = 0;
308 int p2p_listen(struct p2p_data *p2p, unsigned int timeout)
313 p2p_dbg(p2p, "Going to listen(only) state");
315 if (p2p->pending_listen_freq) {
317 p2p_dbg(p2p, "p2p_listen command pending already");
321 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
323 p2p_dbg(p2p, "Unknown regulatory class/channel");
327 p2p->pending_listen_sec = timeout / 1000;
328 p2p->pending_listen_usec = (timeout % 1000) * 1000;
330 if (p2p->p2p_scan_running) {
331 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) {
332 p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen");
335 p2p_dbg(p2p, "p2p_scan running - delay start of listen state");
336 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;
340 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
344 p2p->pending_listen_freq = freq;
346 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
347 p2p_dbg(p2p, "Failed to start listen mode");
348 p2p->pending_listen_freq = 0;
354 p2p_set_state(p2p, P2P_LISTEN_ONLY);
360 static void p2p_device_clear_reported(struct p2p_data *p2p)
363 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
372 * @p2p: P2P module context from p2p_init()
376 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)
379 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
389 * @p2p: P2P module context from p2p_init()
393 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,
397 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
407 * @p2p: P2P module context from p2p_init()
414 static struct p2p_device * p2p_create_device(struct p2p_data *p2p,
420 dev = p2p_get_device(p2p, addr);
424 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
430 if (count + 1 > p2p->cfg->max_peers && oldest) {
431 p2p_dbg(p2p, "Remove oldest peer entry to make room for a new peer");
433 p2p_device_free(p2p, oldest);
439 dl_list_add(&p2p->devices, &dev->list);
461 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,
480 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
490 if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr,
493 dev = p2p_get_device(p2p, cli->p2p_device_addr);
518 dev = p2p_create_device(p2p, cli->p2p_device_addr);
524 p2p->cfg->dev_found(p2p->cfg->cb_ctx,
543 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev,
619 p2p_dbg(p2p, "Update peer " MACSTR
690 * @p2p: P2P module context from p2p_init()
706 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq,
720 p2p_dbg(p2p, "Failed to parse P2P IE for a device entry");
730 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");
735 if (!is_zero_ether_addr(p2p->peer_filter) &&
736 os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) {
737 p2p_dbg(p2p, "Do not add peer filter for " MACSTR
743 dev = p2p_create_device(p2p, p2p_dev_addr);
765 p2p_dbg(p2p,
806 p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz",
813 p2p_dbg(p2p, "Update Listen frequency based on scan results ("
828 p2p_copy_wps_info(p2p, dev, 0, &msg);
855 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq,
870 p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)",
874 p2p_dbg(p2p, "Do not report rejected device");
894 p2p_dbg(p2p, "Do not report peer " MACSTR
899 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
910 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
914 if (p2p->go_neg_peer == dev) {
918 p2p_go_neg_failed(p2p, -1);
920 if (p2p->invite_peer == dev)
921 p2p->invite_peer = NULL;
922 if (p2p->sd_peer == dev)
923 p2p->sd_peer = NULL;
924 if (p2p->pending_client_disc_go == dev)
925 p2p->pending_client_disc_go = NULL;
929 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
946 static int p2p_get_next_prog_freq(struct p2p_data *p2p)
956 c = &p2p->cfg->channels;
959 if (cla->reg_class != p2p->last_prog_scan_class)
962 if (cla->channel[ch] == p2p->last_prog_scan_chan) {
989 p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz",
991 p2p->last_prog_scan_class = reg_class;
992 p2p->last_prog_scan_chan = channel;
1000 static void p2p_search(struct p2p_data *p2p)
1007 if (p2p->drv_in_listen) {
1008 p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing");
1011 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1013 if (p2p->find_pending_full &&
1014 (p2p->find_type == P2P_FIND_PROGRESSIVE ||
1015 p2p->find_type == P2P_FIND_START_WITH_FULL)) {
1017 p2p_dbg(p2p, "Starting search (pending full scan)");
1018 p2p->find_pending_full = 0;
1019 } else if ((p2p->find_type == P2P_FIND_PROGRESSIVE &&
1020 (freq = p2p_get_next_prog_freq(p2p)) > 0) ||
1021 (p2p->find_type == P2P_FIND_START_WITH_FULL &&
1022 (freq = p2p->find_specified_freq) > 0)) {
1024 p2p_dbg(p2p, "Starting search (+ freq %u)", freq);
1027 p2p_dbg(p2p, "Starting search");
1030 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
1031 p2p->num_req_dev_types, p2p->req_dev_types,
1032 p2p->find_dev_id, pw_id);
1034 p2p_dbg(p2p, "Scan request schedule failed");
1035 p2p_continue_find(p2p);
1042 struct p2p_data *p2p = eloop_ctx;
1043 p2p_dbg(p2p, "Find timeout -> stop");
1044 p2p_stop_find(p2p);
1048 void p2p_notify_scan_trigger_status(struct p2p_data *p2p, int status)
1051 p2p_dbg(p2p, "Scan request failed");
1053 p2p_continue_find(p2p);
1055 p2p_dbg(p2p, "Running p2p_scan");
1056 p2p->p2p_scan_running = 1;
1057 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
1059 p2p, NULL);
1064 static int p2p_run_after_scan(struct p2p_data *p2p)
1069 op = p2p->start_after_scan;
1070 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1075 p2p_dbg(p2p, "Start previously requested Listen state");
1076 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
1077 p2p->pending_listen_usec / 1000);
1080 p2p_dbg(p2p, "Start previously requested connect with " MACSTR,
1081 MAC2STR(p2p->after_scan_peer));
1082 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1084 p2p_dbg(p2p, "Peer not known anymore");
1087 p2p_connect_send(p2p, dev);
1097 struct p2p_data *p2p = eloop_ctx;
1099 p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running);
1100 running = p2p->p2p_scan_running;
1102 p2p->p2p_scan_running = 0;
1105 p2p_run_after_scan(p2p);
1109 static void p2p_free_req_dev_types(struct p2p_data *p2p)
1111 p2p->num_req_dev_types = 0;
1112 os_free(p2p->req_dev_types);
1113 p2p->req_dev_types = NULL;
1117 static int p2ps_gen_hash(struct p2p_data *p2p, const char *str, u8 *hash)
1128 os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN);
1152 int p2p_find(struct p2p_data *p2p, unsigned int timeout,
1161 p2p_dbg(p2p, "Starting find (type=%d)", type);
1162 if (p2p->p2p_scan_running) {
1163 p2p_dbg(p2p, "p2p_scan is already running");
1166 p2p_free_req_dev_types(p2p);
1168 p2p->req_dev_types = os_memdup(req_dev_types,
1171 if (p2p->req_dev_types == NULL)
1173 p2p->num_req_dev_types = num_req_dev_types;
1177 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);
1178 p2p->find_dev_id = p2p->find_dev_id_buf;
1180 p2p->find_dev_id = NULL;
1184 p2p->p2ps_seek = 0;
1190 p2p_dbg(p2p, "ASP search");
1191 p2p->p2ps_seek_count = 0;
1192 p2p->p2ps_seek = 1;
1198 if (!p2ps_gen_hash(p2p, seek[i], buf))
1201 p2p_dbg(p2p, "Seek service %s hash " MACSTR,
1203 os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN],
1208 p2p->p2ps_seek_count = count;
1209 p2p->p2ps_seek = 1;
1211 p2p->p2ps_seek_count = 0;
1212 p2p->p2ps_seek = 1;
1216 if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) {
1217 p2p->p2ps_seek_count = 1;
1218 os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash,
1222 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1223 p2p_clear_timeout(p2p);
1224 if (p2p->pending_listen_freq) {
1225 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_find");
1226 p2p->pending_listen_freq = 0;
1228 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1229 p2p->find_pending_full = 0;
1230 p2p->find_type = type;
1232 p2p->find_specified_freq = freq;
1234 p2p->find_specified_freq = 0;
1235 p2p_device_clear_reported(p2p);
1236 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
1237 p2p_set_state(p2p, P2P_SEARCH);
1238 p2p->search_delay = search_delay;
1239 p2p->in_search_delay = 0;
1240 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1241 p2p->last_p2p_find_timeout = timeout;
1244 p2p, NULL);
1253 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx,
1255 p2p->num_req_dev_types,
1256 p2p->req_dev_types, dev_id,
1262 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
1263 p2p->num_req_dev_types,
1264 p2p->req_dev_types, dev_id,
1268 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
1269 p2p->num_req_dev_types,
1270 p2p->req_dev_types, dev_id,
1278 p2p->find_start = start;
1280 if (res != 0 && p2p->p2p_scan_running) {
1281 p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running");
1285 p2p->find_pending_full = 1;
1288 p2p_dbg(p2p, "Failed to start p2p_scan");
1289 p2p_set_state(p2p, P2P_IDLE);
1290 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1297 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)
1299 p2p_dbg(p2p, "Stopping find");
1300 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1301 p2p_clear_timeout(p2p);
1302 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
1303 p2p->cfg->find_stopped(p2p->cfg->cb_ctx);
1305 p2p->p2ps_seek_count = 0;
1307 p2p_set_state(p2p, P2P_IDLE);
1308 p2p_free_req_dev_types(p2p);
1309 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1310 if (p2p->go_neg_peer)
1311 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
1312 p2p->go_neg_peer = NULL;
1313 p2p->sd_peer = NULL;
1314 p2p->invite_peer = NULL;
1315 p2p_stop_listen_for_freq(p2p, freq);
1316 p2p->send_action_in_progress = 0;
1320 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq)
1322 if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) {
1323 p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response");
1326 if (p2p->in_listen) {
1327 p2p->in_listen = 0;
1328 p2p_clear_timeout(p2p);
1330 if (p2p->drv_in_listen) {
1336 p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen);
1337 p2p->drv_in_listen = 0;
1339 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1343 void p2p_stop_listen(struct p2p_data *p2p)
1345 if (p2p->state != P2P_LISTEN_ONLY) {
1346 p2p_dbg(p2p, "Skip stop_listen since not in listen_only state.");
1350 p2p_stop_listen_for_freq(p2p, 0);
1351 p2p_set_state(p2p, P2P_IDLE);
1355 void p2p_stop_find(struct p2p_data *p2p)
1357 p2p->pending_listen_freq = 0;
1358 p2p_stop_find_for_freq(p2p, 0);
1362 static int p2p_prepare_channel_pref(struct p2p_data *p2p,
1369 p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d",
1372 p2p_dbg(p2p, "Unsupported frequency %u MHz", freq);
1376 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) &&
1377 (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class,
1379 p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P",
1384 p2p->op_reg_class = op_class;
1385 p2p->op_channel = op_channel;
1388 p2p->channels.reg_classes = 1;
1389 p2p->channels.reg_class[0].channels = 1;
1390 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
1391 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
1393 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1401 static void p2p_prepare_channel_best(struct p2p_data *p2p)
1408 p2p_dbg(p2p, "Prepare channel best");
1410 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
1411 p2p_supported_freq(p2p, p2p->best_freq_overall) &&
1412 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel)
1414 p2p_dbg(p2p, "Select best overall channel as operating channel preference");
1415 p2p->op_reg_class = op_class;
1416 p2p->op_channel = op_channel;
1417 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
1418 p2p_supported_freq(p2p, p2p->best_freq_5) &&
1419 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel)
1421 p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference");
1422 p2p->op_reg_class = op_class;
1423 p2p->op_channel = op_channel;
1424 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 &&
1425 p2p_supported_freq(p2p, p2p->best_freq_24) &&
1426 p2p_freq_to_channel(p2p->best_freq_24, &op_class,
1428 p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference");
1429 p2p->op_reg_class = op_class;
1430 p2p->op_channel = op_channel;
1431 } else if (p2p->cfg->num_pref_chan > 0 &&
1432 p2p_channels_includes(&p2p->cfg->channels,
1433 p2p->cfg->pref_chan[0].op_class,
1434 p2p->cfg->pref_chan[0].chan)) {
1435 p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference");
1436 p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class;
1437 p2p->op_channel = p2p->cfg->pref_chan[0].chan;
1438 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht,
1439 &p2p->op_reg_class, &p2p->op_channel) ==
1441 p2p_dbg(p2p, "Select possible VHT channel (op_class %u channel %u) as operating channel preference",
1442 p2p->op_reg_class, p2p->op_channel);
1443 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40,
1444 &p2p->op_reg_class, &p2p->op_channel) ==
1446 p2p_dbg(p2p, "Select possible HT40 channel (op_class %u channel %u) as operating channel preference",
1447 p2p->op_reg_class, p2p->op_channel);
1448 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz,
1449 &p2p->op_reg_class, &p2p->op_channel) ==
1451 p2p_dbg(p2p, "Select possible 5 GHz channel (op_class %u channel %u) as operating channel preference",
1452 p2p->op_reg_class, p2p->op_channel);
1453 } else if (p2p_channels_includes(&p2p->cfg->channels,
1454 p2p->cfg->op_reg_class,
1455 p2p->cfg->op_channel)) {
1456 p2p_dbg(p2p, "Select pre-configured channel as operating channel preference");
1457 p2p->op_reg_class = p2p->cfg->op_reg_class;
1458 p2p->op_channel = p2p->cfg->op_channel;
1459 } else if (p2p_channel_random_social(&p2p->cfg->channels,
1460 &p2p->op_reg_class,
1461 &p2p->op_channel,
1463 p2p_dbg(p2p, "Select random available social channel (op_class %u channel %u) as operating channel preference",
1464 p2p->op_reg_class, p2p->op_channel);
1468 p2p_channel_select(&p2p->cfg->channels, NULL,
1469 &p2p->op_reg_class,
1470 &p2p->op_channel);
1471 p2p_dbg(p2p, "Select random available channel %d from operating class %d as operating channel preference",
1472 p2p->op_channel, p2p->op_reg_class);
1475 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1482 * @p2p: P2P module context from p2p_init()
1494 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,
1497 p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d",
1500 if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq, go) <
1504 p2p_prepare_channel_best(p2p);
1506 p2p_channels_dump(p2p, "prepared channels", &p2p->channels);
1508 p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq);
1510 p2p_channels_union_inplace(&p2p->channels,
1511 &p2p->cfg->cli_channels);
1512 p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels);
1514 p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s",
1515 p2p->op_reg_class, p2p->op_channel,
1547 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
1556 p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR
1563 dev = p2p_get_device(p2p, peer_addr);
1565 p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR,
1570 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq,
1577 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR
1583 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR
1596 p2p->ssid_set = 0;
1600 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1601 p2p->ssid_len = force_ssid_len;
1602 p2p->ssid_set = 1;
1620 dev->tie_breaker = p2p->next_tie_breaker;
1621 p2p->next_tie_breaker = !p2p->next_tie_breaker;
1627 p2p->go_intent = go_intent;
1628 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1630 if (p2p->state != P2P_IDLE)
1631 p2p_stop_find(p2p);
1637 if (p2p->p2p_scan_running) {
1638 p2p_dbg(p2p, "p2p_scan running - delay connect send");
1639 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1640 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1644 return p2p_connect_send(p2p, dev);
1648 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
1657 p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR
1663 dev = p2p_get_device(p2p, peer_addr);
1665 p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR,
1670 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent ==
1674 p2p->ssid_set = 0;
1678 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1679 p2p->ssid_len = force_ssid_len;
1680 p2p->ssid_set = 1;
1688 p2p->go_intent = go_intent;
1689 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1699 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,
1704 p2p_copy_wps_info(p2p, dev, 0, msg);
1711 p2p_dbg(p2p, "Unknown peer Listen channel: "
1719 p2p_dbg(p2p, "Update peer " MACSTR
1734 p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request");
1736 p2p_dbg(p2p, "Created device entry based on GO Neg Req: "
1747 p2p_dbg(p2p, "Do not report rejected device");
1751 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1757 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
1762 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1763 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1767 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)
1769 if (p2p->ssid_set) {
1770 os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len);
1771 params->ssid_len = p2p->ssid_len;
1773 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len);
1775 p2p->ssid_set = 0;
1777 p2p_random(params->passphrase, p2p->cfg->passphrase_len);
1782 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)
1788 p2p_dbg(p2p, "GO Negotiation with " MACSTR " completed (%s will be GO)",
1805 res.freq = p2p_channel_to_freq(p2p->op_reg_class,
1806 p2p->op_channel);
1807 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1808 res.ssid_len = p2p->ssid_len;
1809 p2p_random(res.passphrase, p2p->cfg->passphrase_len);
1812 if (p2p->ssid_len) {
1813 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1814 res.ssid_len = p2p->ssid_len;
1818 p2p_channels_dump(p2p, "own channels", &p2p->channels);
1819 p2p_channels_dump(p2p, "peer channels", &peer->channels);
1820 p2p_channels_intersect(&p2p->channels, &peer->channels,
1823 p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq);
1824 p2p_channels_dump(p2p, "intersection after no-GO removal",
1833 p2p_clear_timeout(p2p);
1834 p2p->ssid_set = 0;
1842 p2p_set_state(p2p, P2P_PROVISIONING);
1843 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
1847 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,
1850 p2p_dbg(p2p, "RX P2P Public Action from " MACSTR, MAC2STR(sa));
1858 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
1861 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
1864 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
1867 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
1871 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
1874 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1877 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
1880 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1883 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
1886 p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d",
1893 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da,
1912 p2p_rx_p2p_action(p2p, sa, data, len, freq);
1915 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
1918 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
1921 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
1924 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
1930 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
1935 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);
1951 p2p_dbg(p2p, "RX P2P Action from " MACSTR, MAC2STR(sa));
1958 p2p_dbg(p2p, "Received P2P Action - Notice of Absence");
1962 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
1965 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
1968 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
1971 p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]);
1979 struct p2p_data *p2p = eloop_ctx;
1980 if (p2p->go_neg_peer == NULL)
1982 if (p2p->pending_listen_freq) {
1983 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_go_neg_start");
1984 p2p->pending_listen_freq = 0;
1986 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1987 p2p->go_neg_peer->status = P2P_SC_SUCCESS;
1992 p2p_set_timeout(p2p, 0, 500000);
1993 p2p_connect_send(p2p, p2p->go_neg_peer);
1999 struct p2p_data *p2p = eloop_ctx;
2000 if (p2p->invite_peer == NULL)
2002 if (p2p->pending_listen_freq) {
2003 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_invite_start");
2004 p2p->pending_listen_freq = 0;
2006 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
2007 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr,
2008 p2p->invite_dev_pw_id);
2012 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,
2037 dev = p2p_get_device(p2p, addr);
2049 p2p_dbg(p2p,
2061 dev = p2p_create_device(p2p, addr);
2076 p2p_copy_wps_info(p2p, dev, 1, &msg);
2085 p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR
2093 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,
2099 dev = p2p_get_device(p2p, addr);
2105 dev = p2p_create_device(p2p, addr);
2109 p2p_add_dev_info(p2p, addr, dev, msg);
2141 * @p2p: P2P module context from p2p_init()
2149 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)
2160 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
2164 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) {
2165 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
2176 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p,
2186 if (p2p->wfd_ie_probe_resp)
2187 extra = wpabuf_len(p2p->wfd_ie_probe_resp);
2190 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2191 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2200 if (p2p->go_neg_peer) {
2202 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
2205 if (p2p_build_wps_ie(p2p, buf, pw_id, 1) < 0) {
2206 p2p_dbg(p2p, "Failed to build WPS IE for Probe Response");
2212 if (p2p->wfd_ie_probe_resp)
2213 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp);
2216 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2218 p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2222 p2p_buf_add_capability(buf, p2p->dev_capab &
2224 if (p2p->ext_listen_interval)
2225 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
2226 p2p->ext_listen_interval);
2227 p2p_buf_add_device_info(buf, p2p, NULL);
2231 p2p_buf_add_service_instance(buf, p2p, query_count, query_hash,
2232 p2p->p2ps_adv_list);
2238 static int p2p_build_probe_resp_buf(struct p2p_data *p2p, struct wpabuf *buf,
2251 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
2252 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
2276 channel = p2p->cfg->channel;
2278 p2p_err(p2p, "Failed to convert freq to channel");
2291 static int p2p_service_find_asp(struct p2p_data *p2p, const u8 *hash)
2296 p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list);
2299 any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0;
2301 adv_data = p2p->p2ps_adv_list;
2317 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2329 p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it");
2333 if (elems.p2p == NULL) {
2335 p2p_dbg(p2p, "Not a P2P probe - ignore it");
2340 os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
2343 p2p_dbg(p2p, "Probe Req DA " MACSTR " not ours - ignore it",
2350 p2p_dbg(p2p, "Probe Req BSSID " MACSTR " not wildcard - ignore it",
2359 p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it");
2365 p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it");
2372 p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it");
2381 p2p_dbg(p2p, "in_listen=%d drv_in_listen=%d when received P2PS Probe Request at %u MHz; own Listen channel %u, pending listen freq %u MHz",
2382 p2p->in_listen, p2p->drv_in_listen, rx_freq,
2383 p2p->cfg->channel, p2p->pending_listen_freq);
2385 if (!p2p->in_listen && !p2p->drv_in_listen &&
2386 p2p->pending_listen_freq && rx_freq &&
2387 rx_freq != p2p->pending_listen_freq) {
2388 p2p_dbg(p2p, "Do not reply to Probe Request frame that was received on %u MHz while waiting to start Listen state on %u MHz",
2389 rx_freq, p2p->pending_listen_freq);
2395 if (p2p_service_find_asp(p2p, hash)) {
2396 p2p_dbg(p2p, "Service Hash match found: "
2406 p2p_dbg(p2p, "No Service Hash match found");
2412 p2p_dbg(p2p, "No P2PS Hash in Probe Request");
2414 if (!p2p->in_listen || !p2p->drv_in_listen) {
2416 p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request",
2417 p2p->in_listen, p2p->drv_in_listen);
2424 os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
2426 p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR " did not match - ignore it",
2434 !p2p_match_dev_type(p2p, msg.wps_attributes)) {
2436 p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it");
2441 if (!p2p->cfg->send_probe_resp) {
2443 p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response");
2448 p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state");
2456 ies = p2p_build_probe_resp_ies(p2p, msg.service_hash,
2468 if (p2p_build_probe_resp_buf(p2p, buf, ies, addr, rx_freq)) {
2476 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq);
2485 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2491 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);
2494 p2p_dbg(p2p,
2499 res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len, rx_freq);
2511 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
2512 p2p->go_neg_peer &&
2513 os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)
2515 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
2517 p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout");
2518 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
2519 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);
2523 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
2524 p2p->invite_peer &&
2525 (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) &&
2526 os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)
2529 p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout");
2530 eloop_cancel_timeout(p2p_invite_start, p2p, NULL);
2531 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);
2539 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,
2556 p2p_dbg(p2p, "BSS P2P manageability %s",
2574 if (p2p->num_groups > 0) {
2576 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2577 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
2578 p2p->cross_connect)
2581 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
2582 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2583 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
2584 p2p_buf_add_p2p_interface(tmp, p2p);
2600 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
2611 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);
2614 if (p2p->wfd_ie_assoc_req)
2615 extra = wpabuf_len(p2p->wfd_ie_assoc_req);
2618 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2619 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2632 if (p2p->wfd_ie_assoc_req)
2633 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req);
2636 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2638 p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2640 peer = bssid ? p2p_get_device(p2p, bssid) : NULL;
2643 p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
2644 if (p2p->ext_listen_interval)
2645 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
2646 p2p->ext_listen_interval);
2647 p2p_buf_add_device_info(tmp, p2p, peer);
2679 p2p_service_p2ps_id(struct p2p_data *p2p, u32 adv_id)
2683 if (!p2p)
2686 adv_data = p2p->p2ps_adv_list;
2697 int p2p_service_del_asp(struct p2p_data *p2p, u32 adv_id)
2702 if (!p2p)
2705 adv_data = p2p->p2ps_adv_list;
2706 prior = &p2p->p2ps_adv_list;
2709 p2p_dbg(p2p, "Delete ASP adv_id=0x%x", adv_id);
2722 int p2p_service_add_asp(struct p2p_data *p2p, int auto_accept, u32 adv_id,
2731 if (!p2p || !adv_str || !adv_str[0] || !cpt_priority)
2734 if (!(config_methods & p2p->cfg->config_methods)) {
2735 p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x",
2736 config_methods, p2p->cfg->config_methods);
2740 if (!p2ps_gen_hash(p2p, adv_str, buf))
2756 adv_data->config_methods = config_methods & p2p->cfg->config_methods;
2774 tmp = p2p->p2ps_adv_list;
2775 prev = &p2p->p2ps_adv_list;
2798 adv_data->next = p2p->p2ps_adv_list;
2799 p2p->p2ps_adv_list = adv_data;
2802 p2p_dbg(p2p,
2811 void p2p_service_flush_asp(struct p2p_data *p2p)
2815 if (!p2p)
2818 adv = p2p->p2ps_adv_list;
2825 p2p->p2ps_adv_list = NULL;
2826 p2ps_prov_free(p2p);
2827 p2p_dbg(p2p, "All ASP advertisements flushed");
2865 static void p2p_clear_go_neg(struct p2p_data *p2p)
2867 p2p->go_neg_peer = NULL;
2868 p2p_clear_timeout(p2p);
2869 p2p_set_state(p2p, P2P_IDLE);
2873 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)
2875 if (p2p->go_neg_peer == NULL) {
2876 p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification");
2880 if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) !=
2882 p2p_dbg(p2p, "Ignore WPS registration success notification for "
2885 MAC2STR(p2p->go_neg_peer->intended_addr));
2889 p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR,
2892 p2p_clear_go_neg(p2p);
2896 void p2p_group_formation_failed(struct p2p_data *p2p)
2898 if (p2p->go_neg_peer == NULL) {
2899 p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification");
2903 p2p_dbg(p2p, "Group Formation failed with " MACSTR,
2904 MAC2STR(p2p->go_neg_peer->intended_addr));
2906 p2p_clear_go_neg(p2p);
2912 struct p2p_data *p2p;
2918 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));
2919 if (p2p == NULL)
2921 p2p->cfg = (struct p2p_config *) (p2p + 1);
2922 os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
2924 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
2926 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
2928 p2p->cfg->model_name = os_strdup(cfg->model_name);
2930 p2p->cfg->model_number = os_strdup(cfg->model_number);
2932 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
2934 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *
2936 if (p2p->cfg->pref_chan) {
2937 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,
2941 p2p->cfg->num_pref_chan = 0;
2944 p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash);
2946 p2p->min_disc_int = 1;
2947 p2p->max_disc_int = 3;
2948 p2p->max_disc_tu = -1;
2950 if (os_get_random(&p2p->next_tie_breaker, 1) < 0)
2951 p2p->next_tie_breaker = 0;
2952 p2p->next_tie_breaker &= 0x01;
2954 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
2955 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
2957 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
2958 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
2960 dl_list_init(&p2p->devices);
2962 p2p->go_timeout = 100;
2963 p2p->client_timeout = 20;
2964 p2p->num_p2p_sd_queries = 0;
2966 p2p_dbg(p2p, "initialized");
2967 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
2968 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
2970 return p2p;
2974 void p2p_deinit(struct p2p_data *p2p)
2977 wpabuf_free(p2p->wfd_ie_beacon);
2978 wpabuf_free(p2p->wfd_ie_probe_req);
2979 wpabuf_free(p2p->wfd_ie_probe_resp);
2980 wpabuf_free(p2p->wfd_ie_assoc_req);
2981 wpabuf_free(p2p->wfd_ie_invitation);
2982 wpabuf_free(p2p->wfd_ie_prov_disc_req);
2983 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
2984 wpabuf_free(p2p->wfd_ie_go_neg);
2985 wpabuf_free(p2p->wfd_dev_info);
2986 wpabuf_free(p2p->wfd_assoc_bssid);
2987 wpabuf_free(p2p->wfd_coupled_sink_info);
2988 wpabuf_free(p2p->wfd_r2_dev_info);
2991 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2992 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
2993 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
2994 p2p_flush(p2p);
2995 p2p_free_req_dev_types(p2p);
2996 os_free(p2p->cfg->dev_name);
2997 os_free(p2p->cfg->manufacturer);
2998 os_free(p2p->cfg->model_name);
2999 os_free(p2p->cfg->model_number);
3000 os_free(p2p->cfg->serial_number);
3001 os_free(p2p->cfg->pref_chan);
3002 os_free(p2p->groups);
3003 p2ps_prov_free(p2p);
3004 wpabuf_free(p2p->sd_resp);
3005 p2p_remove_wps_vendor_extensions(p2p);
3006 os_free(p2p->no_go_freq.range);
3007 p2p_service_flush_asp(p2p);
3009 os_free(p2p);
3013 void p2p_flush(struct p2p_data *p2p)
3017 p2p_ext_listen(p2p, 0, 0);
3018 p2p_stop_find(p2p);
3019 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
3022 p2p_device_free(p2p, dev);
3024 p2p_free_sd_queries(p2p);
3025 p2p->ssid_set = 0;
3026 p2ps_prov_free(p2p);
3027 p2p_reset_pending_pd(p2p);
3028 p2p->override_pref_op_class = 0;
3029 p2p->override_pref_channel = 0;
3033 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)
3037 dev = p2p_get_device(p2p, addr);
3041 p2p_dbg(p2p, "Unauthorizing " MACSTR, MAC2STR(addr));
3043 if (p2p->go_neg_peer == dev) {
3044 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
3045 p2p->go_neg_peer = NULL;
3057 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)
3059 os_free(p2p->cfg->dev_name);
3061 p2p->cfg->dev_name = os_strdup(dev_name);
3062 if (p2p->cfg->dev_name == NULL)
3065 p2p->cfg->dev_name = NULL;
3070 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)
3072 os_free(p2p->cfg->manufacturer);
3073 p2p->cfg->manufacturer = NULL;
3075 p2p->cfg->manufacturer = os_strdup(manufacturer);
3076 if (p2p->cfg->manufacturer == NULL)
3084 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)
3086 os_free(p2p->cfg->model_name);
3087 p2p->cfg->model_name = NULL;
3089 p2p->cfg->model_name = os_strdup(model_name);
3090 if (p2p->cfg->model_name == NULL)
3098 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)
3100 os_free(p2p->cfg->model_number);
3101 p2p->cfg->model_number = NULL;
3103 p2p->cfg->model_number = os_strdup(model_number);
3104 if (p2p->cfg->model_number == NULL)
3112 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)
3114 os_free(p2p->cfg->serial_number);
3115 p2p->cfg->serial_number = NULL;
3117 p2p->cfg->serial_number = os_strdup(serial_number);
3118 if (p2p->cfg->serial_number == NULL)
3126 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)
3128 p2p->cfg->config_methods = config_methods;
3132 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)
3134 os_memcpy(p2p->cfg->uuid, uuid, 16);
3138 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)
3140 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
3145 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
3150 p2p->cfg->num_sec_dev_types = num_dev_types;
3151 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
3156 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)
3161 wpabuf_free(p2p->wps_vendor_ext[i]);
3162 p2p->wps_vendor_ext[i] = NULL;
3167 int p2p_add_wps_vendor_extension(struct p2p_data *p2p,
3176 if (p2p->wps_vendor_ext[i] == NULL)
3182 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
3183 if (p2p->wps_vendor_ext[i] == NULL)
3190 int p2p_set_country(struct p2p_data *p2p, const char *country)
3192 os_memcpy(p2p->cfg->country, country, 3);
3197 static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev)
3204 dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries;
3207 res = p2p_start_sd(p2p, dev);
3215 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
3219 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
3227 void p2p_continue_find(struct p2p_data *p2p)
3232 p2p_set_state(p2p, P2P_SEARCH);
3236 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3237 if (dev == p2p->last_p2p_find_oper) {
3243 res = p2p_pre_find_operation(p2p, dev);
3245 p2p->last_p2p_find_oper = dev;
3256 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3257 res = p2p_pre_find_operation(p2p, dev);
3259 p2p->last_p2p_find_oper = dev;
3264 if (dev == p2p->last_p2p_find_oper)
3269 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
3270 p2p_listen_in_find(p2p, 1);
3274 static void p2p_sd_cb(struct p2p_data *p2p, int success)
3276 p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d",
3278 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3281 if (p2p->sd_peer) {
3282 if (is_zero_ether_addr(p2p->sd_query_no_ack)) {
3283 os_memcpy(p2p->sd_query_no_ack,
3284 p2p->sd_peer->info.p2p_device_addr,
3286 p2p_dbg(p2p,
3288 MACSTR, MAC2STR(p2p->sd_query_no_ack));
3290 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3292 p2p->sd_peer = NULL;
3293 if (p2p->state != P2P_IDLE)
3294 p2p_continue_find(p2p);
3298 if (p2p->sd_peer == NULL) {
3299 p2p_dbg(p2p, "No SD peer entry known");
3300 if (p2p->state != P2P_IDLE)
3301 p2p_continue_find(p2p);
3305 if (p2p->sd_query && p2p->sd_query->for_all_peers) {
3308 p2p->sd_peer->sd_pending_bcast_queries--;
3314 if (p2p->sd_peer->sd_pending_bcast_queries == 0)
3315 p2p->sd_peer->sd_pending_bcast_queries = -1;
3319 p2p_set_state(p2p, P2P_SD_DURING_FIND);
3320 p2p_set_timeout(p2p, 0, 200000);
3326 * @p2p: P2P module context from p2p_init()
3328 static void p2p_retry_pd(struct p2p_data *p2p)
3337 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3338 if (os_memcmp(p2p->pending_pd_devaddr,
3344 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
3348 p2p_send_prov_disc_req(p2p, dev,
3350 p2p->pd_force_freq);
3356 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
3358 p2p_dbg(p2p, "Provision Discovery Request TX callback: success=%d",
3372 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3374 if (p2p->user_initiated_pd &&
3375 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY))
3378 p2p->pending_action_state = P2P_PENDING_PD;
3379 p2p_set_timeout(p2p, 0, 50000);
3380 } else if (p2p->state != P2P_IDLE)
3381 p2p_continue_find(p2p);
3382 else if (p2p->user_initiated_pd) {
3383 p2p->pending_action_state = P2P_PENDING_PD;
3384 p2p_set_timeout(p2p, 0, 300000);
3395 if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker &&
3396 p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) {
3397 p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK");
3399 if (p2p->send_action_in_progress) {
3400 p2p->send_action_in_progress = 0;
3401 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3404 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3406 if (p2p->cfg->p2ps_prov_complete) {
3407 p2p->cfg->p2ps_prov_complete(
3408 p2p->cfg->cb_ctx,
3409 p2p->p2ps_prov->status,
3410 p2p->p2ps_prov->adv_mac,
3411 p2p->p2ps_prov->adv_mac,
3412 p2p->p2ps_prov->session_mac,
3413 NULL, p2p->p2ps_prov->adv_id,
3414 p2p->p2ps_prov->session_id,
3419 if (p2p->user_initiated_pd)
3420 p2p_reset_pending_pd(p2p);
3422 p2ps_prov_free(p2p);
3430 if (p2p->user_initiated_pd)
3431 p2p->pending_action_state = P2P_PENDING_PD;
3433 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3436 if (p2p->state == P2P_SEARCH)
3437 p2p_set_state(p2p, P2P_PD_DURING_FIND);
3438 p2p_set_timeout(p2p, 0, 200000);
3442 static void p2p_prov_disc_resp_cb(struct p2p_data *p2p, int success)
3444 p2p_dbg(p2p, "Provision Discovery Response TX callback: success=%d",
3447 if (p2p->send_action_in_progress) {
3448 p2p->send_action_in_progress = 0;
3449 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3452 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3457 if (!p2p->cfg->prov_disc_resp_cb ||
3458 p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1)
3461 p2p_dbg(p2p,
3466 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
3470 if (os_reltime_before(rx_time, &p2p->find_start)) {
3478 p2p_dbg(p2p, "Ignore old scan result for " MACSTR
3482 (unsigned int) p2p->find_start.sec,
3483 (unsigned int) p2p->find_start.usec);
3487 p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1);
3493 void p2p_scan_res_handled(struct p2p_data *p2p)
3495 if (!p2p->p2p_scan_running) {
3496 p2p_dbg(p2p, "p2p_scan was not running, but scan results received");
3498 p2p->p2p_scan_running = 0;
3499 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
3501 if (p2p_run_after_scan(p2p))
3503 if (p2p->state == P2P_SEARCH)
3504 p2p_continue_find(p2p);
3508 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id,
3515 if (p2p->wfd_ie_probe_req)
3516 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req);
3519 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3521 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3525 dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3528 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3535 if (p2p->cfg->reg_class && p2p->cfg->channel)
3536 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
3537 p2p->cfg->reg_class,
3538 p2p->cfg->channel);
3539 if (p2p->ext_listen_interval)
3540 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
3541 p2p->ext_listen_interval);
3544 p2p_buf_add_device_info(ies, p2p, NULL);
3546 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3547 p2p_buf_add_service_hash(ies, p2p);
3554 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p)
3559 if (p2p && p2p->wfd_ie_probe_req)
3560 len += wpabuf_len(p2p->wfd_ie_probe_req);
3563 if (p2p && p2p->vendor_elem &&
3564 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3565 len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3577 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)
3579 struct p2p_device *dev = p2p->go_neg_peer;
3582 p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success);
3585 p2p_dbg(p2p, "No pending GO Negotiation");
3591 p2p_set_state(p2p, P2P_IDLE);
3602 p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability through its GO",
3604 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3605 p2p_send_dev_disc_req(p2p, dev);
3613 p2p_set_state(p2p, P2P_CONNECT);
3615 if (!success && p2p->go_neg_peer &&
3616 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {
3628 p2p_set_timeout(p2p, 0, timeout);
3632 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
3634 p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d",
3636 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
3637 p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore");
3640 p2p_set_state(p2p, P2P_CONNECT);
3641 p2p_set_timeout(p2p, 0, 500000);
3645 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success,
3648 p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success);
3649 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
3650 p2p_go_neg_failed(p2p, p2p->go_neg_peer->status);
3656 dev = p2p_get_device(p2p, addr);
3662 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
3663 p2p_continue_find(p2p);
3667 static void p2p_go_neg_conf_cb(struct p2p_data *p2p,
3672 p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result);
3674 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3675 p2p_go_neg_failed(p2p, -1);
3679 dev = p2p->go_neg_peer;
3689 p2p_dbg(p2p, "GO Negotiation Confirm retry %d",
3691 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
3692 if (p2p_send_action(p2p, dev->go_neg_conf_freq,
3694 p2p->cfg->dev_addr,
3702 p2p_dbg(p2p, "Failed to re-send Action frame");
3720 p2p_dbg(p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack was not reported");
3723 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3728 p2p_go_complete(p2p, dev);
3732 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
3739 p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR
3741 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),
3742 MAC2STR(bssid), result, p2p_state_txt(p2p->state));
3744 state = p2p->pending_action_state;
3745 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3748 if (p2p->send_action_in_progress) {
3749 p2p->send_action_in_progress = 0;
3750 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3754 p2p_go_neg_req_cb(p2p, success);
3757 p2p_go_neg_resp_cb(p2p, success);
3760 p2p_go_neg_resp_failure_cb(p2p, success, dst);
3763 p2p_go_neg_conf_cb(p2p, result);
3766 p2p_sd_cb(p2p, success);
3769 p2p_prov_disc_cb(p2p, success);
3772 p2p_prov_disc_resp_cb(p2p, success);
3775 p2p_invitation_req_cb(p2p, success);
3778 p2p_invitation_resp_cb(p2p, success);
3781 p2p_dev_disc_req_cb(p2p, success);
3784 p2p_dev_disc_resp_cb(p2p, success);
3787 p2p_go_disc_req_cb(p2p, success);
3793 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
3796 if (freq == p2p->pending_client_disc_freq) {
3797 p2p_dbg(p2p, "Client discoverability remain-awake completed");
3798 p2p->pending_client_disc_freq = 0;
3802 if (freq != p2p->pending_listen_freq) {
3803 p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)",
3804 freq, duration, p2p->pending_listen_freq);
3808 p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback",
3809 p2p->pending_listen_sec, p2p->pending_listen_usec,
3810 p2p->pending_listen_freq);
3811 p2p->in_listen = 1;
3812 p2p->drv_in_listen = freq;
3813 if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
3819 p2p_set_timeout(p2p, p2p->pending_listen_sec,
3820 p2p->pending_listen_usec + 20000);
3823 p2p->pending_listen_freq = 0;
3827 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)
3829 p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq);
3830 p2p->drv_in_listen = 0;
3831 if (p2p->in_listen)
3834 if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer &&
3835 p2p->pending_listen_freq) {
3841 p2p_dbg(p2p,
3843 p2p_set_timeout(p2p, 0, 100000);
3847 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
3848 if (p2p->go_neg_peer->connect_reqs >= 120) {
3849 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");
3850 p2p_go_neg_failed(p2p, -1);
3854 p2p_set_state(p2p, P2P_CONNECT);
3855 p2p_connect_send(p2p, p2p->go_neg_peer);
3857 } else if (p2p->state == P2P_SEARCH) {
3858 if (p2p->p2p_scan_running) {
3867 p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one");
3870 if (p2p->pending_listen_freq) {
3876 p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop");
3877 p2p_set_timeout(p2p, 0, 100000);
3880 if (p2p->search_delay) {
3881 p2p_dbg(p2p, "Delay search operation by %u ms",
3882 p2p->search_delay);
3883 p2p_set_timeout(p2p, p2p->search_delay / 1000,
3884 (p2p->search_delay % 1000) * 1000);
3887 p2p_search(p2p);
3895 static void p2p_timeout_connect(struct p2p_data *p2p)
3897 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3898 if (p2p->go_neg_peer &&
3899 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
3900 p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed");
3901 p2p_go_neg_failed(p2p, -1);
3904 if (p2p->go_neg_peer &&
3905 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) &&
3906 p2p->go_neg_peer->connect_reqs < 120) {
3907 p2p_dbg(p2p, "Peer expected to wait our response - skip listen");
3908 p2p_connect_send(p2p, p2p->go_neg_peer);
3911 if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) {
3912 p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)");
3913 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
3914 p2p_set_timeout(p2p, 0, 30000);
3917 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
3918 p2p_listen_in_find(p2p, 0);
3922 static void p2p_timeout_connect_listen(struct p2p_data *p2p)
3924 if (p2p->go_neg_peer) {
3925 if (p2p->drv_in_listen) {
3926 p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete");
3930 if (p2p->go_neg_peer->connect_reqs >= 120) {
3931 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");
3932 p2p_go_neg_failed(p2p, -1);
3936 p2p_set_state(p2p, P2P_CONNECT);
3937 p2p_connect_send(p2p, p2p->go_neg_peer);
3939 p2p_set_state(p2p, P2P_IDLE);
3943 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)
3945 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
3947 if (p2p->cfg->is_concurrent_session_active &&
3948 p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx))
3949 p2p_set_timeout(p2p, 0, 500000);
3951 p2p_set_timeout(p2p, 0, 200000);
3955 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)
3957 struct p2p_device *dev = p2p->go_neg_peer;
3960 p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait");
3964 p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation");
3965 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
3966 p2p_listen_in_find(p2p, 0);
3970 static void p2p_timeout_sd_during_find(struct p2p_data *p2p)
3972 p2p_dbg(p2p, "Service Discovery Query timeout");
3973 if (p2p->sd_peer) {
3974 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3975 p2p->sd_peer = NULL;
3977 p2p_continue_find(p2p);
3981 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)
3983 p2p_dbg(p2p, "Provision Discovery Request timeout");
3984 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3985 p2p_continue_find(p2p);
3989 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)
3994 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4001 if (!p2p->user_initiated_pd)
4004 p2p_dbg(p2p, "User initiated Provision Discovery Request timeout");
4006 if (p2p->pd_retries) {
4007 p2p->pd_retries--;
4008 p2p_retry_pd(p2p);
4013 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
4014 if (os_memcmp(p2p->pending_pd_devaddr,
4022 if (p2p->p2ps_prov) {
4023 adv_id = p2p->p2ps_prov->adv_id;
4024 adv_mac = p2p->p2ps_prov->adv_mac;
4027 if (p2p->cfg->prov_disc_fail)
4028 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
4029 p2p->pending_pd_devaddr,
4034 p2p_reset_pending_pd(p2p);
4039 static void p2p_timeout_invite(struct p2p_data *p2p)
4041 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4042 p2p_set_state(p2p, P2P_INVITE_LISTEN);
4043 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
4048 p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel");
4049 p2p_set_timeout(p2p, 0, 100000);
4052 p2p_listen_in_find(p2p, 0);
4056 static void p2p_timeout_invite_listen(struct p2p_data *p2p)
4058 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
4059 p2p_set_state(p2p, P2P_INVITE);
4060 p2p_invite_send(p2p, p2p->invite_peer,
4061 p2p->invite_go_dev_addr, p2p->invite_dev_pw_id);
4063 if (p2p->invite_peer) {
4064 p2p_dbg(p2p, "Invitation Request retry limit reached");
4065 if (p2p->cfg->invitation_result)
4066 p2p->cfg->invitation_result(
4067 p2p->cfg->cb_ctx, -1, NULL, NULL,
4068 p2p->invite_peer->info.p2p_device_addr,
4071 p2p_set_state(p2p, P2P_IDLE);
4078 struct p2p_data *p2p = eloop_ctx;
4080 p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state));
4082 p2p->in_listen = 0;
4083 if (p2p->drv_in_listen) {
4084 p2p_dbg(p2p, "Driver is still in listen state - stop it");
4085 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
4088 switch (p2p->state) {
4091 if (p2p->pending_action_state == P2P_PENDING_PD)
4092 p2p_timeout_prov_disc_req(p2p);
4096 if (p2p->pending_action_state == P2P_PENDING_PD)
4097 p2p_timeout_prov_disc_req(p2p);
4098 if (p2p->search_delay && !p2p->in_search_delay) {
4099 p2p_dbg(p2p, "Delay search operation by %u ms",
4100 p2p->search_delay);
4101 p2p->in_search_delay = 1;
4102 p2p_set_timeout(p2p, p2p->search_delay / 1000,
4103 (p2p->search_delay % 1000) * 1000);
4106 p2p->in_search_delay = 0;
4107 p2p_search(p2p);
4110 p2p_timeout_connect(p2p);
4113 p2p_timeout_connect_listen(p2p);
4119 if (p2p->pending_action_state == P2P_PENDING_PD)
4120 p2p_timeout_prov_disc_req(p2p);
4122 if (p2p->ext_listen_only) {
4123 p2p_dbg(p2p, "Extended Listen Timing - Listen State completed");
4124 p2p->ext_listen_only = 0;
4125 p2p_set_state(p2p, P2P_IDLE);
4129 p2p_timeout_wait_peer_connect(p2p);
4132 p2p_timeout_wait_peer_idle(p2p);
4135 p2p_timeout_sd_during_find(p2p);
4140 p2p_timeout_prov_disc_during_find(p2p);
4143 p2p_timeout_invite(p2p);
4146 p2p_timeout_invite_listen(p2p);
4152 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)
4156 dev = p2p_get_device(p2p, peer_addr);
4157 p2p_dbg(p2p, "Local request to reject connection attempts by peer "
4160 p2p_dbg(p2p, "Peer " MACSTR " unknown", MAC2STR(peer_addr));
4205 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p,
4211 dev = p2p_get_device(p2p, addr);
4213 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4217 if (&dev->list == &p2p->devices)
4355 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr)
4357 return p2p_get_device(p2p, addr) != NULL;
4361 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)
4364 p2p_dbg(p2p, "Client discoverability enabled");
4365 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4367 p2p_dbg(p2p, "Client discoverability disabled");
4368 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4409 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
4416 p2p_dbg(p2p, "Send Presence Request to GO " MACSTR
4427 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4428 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,
4431 p2p_dbg(p2p, "Failed to send Action frame");
4464 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
4477 p2p_dbg(p2p, "Received P2P Action - P2P Presence Request");
4479 for (g = 0; g < p2p->num_groups; g++) {
4480 if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]),
4482 group = p2p->groups[g];
4487 p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group "
4493 p2p_dbg(p2p, "Failed to parse P2P Presence Request");
4500 p2p_dbg(p2p, "No NoA attribute in P2P Presence Request");
4508 if (p2p->cfg->get_noa)
4509 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
4521 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4522 if (p2p_send_action(p2p, rx_freq, sa, da, da,
4524 p2p_dbg(p2p, "Failed to send Action frame");
4530 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
4535 p2p_dbg(p2p, "Received P2P Action - P2P Presence Response");
4538 p2p_dbg(p2p, "Failed to parse P2P Presence Response");
4543 p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response");
4548 if (p2p->cfg->presence_resp) {
4549 p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status,
4554 p2p_dbg(p2p, "P2P Presence Request was rejected: status %u",
4560 p2p_dbg(p2p, "P2P Presence Request was accepted");
4570 struct p2p_data *p2p = eloop_ctx;
4572 if (p2p->ext_listen_interval) {
4574 eloop_register_timeout(p2p->ext_listen_interval_sec,
4575 p2p->ext_listen_interval_usec,
4576 p2p_ext_listen_timeout, p2p, NULL);
4579 if ((p2p->cfg->is_p2p_in_progress &&
4580 p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) ||
4581 (p2p->pending_action_state == P2P_PENDING_PD &&
4582 p2p->pd_retries > 0)) {
4583 p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)",
4584 p2p_state_txt(p2p->state));
4588 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
4595 p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");
4596 p2p->ext_listen_only = 0;
4597 p2p_set_state(p2p, P2P_IDLE);
4600 if (p2p->state != P2P_IDLE) {
4601 p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state));
4605 p2p_dbg(p2p, "Extended Listen timeout");
4606 p2p->ext_listen_only = 1;
4607 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
4608 p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing");
4609 p2p->ext_listen_only = 0;
4614 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
4619 p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u",
4624 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
4627 p2p_dbg(p2p, "Disabling Extended Listen Timing");
4628 p2p->ext_listen_period = 0;
4629 p2p->ext_listen_interval = 0;
4633 p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec",
4635 p2p->ext_listen_period = period;
4636 p2p->ext_listen_interval = interval;
4637 p2p->ext_listen_interval_sec = interval / 1000;
4638 p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
4640 eloop_register_timeout(p2p->ext_listen_interval_sec,
4641 p2p->ext_listen_interval_usec,
4642 p2p_ext_listen_timeout, p2p, NULL);
4648 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
4664 p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR
4672 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
4688 p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR
4696 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)
4699 p2p_dbg(p2p, "Managed P2P Device operations enabled");
4700 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
4702 p2p_dbg(p2p, "Managed P2P Device operations disabled");
4703 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
4708 int p2p_config_get_random_social(struct p2p_config *p2p, u8 *op_class,
4713 return p2p_channel_random_social(&p2p->channels, op_class, op_channel,
4718 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel,
4728 if (p2p->cfg->channel_forced && forced == 0) {
4729 p2p_dbg(p2p,
4734 p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u",
4737 if (p2p->state == P2P_IDLE) {
4738 p2p->cfg->reg_class = reg_class;
4739 p2p->cfg->channel = channel;
4740 p2p->cfg->channel_forced = forced;
4742 p2p_dbg(p2p, "Defer setting listen channel");
4743 p2p->pending_reg_class = reg_class;
4744 p2p->pending_channel = channel;
4745 p2p->pending_channel_forced = forced;
4752 u8 p2p_get_listen_channel(struct p2p_data *p2p)
4754 return p2p->cfg->channel;
4758 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)
4760 p2p_dbg(p2p, "New SSID postfix: %s", wpa_ssid_txt(postfix, len));
4762 p2p->cfg->ssid_postfix_len = 0;
4765 if (len > sizeof(p2p->cfg->ssid_postfix))
4767 os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
4768 p2p->cfg->ssid_postfix_len = len;
4773 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,
4779 p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u",
4781 p2p->cfg->op_reg_class = op_reg_class;
4782 p2p->cfg->op_channel = op_channel;
4783 p2p->cfg->cfg_op_channel = cfg_op_channel;
4788 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
4801 os_free(p2p->cfg->pref_chan);
4802 p2p->cfg->pref_chan = n;
4803 p2p->cfg->num_pref_chan = num_pref_chan;
4809 int p2p_set_no_go_freq(struct p2p_data *p2p,
4815 os_free(p2p->no_go_freq.range);
4816 p2p->no_go_freq.range = NULL;
4817 p2p->no_go_freq.num = 0;
4825 os_free(p2p->no_go_freq.range);
4826 p2p->no_go_freq.range = tmp;
4827 p2p->no_go_freq.num = list->num;
4828 p2p_dbg(p2p, "Updated no GO chan list");
4834 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
4837 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
4845 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
4848 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4856 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)
4858 os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
4859 if (is_zero_ether_addr(p2p->peer_filter))
4860 p2p_dbg(p2p, "Disable peer filter");
4862 p2p_dbg(p2p, "Enable peer filter for " MACSTR,
4863 MAC2STR(p2p->peer_filter));
4867 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)
4869 p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled");
4870 if (p2p->cross_connect == enabled)
4872 p2p->cross_connect = enabled;
4877 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)
4879 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4888 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)
4890 p2p_dbg(p2p, "Intra BSS distribution %s",
4892 p2p->cfg->p2p_intra_bss = enabled;
4896 void p2p_update_channel_list(struct p2p_data *p2p,
4900 p2p_dbg(p2p, "Update channel list");
4901 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
4902 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
4903 os_memcpy(&p2p->cfg->cli_channels, cli_chan,
4905 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
4909 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
4915 res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
4917 if (res == 0 && scheduled && p2p->in_listen && freq > 0 &&
4918 (unsigned int) p2p->drv_in_listen != freq) {
4919 p2p_dbg(p2p,
4921 p2p->drv_in_listen, freq);
4922 p2p_stop_listen_for_freq(p2p, freq);
4928 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,
4931 p2p_dbg(p2p, "Best channel: 2.4 GHz: %d, 5 GHz: %d, overall: %d",
4933 p2p->best_freq_24 = freq_24;
4934 p2p->best_freq_5 = freq_5;
4935 p2p->best_freq_overall = freq_overall;
4939 void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq)
4941 p2p_dbg(p2p, "Own frequency preference: %d MHz", freq);
4942 p2p->own_freq_preference = freq;
4946 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)
4948 if (p2p == NULL || p2p->go_neg_peer == NULL)
4950 return p2p->go_neg_peer->info.p2p_device_addr;
4955 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)
4960 dev = p2p_get_device(p2p, addr);
4974 if (!dev || &dev->list == &p2p->devices)
4979 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4986 if (!dev || &dev->list == &p2p->devices)
4995 int p2p_in_progress(struct p2p_data *p2p)
4997 if (p2p == NULL)
4999 if (p2p->state == P2P_SEARCH)
5001 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;
5005 void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout,
5008 if (p2p) {
5009 p2p->go_timeout = go_timeout;
5010 p2p->client_timeout = client_timeout;
5017 static void p2p_update_wfd_ie_groups(struct p2p_data *p2p)
5022 for (g = 0; g < p2p->num_groups; g++) {
5023 group = p2p->groups[g];
5029 int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie)
5031 wpabuf_free(p2p->wfd_ie_beacon);
5032 p2p->wfd_ie_beacon = ie;
5033 p2p_update_wfd_ie_groups(p2p);
5038 int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie)
5040 wpabuf_free(p2p->wfd_ie_probe_req);
5041 p2p->wfd_ie_probe_req = ie;
5046 int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie)
5048 wpabuf_free(p2p->wfd_ie_probe_resp);
5049 p2p->wfd_ie_probe_resp = ie;
5050 p2p_update_wfd_ie_groups(p2p);
5055 int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie)
5057 wpabuf_free(p2p->wfd_ie_assoc_req);
5058 p2p->wfd_ie_assoc_req = ie;
5063 int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie)
5065 wpabuf_free(p2p->wfd_ie_invitation);
5066 p2p->wfd_ie_invitation = ie;
5071 int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie)
5073 wpabuf_free(p2p->wfd_ie_prov_disc_req);
5074 p2p->wfd_ie_prov_disc_req = ie;
5079 int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie)
5081 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
5082 p2p->wfd_ie_prov_disc_resp = ie;
5087 int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie)
5089 wpabuf_free(p2p->wfd_ie_go_neg);
5090 p2p->wfd_ie_go_neg = ie;
5095 int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)
5097 wpabuf_free(p2p->wfd_dev_info);
5099 p2p->wfd_dev_info = wpabuf_dup(elem);
5100 if (p2p->wfd_dev_info == NULL)
5103 p2p->wfd_dev_info = NULL;
5109 int p2p_set_wfd_r2_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)
5111 wpabuf_free(p2p->wfd_r2_dev_info);
5113 p2p->wfd_r2_dev_info = wpabuf_dup(elem);
5114 if (p2p->wfd_r2_dev_info == NULL)
5117 p2p->wfd_r2_dev_info = NULL;
5123 int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem)
5125 wpabuf_free(p2p->wfd_assoc_bssid);
5127 p2p->wfd_assoc_bssid = wpabuf_dup(elem);
5128 if (p2p->wfd_assoc_bssid == NULL)
5131 p2p->wfd_assoc_bssid = NULL;
5137 int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p,
5140 wpabuf_free(p2p->wfd_coupled_sink_info);
5142 p2p->wfd_coupled_sink_info = wpabuf_dup(elem);
5143 if (p2p->wfd_coupled_sink_info == NULL)
5146 p2p->wfd_coupled_sink_info = NULL;
5154 int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int,
5160 p2p->min_disc_int = min_disc_int;
5161 p2p->max_disc_int = max_disc_int;
5162 p2p->max_disc_tu = max_disc_tu;
5163 p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d",
5170 void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...)
5175 if (!p2p->cfg->debug_print)
5182 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf);
5186 void p2p_info(struct p2p_data *p2p, const char *fmt, ...)
5191 if (!p2p->cfg->debug_print)
5198 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf);
5202 void p2p_err(struct p2p_data *p2p, const char *fmt, ...)
5207 if (!p2p->cfg->debug_print)
5214 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf);
5218 void p2p_loop_on_known_peers(struct p2p_data *p2p,
5225 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
5233 static struct wpabuf * p2p_build_nfc_handover(struct p2p_data *p2p,
5246 op_class = p2p->cfg->reg_class;
5247 channel = p2p->cfg->channel;
5249 p2p_buf_add_capability(buf, p2p->dev_capab &
5251 p2p_buf_add_device_info(buf, p2p, NULL);
5253 if (p2p->num_groups > 0) {
5254 int freq = p2p_group_get_freq(p2p->groups[0]);
5257 p2p_dbg(p2p,
5266 p2p_dbg(p2p,
5274 p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class,
5277 if (p2p->num_groups > 0) {
5279 p2p_buf_add_group_info(p2p->groups[0], buf, 5);
5280 p2p_group_buf_add_id(p2p->groups[0], buf);
5295 struct wpabuf * p2p_build_nfc_handover_req(struct p2p_data *p2p,
5300 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,
5305 struct wpabuf * p2p_build_nfc_handover_sel(struct p2p_data *p2p,
5310 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,
5315 int p2p_process_nfc_connection_handover(struct p2p_data *p2p,
5328 p2p_dbg(p2p, "Failed to parse WSC/P2P attributes from NFC");
5338 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");
5349 dev = p2p_create_device(p2p, p2p_dev_addr);
5359 p2p_copy_wps_info(p2p, dev, 0, &msg);
5362 p2p_dbg(p2p, "OOB GO Negotiation Channel attribute not included");
5374 p2p_dbg(p2p, "Unknown peer OOB GO Neg channel");
5381 p2p_dbg(p2p, "Peer OOB GO operating channel: %u MHz", freq);
5384 p2p_dbg(p2p, "Peer (client) OOB GO operating channel: %u MHz",
5388 p2p_dbg(p2p, "Peer OOB GO Neg channel: %u MHz", freq);
5392 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
5393 p2p->cfg->channel);
5395 p2p_dbg(p2p, "Own listen channel not known");
5399 p2p_dbg(p2p, "Use own Listen channel as OOB GO Neg channel: %u MHz", freq);
5411 p2p_dbg(p2p, "Do not report rejected device");
5417 p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info,
5423 if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0)
5430 } else if (p2p->num_groups > 0)
5441 void p2p_set_authorized_oob_dev_pw_id(struct p2p_data *p2p, u16 dev_pw_id,
5446 p2p->authorized_oob_dev_pw_id = dev_pw_id;
5448 p2p_dbg(p2p, "NFC OOB Password unauthorized for static handover");
5452 p2p_dbg(p2p, "NFC OOB Password (id=%u) authorized for static handover",
5455 p2p->go_intent = go_intent;
5456 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
5462 int p2p_set_passphrase_len(struct p2p_data *p2p, unsigned int len)
5466 p2p->cfg->passphrase_len = len;
5471 void p2p_set_vendor_elems(struct p2p_data *p2p, struct wpabuf **vendor_elem)
5473 p2p->vendor_elem = vendor_elem;
5479 struct p2p_data *p2p = eloop_ctx;
5481 p2p_dbg(p2p,
5483 p2p_go_neg_failed(p2p, -1);
5487 void p2p_set_own_pref_freq_list(struct p2p_data *p2p,
5495 p2p->num_pref_freq = size;
5497 p2p->pref_freq_list[i] = pref_freq_list[i];
5498 p2p_dbg(p2p, "Own preferred frequency list[%u]=%u MHz",
5499 i, p2p->pref_freq_list[i]);
5504 void p2p_set_override_pref_op_chan(struct p2p_data *p2p, u8 op_class,
5507 p2p->override_pref_op_class = op_class;
5508 p2p->override_pref_channel = chan;
5512 struct wpabuf * p2p_build_probe_resp_template(struct p2p_data *p2p,
5519 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
5532 ret = p2p_build_probe_resp_buf(p2p, buf, ies, addr, freq);