Lines Matching refs:p2p
2 * Wi-Fi Direct - P2P module
17 #include "p2p.h"
21 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
22 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
25 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
36 * timeout for this to avoid hitting P2P timeout unnecessarily.
53 int p2p_connection_in_progress(struct p2p_data *p2p)
57 switch (p2p->state) {
70 wpa_printf(MSG_DEBUG, "p2p_connection_in_progress state %d", p2p->state);
78 static void p2p_expire_peers(struct p2p_data *p2p)
85 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
89 if (p2p->cfg->go_connected &&
90 p2p->cfg->go_connected(p2p->cfg->cb_ctx,
100 for (i = 0; i < p2p->num_groups; i++) {
102 p2p->groups[i], dev->info.p2p_device_addr))
105 if (i < p2p->num_groups) {
117 if (p2p_connection_in_progress(p2p))
121 p2p_dbg(p2p, "Expiring old peer entry " MACSTR,
126 if(&dev->list == p2p->sd_dev_list)
127 p2p->sd_dev_list = dev->list.next;
130 p2p_device_free(p2p, dev);
137 struct p2p_data *p2p = eloop_ctx;
138 p2p_expire_peers(p2p);
140 p2p_expiration_timeout, p2p, NULL);
183 const char * p2p_get_state_txt(struct p2p_data *p2p)
185 return p2p_state_txt(p2p->state);
189 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr)
193 if (!addr || !p2p)
196 dev = p2p_get_device(p2p, addr);
204 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr)
208 if (!addr || !p2p)
211 dev = p2p_get_device(p2p, addr);
217 void p2p_set_state(struct p2p_data *p2p, int new_state)
219 p2p_dbg(p2p, "State %s -> %s",
220 p2p_state_txt(p2p->state), p2p_state_txt(new_state));
221 p2p->state = new_state;
225 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)
227 p2p_dbg(p2p, "Set timeout (state=%s): %u.%06u sec",
228 p2p_state_txt(p2p->state), sec, usec);
229 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
230 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);
234 void p2p_clear_timeout(struct p2p_data *p2p)
236 p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state));
237 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
241 void p2p_go_neg_failed(struct p2p_data *p2p, struct p2p_device *peer,
245 p2p_clear_timeout(p2p);
246 p2p_set_state(p2p, P2P_IDLE);
247 if (p2p->go_neg_peer) {
248 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
249 p2p->go_neg_peer->wps_method = WPS_NOT_READY;
251 p2p->go_neg_peer = NULL;
261 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
265 static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc)
271 p2p_dbg(p2p, "Starting short listen state (state=%s)",
272 p2p_state_txt(p2p->state));
274 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
276 p2p_dbg(p2p, "Unknown regulatory class/channel");
281 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +
282 p2p->min_disc_int) * 100;
283 if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu)
284 tu = p2p->max_disc_tu;
287 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen)
288 tu = p2p->cfg->max_listen * 1000 / 1024;
291 p2p_dbg(p2p, "Skip listen state since duration was 0 TU");
292 p2p_set_timeout(p2p, 0, 0);
296 p2p->pending_listen_freq = freq;
297 p2p->pending_listen_sec = 0;
298 p2p->pending_listen_usec = 1024 * tu;
300 ies = p2p_build_probe_resp_ies(p2p);
304 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,
306 p2p_dbg(p2p, "Failed to start listen mode");
307 p2p->pending_listen_freq = 0;
313 int p2p_listen(struct p2p_data *p2p, unsigned int timeout)
318 p2p_dbg(p2p, "Going to listen(only) state");
320 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
322 p2p_dbg(p2p, "Unknown regulatory class/channel");
326 p2p->pending_listen_freq = freq;
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);
344 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
345 p2p_dbg(p2p, "Failed to start listen mode");
346 p2p->pending_listen_freq = 0;
352 p2p_set_state(p2p, P2P_LISTEN_ONLY);
358 static void p2p_device_clear_reported(struct p2p_data *p2p)
361 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list)
368 * @p2p: P2P module context from p2p_init()
369 * @addr: P2P Device Address of the peer
372 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)
375 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
384 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address
385 * @p2p: P2P module context from p2p_init()
386 * @addr: P2P Interface Address of the peer
389 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,
393 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
403 * @p2p: P2P module context from p2p_init()
404 * @addr: P2P Device Address of the peer
410 static struct p2p_device * p2p_create_device(struct p2p_data *p2p,
416 dev = p2p_get_device(p2p, addr);
420 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
426 if (count + 1 > p2p->cfg->max_peers && oldest) {
427 p2p_dbg(p2p, "Remove oldest peer entry to make room for a new peer");
430 if(&oldest->list == p2p->sd_dev_list)
431 p2p->sd_dev_list = oldest->list.next;
434 p2p_device_free(p2p, oldest);
440 dl_list_add(&p2p->devices, &dev->list);
461 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,
479 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
489 if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr,
492 dev = p2p_get_device(p2p, cli->p2p_device_addr);
503 * Need to update P2P Client Discoverability
504 * flag since it is valid only in P2P Group
517 dev = p2p_create_device(p2p, cli->p2p_device_addr);
523 p2p->cfg->dev_found(p2p->cfg->cb_ctx,
541 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev,
596 * P2P Client Discoverability bit is reserved in all frames
617 p2p_dbg(p2p, "Update peer " MACSTR
629 * p2p_add_device - Add peer entries based on scan results or P2P frames
630 * @p2p: P2P module context from p2p_init()
632 * P2P Device Address or P2P Interface Address)
643 * like Provision Discovery Request that contains P2P Capability and P2P Device
646 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq,
658 p2p_dbg(p2p, "Failed to parse P2P IE for a device entry");
668 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");
673 if (!is_zero_ether_addr(p2p->peer_filter) &&
674 os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) {
675 p2p_dbg(p2p, "Do not add peer filter for " MACSTR
681 dev = p2p_create_device(p2p, p2p_dev_addr);
698 p2p_dbg(p2p, "Do not update peer entry based on old frame (rx_time=%u.%06u last_seen=%u.%06u)",
729 p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz",
736 p2p_dbg(p2p, "Update Listen frequency based on scan results ("
748 p2p_copy_wps_info(p2p, dev, 0, &msg);
770 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq,
776 if (p2p_pending_sd_req(p2p, dev))
782 p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)",
786 p2p_dbg(p2p, "Do not report rejected device");
795 * applications use config_methods value from P2P-DEVICE-FOUND
806 p2p_dbg(p2p, "Do not report peer " MACSTR
811 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
819 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
823 if (p2p->go_neg_peer == dev) {
827 p2p_go_neg_failed(p2p, dev, -1);
828 p2p->go_neg_peer = NULL;
830 if (p2p->invite_peer == dev)
831 p2p->invite_peer = NULL;
832 if (p2p->sd_peer == dev)
833 p2p->sd_peer = NULL;
834 if (p2p->pending_client_disc_go == dev)
835 p2p->pending_client_disc_go = NULL;
839 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
853 static int p2p_get_next_prog_freq(struct p2p_data *p2p)
863 c = &p2p->cfg->channels;
866 if (cla->reg_class != p2p->last_prog_scan_class)
869 if (cla->channel[ch] == p2p->last_prog_scan_chan) {
896 p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz",
898 p2p->last_prog_scan_class = reg_class;
899 p2p->last_prog_scan_chan = channel;
907 static void p2p_search(struct p2p_data *p2p)
914 if (p2p->drv_in_listen) {
915 p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing");
918 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
920 if (p2p->find_type == P2P_FIND_PROGRESSIVE &&
921 (freq = p2p_get_next_prog_freq(p2p)) > 0) {
923 p2p_dbg(p2p, "Starting search (+ freq %u)", freq);
926 p2p_dbg(p2p, "Starting search");
929 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
930 p2p->num_req_dev_types, p2p->req_dev_types,
931 p2p->find_dev_id, pw_id);
933 p2p_dbg(p2p, "Scan request failed");
934 p2p_continue_find(p2p);
936 p2p_dbg(p2p, "Could not start p2p_scan at this point - will try again after previous scan completes");
937 p2p_set_state(p2p, P2P_CONTINUE_SEARCH_WHEN_READY);
939 p2p_dbg(p2p, "Running p2p_scan");
940 p2p->p2p_scan_running = 1;
941 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
943 p2p, NULL);
950 struct p2p_data *p2p = eloop_ctx;
951 p2p_dbg(p2p, "Find timeout -> stop");
952 p2p_stop_find(p2p);
956 static int p2p_run_after_scan(struct p2p_data *p2p)
961 if (p2p->after_scan_tx) {
962 p2p->after_scan_tx_in_progress = 1;
963 p2p_dbg(p2p, "Send pending Action frame at p2p_scan completion");
964 p2p->cfg->send_action(p2p->cfg->cb_ctx,
965 p2p->after_scan_tx->freq,
966 p2p->after_scan_tx->dst,
967 p2p->after_scan_tx->src,
968 p2p->after_scan_tx->bssid,
969 (u8 *) (p2p->after_scan_tx + 1),
970 p2p->after_scan_tx->len,
971 p2p->after_scan_tx->wait_time);
972 os_free(p2p->after_scan_tx);
973 p2p->after_scan_tx = NULL;
985 op = p2p->start_after_scan;
986 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
991 p2p_dbg(p2p, "Start previously requested Listen state");
992 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
993 p2p->pending_listen_usec / 1000);
996 p2p_dbg(p2p, "Start previously requested connect with " MACSTR,
997 MAC2STR(p2p->after_scan_peer));
998 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1000 p2p_dbg(p2p, "Peer not known anymore");
1003 p2p_connect_send(p2p, dev);
1013 struct p2p_data *p2p = eloop_ctx;
1015 p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running);
1016 running = p2p->p2p_scan_running;
1018 p2p->p2p_scan_running = 0;
1021 p2p_run_after_scan(p2p);
1025 static void p2p_free_req_dev_types(struct p2p_data *p2p)
1027 p2p->num_req_dev_types = 0;
1028 os_free(p2p->req_dev_types);
1029 p2p->req_dev_types = NULL;
1033 int p2p_find(struct p2p_data *p2p, unsigned int timeout,
1040 p2p_dbg(p2p, "Starting find (type=%d)", type);
1041 os_get_time(&p2p->find_start);
1042 if (p2p->p2p_scan_running) {
1043 p2p_dbg(p2p, "p2p_scan is already running");
1046 p2p_free_req_dev_types(p2p);
1048 p2p->req_dev_types = os_malloc(num_req_dev_types *
1050 if (p2p->req_dev_types == NULL)
1052 os_memcpy(p2p->req_dev_types, req_dev_types,
1054 p2p->num_req_dev_types = num_req_dev_types;
1058 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);
1059 p2p->find_dev_id = p2p->find_dev_id_buf;
1061 p2p->find_dev_id = NULL;
1063 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1064 p2p_clear_timeout(p2p);
1065 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1066 p2p->find_type = type;
1067 p2p_device_clear_reported(p2p);
1068 p2p_set_state(p2p, P2P_SEARCH);
1069 p2p->search_delay = search_delay;
1070 p2p->in_search_delay = 0;
1071 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1072 p2p->last_p2p_find_timeout = timeout;
1075 p2p, NULL);
1079 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
1080 p2p->num_req_dev_types,
1081 p2p->req_dev_types, dev_id,
1085 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
1086 p2p->num_req_dev_types,
1087 p2p->req_dev_types, dev_id,
1095 p2p_dbg(p2p, "Running p2p_scan");
1096 p2p->p2p_scan_running = 1;
1097 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
1099 p2p, NULL);
1101 p2p_dbg(p2p, "Could not start p2p_scan at this point - will try again after previous scan completes");
1103 p2p_set_state(p2p, P2P_SEARCH_WHEN_READY);
1104 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1106 p2p_dbg(p2p, "Failed to start p2p_scan");
1107 p2p_set_state(p2p, P2P_IDLE);
1108 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1115 int p2p_search_pending(struct p2p_data *p2p)
1117 if(p2p == NULL)
1120 if(p2p->state == P2P_SEARCH_WHEN_READY)
1127 int p2p_other_scan_completed(struct p2p_data *p2p)
1129 if (p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY) {
1130 p2p_set_state(p2p, P2P_SEARCH);
1131 p2p_search(p2p);
1134 if (p2p->state != P2P_SEARCH_WHEN_READY)
1136 p2p_dbg(p2p, "Starting pending P2P find now that previous scan was completed");
1137 if (p2p_find(p2p, p2p->last_p2p_find_timeout, p2p->find_type,
1138 p2p->num_req_dev_types, p2p->req_dev_types,
1139 p2p->find_dev_id, p2p->search_delay) < 0) {
1140 p2p->cfg->find_stopped(p2p->cfg->cb_ctx);
1147 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)
1149 p2p_dbg(p2p, "Stopping find");
1150 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1151 p2p_clear_timeout(p2p);
1152 if (p2p->state == P2P_SEARCH ||
1153 p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY ||
1154 p2p->state == P2P_SEARCH_WHEN_READY)
1155 p2p->cfg->find_stopped(p2p->cfg->cb_ctx);
1156 p2p_set_state(p2p, P2P_IDLE);
1157 p2p_free_req_dev_types(p2p);
1158 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1159 if (p2p->go_neg_peer)
1160 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
1161 p2p->go_neg_peer = NULL;
1162 p2p->sd_peer = NULL;
1163 p2p->invite_peer = NULL;
1164 p2p_stop_listen_for_freq(p2p, freq);
1168 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq)
1170 if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) {
1171 p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response");
1174 if (p2p->in_listen) {
1175 p2p->in_listen = 0;
1176 p2p_clear_timeout(p2p);
1178 if (p2p->drv_in_listen) {
1184 p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen);
1185 p2p->drv_in_listen = 0;
1187 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1191 void p2p_stop_listen(struct p2p_data *p2p)
1193 if (p2p->state != P2P_LISTEN_ONLY) {
1194 p2p_dbg(p2p, "Skip stop_listen since not in listen_only state.");
1198 p2p_stop_listen_for_freq(p2p, 0);
1199 p2p_set_state(p2p, P2P_IDLE);
1203 void p2p_stop_find(struct p2p_data *p2p)
1205 p2p_stop_find_for_freq(p2p, 0);
1209 static int p2p_prepare_channel_pref(struct p2p_data *p2p,
1216 p2p_dbg(p2p
1219 p2p_dbg(p2p, "Unsupported frequency %u MHz", freq);
1223 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel)) {
1224 p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P",
1229 p2p->op_reg_class = op_class;
1230 p2p->op_channel = op_channel;
1233 p2p->channels.reg_classes = 1;
1234 p2p->channels.reg_class[0].channels = 1;
1235 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
1236 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
1238 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1246 static void p2p_prepare_channel_best(struct p2p_data *p2p)
1250 p2p_dbg(p2p, "Prepare channel best");
1252 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
1253 p2p_supported_freq(p2p, p2p->best_freq_overall) &&
1254 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel)
1256 p2p_dbg(p2p, "Select best overall channel as operating channel preference");
1257 p2p->op_reg_class = op_class;
1258 p2p->op_channel = op_channel;
1259 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
1260 p2p_supported_freq(p2p, p2p->best_freq_5) &&
1261 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel)
1263 p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference");
1264 p2p->op_reg_class = op_class;
1265 p2p->op_channel = op_channel;
1266 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 &&
1267 p2p_supported_freq(p2p, p2p->best_freq_24) &&
1268 p2p_freq_to_channel(p2p->best_freq_24, &op_class,
1270 p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference");
1271 p2p->op_reg_class = op_class;
1272 p2p->op_channel = op_channel;
1273 } else if (p2p->cfg->num_pref_chan > 0 &&
1274 p2p_channels_includes(&p2p->cfg->channels,
1275 p2p->cfg->pref_chan[0].op_class,
1276 p2p->cfg->pref_chan[0].chan)) {
1277 p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference");
1278 p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class;
1279 p2p->op_channel = p2p->cfg->pref_chan[0].chan;
1281 p2p_dbg(p2p, "Select pre-configured channel as operating channel preference");
1282 p2p->op_reg_class = p2p->cfg->op_reg_class;
1283 p2p->op_channel = p2p->cfg->op_channel;
1286 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1293 * @p2p: P2P module context from p2p_init()
1297 * Returns: 0 on success, -1 on failure (channel not supported for P2P)
1304 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,
1307 p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u",
1310 if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq) < 0)
1313 p2p_prepare_channel_best(p2p);
1315 p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s",
1316 p2p->op_reg_class, p2p->op_channel,
1348 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
1357 p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR
1363 dev = p2p_get_device(p2p, peer_addr);
1365 p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR,
1370 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0)
1376 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR
1382 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR
1395 p2p->ssid_set = 0;
1397 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1399 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1400 p2p->ssid_len = force_ssid_len;
1401 p2p->ssid_set = 1;
1419 dev->tie_breaker = p2p->next_tie_breaker;
1420 p2p->next_tie_breaker = !p2p->next_tie_breaker;
1426 p2p->go_intent = go_intent;
1427 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1429 if (p2p->state != P2P_IDLE)
1430 p2p_stop_find(p2p);
1432 if (p2p->after_scan_tx) {
1438 p2p_dbg(p2p, "Dropped previous pending Action frame TX that was waiting for p2p_scan completion");
1439 os_free(p2p->after_scan_tx);
1440 p2p->after_scan_tx = NULL;
1446 if (p2p->p2p_scan_running) {
1447 p2p_dbg(p2p, "p2p_scan running - delay connect send");
1448 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1449 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1452 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1454 return p2p_connect_send(p2p, dev);
1458 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
1467 p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR
1473 dev = p2p_get_device(p2p, peer_addr);
1475 p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR,
1480 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0)
1483 p2p->ssid_set = 0;
1485 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1487 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1488 p2p->ssid_len = force_ssid_len;
1489 p2p->ssid_set = 1;
1497 p2p->go_intent = go_intent;
1498 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1507 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,
1512 p2p_copy_wps_info(p2p, dev, 0, msg);
1519 p2p_dbg(p2p, "Unknown peer Listen channel: "
1527 p2p_dbg(p2p, "Update peer " MACSTR
1542 p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request");
1544 p2p_dbg(p2p, "Created device entry based on GO Neg Req: "
1555 p2p_dbg(p2p, "Do not report rejected device");
1559 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1565 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
1570 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1571 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1575 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)
1577 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len);
1583 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)
1591 p2p_dbg(p2p, "GO Negotiation with " MACSTR " completed (%s will be GO)",
1608 res.freq = p2p_channel_to_freq(p2p->op_reg_class,
1609 p2p->op_channel);
1610 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1611 res.ssid_len = p2p->ssid_len;
1615 if (p2p->ssid_len) {
1616 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1617 res.ssid_len = p2p->ssid_len;
1621 p2p_channels_intersect(&p2p->channels, &peer->channels,
1641 p2p_clear_timeout(p2p);
1642 p2p->ssid_set = 0;
1646 p2p_set_state(p2p, P2P_PROVISIONING);
1647 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
1651 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,
1654 p2p_dbg(p2p, "RX P2P Public Action from " MACSTR, MAC2STR(sa));
1655 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len);
1662 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
1665 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
1668 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
1671 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
1675 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
1678 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1681 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
1684 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1687 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
1690 p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d",
1697 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da,
1721 p2p_rx_p2p_action(p2p, sa, data + 1, len - 1, freq);
1724 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
1727 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
1730 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
1733 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
1739 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
1744 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);
1764 /* P2P action frame */
1765 p2p_dbg(p2p, "RX P2P Action from " MACSTR, MAC2STR(sa));
1766 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len);
1772 p2p_dbg(p2p, "Received P2P Action - Notice of Absence");
1776 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
1779 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
1782 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
1785 p2p_dbg(p2pP2P Action - unknown type %u", data[0]);
1793 struct p2p_data *p2p = eloop_ctx;
1794 if (p2p->go_neg_peer == NULL)
1796 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1797 p2p->go_neg_peer->status = P2P_SC_SUCCESS;
1798 p2p_connect_send(p2p, p2p->go_neg_peer);
1804 struct p2p_data *p2p = eloop_ctx;
1805 if (p2p->invite_peer == NULL)
1807 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1808 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr);
1812 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,
1822 return; /* not a P2P probe */
1828 /* The Probe Request is not part of P2P Device Discovery. It is
1829 * not known whether the source address of the frame is the P2P
1830 * Device Address or P2P Interface Address. Do not add a new
1837 dev = p2p_get_device(p2p, addr);
1846 dev = p2p_create_device(p2p, addr);
1861 p2p_copy_wps_info(p2p, dev, 1, &msg);
1870 p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR
1878 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,
1884 dev = p2p_get_device(p2p, addr);
1890 dev = p2p_create_device(p2p, addr);
1894 p2p_add_dev_info(p2p, addr, dev, msg);
1926 * @p2p: P2P module context from p2p_init()
1934 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)
1945 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
1949 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++)
1950 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
1960 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p)
1968 if (p2p->wfd_ie_probe_resp)
1969 extra = wpabuf_len(p2p->wfd_ie_probe_resp);
1976 if (p2p->go_neg_peer) {
1978 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
1981 p2p_build_wps_ie(p2p, buf, pw_id, 1);
1984 if (p2p->wfd_ie_probe_resp)
1985 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp);
1988 /* P2P IE */
1990 p2p_buf_add_capability(buf, p2p->dev_capab &
1992 if (p2p->ext_listen_interval)
1993 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
1994 p2p->ext_listen_interval);
1995 p2p_buf_add_device_info(buf, p2p, NULL);
2003 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2012 if (!p2p->in_listen || !p2p->drv_in_listen) {
2023 if (elems.p2p == NULL) {
2024 /* not a P2P probe - ignore it */
2029 os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
2030 /* Not sent to the broadcast address or our P2P Device Address
2043 /* not using P2P Wildcard SSID - ignore */
2054 /* Could not parse P2P attributes */
2059 os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
2067 !p2p_match_dev_type(p2p, msg.wps_attributes)) {
2074 if (!p2p->cfg->send_probe_resp) {
2079 p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state");
2087 ies = p2p_build_probe_resp_ies(p2p);
2103 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
2104 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
2129 wpabuf_put_u8(buf, p2p->cfg->channel);
2134 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf);
2143 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2148 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);
2150 res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len);
2152 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
2153 p2p->go_neg_peer &&
2154 os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)
2156 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
2158 p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout");
2159 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
2160 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);
2164 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
2165 p2p->invite_peer &&
2166 os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)
2169 p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout");
2170 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);
2178 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,
2188 return 0; /* WLAN AP is not a P2P manager */
2191 * (Re)Association Request - P2P IE
2192 * P2P Capability attribute (shall be present)
2193 * P2P Interface attribute (present if concurrent device and
2194 * P2P Management is enabled)
2202 if (p2p->num_groups > 0) {
2204 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2205 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
2206 p2p->cross_connect)
2209 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
2210 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2211 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
2212 p2p_buf_add_p2p_interface(tmp, p2p);
2228 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
2239 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);
2242 if (p2p->wfd_ie_assoc_req)
2243 extra = wpabuf_len(p2p->wfd_ie_assoc_req);
2247 * (Re)Association Request - P2P IE
2248 * P2P Capability attribute (shall be present)
2250 * P2P Device Info attribute (shall be present)
2257 if (p2p->wfd_ie_assoc_req)
2258 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req);
2261 peer = bssid ? p2p_get_device(p2p, bssid) : NULL;
2264 p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
2265 if (p2p->ext_listen_interval)
2266 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
2267 p2p->ext_listen_interval);
2268 p2p_buf_add_device_info(tmp, p2p, peer);
2333 static void p2p_clear_go_neg(struct p2p_data *p2p)
2335 p2p->go_neg_peer = NULL;
2336 p2p_clear_timeout(p2p);
2337 p2p_set_state(p2p, P2P_IDLE);
2341 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)
2343 if (p2p->go_neg_peer == NULL) {
2344 p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification");
2348 if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) !=
2350 p2p_dbg(p2p, "Ignore WPS registration success notification for "
2353 MAC2STR(p2p->go_neg_peer->intended_addr));
2357 p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR,
2360 p2p_clear_go_neg(p2p);
2364 void p2p_group_formation_failed(struct p2p_data *p2p)
2366 if (p2p->go_neg_peer == NULL) {
2367 p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification");
2371 p2p_dbg(p2p, "Group Formation failed with " MACSTR,
2372 MAC2STR(p2p->go_neg_peer->intended_addr));
2374 p2p_clear_go_neg(p2p);
2380 struct p2p_data *p2p;
2385 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));
2386 if (p2p == NULL)
2388 p2p->cfg = (struct p2p_config *) (p2p + 1);
2389 os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
2391 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
2393 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
2395 p2p->cfg->model_name = os_strdup(cfg->model_name);
2397 p2p->cfg->model_number = os_strdup(cfg->model_number);
2399 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
2401 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *
2403 if (p2p->cfg->pref_chan) {
2404 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,
2408 p2p
2415 p2p->min_disc_int = 2;
2417 p2p->sd_dev_list = NULL;
2419 p2p->min_disc_int = 1;
2421 p2p->max_disc_int = 3;
2422 p2p->max_disc_tu = -1;
2424 os_get_random(&p2p->next_tie_breaker, 1);
2425 p2p->next_tie_breaker &= 0x01;
2427 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
2428 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
2430 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
2431 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
2433 dl_list_init(&p2p->devices);
2436 p2p_expiration_timeout, p2p, NULL);
2438 p2p->go_timeout = 100;
2439 p2p->client_timeout = 20;
2441 return p2p;
2445 void p2p_deinit(struct p2p_data *p2p)
2448 wpabuf_free(p2p->wfd_ie_beacon);
2449 wpabuf_free(p2p->wfd_ie_probe_req);
2450 wpabuf_free(p2p->wfd_ie_probe_resp);
2451 wpabuf_free(p2p->wfd_ie_assoc_req);
2452 wpabuf_free(p2p->wfd_ie_invitation);
2453 wpabuf_free(p2p->wfd_ie_prov_disc_req);
2454 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
2455 wpabuf_free(p2p->wfd_ie_go_neg);
2456 wpabuf_free(p2p->wfd_dev_info);
2457 wpabuf_free(p2p->wfd_assoc_bssid);
2458 wpabuf_free(p2p->wfd_coupled_sink_info);
2461 eloop_cancel_timeout(p2p_expiration_timeout, p2p, NULL);
2462 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
2463 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2464 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
2465 p2p_flush(p2p);
2466 p2p_free_req_dev_types(p2p);
2467 os_free(p2p->cfg->dev_name);
2468 os_free(p2p->cfg->manufacturer);
2469 os_free(p2p->cfg->model_name);
2470 os_free(p2p->cfg->model_number);
2471 os_free(p2p->cfg->serial_number);
2472 os_free(p2p->cfg->pref_chan);
2473 os_free(p2p->groups);
2474 wpabuf_free(p2p->sd_resp);
2475 os_free(p2p->after_scan_tx);
2476 p2p_remove_wps_vendor_extensions(p2p);
2477 os_free(p2p);
2481 void p2p_flush(struct p2p_data *p2p)
2484 p2p_stop_find(p2p);
2485 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
2488 p2p_device_free(p2p, dev);
2492 p2p->sd_dev_list = NULL;
2494 p2p_free_sd_queries(p2p);
2495 os_free(p2p->after_scan_tx);
2496 p2p->after_scan_tx = NULL;
2500 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)
2504 dev = p2p_get_device(p2p, addr);
2508 p2p_dbg(p2p, "Unauthorizing " MACSTR, MAC2STR(addr));
2510 if (p2p->go_neg_peer == dev)
2511 p2p->go_neg_peer = NULL;
2518 if (p2p->after_scan_tx &&
2519 os_memcmp(addr, p2p->after_scan_tx->dst, ETH_ALEN) == 0) {
2520 os_free(p2p->after_scan_tx);
2521 p2p->after_scan_tx = NULL;
2528 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)
2530 os_free(p2p->cfg->dev_name);
2532 p2p->cfg->dev_name = os_strdup(dev_name);
2533 if (p2p->cfg->dev_name == NULL)
2536 p2p->cfg->dev_name = NULL;
2541 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)
2543 os_free(p2p->cfg->manufacturer);
2544 p2p->cfg->manufacturer = NULL;
2546 p2p->cfg->manufacturer = os_strdup(manufacturer);
2547 if (p2p->cfg->manufacturer == NULL)
2555 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)
2557 os_free(p2p->cfg->model_name);
2558 p2p->cfg->model_name = NULL;
2560 p2p->cfg->model_name = os_strdup(model_name);
2561 if (p2p->cfg->model_name == NULL)
2569 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)
2571 os_free(p2p->cfg->model_number);
2572 p2p->cfg->model_number = NULL;
2574 p2p->cfg->model_number = os_strdup(model_number);
2575 if (p2p->cfg->model_number == NULL)
2583 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)
2585 os_free(p2p->cfg->serial_number);
2586 p2p->cfg->serial_number = NULL;
2588 p2p->cfg->serial_number = os_strdup(serial_number);
2589 if (p2p->cfg->serial_number == NULL)
2597 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)
2599 p2p->cfg->config_methods = config_methods;
2603 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)
2605 os_memcpy(p2p->cfg->uuid, uuid, 16);
2609 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)
2611 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
2616 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
2621 p2p->cfg->num_sec_dev_types = num_dev_types;
2622 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
2627 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)
2632 wpabuf_free(p2p->wps_vendor_ext[i]);
2633 p2p->wps_vendor_ext[i] = NULL;
2638 int p2p_add_wps_vendor_extension(struct p2p_data *p2p,
2647 if (p2p->wps_vendor_ext[i] == NULL)
2653 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
2654 if (p2p->wps_vendor_ext[i] == NULL)
2661 int p2p_set_country(struct p2p_data *p2p, const char *country)
2663 os_memcpy(p2p->cfg->country, country, 3);
2668 void p2p_continue_find(struct p2p_data *p2p)
2674 p2p_set_state(p2p, P2P_SEARCH);
2675 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2687 if (p2p->sd_dev_list && p2p->sd_dev_list != &p2p->devices) {
2689 if ((&dev->list == p2p->sd_dev_list) ) {
2691 if (dev->list.next == &p2p->devices)
2692 p2p->sd_dev_list = NULL;
2697 p2p->sd_dev_list = &dev->list;
2698 wpa_printf(MSG_DEBUG, "P2P: ### Servicing %p dev->flags 0x%x SD schedule %s devaddr " MACSTR,
2699 p2p->sd_dev_list, dev->flags, dev->flags & P2P_DEV_SD_SCHEDULE ? "TRUE": "FALSE",
2703 if (p2p_start_sd(p2p, dev) == 0)
2709 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
2713 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
2718 p2p_listen_in_find(p2p, 1);
2722 static void p2p_sd_cb(struct p2p_data *p2p, int success)
2724 p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d",
2726 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2729 if (p2p->sd_peer) {
2730 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
2731 p2p->sd_peer = NULL;
2733 p2p_continue_find(p2p);
2737 if (p2p->sd_peer == NULL) {
2738 p2p_dbg(p2p, "No SD peer entry known");
2739 p2p_continue_find(p2p);
2744 p2p_set_state(p2p, P2P_SD_DURING_FIND);
2745 p2p_set_timeout(p2p, 0, 200000);
2751 * @p2p: P2P module context from p2p_init()
2753 static void p2p_retry_pd(struct p2p_data *p2p)
2757 if (p2p->state != P2P_IDLE)
2765 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2766 if (os_memcmp(p2p->pending_pd_devaddr,
2772 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
2776 p2p_send_prov_disc_req(p2p, dev,
2783 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
2785 p2p_dbg(p2p, "Provision Discovery Request TX callback: success=%d",
2799 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2801 if (p2p->user_initiated_pd &&
2802 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY))
2805 p2p->pending_action_state = P2P_PENDING_PD;
2806 p2p_set_timeout(p2p, 0, 50000);
2807 } else if (p2p->state != P2P_IDLE)
2808 p2p_continue_find(p2p);
2809 else if (p2p->user_initiated_pd) {
2810 p2p->pending_action_state = P2P_PENDING_PD;
2812 p2p_set_timeout(p2p, 0, 350000);
2814 p2p_set_timeout(p2p, 0, 300000);
2824 if (p2p->user_initiated_pd)
2825 p2p->pending_action_state = P2P_PENDING_PD;
2827 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2830 if (p2p->state == P2P_SEARCH)
2831 p2p_set_state(p2p, P2P_PD_DURING_FIND);
2833 p2p_set_timeout(p2p, 0, 350000);
2835 p2p_set_timeout(p2p, 0, 200000);
2840 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
2844 if (os_time_before(rx_time, &p2p->find_start)) {
2848 * stale information, update P2P peers only based on results
2852 p2p_dbg(p2p, "Ignore old scan result for " MACSTR
2859 p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1);
2865 void p2p_scan_res_handled(struct p2p_data *p2p)
2867 if (!p2p->p2p_scan_running) {
2868 p2p_dbg(p2p, "p2p_scan was not running, but scan results received");
2870 p2p->p2p_scan_running = 0;
2871 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2873 if (p2p_run_after_scan(p2p))
2875 if (p2p->state == P2P_SEARCH)
2876 p2p_continue_find(p2p);
2880 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id)
2885 if (p2p->wfd_ie_probe_req)
2886 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req);
2890 p2p_buf_add_capability(ies, p2p->dev_capab &
2894 if (p2p->cfg->reg_class && p2p->cfg->channel)
2895 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
2896 p2p->cfg->reg_class,
2897 p2p->cfg->channel);
2898 if (p2p->ext_listen_interval)
2899 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
2900 p2p->ext_listen_interval);
2906 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p)
2911 if (p2p && p2p->wfd_ie_probe_req)
2912 len += wpabuf_len(p2p->wfd_ie_probe_req);
2925 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)
2927 struct p2p_device *dev = p2p->go_neg_peer;
2930 p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success);
2933 p2p_dbg(p2p, "No pending GO Negotiation");
2939 p2p_set_state(p2p, P2P_IDLE);
2950 p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability through its GO",
2952 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2953 p2p_send_dev_disc_req(p2p, dev);
2958 * Use P2P find, if needed, to find the other device from its listen
2961 p2p_set_state(p2p, P2P_CONNECT);
2963 if (!success && p2p->go_neg_peer &&
2964 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {
2975 p2p_set_timeout(p2p, 0, timeout);
2979 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
2981 p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d",
2983 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
2984 p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore");
2987 p2p_set_state(p2p, P2P_CONNECT);
2988 p2p_set_timeout(p2p, 0, 500000);
2992 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success,
2995 p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success);
2996 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
2997 p2p_go_neg_failed(p2p, p2p->go_neg_peer,
2998 p2p->go_neg_peer->status);
3001 dev = p2p_get_device(p2p, addr);
3009 static void p2p_go_neg_conf_cb(struct p2p_data *p2p,
3014 p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result);
3015 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3017 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
3031 p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack was not reported");
3034 dev = p2p->go_neg_peer;
3038 p2p_go_complete(p2p, dev);
3042 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
3049 p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR
3051 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),
3054 state = p2p->pending_action_state;
3055 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3058 if (p2p->after_scan_tx_in_progress) {
3059 p2p->after_scan_tx_in_progress = 0;
3060 if (p2p->start_after_scan != P2P_AFTER_SCAN_NOTHING &&
3061 p2p_run_after_scan(p2p))
3063 if (p2p->state == P2P_SEARCH) {
3064 p2p_dbg(p2p, "Continue find after after_scan_tx completion");
3065 p2p_continue_find(p2p);
3070 p2p_go_neg_req_cb(p2p, success);
3073 p2p_go_neg_resp_cb(p2p, success);
3076 p2p_go_neg_resp_failure_cb(p2p, success, dst);
3079 p2p_go_neg_conf_cb(p2p, result);
3082 p2p_sd_cb(p2p, success);
3085 p2p_prov_disc_cb(p2p, success);
3088 p2p_invitation_req_cb(p2p, success);
3091 p2p_invitation_resp_cb(p2p, success);
3094 p2p_dev_disc_req_cb(p2p, success);
3097 p2p_dev_disc_resp_cb(p2p, success);
3100 p2p_go_disc_req_cb(p2p, success);
3104 p2p->after_scan_tx_in_progress = 0;
3108 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
3111 if (freq == p2p->pending_client_disc_freq) {
3112 p2p_dbg(p2p, "Client discoverability remain-awake completed");
3113 p2p->pending_client_disc_freq = 0;
3117 if (freq != p2p->pending_listen_freq) {
3118 p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)",
3119 freq, duration, p2p->pending_listen_freq);
3123 p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback",
3124 p2p->pending_listen_sec, p2p->pending_listen_usec,
3125 p2p->pending_listen_freq);
3126 p2p->in_listen = 1;
3127 p2p->drv_in_listen = freq;
3128 if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
3134 p2p_set_timeout(p2p, p2p->pending_listen_sec,
3135 p2p->pending_listen_usec + 20000);
3138 p2p->pending_listen_freq = 0;
3142 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)
3144 p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq);
3145 p2p->drv_in_listen = 0;
3146 if (p2p->in_listen)
3149 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
3150 if (p2p->go_neg_peer->connect_reqs >= 120) {
3151 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");
3152 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
3156 p2p_set_state(p2p, P2P_CONNECT);
3157 p2p_connect_send(p2p, p2p->go_neg_peer);
3159 } else if (p2p->state == P2P_SEARCH) {
3160 if (p2p->p2p_scan_running) {
3169 p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one");
3172 if (p2p->pending_listen_freq) {
3178 p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop");
3179 p2p_set_timeout(p2p, 0, 100000);
3182 if (p2p->search_delay) {
3183 p2p_dbg(p2p, "Delay search operation by %u ms",
3184 p2p->search_delay);
3185 p2p_set_timeout(p2p, p2p->search_delay / 1000,
3186 (p2p->search_delay % 1000) * 1000);
3189 p2p_search(p2p);
3197 static void p2p_timeout_connect(struct p2p_data *p2p)
3199 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3200 if (p2p->go_neg_peer &&
3201 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
3202 p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed");
3203 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
3206 if (p2p->go_neg_peer &&
3207 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) &&
3208 p2p->go_neg_peer->connect_reqs < 120) {
3209 p2p_dbg(p2p, "Peer expected to wait our response - skip listen");
3210 p2p_connect_send(p2p, p2p->go_neg_peer);
3214 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
3215 p2p_listen_in_find(p2p, 0);
3219 static void p2p_timeout_connect_listen(struct p2p_data *p2p)
3221 if (p2p->go_neg_peer) {
3222 if (p2p->drv_in_listen) {
3223 p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete");
3227 if (p2p->go_neg_peer->connect_reqs >= 120) {
3228 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");
3229 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
3233 p2p_set_state(p2p, P2P_CONNECT);
3234 p2p_connect_send(p2p, p2p->go_neg_peer);
3236 p2p_set_state(p2p, P2P_IDLE);
3240 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)
3247 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
3248 p2p_set_timeout(p2p, 0, 500000);
3252 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)
3254 struct p2p_device *dev = p2p->go_neg_peer;
3257 p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait");
3263 p2p_dbg(p2p, "Timeout on waiting peer to become ready for GO Negotiation");
3264 p2p_go_neg_failed(p2p, dev, -1);
3268 p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation");
3269 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
3270 p2p_listen_in_find(p2p, 0);
3274 static void p2p_timeout_sd_during_find(struct p2p_data *p2p)
3276 p2p_dbg(p2p, "Service Discovery Query timeout");
3277 if (p2p->sd_peer) {
3278 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3279 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
3280 p2p->sd_peer = NULL;
3282 p2p_continue_find(p2p);
3286 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)
3288 p2p_dbg(p2p, "Provision Discovery Request timeout");
3289 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3290 p2p_continue_find(p2p);
3294 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)
3296 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3303 if (!p2p->user_initiated_pd)
3306 p2p_dbg(p2p, "User initiated Provision Discovery Request timeout");
3308 if (p2p->pd_retries) {
3309 p2p->pd_retries--;
3310 p2p_retry_pd(p2p);
3315 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3316 if (os_memcmp(p2p->pending_pd_devaddr,
3324 if (p2p->cfg->prov_disc_fail)
3325 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
3326 p2p->pending_pd_devaddr,
3330 p2p_reset_pending_pd(p2p);
3335 static void p2p_timeout_invite(struct p2p_data *p2p)
3337 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3338 p2p_set_state(p2p, P2P_INVITE_LISTEN);
3339 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
3344 p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel");
3345 p2p_set_timeout(p2p, 0, 100000);
3348 p2p_listen_in_find(p2p, 0);
3352 static void p2p_timeout_invite_listen(struct p2p_data *p2p)
3354 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
3355 p2p_set_state(p2p, P2P_INVITE);
3356 p2p_invite_send(p2p, p2p->invite_peer,
3357 p2p->invite_go_dev_addr);
3359 if (p2p->invite_peer) {
3360 p2p_dbg(p2p, "Invitation Request retry limit reached");
3361 if (p2p->cfg->invitation_result)
3362 p2p->cfg->invitation_result(
3363 p2p->cfg->cb_ctx, -1, NULL, NULL,
3364 p2p->invite_peer->info.p2p_device_addr);
3366 p2p_set_state(p2p, P2P_IDLE);
3373 struct p2p_data *p2p = eloop_ctx;
3375 p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state));
3377 p2p->in_listen = 0;
3379 switch (p2p->state) {
3382 if (p2p->pending_action_state == P2P_PENDING_PD)
3383 p2p_timeout_prov_disc_req(p2p);
3387 if (p2p->pending_action_state == P2P_PENDING_PD)
3388 p2p_timeout_prov_disc_req(p2p);
3389 if (p2p->search_delay && !p2p->in_search_delay) {
3390 p2p_dbg(p2p, "Delay search operation by %u ms",
3391 p2p->search_delay);
3392 p2p->in_search_delay = 1;
3393 p2p_set_timeout(p2p, p2p->search_delay / 1000,
3394 (p2p->search_delay % 1000) * 1000);
3397 p2p->in_search_delay = 0;
3398 p2p_search(p2p);
3401 p2p_timeout_connect(p2p);
3404 p2p_timeout_connect_listen(p2p);
3410 if (p2p->pending_action_state == P2P_PENDING_PD)
3411 p2p_timeout_prov_disc_req(p2p);
3413 if (p2p->ext_listen_only) {
3414 p2p_dbg(p2p, "Extended Listen Timing - Listen State completed");
3415 p2p->ext_listen_only = 0;
3416 p2p_set_state(p2p, P2P_IDLE);
3420 p2p_timeout_wait_peer_connect(p2p);
3423 p2p_timeout_wait_peer_idle(p2p);
3426 p2p_timeout_sd_during_find(p2p);
3431 p2p_timeout_prov_disc_during_find(p2p);
3434 p2p_timeout_invite(p2p);
3437 p2p_timeout_invite_listen(p2p);
3447 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)
3451 dev = p2p_get_device(p2p, peer_addr);
3452 p2p_dbg(p2p, "Local request to reject connection attempts by peer "
3455 p2p_dbg(p2p, "Peer " MACSTR " unknown", MAC2STR(peer_addr));
3496 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p,
3502 dev = p2p_get_device(p2p, addr);
3504 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
3508 if (&dev->list == &p2p->devices)
3647 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr)
3649 return p2p_get_device(p2p, addr) != NULL;
3653 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)
3656 p2p_dbg(p2p
3657 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3659 p2p_dbg(p2p, "Client discoverability disabled");
3660 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3701 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
3708 p2p_dbg(p2p, "Send Presence Request to GO " MACSTR
3719 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3720 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,
3723 p2p_dbg(p2p, "Failed to send Action frame");
3756 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
3769 p2p_dbg(p2p, "Received P2P Action - P2P Presence Request");
3771 for (g = 0; g < p2p->num_groups; g++) {
3772 if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]),
3774 group = p2p->groups[g];
3779 p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group "
3785 p2p_dbg(p2p, "Failed to parse P2P Presence Request");
3792 p2p_dbg(p2p, "No NoA attribute in P2P Presence Request");
3800 if (p2p->cfg->get_noa)
3801 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
3813 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3814 if (p2p_send_action(p2p, rx_freq, sa, da, da,
3816 p2p_dbg(p2p, "Failed to send Action frame");
3822 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
3827 p2p_dbg(p2p, "Received P2P Action - P2P Presence Response");
3830 p2p_dbg(p2p, "Failed to parse P2P Presence Response");
3835 p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response");
3841 p2p_dbg(p2p, "P2P Presence Request was rejected: status %u",
3847 p2p_dbg(p2p, "P2P Presence Request was accepted");
3848 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA",
3857 struct p2p_data *p2p = eloop_ctx;
3859 if (p2p->ext_listen_interval) {
3861 eloop_register_timeout(p2p->ext_listen_interval_sec,
3862 p2p->ext_listen_interval_usec,
3863 p2p_ext_listen_timeout, p2p, NULL);
3866 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
3873 p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");
3874 p2p->ext_listen_only = 0;
3875 p2p_set_state(p2p, P2P_IDLE);
3878 if (p2p->state != P2P_IDLE) {
3879 p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state));
3883 p2p_dbg(p2p, "Extended Listen timeout");
3884 p2p->ext_listen_only = 1;
3885 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
3886 p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing");
3887 p2p->ext_listen_only = 0;
3892 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
3897 p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u",
3902 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
3905 p2p_dbg(p2p, "Disabling Extended Listen Timing");
3906 p2p->ext_listen_period = 0;
3907 p2p->ext_listen_interval = 0;
3911 p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec",
3913 p2p->ext_listen_period = period;
3914 p2p->ext_listen_interval = interval;
3915 p2p->ext_listen_interval_sec = interval / 1000;
3916 p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
3918 eloop_register_timeout(p2p->ext_listen_interval_sec,
3919 p2p->ext_listen_interval_usec,
3920 p2p_ext_listen_timeout, p2p, NULL);
3926 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3940 p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR
3948 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3962 p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR
3970 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)
3973 p2p_dbg(p2p, "Managed P2P Device operations enabled");
3974 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
3976 p2p_dbg(p2p, "Managed P2P Device operations disabled");
3977 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
3982 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel)
3987 p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u",
3989 p2p->cfg->reg_class = reg_class;
3990 p2p->cfg->channel = channel;
3996 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)
3998 p2p_dbg(p2p, "New SSID postfix: %s", wpa_ssid_txt(postfix, len));
4000 p2p->cfg->ssid_postfix_len = 0;
4003 if (len > sizeof(p2p->cfg->ssid_postfix))
4005 os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
4006 p2p->cfg->ssid_postfix_len = len;
4011 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,
4017 p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u",
4019 p2p->cfg->op_reg_class = op_reg_class;
4020 p2p->cfg->op_channel = op_channel;
4021 p2p->cfg->cfg_op_channel = cfg_op_channel;
4026 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
4040 os_free(p2p->cfg->pref_chan);
4041 p2p->cfg->pref_chan = n;
4042 p2p->cfg->num_pref_chan = num_pref_chan;
4048 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
4051 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
4059 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
4062 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4070 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)
4072 os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
4073 if (is_zero_ether_addr(p2p->peer_filter))
4074 p2p_dbg(p2p, "Disable peer filter");
4076 p2p_dbg(p2p, "Enable peer filter for " MACSTR,
4077 MAC2STR(p2p->peer_filter));
4081 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)
4083 p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled");
4084 if (p2p->cross_connect == enabled)
4086 p2p->cross_connect = enabled;
4091 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)
4093 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4102 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)
4104 p2p_dbg(p2p, "Intra BSS distribution %s",
4106 p2p->cfg->p2p_intra_bss = enabled;
4110 void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan)
4112 p2p_dbg(p2p, "Update channel list");
4113 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
4117 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
4121 if (p2p->p2p_scan_running) {
4122 p2p_dbg(p2p, "Delay Action frame TX until p2p_scan completes");
4123 if (p2p->after_scan_tx) {
4124 p2p_dbg(p2p, "Dropped previous pending Action frame TX");
4125 os_free(p2p->after_scan_tx);
4127 p2p->after_scan_tx = os_malloc(sizeof(*p2p->after_scan_tx) +
4129 if (p2p->after_scan_tx == NULL)
4131 p2p->after_scan_tx->freq = freq;
4132 os_memcpy(p2p->after_scan_tx->dst, dst, ETH_ALEN);
4133 os_memcpy(p2p->after_scan_tx->src, src, ETH_ALEN);
4134 os_memcpy(p2p->after_scan_tx->bssid, bssid, ETH_ALEN);
4135 p2p->after_scan_tx->len = len;
4136 p2p->after_scan_tx->wait_time = wait_time;
4137 os_memcpy(p2p->after_scan_tx + 1, buf, len);
4141 return p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
4146 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,
4149 p2p_dbg(p2p, "Best channel: 2.4 GHz: %d, 5 GHz: %d, overall: %d",
4151 p2p->best_freq_24 = freq_24;
4152 p2p->best_freq_5 = freq_5;
4153 p2p->best_freq_overall = freq_overall;
4157 void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq)
4159 p2p_dbg(p2p, "Own frequency preference: %d MHz", freq);
4160 p2p->own_freq_preference = freq;
4164 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)
4166 if (p2p == NULL || p2p->go_neg_peer == NULL)
4168 return p2p->go_neg_peer->info.p2p_device_addr;
4173 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)
4178 dev = p2p_get_device(p2p, addr);
4192 if (&dev->list == &p2p->devices)
4197 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4204 if (&dev->list == &p2p->devices)
4213 int p2p_search_in_progress(struct p2p_data *p2p)
4215 if (p2p == NULL)
4218 return p2p->state == P2P_SEARCH;
4222 int p2p_in_progress(struct p2p_data *p2p)
4224 if (p2p == NULL)
4226 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SEARCH_WHEN_READY ||
4227 p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY)
4229 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;
4233 void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout,
4236 if (p2p) {
4237 p2p->go_timeout = go_timeout;
4238 p2p->client_timeout = client_timeout;
4243 void p2p_increase_search_delay(struct p2p_data *p2p, unsigned int delay)
4245 if (p2p && p2p->search_delay < delay)
4246 p2p->search_delay = delay;
4252 static void p2p_update_wfd_ie_groups(struct p2p_data *p2p)
4257 for (g = 0; g < p2p->num_groups; g++) {
4258 group = p2p->groups[g];
4264 int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie)
4266 wpabuf_free(p2p->wfd_ie_beacon);
4267 p2p->wfd_ie_beacon = ie;
4268 p2p_update_wfd_ie_groups(p2p);
4273 int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie)
4275 wpabuf_free(p2p->wfd_ie_probe_req);
4276 p2p->wfd_ie_probe_req = ie;
4281 int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie)
4283 wpabuf_free(p2p->wfd_ie_probe_resp);
4284 p2p->wfd_ie_probe_resp = ie;
4285 p2p_update_wfd_ie_groups(p2p);
4290 int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie)
4292 wpabuf_free(p2p->wfd_ie_assoc_req);
4293 p2p->wfd_ie_assoc_req = ie;
4298 int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie)
4300 wpabuf_free(p2p->wfd_ie_invitation);
4301 p2p->wfd_ie_invitation = ie;
4306 int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie)
4308 wpabuf_free(p2p->wfd_ie_prov_disc_req);
4309 p2p->wfd_ie_prov_disc_req = ie;
4314 int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie)
4316 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
4317 p2p->wfd_ie_prov_disc_resp = ie;
4322 int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie)
4324 wpabuf_free(p2p->wfd_ie_go_neg);
4325 p2p->wfd_ie_go_neg = ie;
4330 int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)
4332 wpabuf_free(p2p->wfd_dev_info);
4334 p2p->wfd_dev_info = wpabuf_dup(elem);
4335 if (p2p->wfd_dev_info == NULL)
4338 p2p->wfd_dev_info = NULL;
4344 int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem)
4346 wpabuf_free(p2p->wfd_assoc_bssid);
4348 p2p->wfd_assoc_bssid = wpabuf_dup(elem);
4349 if (p2p->wfd_assoc_bssid == NULL)
4352 p2p->wfd_assoc_bssid = NULL;
4358 int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p,
4361 wpabuf_free(p2p->wfd_coupled_sink_info);
4363 p2p->wfd_coupled_sink_info = wpabuf_dup(elem);
4364 if (p2p->wfd_coupled_sink_info == NULL)
4367 p2p->wfd_coupled_sink_info = NULL;
4375 int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int,
4381 p2p->min_disc_int = min_disc_int;
4382 p2p->max_disc_int = max_disc_int;
4383 p2p->max_disc_tu = max_disc_tu;
4384 p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d",
4391 void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...)
4396 if (!p2p->cfg->debug_print)
4403 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf);
4407 void p2p_info(struct p2p_data *p2p, const char *fmt, ...)
4412 if (!p2p->cfg->debug_print)
4419 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf);
4423 void p2p_err(struct p2p_data *p2p, const char *fmt, ...)
4428 if (!p2p->cfg->debug_print)
4435 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf);
