26 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
27 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
30 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
54 void p2p_expire_peers(struct p2p_data *p2p)  in p2p_expire_peers()  argument
61 	dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {  in p2p_expire_peers()
65 		if (dev == p2p->go_neg_peer) {  in p2p_expire_peers()
74 		if (p2p->cfg->go_connected &&  in p2p_expire_peers()
75 		    p2p->cfg->go_connected(p2p->cfg->cb_ctx,  in p2p_expire_peers()
85 		for (i = 0; i < p2p->num_groups; i++) {  in p2p_expire_peers()
87 				    p2p->groups[i], dev->info.p2p_device_addr))  in p2p_expire_peers()
90 		if (i < p2p->num_groups) {  in p2p_expire_peers()
99 		p2p_dbg(p2p, "Expiring old peer entry " MACSTR,  in p2p_expire_peers()
102 		p2p_device_free(p2p, dev);  in p2p_expire_peers()
142 const char * p2p_get_state_txt(struct p2p_data *p2p)  in p2p_get_state_txt()  argument
144 	return p2p_state_txt(p2p->state);  in p2p_get_state_txt()
148 struct p2ps_advertisement * p2p_get_p2ps_adv_list(struct p2p_data *p2p)  in p2p_get_p2ps_adv_list()  argument
150 	return p2p ? p2p->p2ps_adv_list : NULL;  in p2p_get_p2ps_adv_list()
154 void p2p_set_intended_addr(struct p2p_data *p2p, const u8 *intended_addr)  in p2p_set_intended_addr()  argument
156 	if (p2p && intended_addr)  in p2p_set_intended_addr()
157 		os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN);  in p2p_set_intended_addr()
161 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr)  in p2p_get_provisioning_info()  argument
165 	if (!addr || !p2p)  in p2p_get_provisioning_info()
168 	dev = p2p_get_device(p2p, addr);  in p2p_get_provisioning_info()
176 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr)  in p2p_clear_provisioning_info()  argument
180 	if (!addr || !p2p)  in p2p_clear_provisioning_info()
183 	dev = p2p_get_device(p2p, addr);  in p2p_clear_provisioning_info()
189 void p2p_set_state(struct p2p_data *p2p, int new_state)  in p2p_set_state()  argument
191 	p2p_dbg(p2p, "State %s -> %s",  in p2p_set_state()
192 		p2p_state_txt(p2p->state), p2p_state_txt(new_state));  in p2p_set_state()
193 	p2p->state = new_state;  in p2p_set_state()
195 	if (new_state == P2P_IDLE && p2p->pending_channel) {  in p2p_set_state()
196 		p2p_dbg(p2p, "Apply change in listen channel");  in p2p_set_state()
197 		p2p->cfg->reg_class = p2p->pending_reg_class;  in p2p_set_state()
198 		p2p->cfg->channel = p2p->pending_channel;  in p2p_set_state()
199 		p2p->pending_reg_class = 0;  in p2p_set_state()
200 		p2p->pending_channel = 0;  in p2p_set_state()
205 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)  in p2p_set_timeout()  argument
207 	p2p_dbg(p2p, "Set timeout (state=%s): %u.%06u sec",  in p2p_set_timeout()
208 		p2p_state_txt(p2p->state), sec, usec);  in p2p_set_timeout()
209 	eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);  in p2p_set_timeout()
210 	eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);  in p2p_set_timeout()
214 void p2p_clear_timeout(struct p2p_data *p2p)  in p2p_clear_timeout()  argument
216 	p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state));  in p2p_clear_timeout()
217 	eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);  in p2p_clear_timeout()
221 void p2p_go_neg_failed(struct p2p_data *p2p, int status)  in p2p_go_neg_failed()  argument
224 	struct p2p_device *peer = p2p->go_neg_peer;  in p2p_go_neg_failed()
229 	eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);  in p2p_go_neg_failed()
230 	if (p2p->state != P2P_SEARCH) {  in p2p_go_neg_failed()
235 		p2p_clear_timeout(p2p);  in p2p_go_neg_failed()
236 		p2p_set_state(p2p, P2P_IDLE);  in p2p_go_neg_failed()
244 	p2p->go_neg_peer = NULL;  in p2p_go_neg_failed()
250 	p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);  in p2p_go_neg_failed()
254 static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc)  in p2p_listen_in_find()  argument
260 	p2p_dbg(p2p, "Starting short listen state (state=%s)",  in p2p_listen_in_find()
261 		p2p_state_txt(p2p->state));  in p2p_listen_in_find()
263 	if (p2p->pending_listen_freq) {  in p2p_listen_in_find()
265 		p2p_dbg(p2p, "p2p_listen command pending already");  in p2p_listen_in_find()
269 	freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);  in p2p_listen_in_find()
271 		p2p_dbg(p2p, "Unknown regulatory class/channel");  in p2p_listen_in_find()
277 	tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +  in p2p_listen_in_find()
278 	      p2p->min_disc_int) * 100;  in p2p_listen_in_find()
279 	if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu)  in p2p_listen_in_find()
280 		tu = p2p->max_disc_tu;  in p2p_listen_in_find()
283 	if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen)  in p2p_listen_in_find()
284 		tu = p2p->cfg->max_listen * 1000 / 1024;  in p2p_listen_in_find()
287 		p2p_dbg(p2p, "Skip listen state since duration was 0 TU");  in p2p_listen_in_find()
288 		p2p_set_timeout(p2p, 0, 0);  in p2p_listen_in_find()
292 	ies = p2p_build_probe_resp_ies(p2p, NULL, 0);  in p2p_listen_in_find()
296 	p2p->pending_listen_freq = freq;  in p2p_listen_in_find()
297 	p2p->pending_listen_sec = 0;  in p2p_listen_in_find()
298 	p2p->pending_listen_usec = 1024 * tu;  in p2p_listen_in_find()
300 	if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,  in p2p_listen_in_find()
302 		p2p_dbg(p2p, "Failed to start listen mode");  in p2p_listen_in_find()
303 		p2p->pending_listen_freq = 0;  in p2p_listen_in_find()
309 int p2p_listen(struct p2p_data *p2p, unsigned int timeout)  in p2p_listen()  argument
314 	p2p_dbg(p2p, "Going to listen(only) state");  in p2p_listen()
316 	if (p2p->pending_listen_freq) {  in p2p_listen()
318 		p2p_dbg(p2p, "p2p_listen command pending already");  in p2p_listen()
322 	freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);  in p2p_listen()
324 		p2p_dbg(p2p, "Unknown regulatory class/channel");  in p2p_listen()
328 	p2p->pending_listen_sec = timeout / 1000;  in p2p_listen()
329 	p2p->pending_listen_usec = (timeout % 1000) * 1000;  in p2p_listen()
331 	if (p2p->p2p_scan_running) {  in p2p_listen()
332 		if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) {  in p2p_listen()
333 			p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen");  in p2p_listen()
336 		p2p_dbg(p2p, "p2p_scan running - delay start of listen state");  in p2p_listen()
337 		p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;  in p2p_listen()
341 	ies = p2p_build_probe_resp_ies(p2p, NULL, 0);  in p2p_listen()
345 	p2p->pending_listen_freq = freq;  in p2p_listen()
347 	if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {  in p2p_listen()
348 		p2p_dbg(p2p, "Failed to start listen mode");  in p2p_listen()
349 		p2p->pending_listen_freq = 0;  in p2p_listen()
355 	p2p_set_state(p2p, P2P_LISTEN_ONLY);  in p2p_listen()
361 static void p2p_device_clear_reported(struct p2p_data *p2p)  in p2p_device_clear_reported()  argument
364 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_device_clear_reported()
377 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)  in p2p_get_device()  argument
380 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_get_device()
394 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,  in p2p_get_device_interface()  argument
398 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_get_device_interface()
415 static struct p2p_device * p2p_create_device(struct p2p_data *p2p,  in p2p_create_device()  argument
421 	dev = p2p_get_device(p2p, addr);  in p2p_create_device()
425 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_create_device()
431 	if (count + 1 > p2p->cfg->max_peers && oldest) {  in p2p_create_device()
432 		p2p_dbg(p2p, "Remove oldest peer entry to make room for a new peer");  in p2p_create_device()
434 		p2p_device_free(p2p, oldest);  in p2p_create_device()
440 	dl_list_add(&p2p->devices, &dev->list);  in p2p_create_device()
466 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,  in p2p_add_group_clients()  argument
485 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_add_group_clients()
495 		if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr,  in p2p_add_group_clients()
498 		dev = p2p_get_device(p2p, cli->p2p_device_addr);  in p2p_add_group_clients()
523 			dev = p2p_create_device(p2p, cli->p2p_device_addr);  in p2p_add_group_clients()
529 			p2p->cfg->dev_found(p2p->cfg->cb_ctx,  in p2p_add_group_clients()
548 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev,  in p2p_copy_wps_info()  argument
624 			p2p_dbg(p2p, "Update peer " MACSTR  in p2p_copy_wps_info()
713 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq,  in p2p_add_device()  argument
727 		p2p_dbg(p2p, "Failed to parse P2P IE for a device entry");  in p2p_add_device()
737 		p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");  in p2p_add_device()
742 	if (!is_zero_ether_addr(p2p->peer_filter) &&  in p2p_add_device()
743 	    os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) {  in p2p_add_device()
744 		p2p_dbg(p2p, "Do not add peer filter for " MACSTR  in p2p_add_device()
750 	dev = p2p_create_device(p2p, p2p_dev_addr);  in p2p_add_device()
772 		p2p_dbg(p2p,  in p2p_add_device()
813 			p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz",  in p2p_add_device()
820 		p2p_dbg(p2p, "Update Listen frequency based on scan results ("  in p2p_add_device()
835 	p2p_copy_wps_info(p2p, dev, 0, &msg);  in p2p_add_device()
862 		p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq,  in p2p_add_device()
877 	p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)",  in p2p_add_device()
881 		p2p_dbg(p2p, "Do not report rejected device");  in p2p_add_device()
901 		p2p_dbg(p2p, "Do not report peer " MACSTR  in p2p_add_device()
906 	p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,  in p2p_add_device()
917 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)  in p2p_device_free()  argument
921 	if (p2p->go_neg_peer == dev) {  in p2p_device_free()
925 		p2p_go_neg_failed(p2p, -1);  in p2p_device_free()
927 	if (p2p->invite_peer == dev)  in p2p_device_free()
928 		p2p->invite_peer = NULL;  in p2p_device_free()
929 	if (p2p->sd_peer == dev)  in p2p_device_free()
930 		p2p->sd_peer = NULL;  in p2p_device_free()
931 	if (p2p->pending_client_disc_go == dev)  in p2p_device_free()
932 		p2p->pending_client_disc_go = NULL;  in p2p_device_free()
936 		p2p->cfg->dev_lost(p2p->cfg->cb_ctx,  in p2p_device_free()
953 static int p2p_get_next_prog_freq(struct p2p_data *p2p)  in p2p_get_next_prog_freq()  argument
963 	c = &p2p->cfg->channels;  in p2p_get_next_prog_freq()
966 		if (cla->reg_class != p2p->last_prog_scan_class)  in p2p_get_next_prog_freq()
969 			if (cla->channel[ch] == p2p->last_prog_scan_chan) {  in p2p_get_next_prog_freq()
996 	p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz",  in p2p_get_next_prog_freq()
998 	p2p->last_prog_scan_class = reg_class;  in p2p_get_next_prog_freq()
999 	p2p->last_prog_scan_chan = channel;  in p2p_get_next_prog_freq()
1007 static void p2p_search(struct p2p_data *p2p)  in p2p_search()  argument
1014 	if (p2p->drv_in_listen) {  in p2p_search()
1015 		p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing");  in p2p_search()
1018 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_search()
1020 	if (p2p->find_pending_full &&  in p2p_search()
1021 	    (p2p->find_type == P2P_FIND_PROGRESSIVE ||  in p2p_search()
1022 	     p2p->find_type == P2P_FIND_START_WITH_FULL)) {  in p2p_search()
1024 		p2p_dbg(p2p, "Starting search (pending full scan)");  in p2p_search()
1025 		p2p->find_pending_full = 0;  in p2p_search()
1026 	} else if ((p2p->find_type == P2P_FIND_PROGRESSIVE &&  in p2p_search()
1027 	    (freq = p2p_get_next_prog_freq(p2p)) > 0) ||  in p2p_search()
1028 	    (p2p->find_type == P2P_FIND_START_WITH_FULL &&  in p2p_search()
1029 	     (freq = p2p->find_specified_freq) > 0)) {  in p2p_search()
1031 		p2p_dbg(p2p, "Starting search (+ freq %u)", freq);  in p2p_search()
1034 		p2p_dbg(p2p, "Starting search");  in p2p_search()
1037 	res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,  in p2p_search()
1038 				 p2p->num_req_dev_types, p2p->req_dev_types,  in p2p_search()
1039 				 p2p->find_dev_id, pw_id);  in p2p_search()
1041 		p2p_dbg(p2p, "Scan request schedule failed");  in p2p_search()
1042 		p2p_continue_find(p2p);  in p2p_search()
1049 	struct p2p_data *p2p = eloop_ctx;  in p2p_find_timeout()  local
1050 	p2p_dbg(p2p, "Find timeout -> stop");  in p2p_find_timeout()
1051 	p2p_stop_find(p2p);  in p2p_find_timeout()
1055 void p2p_notify_scan_trigger_status(struct p2p_data *p2p, int status)  in p2p_notify_scan_trigger_status()  argument
1058 		p2p_dbg(p2p, "Scan request failed");  in p2p_notify_scan_trigger_status()
1060 		p2p_continue_find(p2p);  in p2p_notify_scan_trigger_status()
1062 		p2p_dbg(p2p, "Running p2p_scan");  in p2p_notify_scan_trigger_status()
1063 		p2p->p2p_scan_running = 1;  in p2p_notify_scan_trigger_status()
1064 		eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);  in p2p_notify_scan_trigger_status()
1066 				       p2p, NULL);  in p2p_notify_scan_trigger_status()
1071 static int p2p_run_after_scan(struct p2p_data *p2p)  in p2p_run_after_scan()  argument
1076 	op = p2p->start_after_scan;  in p2p_run_after_scan()
1077 	p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;  in p2p_run_after_scan()
1082 		p2p_dbg(p2p, "Start previously requested Listen state");  in p2p_run_after_scan()
1083 		p2p_listen(p2p, p2p->pending_listen_sec * 1000 +  in p2p_run_after_scan()
1084 			   p2p->pending_listen_usec / 1000);  in p2p_run_after_scan()
1087 		p2p_dbg(p2p, "Start previously requested connect with " MACSTR,  in p2p_run_after_scan()
1088 			MAC2STR(p2p->after_scan_peer));  in p2p_run_after_scan()
1089 		dev = p2p_get_device(p2p, p2p->after_scan_peer);  in p2p_run_after_scan()
1091 			p2p_dbg(p2p, "Peer not known anymore");  in p2p_run_after_scan()
1094 		p2p_connect_send(p2p, dev);  in p2p_run_after_scan()
1104 	struct p2p_data *p2p = eloop_ctx;  in p2p_scan_timeout()  local
1106 	p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running);  in p2p_scan_timeout()
1107 	running = p2p->p2p_scan_running;  in p2p_scan_timeout()
1109 	p2p->p2p_scan_running = 0;  in p2p_scan_timeout()
1112 		p2p_run_after_scan(p2p);  in p2p_scan_timeout()
1116 static void p2p_free_req_dev_types(struct p2p_data *p2p)  in p2p_free_req_dev_types()  argument
1118 	p2p->num_req_dev_types = 0;  in p2p_free_req_dev_types()
1119 	os_free(p2p->req_dev_types);  in p2p_free_req_dev_types()
1120 	p2p->req_dev_types = NULL;  in p2p_free_req_dev_types()
1124 static int p2ps_gen_hash(struct p2p_data *p2p, const char *str, u8 *hash)  in p2ps_gen_hash()  argument
1135 		os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN);  in p2ps_gen_hash()
1159 int p2p_find(struct p2p_data *p2p, unsigned int timeout,  in p2p_find()  argument
1168 	p2p_dbg(p2p, "Starting find (type=%d)", type);  in p2p_find()
1169 	if (p2p->p2p_scan_running) {  in p2p_find()
1170 		p2p_dbg(p2p, "p2p_scan is already running");  in p2p_find()
1173 	p2p_free_req_dev_types(p2p);  in p2p_find()
1175 		p2p->req_dev_types = os_memdup(req_dev_types,  in p2p_find()
1178 		if (p2p->req_dev_types == NULL)  in p2p_find()
1180 		p2p->num_req_dev_types = num_req_dev_types;  in p2p_find()
1184 		os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);  in p2p_find()
1185 		p2p->find_dev_id = p2p->find_dev_id_buf;  in p2p_find()
1187 		p2p->find_dev_id = NULL;  in p2p_find()
1191 		p2p->p2ps_seek = 0;  in p2p_find()
1197 		p2p_dbg(p2p, "ASP search");  in p2p_find()
1198 		p2p->p2ps_seek_count = 0;  in p2p_find()
1199 		p2p->p2ps_seek = 1;  in p2p_find()
1205 			if (!p2ps_gen_hash(p2p, seek[i], buf))  in p2p_find()
1208 			p2p_dbg(p2p, "Seek service %s hash " MACSTR,  in p2p_find()
1210 			os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN],  in p2p_find()
1215 		p2p->p2ps_seek_count = count;  in p2p_find()
1216 		p2p->p2ps_seek = 1;  in p2p_find()
1218 		p2p->p2ps_seek_count = 0;  in p2p_find()
1219 		p2p->p2ps_seek = 1;  in p2p_find()
1223 	if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) {  in p2p_find()
1224 		p2p->p2ps_seek_count = 1;  in p2p_find()
1225 		os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash,  in p2p_find()
1229 	p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;  in p2p_find()
1230 	p2p_clear_timeout(p2p);  in p2p_find()
1231 	if (p2p->pending_listen_freq) {  in p2p_find()
1232 		p2p_dbg(p2p, "Clear pending_listen_freq for p2p_find");  in p2p_find()
1233 		p2p->pending_listen_freq = 0;  in p2p_find()
1235 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_find()
1236 	p2p->find_pending_full = 0;  in p2p_find()
1237 	p2p->find_type = type;  in p2p_find()
1239 		p2p->find_specified_freq = freq;  in p2p_find()
1241 		p2p->find_specified_freq = 0;  in p2p_find()
1242 	p2p_device_clear_reported(p2p);  in p2p_find()
1243 	os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);  in p2p_find()
1244 	p2p_set_state(p2p, P2P_SEARCH);  in p2p_find()
1245 	p2p->search_delay = search_delay;  in p2p_find()
1246 	p2p->in_search_delay = 0;  in p2p_find()
1247 	eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);  in p2p_find()
1248 	p2p->last_p2p_find_timeout = timeout;  in p2p_find()
1251 				       p2p, NULL);  in p2p_find()
1260 			res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx,  in p2p_find()
1262 						 p2p->num_req_dev_types,  in p2p_find()
1263 						 p2p->req_dev_types, dev_id,  in p2p_find()
1269 		res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,  in p2p_find()
1270 					 p2p->num_req_dev_types,  in p2p_find()
1271 					 p2p->req_dev_types, dev_id,  in p2p_find()
1275 		res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,  in p2p_find()
1276 					 p2p->num_req_dev_types,  in p2p_find()
1277 					 p2p->req_dev_types, dev_id,  in p2p_find()
1285 		p2p->find_start = start;  in p2p_find()
1287 	if (res != 0 && p2p->p2p_scan_running) {  in p2p_find()
1288 		p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running");  in p2p_find()
1292 			p2p->find_pending_full = 1;  in p2p_find()
1295 		p2p_dbg(p2p, "Failed to start p2p_scan");  in p2p_find()
1296 		p2p_set_state(p2p, P2P_IDLE);  in p2p_find()
1297 		eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);  in p2p_find()
1304 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)  in p2p_stop_find_for_freq()  argument
1306 	p2p_dbg(p2p, "Stopping find");  in p2p_stop_find_for_freq()
1307 	eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);  in p2p_stop_find_for_freq()
1308 	p2p_clear_timeout(p2p);  in p2p_stop_find_for_freq()
1309 	if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)  in p2p_stop_find_for_freq()
1310 		p2p->cfg->find_stopped(p2p->cfg->cb_ctx);  in p2p_stop_find_for_freq()
1312 	p2p->p2ps_seek_count = 0;  in p2p_stop_find_for_freq()
1314 	p2p_set_state(p2p, P2P_IDLE);  in p2p_stop_find_for_freq()
1315 	p2p_free_req_dev_types(p2p);  in p2p_stop_find_for_freq()
1316 	p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;  in p2p_stop_find_for_freq()
1317 	if (p2p->go_neg_peer)  in p2p_stop_find_for_freq()
1318 		p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;  in p2p_stop_find_for_freq()
1319 	p2p->go_neg_peer = NULL;  in p2p_stop_find_for_freq()
1320 	p2p->sd_peer = NULL;  in p2p_stop_find_for_freq()
1321 	p2p->invite_peer = NULL;  in p2p_stop_find_for_freq()
1322 	p2p_stop_listen_for_freq(p2p, freq);  in p2p_stop_find_for_freq()
1323 	p2p->send_action_in_progress = 0;  in p2p_stop_find_for_freq()
1327 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq)  in p2p_stop_listen_for_freq()  argument
1329 	if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) {  in p2p_stop_listen_for_freq()
1330 		p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response");  in p2p_stop_listen_for_freq()
1333 	if (p2p->in_listen) {  in p2p_stop_listen_for_freq()
1334 		p2p->in_listen = 0;  in p2p_stop_listen_for_freq()
1335 		p2p_clear_timeout(p2p);  in p2p_stop_listen_for_freq()
1337 	if (p2p->drv_in_listen) {  in p2p_stop_listen_for_freq()
1343 		p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen);  in p2p_stop_listen_for_freq()
1344 		p2p->drv_in_listen = 0;  in p2p_stop_listen_for_freq()
1346 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_stop_listen_for_freq()
1350 void p2p_stop_listen(struct p2p_data *p2p)  in p2p_stop_listen()  argument
1352 	if (p2p->state != P2P_LISTEN_ONLY) {  in p2p_stop_listen()
1353 		p2p_dbg(p2p, "Skip stop_listen since not in listen_only state.");  in p2p_stop_listen()
1357 	p2p_stop_listen_for_freq(p2p, 0);  in p2p_stop_listen()
1358 	p2p_set_state(p2p, P2P_IDLE);  in p2p_stop_listen()
1362 void p2p_stop_find(struct p2p_data *p2p)  in p2p_stop_find()  argument
1364 	p2p->pending_listen_freq = 0;  in p2p_stop_find()
1365 	p2p_stop_find_for_freq(p2p, 0);  in p2p_stop_find()
1369 static int p2p_prepare_channel_pref(struct p2p_data *p2p,  in p2p_prepare_channel_pref()  argument
1376 	p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d",  in p2p_prepare_channel_pref()
1379 		p2p_dbg(p2p, "Unsupported frequency %u MHz", freq);  in p2p_prepare_channel_pref()
1383 	if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) &&  in p2p_prepare_channel_pref()
1384 	    (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class,  in p2p_prepare_channel_pref()
1386 		p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P",  in p2p_prepare_channel_pref()
1391 	p2p->op_reg_class = op_class;  in p2p_prepare_channel_pref()
1392 	p2p->op_channel = op_channel;  in p2p_prepare_channel_pref()
1395 		p2p->channels.reg_classes = 1;  in p2p_prepare_channel_pref()
1396 		p2p->channels.reg_class[0].channels = 1;  in p2p_prepare_channel_pref()
1397 		p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;  in p2p_prepare_channel_pref()
1398 		p2p->channels.reg_class[0].channel[0] = p2p->op_channel;  in p2p_prepare_channel_pref()
1400 		os_memcpy(&p2p->channels, &p2p->cfg->channels,  in p2p_prepare_channel_pref()
1408 static void p2p_prepare_channel_best(struct p2p_data *p2p)  in p2p_prepare_channel_best()  argument
1416 	p2p_dbg(p2p, "Prepare channel best");  in p2p_prepare_channel_best()
1418 	if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&  in p2p_prepare_channel_best()
1419 	    p2p_supported_freq(p2p, p2p->best_freq_overall) &&  in p2p_prepare_channel_best()
1420 	    p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel)  in p2p_prepare_channel_best()
1422 		p2p_dbg(p2p, "Select best overall channel as operating channel preference");  in p2p_prepare_channel_best()
1423 		p2p->op_reg_class = op_class;  in p2p_prepare_channel_best()
1424 		p2p->op_channel = op_channel;  in p2p_prepare_channel_best()
1425 	} else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&  in p2p_prepare_channel_best()
1426 		   p2p_supported_freq(p2p, p2p->best_freq_5) &&  in p2p_prepare_channel_best()
1427 		   p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel)  in p2p_prepare_channel_best()
1429 		p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference");  in p2p_prepare_channel_best()
1430 		p2p->op_reg_class = op_class;  in p2p_prepare_channel_best()
1431 		p2p->op_channel = op_channel;  in p2p_prepare_channel_best()
1432 	} else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 &&  in p2p_prepare_channel_best()
1433 		   p2p_supported_freq(p2p, p2p->best_freq_24) &&  in p2p_prepare_channel_best()
1434 		   p2p_freq_to_channel(p2p->best_freq_24, &op_class,  in p2p_prepare_channel_best()
1436 		p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference");  in p2p_prepare_channel_best()
1437 		p2p->op_reg_class = op_class;  in p2p_prepare_channel_best()
1438 		p2p->op_channel = op_channel;  in p2p_prepare_channel_best()
1439 	} else if (p2p->cfg->num_pref_chan > 0 &&  in p2p_prepare_channel_best()
1440 		   p2p_channels_includes(&p2p->cfg->channels,  in p2p_prepare_channel_best()
1441 					 p2p->cfg->pref_chan[0].op_class,  in p2p_prepare_channel_best()
1442 					 p2p->cfg->pref_chan[0].chan)) {  in p2p_prepare_channel_best()
1443 		p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference");  in p2p_prepare_channel_best()
1444 		p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class;  in p2p_prepare_channel_best()
1445 		p2p->op_channel = p2p->cfg->pref_chan[0].chan;  in p2p_prepare_channel_best()
1446 	} else if (p2p_channel_select(&p2p->cfg->channels, op_classes_edmg,  in p2p_prepare_channel_best()
1447 				      &p2p->op_reg_class, &p2p->op_channel) ==  in p2p_prepare_channel_best()
1449 …p2p_dbg(p2p, "Select possible EDMG channel (op_class %u channel %u) as operating channel preferenc…  in p2p_prepare_channel_best()
1450 			p2p->op_reg_class, p2p->op_channel);  in p2p_prepare_channel_best()
1451 	} else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht,  in p2p_prepare_channel_best()
1452 				      &p2p->op_reg_class, &p2p->op_channel) ==  in p2p_prepare_channel_best()
1454 …p2p_dbg(p2p, "Select possible VHT channel (op_class %u channel %u) as operating channel preference…  in p2p_prepare_channel_best()
1455 			p2p->op_reg_class, p2p->op_channel);  in p2p_prepare_channel_best()
1456 	} else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40,  in p2p_prepare_channel_best()
1457 				      &p2p->op_reg_class, &p2p->op_channel) ==  in p2p_prepare_channel_best()
1459 …p2p_dbg(p2p, "Select possible HT40 channel (op_class %u channel %u) as operating channel preferenc…  in p2p_prepare_channel_best()
1460 			p2p->op_reg_class, p2p->op_channel);  in p2p_prepare_channel_best()
1461 	} else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz,  in p2p_prepare_channel_best()
1462 				      &p2p->op_reg_class, &p2p->op_channel) ==  in p2p_prepare_channel_best()
1464 …p2p_dbg(p2p, "Select possible 5 GHz channel (op_class %u channel %u) as operating channel preferen…  in p2p_prepare_channel_best()
1465 			p2p->op_reg_class, p2p->op_channel);  in p2p_prepare_channel_best()
1466 	} else if (p2p_channels_includes(&p2p->cfg->channels,  in p2p_prepare_channel_best()
1467 					 p2p->cfg->op_reg_class,  in p2p_prepare_channel_best()
1468 					 p2p->cfg->op_channel)) {  in p2p_prepare_channel_best()
1469 		p2p_dbg(p2p, "Select pre-configured channel as operating channel preference");  in p2p_prepare_channel_best()
1470 		p2p->op_reg_class = p2p->cfg->op_reg_class;  in p2p_prepare_channel_best()
1471 		p2p->op_channel = p2p->cfg->op_channel;  in p2p_prepare_channel_best()
1472 	} else if (p2p_channel_random_social(&p2p->cfg->channels,  in p2p_prepare_channel_best()
1473 					     &p2p->op_reg_class,  in p2p_prepare_channel_best()
1474 					     &p2p->op_channel,  in p2p_prepare_channel_best()
1476 …p2p_dbg(p2p, "Select random available social channel (op_class %u channel %u) as operating channel…  in p2p_prepare_channel_best()
1477 			p2p->op_reg_class, p2p->op_channel);  in p2p_prepare_channel_best()
1481 		p2p_channel_select(&p2p->cfg->channels, NULL,  in p2p_prepare_channel_best()
1482 				   &p2p->op_reg_class,  in p2p_prepare_channel_best()
1483 				   &p2p->op_channel);  in p2p_prepare_channel_best()
1484 …p2p_dbg(p2p, "Select random available channel %d from operating class %d as operating channel pref…  in p2p_prepare_channel_best()
1485 			p2p->op_channel, p2p->op_reg_class);  in p2p_prepare_channel_best()
1488 	os_memcpy(&p2p->channels, &p2p->cfg->channels,  in p2p_prepare_channel_best()
1507 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,  in p2p_prepare_channel()  argument
1510 	p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d",  in p2p_prepare_channel()
1513 		if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq, go) <  in p2p_prepare_channel()
1517 		p2p_prepare_channel_best(p2p);  in p2p_prepare_channel()
1519 	p2p_channels_dump(p2p, "prepared channels", &p2p->channels);  in p2p_prepare_channel()
1521 		p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq);  in p2p_prepare_channel()
1523 		p2p_channels_union_inplace(&p2p->channels,  in p2p_prepare_channel()
1524 					   &p2p->cfg->cli_channels);  in p2p_prepare_channel()
1525 	p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels);  in p2p_prepare_channel()
1527 	p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s",  in p2p_prepare_channel()
1528 		p2p->op_reg_class, p2p->op_channel,  in p2p_prepare_channel()
1560 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,  in p2p_connect()  argument
1569 	p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR  in p2p_connect()
1576 	dev = p2p_get_device(p2p, peer_addr);  in p2p_connect()
1578 		p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR,  in p2p_connect()
1583 	if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq,  in p2p_connect()
1590 			p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR  in p2p_connect()
1596 			p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR  in p2p_connect()
1609 	p2p->ssid_set = 0;  in p2p_connect()
1613 		os_memcpy(p2p->ssid, force_ssid, force_ssid_len);  in p2p_connect()
1614 		p2p->ssid_len = force_ssid_len;  in p2p_connect()
1615 		p2p->ssid_set = 1;  in p2p_connect()
1633 		dev->tie_breaker = p2p->next_tie_breaker;  in p2p_connect()
1634 		p2p->next_tie_breaker = !p2p->next_tie_breaker;  in p2p_connect()
1640 	p2p->go_intent = go_intent;  in p2p_connect()
1641 	os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);  in p2p_connect()
1643 	if (p2p->state != P2P_IDLE)  in p2p_connect()
1644 		p2p_stop_find(p2p);  in p2p_connect()
1650 	if (p2p->p2p_scan_running) {  in p2p_connect()
1651 		p2p_dbg(p2p, "p2p_scan running - delay connect send");  in p2p_connect()
1652 		p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;  in p2p_connect()
1653 		os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);  in p2p_connect()
1657 	return p2p_connect_send(p2p, dev);  in p2p_connect()
1661 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,  in p2p_authorize()  argument
1670 	p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR  in p2p_authorize()
1676 	dev = p2p_get_device(p2p, peer_addr);  in p2p_authorize()
1678 		p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR,  in p2p_authorize()
1683 	if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent ==  in p2p_authorize()
1687 	p2p->ssid_set = 0;  in p2p_authorize()
1691 		os_memcpy(p2p->ssid, force_ssid, force_ssid_len);  in p2p_authorize()
1692 		p2p->ssid_len = force_ssid_len;  in p2p_authorize()
1693 		p2p->ssid_set = 1;  in p2p_authorize()
1701 	p2p->go_intent = go_intent;  in p2p_authorize()
1702 	os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);  in p2p_authorize()
1712 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,  in p2p_add_dev_info()  argument
1717 	p2p_copy_wps_info(p2p, dev, 0, msg);  in p2p_add_dev_info()
1724 			p2p_dbg(p2p, "Unknown peer Listen channel: "  in p2p_add_dev_info()
1732 			p2p_dbg(p2p, "Update peer " MACSTR  in p2p_add_dev_info()
1747 		p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request");  in p2p_add_dev_info()
1749 		p2p_dbg(p2p, "Created device entry based on GO Neg Req: "  in p2p_add_dev_info()
1760 		p2p_dbg(p2p, "Do not report rejected device");  in p2p_add_dev_info()
1764 	p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,  in p2p_add_dev_info()
1770 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)  in p2p_build_ssid()  argument
1775 		  p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);  in p2p_build_ssid()
1776 	*ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;  in p2p_build_ssid()
1780 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)  in p2p_go_params()  argument
1782 	if (p2p->ssid_set) {  in p2p_go_params()
1783 		os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len);  in p2p_go_params()
1784 		params->ssid_len = p2p->ssid_len;  in p2p_go_params()
1786 		p2p_build_ssid(p2p, params->ssid, &params->ssid_len);  in p2p_go_params()
1788 	p2p->ssid_set = 0;  in p2p_go_params()
1790 	if (p2p->passphrase_set) {  in p2p_go_params()
1791 		os_memcpy(params->passphrase, p2p->passphrase, os_strlen(p2p->passphrase));  in p2p_go_params()
1793 		p2p_random(params->passphrase, p2p->cfg->passphrase_len);  in p2p_go_params()
1795 	p2p->passphrase_set = 0;  in p2p_go_params()
1800 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)  in p2p_go_complete()  argument
1806 	p2p_dbg(p2p, "GO Negotiation with " MACSTR " completed (%s will be GO)",  in p2p_go_complete()
1823 		res.freq = p2p_channel_to_freq(p2p->op_reg_class,  in p2p_go_complete()
1824 					       p2p->op_channel);  in p2p_go_complete()
1825 		os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);  in p2p_go_complete()
1826 		res.ssid_len = p2p->ssid_len;  in p2p_go_complete()
1827 		p2p_random(res.passphrase, p2p->cfg->passphrase_len);  in p2p_go_complete()
1830 		if (p2p->ssid_len) {  in p2p_go_complete()
1831 			os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);  in p2p_go_complete()
1832 			res.ssid_len = p2p->ssid_len;  in p2p_go_complete()
1836 	p2p_channels_dump(p2p, "own channels", &p2p->channels);  in p2p_go_complete()
1837 	p2p_channels_dump(p2p, "peer channels", &peer->channels);  in p2p_go_complete()
1838 	p2p_channels_intersect(&p2p->channels, &peer->channels,  in p2p_go_complete()
1841 		p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq);  in p2p_go_complete()
1842 		p2p_channels_dump(p2p, "intersection after no-GO removal",  in p2p_go_complete()
1851 	p2p_clear_timeout(p2p);  in p2p_go_complete()
1852 	p2p->ssid_set = 0;  in p2p_go_complete()
1860 	p2p_set_state(p2p, P2P_PROVISIONING);  in p2p_go_complete()
1861 	p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);  in p2p_go_complete()
1865 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,  in p2p_rx_p2p_action()  argument
1868 	p2p_dbg(p2p, "RX P2P Public Action from " MACSTR, MAC2STR(sa));  in p2p_rx_p2p_action()
1876 		p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);  in p2p_rx_p2p_action()
1879 		p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);  in p2p_rx_p2p_action()
1882 		p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);  in p2p_rx_p2p_action()
1885 		p2p_process_invitation_req(p2p, sa, data + 1, len - 1,  in p2p_rx_p2p_action()
1889 		p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);  in p2p_rx_p2p_action()
1892 		p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);  in p2p_rx_p2p_action()
1895 		p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);  in p2p_rx_p2p_action()
1898 		p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);  in p2p_rx_p2p_action()
1901 		p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);  in p2p_rx_p2p_action()
1904 		p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d",  in p2p_rx_p2p_action()
1911 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da,  in p2p_rx_action_public()  argument
1930 		p2p_rx_p2p_action(p2p, sa, data, len, freq);  in p2p_rx_action_public()
1933 		p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);  in p2p_rx_action_public()
1936 		p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);  in p2p_rx_action_public()
1939 		p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);  in p2p_rx_action_public()
1942 		p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);  in p2p_rx_action_public()
1948 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,  in p2p_rx_action()  argument
1953 		p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);  in p2p_rx_action()
1969 	p2p_dbg(p2p, "RX P2P Action from " MACSTR, MAC2STR(sa));  in p2p_rx_action()
1976 		p2p_dbg(p2p, "Received P2P Action - Notice of Absence");  in p2p_rx_action()
1980 		p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);  in p2p_rx_action()
1983 		p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);  in p2p_rx_action()
1986 		p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);  in p2p_rx_action()
1989 		p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]);  in p2p_rx_action()
1997 	struct p2p_data *p2p = eloop_ctx;  in p2p_go_neg_start()  local
1998 	if (p2p->go_neg_peer == NULL)  in p2p_go_neg_start()
2000 	if (p2p->pending_listen_freq) {  in p2p_go_neg_start()
2001 		p2p_dbg(p2p, "Clear pending_listen_freq for p2p_go_neg_start");  in p2p_go_neg_start()
2002 		p2p->pending_listen_freq = 0;  in p2p_go_neg_start()
2004 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_go_neg_start()
2005 	p2p->go_neg_peer->status = P2P_SC_SUCCESS;  in p2p_go_neg_start()
2010 	p2p_set_timeout(p2p, 0, 500000);  in p2p_go_neg_start()
2011 	p2p_connect_send(p2p, p2p->go_neg_peer);  in p2p_go_neg_start()
2017 	struct p2p_data *p2p = eloop_ctx;  in p2p_invite_start()  local
2018 	if (p2p->invite_peer == NULL)  in p2p_invite_start()
2020 	if (p2p->pending_listen_freq) {  in p2p_invite_start()
2021 		p2p_dbg(p2p, "Clear pending_listen_freq for p2p_invite_start");  in p2p_invite_start()
2022 		p2p->pending_listen_freq = 0;  in p2p_invite_start()
2024 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_invite_start()
2025 	p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr,  in p2p_invite_start()
2026 			p2p->invite_dev_pw_id);  in p2p_invite_start()
2030 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,  in p2p_add_dev_from_probe_req()  argument
2055 	dev = p2p_get_device(p2p, addr);  in p2p_add_dev_from_probe_req()
2067 				p2p_dbg(p2p,  in p2p_add_dev_from_probe_req()
2079 	dev = p2p_create_device(p2p, addr);  in p2p_add_dev_from_probe_req()
2094 	p2p_copy_wps_info(p2p, dev, 1, &msg);  in p2p_add_dev_from_probe_req()
2103 	p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR  in p2p_add_dev_from_probe_req()
2111 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,  in p2p_add_dev_from_go_neg_req()  argument
2117 	dev = p2p_get_device(p2p, addr);  in p2p_add_dev_from_go_neg_req()
2123 	dev = p2p_create_device(p2p, addr);  in p2p_add_dev_from_go_neg_req()
2127 	p2p_add_dev_info(p2p, addr, dev, msg);  in p2p_add_dev_from_go_neg_req()
2167 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)  in p2p_match_dev_type()  argument
2178 	if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,  in p2p_match_dev_type()
2182 	for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) {  in p2p_match_dev_type()
2183 		if (dev_type_list_match(p2p->cfg->sec_dev_type[i],  in p2p_match_dev_type()
2194 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p,  in p2p_build_probe_resp_ies()  argument
2204 	if (p2p->wfd_ie_probe_resp)  in p2p_build_probe_resp_ies()
2205 		extra = wpabuf_len(p2p->wfd_ie_probe_resp);  in p2p_build_probe_resp_ies()
2208 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])  in p2p_build_probe_resp_ies()
2209 		extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);  in p2p_build_probe_resp_ies()
2218 	if (p2p->go_neg_peer) {  in p2p_build_probe_resp_ies()
2220 		pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);  in p2p_build_probe_resp_ies()
2223 	if (p2p_build_wps_ie(p2p, buf, pw_id, 1) < 0) {  in p2p_build_probe_resp_ies()
2224 		p2p_dbg(p2p, "Failed to build WPS IE for Probe Response");  in p2p_build_probe_resp_ies()
2230 	if (p2p->wfd_ie_probe_resp)  in p2p_build_probe_resp_ies()
2231 		wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp);  in p2p_build_probe_resp_ies()
2234 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])  in p2p_build_probe_resp_ies()
2236 			       p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);  in p2p_build_probe_resp_ies()
2240 	p2p_buf_add_capability(buf, p2p->dev_capab &  in p2p_build_probe_resp_ies()
2242 	if (p2p->ext_listen_interval)  in p2p_build_probe_resp_ies()
2243 		p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,  in p2p_build_probe_resp_ies()
2244 					      p2p->ext_listen_interval);  in p2p_build_probe_resp_ies()
2245 	p2p_buf_add_device_info(buf, p2p, NULL);  in p2p_build_probe_resp_ies()
2249 		p2p_buf_add_service_instance(buf, p2p, query_count, query_hash,  in p2p_build_probe_resp_ies()
2250 					     p2p->p2ps_adv_list);  in p2p_build_probe_resp_ies()
2256 static int p2p_build_probe_resp_buf(struct p2p_data *p2p, struct wpabuf *buf,  in p2p_build_probe_resp_buf()  argument
2269 	os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);  in p2p_build_probe_resp_buf()
2270 	os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);  in p2p_build_probe_resp_buf()
2294 		channel = p2p->cfg->channel;  in p2p_build_probe_resp_buf()
2296 		p2p_err(p2p, "Failed to convert freq to channel");  in p2p_build_probe_resp_buf()
2309 static int p2p_service_find_asp(struct p2p_data *p2p, const u8 *hash)  in p2p_service_find_asp()  argument
2314 	p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list);  in p2p_service_find_asp()
2317 	any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0;  in p2p_service_find_asp()
2319 	adv_data = p2p->p2ps_adv_list;  in p2p_service_find_asp()
2335 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst,  in p2p_reply_probe()  argument
2347 		p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it");  in p2p_reply_probe()
2351 	if (elems.p2p == NULL) {  in p2p_reply_probe()
2353 		p2p_dbg(p2p, "Not a P2P probe - ignore it");  in p2p_reply_probe()
2358 	    os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) {  in p2p_reply_probe()
2361 		p2p_dbg(p2p, "Probe Req DA " MACSTR " not ours - ignore it",  in p2p_reply_probe()
2368 		p2p_dbg(p2p, "Probe Req BSSID " MACSTR " not wildcard - ignore it",  in p2p_reply_probe()
2377 		p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it");  in p2p_reply_probe()
2383 		p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it");  in p2p_reply_probe()
2390 		p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it");  in p2p_reply_probe()
2399 …p2p_dbg(p2p, "in_listen=%d drv_in_listen=%d when received P2PS Probe Request at %u MHz; own Listen…  in p2p_reply_probe()
2400 			p2p->in_listen, p2p->drv_in_listen, rx_freq,  in p2p_reply_probe()
2401 			p2p->cfg->channel, p2p->pending_listen_freq);  in p2p_reply_probe()
2403 		if (!p2p->in_listen && !p2p->drv_in_listen &&  in p2p_reply_probe()
2404 		    p2p->pending_listen_freq && rx_freq &&  in p2p_reply_probe()
2405 		    rx_freq != p2p->pending_listen_freq) {  in p2p_reply_probe()
2406 …p2p_dbg(p2p, "Do not reply to Probe Request frame that was received on %u MHz while waiting to sta…  in p2p_reply_probe()
2407 				rx_freq, p2p->pending_listen_freq);  in p2p_reply_probe()
2413 			if (p2p_service_find_asp(p2p, hash)) {  in p2p_reply_probe()
2414 				p2p_dbg(p2p, "Service Hash match found: "  in p2p_reply_probe()
2424 			p2p_dbg(p2p, "No Service Hash match found");  in p2p_reply_probe()
2430 		p2p_dbg(p2p, "No P2PS Hash in Probe Request");  in p2p_reply_probe()
2432 		if (!p2p->in_listen || !p2p->drv_in_listen) {  in p2p_reply_probe()
2434 			p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request",  in p2p_reply_probe()
2435 				p2p->in_listen, p2p->drv_in_listen);  in p2p_reply_probe()
2442 	    os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) {  in p2p_reply_probe()
2444 		p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR " did not match - ignore it",  in p2p_reply_probe()
2452 	    !p2p_match_dev_type(p2p, msg.wps_attributes)) {  in p2p_reply_probe()
2454 		p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it");  in p2p_reply_probe()
2459 	if (!p2p->cfg->send_probe_resp) {  in p2p_reply_probe()
2461 		p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response");  in p2p_reply_probe()
2466 	p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state");  in p2p_reply_probe()
2474 	ies = p2p_build_probe_resp_ies(p2p, msg.service_hash,  in p2p_reply_probe()
2486 	if (p2p_build_probe_resp_buf(p2p, buf, ies, addr, rx_freq)) {  in p2p_reply_probe()
2494 	p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq);  in p2p_reply_probe()
2503 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst,  in p2p_probe_req_rx()  argument
2509 	p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);  in p2p_probe_req_rx()
2512 		p2p_dbg(p2p,  in p2p_probe_req_rx()
2517 	res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len, rx_freq);  in p2p_probe_req_rx()
2529 	if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&  in p2p_probe_req_rx()
2530 	    p2p->go_neg_peer &&  in p2p_probe_req_rx()
2531 	    os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)  in p2p_probe_req_rx()
2533 	    !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {  in p2p_probe_req_rx()
2535 		p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout");  in p2p_probe_req_rx()
2536 		eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);  in p2p_probe_req_rx()
2537 		eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);  in p2p_probe_req_rx()
2541 	if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&  in p2p_probe_req_rx()
2542 	    p2p->invite_peer &&  in p2p_probe_req_rx()
2543 	    (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) &&  in p2p_probe_req_rx()
2544 	    os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)  in p2p_probe_req_rx()
2547 		p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout");  in p2p_probe_req_rx()
2548 		eloop_cancel_timeout(p2p_invite_start, p2p, NULL);  in p2p_probe_req_rx()
2549 		eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);  in p2p_probe_req_rx()
2557 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,  in p2p_assoc_req_ie_wlan_ap()  argument
2574 	p2p_dbg(p2p, "BSS P2P manageability %s",  in p2p_assoc_req_ie_wlan_ap()
2592 	if (p2p->num_groups > 0) {  in p2p_assoc_req_ie_wlan_ap()
2594 		if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&  in p2p_assoc_req_ie_wlan_ap()
2595 		    (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&  in p2p_assoc_req_ie_wlan_ap()
2596 		    p2p->cross_connect)  in p2p_assoc_req_ie_wlan_ap()
2599 	p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);  in p2p_assoc_req_ie_wlan_ap()
2600 	if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&  in p2p_assoc_req_ie_wlan_ap()
2601 	    (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))  in p2p_assoc_req_ie_wlan_ap()
2602 		p2p_buf_add_p2p_interface(tmp, p2p);  in p2p_assoc_req_ie_wlan_ap()
2618 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,  in p2p_assoc_req_ie()  argument
2629 		return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);  in p2p_assoc_req_ie()
2632 	if (p2p->wfd_ie_assoc_req)  in p2p_assoc_req_ie()
2633 		extra = wpabuf_len(p2p->wfd_ie_assoc_req);  in p2p_assoc_req_ie()
2636 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])  in p2p_assoc_req_ie()
2637 		extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);  in p2p_assoc_req_ie()
2650 	if (p2p->wfd_ie_assoc_req)  in p2p_assoc_req_ie()
2651 		wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req);  in p2p_assoc_req_ie()
2654 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])  in p2p_assoc_req_ie()
2656 			       p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);  in p2p_assoc_req_ie()
2658 	peer = bssid ? p2p_get_device(p2p, bssid) : NULL;  in p2p_assoc_req_ie()
2661 	p2p_buf_add_capability(tmp, p2p->dev_capab, 0);  in p2p_assoc_req_ie()
2662 	if (p2p->ext_listen_interval)  in p2p_assoc_req_ie()
2663 		p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,  in p2p_assoc_req_ie()
2664 					      p2p->ext_listen_interval);  in p2p_assoc_req_ie()
2665 	p2p_buf_add_device_info(tmp, p2p, peer);  in p2p_assoc_req_ie()
2697 p2p_service_p2ps_id(struct p2p_data *p2p, u32 adv_id)  in p2p_service_p2ps_id()  argument
2701 	if (!p2p)  in p2p_service_p2ps_id()
2704 	adv_data = p2p->p2ps_adv_list;  in p2p_service_p2ps_id()
2715 int p2p_service_del_asp(struct p2p_data *p2p, u32 adv_id)  in p2p_service_del_asp()  argument
2720 	if (!p2p)  in p2p_service_del_asp()
2723 	adv_data = p2p->p2ps_adv_list;  in p2p_service_del_asp()
2724 	prior = &p2p->p2ps_adv_list;  in p2p_service_del_asp()
2727 			p2p_dbg(p2p, "Delete ASP adv_id=0x%x", adv_id);  in p2p_service_del_asp()
2740 int p2p_service_add_asp(struct p2p_data *p2p, int auto_accept, u32 adv_id,  in p2p_service_add_asp()  argument
2749 	if (!p2p || !adv_str || !adv_str[0] || !cpt_priority)  in p2p_service_add_asp()
2752 	if (!(config_methods & p2p->cfg->config_methods)) {  in p2p_service_add_asp()
2753 		p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x",  in p2p_service_add_asp()
2754 			config_methods, p2p->cfg->config_methods);  in p2p_service_add_asp()
2758 	if (!p2ps_gen_hash(p2p, adv_str, buf))  in p2p_service_add_asp()
2774 	adv_data->config_methods = config_methods & p2p->cfg->config_methods;  in p2p_service_add_asp()
2792 	tmp = p2p->p2ps_adv_list;  in p2p_service_add_asp()
2793 	prev = &p2p->p2ps_adv_list;  in p2p_service_add_asp()
2816 	adv_data->next = p2p->p2ps_adv_list;  in p2p_service_add_asp()
2817 	p2p->p2ps_adv_list = adv_data;  in p2p_service_add_asp()
2820 	p2p_dbg(p2p,  in p2p_service_add_asp()
2829 void p2p_service_flush_asp(struct p2p_data *p2p)  in p2p_service_flush_asp()  argument
2833 	if (!p2p)  in p2p_service_flush_asp()
2836 	adv = p2p->p2ps_adv_list;  in p2p_service_flush_asp()
2843 	p2p->p2ps_adv_list = NULL;  in p2p_service_flush_asp()
2844 	p2ps_prov_free(p2p);  in p2p_service_flush_asp()
2845 	p2p_dbg(p2p, "All ASP advertisements flushed");  in p2p_service_flush_asp()
2883 static void p2p_clear_go_neg(struct p2p_data *p2p)  in p2p_clear_go_neg()  argument
2885 	p2p->go_neg_peer = NULL;  in p2p_clear_go_neg()
2886 	p2p_clear_timeout(p2p);  in p2p_clear_go_neg()
2887 	p2p_set_state(p2p, P2P_IDLE);  in p2p_clear_go_neg()
2891 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)  in p2p_wps_success_cb()  argument
2893 	if (p2p->go_neg_peer == NULL) {  in p2p_wps_success_cb()
2894 		p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification");  in p2p_wps_success_cb()
2898 	if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) !=  in p2p_wps_success_cb()
2900 		p2p_dbg(p2p, "Ignore WPS registration success notification for "  in p2p_wps_success_cb()
2903 			MAC2STR(p2p->go_neg_peer->intended_addr));  in p2p_wps_success_cb()
2907 	p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR,  in p2p_wps_success_cb()
2910 	p2p_clear_go_neg(p2p);  in p2p_wps_success_cb()
2914 void p2p_group_formation_failed(struct p2p_data *p2p)  in p2p_group_formation_failed()  argument
2916 	if (p2p->go_neg_peer == NULL) {  in p2p_group_formation_failed()
2917 		p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification");  in p2p_group_formation_failed()
2921 	p2p_dbg(p2p, "Group Formation failed with " MACSTR,  in p2p_group_formation_failed()
2922 		MAC2STR(p2p->go_neg_peer->intended_addr));  in p2p_group_formation_failed()
2924 	p2p_clear_go_neg(p2p);  in p2p_group_formation_failed()
2928 bool is_p2p_6ghz_disabled(struct p2p_data *p2p)  in is_p2p_6ghz_disabled()  argument
2930 	if (p2p)  in is_p2p_6ghz_disabled()
2931 		return p2p->cfg->p2p_6ghz_disable;  in is_p2p_6ghz_disabled()
2938 	struct p2p_data *p2p;  in p2p_init()  local
2944 	p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));  in p2p_init()
2945 	if (p2p == NULL)  in p2p_init()
2947 	p2p->cfg = (struct p2p_config *) (p2p + 1);  in p2p_init()
2948 	os_memcpy(p2p->cfg, cfg, sizeof(*cfg));  in p2p_init()
2950 		p2p->cfg->dev_name = os_strdup(cfg->dev_name);  in p2p_init()
2952 		p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);  in p2p_init()
2954 		p2p->cfg->model_name = os_strdup(cfg->model_name);  in p2p_init()
2956 		p2p->cfg->model_number = os_strdup(cfg->model_number);  in p2p_init()
2958 		p2p->cfg->serial_number = os_strdup(cfg->serial_number);  in p2p_init()
2960 		p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *  in p2p_init()
2962 		if (p2p->cfg->pref_chan) {  in p2p_init()
2963 			os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,  in p2p_init()
2967 			p2p->cfg->num_pref_chan = 0;  in p2p_init()
2970 	p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash);  in p2p_init()
2972 	p2p->min_disc_int = 1;  in p2p_init()
2973 	p2p->max_disc_int = 3;  in p2p_init()
2974 	p2p->max_disc_tu = -1;  in p2p_init()
2976 	if (os_get_random(&p2p->next_tie_breaker, 1) < 0)  in p2p_init()
2977 		p2p->next_tie_breaker = 0;  in p2p_init()
2978 	p2p->next_tie_breaker &= 0x01;  in p2p_init()
2980 		p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;  in p2p_init()
2981 	p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;  in p2p_init()
2983 		p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;  in p2p_init()
2984 	p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;  in p2p_init()
2986 	dl_list_init(&p2p->devices);  in p2p_init()
2988 	p2p->go_timeout = 100;  in p2p_init()
2989 	p2p->client_timeout = 20;  in p2p_init()
2990 	p2p->num_p2p_sd_queries = 0;  in p2p_init()
2992 	p2p_dbg(p2p, "initialized");  in p2p_init()
2993 	p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);  in p2p_init()
2994 	p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);  in p2p_init()
2996 	return p2p;  in p2p_init()
3000 void p2p_deinit(struct p2p_data *p2p)  in p2p_deinit()  argument
3003 	wpabuf_free(p2p->wfd_ie_beacon);  in p2p_deinit()
3004 	wpabuf_free(p2p->wfd_ie_probe_req);  in p2p_deinit()
3005 	wpabuf_free(p2p->wfd_ie_probe_resp);  in p2p_deinit()
3006 	wpabuf_free(p2p->wfd_ie_assoc_req);  in p2p_deinit()
3007 	wpabuf_free(p2p->wfd_ie_invitation);  in p2p_deinit()
3008 	wpabuf_free(p2p->wfd_ie_prov_disc_req);  in p2p_deinit()
3009 	wpabuf_free(p2p->wfd_ie_prov_disc_resp);  in p2p_deinit()
3010 	wpabuf_free(p2p->wfd_ie_go_neg);  in p2p_deinit()
3011 	wpabuf_free(p2p->wfd_dev_info);  in p2p_deinit()
3012 	wpabuf_free(p2p->wfd_assoc_bssid);  in p2p_deinit()
3013 	wpabuf_free(p2p->wfd_coupled_sink_info);  in p2p_deinit()
3014 	wpabuf_free(p2p->wfd_r2_dev_info);  in p2p_deinit()
3017 	eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);  in p2p_deinit()
3018 	eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);  in p2p_deinit()
3019 	eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);  in p2p_deinit()
3020 	p2p_flush(p2p);  in p2p_deinit()
3021 	p2p_free_req_dev_types(p2p);  in p2p_deinit()
3022 	os_free(p2p->cfg->dev_name);  in p2p_deinit()
3023 	os_free(p2p->cfg->manufacturer);  in p2p_deinit()
3024 	os_free(p2p->cfg->model_name);  in p2p_deinit()
3025 	os_free(p2p->cfg->model_number);  in p2p_deinit()
3026 	os_free(p2p->cfg->serial_number);  in p2p_deinit()
3027 	os_free(p2p->cfg->pref_chan);  in p2p_deinit()
3028 	os_free(p2p->groups);  in p2p_deinit()
3029 	p2ps_prov_free(p2p);  in p2p_deinit()
3030 	wpabuf_free(p2p->sd_resp);  in p2p_deinit()
3031 	p2p_remove_wps_vendor_extensions(p2p);  in p2p_deinit()
3032 	os_free(p2p->no_go_freq.range);  in p2p_deinit()
3033 	p2p_service_flush_asp(p2p);  in p2p_deinit()
3035 	os_free(p2p);  in p2p_deinit()
3039 void p2p_flush(struct p2p_data *p2p)  in p2p_flush()  argument
3043 	p2p_ext_listen(p2p, 0, 0);  in p2p_flush()
3044 	p2p_stop_find(p2p);  in p2p_flush()
3045 	dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,  in p2p_flush()
3048 		p2p_device_free(p2p, dev);  in p2p_flush()
3050 	p2p_free_sd_queries(p2p);  in p2p_flush()
3051 	p2p->ssid_set = 0;  in p2p_flush()
3052 	p2ps_prov_free(p2p);  in p2p_flush()
3053 	p2p_reset_pending_pd(p2p);  in p2p_flush()
3054 	p2p->override_pref_op_class = 0;  in p2p_flush()
3055 	p2p->override_pref_channel = 0;  in p2p_flush()
3059 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)  in p2p_unauthorize()  argument
3063 	dev = p2p_get_device(p2p, addr);  in p2p_unauthorize()
3067 	p2p_dbg(p2p, "Unauthorizing " MACSTR, MAC2STR(addr));  in p2p_unauthorize()
3069 	if (p2p->go_neg_peer == dev) {  in p2p_unauthorize()
3070 		eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);  in p2p_unauthorize()
3071 		p2p->go_neg_peer = NULL;  in p2p_unauthorize()
3083 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)  in p2p_set_dev_name()  argument
3085 	os_free(p2p->cfg->dev_name);  in p2p_set_dev_name()
3087 		p2p->cfg->dev_name = os_strdup(dev_name);  in p2p_set_dev_name()
3088 		if (p2p->cfg->dev_name == NULL)  in p2p_set_dev_name()
3091 		p2p->cfg->dev_name = NULL;  in p2p_set_dev_name()
3096 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)  in p2p_set_manufacturer()  argument
3098 	os_free(p2p->cfg->manufacturer);  in p2p_set_manufacturer()
3099 	p2p->cfg->manufacturer = NULL;  in p2p_set_manufacturer()
3101 		p2p->cfg->manufacturer = os_strdup(manufacturer);  in p2p_set_manufacturer()
3102 		if (p2p->cfg->manufacturer == NULL)  in p2p_set_manufacturer()
3110 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)  in p2p_set_model_name()  argument
3112 	os_free(p2p->cfg->model_name);  in p2p_set_model_name()
3113 	p2p->cfg->model_name = NULL;  in p2p_set_model_name()
3115 		p2p->cfg->model_name = os_strdup(model_name);  in p2p_set_model_name()
3116 		if (p2p->cfg->model_name == NULL)  in p2p_set_model_name()
3124 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)  in p2p_set_model_number()  argument
3126 	os_free(p2p->cfg->model_number);  in p2p_set_model_number()
3127 	p2p->cfg->model_number = NULL;  in p2p_set_model_number()
3129 		p2p->cfg->model_number = os_strdup(model_number);  in p2p_set_model_number()
3130 		if (p2p->cfg->model_number == NULL)  in p2p_set_model_number()
3138 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)  in p2p_set_serial_number()  argument
3140 	os_free(p2p->cfg->serial_number);  in p2p_set_serial_number()
3141 	p2p->cfg->serial_number = NULL;  in p2p_set_serial_number()
3143 		p2p->cfg->serial_number = os_strdup(serial_number);  in p2p_set_serial_number()
3144 		if (p2p->cfg->serial_number == NULL)  in p2p_set_serial_number()
3152 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)  in p2p_set_config_methods()  argument
3154 	p2p->cfg->config_methods = config_methods;  in p2p_set_config_methods()
3158 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)  in p2p_set_uuid()  argument
3160 	os_memcpy(p2p->cfg->uuid, uuid, 16);  in p2p_set_uuid()
3164 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)  in p2p_set_pri_dev_type()  argument
3166 	os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);  in p2p_set_pri_dev_type()
3171 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],  in p2p_set_sec_dev_types()  argument
3176 	p2p->cfg->num_sec_dev_types = num_dev_types;  in p2p_set_sec_dev_types()
3177 	os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);  in p2p_set_sec_dev_types()
3182 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)  in p2p_remove_wps_vendor_extensions()  argument
3187 		wpabuf_free(p2p->wps_vendor_ext[i]);  in p2p_remove_wps_vendor_extensions()
3188 		p2p->wps_vendor_ext[i] = NULL;  in p2p_remove_wps_vendor_extensions()
3193 int p2p_add_wps_vendor_extension(struct p2p_data *p2p,  in p2p_add_wps_vendor_extension()  argument
3202 		if (p2p->wps_vendor_ext[i] == NULL)  in p2p_add_wps_vendor_extension()
3208 	p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);  in p2p_add_wps_vendor_extension()
3209 	if (p2p->wps_vendor_ext[i] == NULL)  in p2p_add_wps_vendor_extension()
3216 int p2p_set_country(struct p2p_data *p2p, const char *country)  in p2p_set_country()  argument
3218 	os_memcpy(p2p->cfg->country, country, 3);  in p2p_set_country()
3223 static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev)  in p2p_pre_find_operation()  argument
3230 		dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries;  in p2p_pre_find_operation()
3233 	res = p2p_start_sd(p2p, dev);  in p2p_pre_find_operation()
3241 		p2p_dbg(p2p, "Send pending Provision Discovery Request to "  in p2p_pre_find_operation()
3245 		if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)  in p2p_pre_find_operation()
3253 void p2p_continue_find(struct p2p_data *p2p)  in p2p_continue_find()  argument
3258 	p2p_set_state(p2p, P2P_SEARCH);  in p2p_continue_find()
3262 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_continue_find()
3263 		if (dev == p2p->last_p2p_find_oper) {  in p2p_continue_find()
3269 		res = p2p_pre_find_operation(p2p, dev);  in p2p_continue_find()
3271 			p2p->last_p2p_find_oper = dev;  in p2p_continue_find()
3282 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_continue_find()
3283 		res = p2p_pre_find_operation(p2p, dev);  in p2p_continue_find()
3285 			p2p->last_p2p_find_oper = dev;  in p2p_continue_find()
3290 		if (dev == p2p->last_p2p_find_oper)  in p2p_continue_find()
3295 	os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);  in p2p_continue_find()
3296 	p2p_listen_in_find(p2p, 1);  in p2p_continue_find()
3300 static void p2p_sd_cb(struct p2p_data *p2p, int success)  in p2p_sd_cb()  argument
3302 	p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d",  in p2p_sd_cb()
3304 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_sd_cb()
3307 		if (p2p->sd_peer) {  in p2p_sd_cb()
3308 			if (is_zero_ether_addr(p2p->sd_query_no_ack)) {  in p2p_sd_cb()
3309 				os_memcpy(p2p->sd_query_no_ack,  in p2p_sd_cb()
3310 					  p2p->sd_peer->info.p2p_device_addr,  in p2p_sd_cb()
3312 				p2p_dbg(p2p,  in p2p_sd_cb()
3314 					MACSTR, MAC2STR(p2p->sd_query_no_ack));  in p2p_sd_cb()
3316 			p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_sd_cb()
3318 		p2p->sd_peer = NULL;  in p2p_sd_cb()
3319 		if (p2p->state != P2P_IDLE)  in p2p_sd_cb()
3320 			p2p_continue_find(p2p);  in p2p_sd_cb()
3324 	if (p2p->sd_peer == NULL) {  in p2p_sd_cb()
3325 		p2p_dbg(p2p, "No SD peer entry known");  in p2p_sd_cb()
3326 		if (p2p->state != P2P_IDLE)  in p2p_sd_cb()
3327 			p2p_continue_find(p2p);  in p2p_sd_cb()
3331 	if (p2p->sd_query && p2p->sd_query->for_all_peers) {  in p2p_sd_cb()
3334 		p2p->sd_peer->sd_pending_bcast_queries--;  in p2p_sd_cb()
3340 		if (p2p->sd_peer->sd_pending_bcast_queries == 0)  in p2p_sd_cb()
3341 			p2p->sd_peer->sd_pending_bcast_queries = -1;  in p2p_sd_cb()
3345 	p2p_set_state(p2p, P2P_SD_DURING_FIND);  in p2p_sd_cb()
3346 	p2p_set_timeout(p2p, 0, 200000);  in p2p_sd_cb()
3354 static void p2p_retry_pd(struct p2p_data *p2p)  in p2p_retry_pd()  argument
3363 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_retry_pd()
3364 		if (os_memcmp(p2p->pending_pd_devaddr,  in p2p_retry_pd()
3370 		p2p_dbg(p2p, "Send pending Provision Discovery Request to "  in p2p_retry_pd()
3374 		p2p_send_prov_disc_req(p2p, dev,  in p2p_retry_pd()
3376 				       p2p->pd_force_freq);  in p2p_retry_pd()
3382 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)  in p2p_prov_disc_cb()  argument
3384 	p2p_dbg(p2p, "Provision Discovery Request TX callback: success=%d",  in p2p_prov_disc_cb()
3398 		p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_prov_disc_cb()
3400 		if (p2p->user_initiated_pd &&  in p2p_prov_disc_cb()
3401 		    (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY))  in p2p_prov_disc_cb()
3404 			p2p->pending_action_state = P2P_PENDING_PD;  in p2p_prov_disc_cb()
3405 			p2p_set_timeout(p2p, 0, 50000);  in p2p_prov_disc_cb()
3406 		} else if (p2p->state != P2P_IDLE)  in p2p_prov_disc_cb()
3407 			p2p_continue_find(p2p);  in p2p_prov_disc_cb()
3408 		else if (p2p->user_initiated_pd) {  in p2p_prov_disc_cb()
3409 			p2p->pending_action_state = P2P_PENDING_PD;  in p2p_prov_disc_cb()
3410 			p2p_set_timeout(p2p, 0, 300000);  in p2p_prov_disc_cb()
3421 	if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker &&  in p2p_prov_disc_cb()
3422 	    p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) {  in p2p_prov_disc_cb()
3423 		p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK");  in p2p_prov_disc_cb()
3425 		if (p2p->send_action_in_progress) {  in p2p_prov_disc_cb()
3426 			p2p->send_action_in_progress = 0;  in p2p_prov_disc_cb()
3427 			p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_prov_disc_cb()
3430 		p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_prov_disc_cb()
3432 		if (p2p->cfg->p2ps_prov_complete) {  in p2p_prov_disc_cb()
3433 			p2p->cfg->p2ps_prov_complete(  in p2p_prov_disc_cb()
3434 				p2p->cfg->cb_ctx,  in p2p_prov_disc_cb()
3435 				p2p->p2ps_prov->status,  in p2p_prov_disc_cb()
3436 				p2p->p2ps_prov->adv_mac,  in p2p_prov_disc_cb()
3437 				p2p->p2ps_prov->adv_mac,  in p2p_prov_disc_cb()
3438 				p2p->p2ps_prov->session_mac,  in p2p_prov_disc_cb()
3439 				NULL, p2p->p2ps_prov->adv_id,  in p2p_prov_disc_cb()
3440 				p2p->p2ps_prov->session_id,  in p2p_prov_disc_cb()
3445 		if (p2p->user_initiated_pd)  in p2p_prov_disc_cb()
3446 			p2p_reset_pending_pd(p2p);  in p2p_prov_disc_cb()
3448 		p2ps_prov_free(p2p);  in p2p_prov_disc_cb()
3456 	if (p2p->user_initiated_pd)  in p2p_prov_disc_cb()
3457 		p2p->pending_action_state = P2P_PENDING_PD;  in p2p_prov_disc_cb()
3459 		p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_prov_disc_cb()
3462 	if (p2p->state == P2P_SEARCH)  in p2p_prov_disc_cb()
3463 		p2p_set_state(p2p, P2P_PD_DURING_FIND);  in p2p_prov_disc_cb()
3464 	p2p_set_timeout(p2p, 0, 200000);  in p2p_prov_disc_cb()
3468 static void p2p_prov_disc_resp_cb(struct p2p_data *p2p, int success)  in p2p_prov_disc_resp_cb()  argument
3470 	p2p_dbg(p2p, "Provision Discovery Response TX callback: success=%d",  in p2p_prov_disc_resp_cb()
3473 	if (p2p->send_action_in_progress) {  in p2p_prov_disc_resp_cb()
3474 		p2p->send_action_in_progress = 0;  in p2p_prov_disc_resp_cb()
3475 		p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_prov_disc_resp_cb()
3478 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_prov_disc_resp_cb()
3481 		if (p2p->state == P2P_SEARCH)  in p2p_prov_disc_resp_cb()
3482 			p2p_continue_find(p2p);  in p2p_prov_disc_resp_cb()
3486 	if (!p2p->cfg->prov_disc_resp_cb ||  in p2p_prov_disc_resp_cb()
3487 	    p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1) {  in p2p_prov_disc_resp_cb()
3488 		if (p2p->state == P2P_SEARCH)  in p2p_prov_disc_resp_cb()
3489 			p2p_continue_find(p2p);  in p2p_prov_disc_resp_cb()
3493 	p2p_dbg(p2p,  in p2p_prov_disc_resp_cb()
3498 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,  in p2p_scan_res_handler()  argument
3502 	if (os_reltime_before(rx_time, &p2p->find_start)) {  in p2p_scan_res_handler()
3510 		p2p_dbg(p2p, "Ignore old scan result for " MACSTR  in p2p_scan_res_handler()
3514 			(unsigned int) p2p->find_start.sec,  in p2p_scan_res_handler()
3515 			(unsigned int) p2p->find_start.usec);  in p2p_scan_res_handler()
3519 	p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1);  in p2p_scan_res_handler()
3525 void p2p_scan_res_handled(struct p2p_data *p2p, unsigned int delay)  in p2p_scan_res_handled()  argument
3527 	if (!p2p->p2p_scan_running) {  in p2p_scan_res_handled()
3528 		p2p_dbg(p2p, "p2p_scan was not running, but scan results received");  in p2p_scan_res_handled()
3530 	p2p->p2p_scan_running = 0;  in p2p_scan_res_handled()
3533 	if (!p2p->search_delay)  in p2p_scan_res_handled()
3534 		p2p->search_delay = delay;  in p2p_scan_res_handled()
3536 	eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);  in p2p_scan_res_handled()
3538 	if (p2p_run_after_scan(p2p))  in p2p_scan_res_handled()
3540 	if (p2p->state == P2P_SEARCH)  in p2p_scan_res_handled()
3541 		p2p_continue_find(p2p);  in p2p_scan_res_handled()
3545 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id,  in p2p_scan_ie()  argument
3552 	if (p2p->wfd_ie_probe_req)  in p2p_scan_ie()
3553 		wpabuf_put_buf(ies, p2p->wfd_ie_probe_req);  in p2p_scan_ie()
3556 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])  in p2p_scan_ie()
3558 			       p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);  in p2p_scan_ie()
3562 	dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;  in p2p_scan_ie()
3565 	if (p2p->p2ps_seek && p2p->p2ps_seek_count)  in p2p_scan_ie()
3572 	if (p2p->cfg->reg_class && p2p->cfg->channel)  in p2p_scan_ie()
3573 		p2p_buf_add_listen_channel(ies, p2p->cfg->country,  in p2p_scan_ie()
3574 					   p2p->cfg->reg_class,  in p2p_scan_ie()
3575 					   p2p->cfg->channel);  in p2p_scan_ie()
3576 	if (p2p->ext_listen_interval)  in p2p_scan_ie()
3577 		p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,  in p2p_scan_ie()
3578 					      p2p->ext_listen_interval);  in p2p_scan_ie()
3581 		p2p_buf_add_device_info(ies, p2p, NULL);  in p2p_scan_ie()
3583 	if (p2p->p2ps_seek && p2p->p2ps_seek_count)  in p2p_scan_ie()
3584 		p2p_buf_add_service_hash(ies, p2p);  in p2p_scan_ie()
3591 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p)  in p2p_scan_ie_buf_len()  argument
3596 	if (p2p && p2p->wfd_ie_probe_req)  in p2p_scan_ie_buf_len()
3597 		len += wpabuf_len(p2p->wfd_ie_probe_req);  in p2p_scan_ie_buf_len()
3600 	if (p2p && p2p->vendor_elem &&  in p2p_scan_ie_buf_len()
3601 	    p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])  in p2p_scan_ie_buf_len()
3602 		len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);  in p2p_scan_ie_buf_len()
3614 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)  in p2p_go_neg_req_cb()  argument
3616 	struct p2p_device *dev = p2p->go_neg_peer;  in p2p_go_neg_req_cb()
3619 	p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success);  in p2p_go_neg_req_cb()
3622 		p2p_dbg(p2p, "No pending GO Negotiation");  in p2p_go_neg_req_cb()
3628 			p2p_set_state(p2p, P2P_IDLE);  in p2p_go_neg_req_cb()
3639 …p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability thro…  in p2p_go_neg_req_cb()
3641 		p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_go_neg_req_cb()
3642 		p2p_send_dev_disc_req(p2p, dev);  in p2p_go_neg_req_cb()
3650 	p2p_set_state(p2p, P2P_CONNECT);  in p2p_go_neg_req_cb()
3652 	if (!success && p2p->go_neg_peer &&  in p2p_go_neg_req_cb()
3653 	    (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {  in p2p_go_neg_req_cb()
3665 	p2p_set_timeout(p2p, 0, timeout);  in p2p_go_neg_req_cb()
3669 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)  in p2p_go_neg_resp_cb()  argument
3671 	p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d",  in p2p_go_neg_resp_cb()
3673 	if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {  in p2p_go_neg_resp_cb()
3674 		p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore");  in p2p_go_neg_resp_cb()
3677 	p2p_set_state(p2p, P2P_CONNECT);  in p2p_go_neg_resp_cb()
3678 	p2p_set_timeout(p2p, 0, 500000);  in p2p_go_neg_resp_cb()
3682 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success,  in p2p_go_neg_resp_failure_cb()  argument
3685 	p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success);  in p2p_go_neg_resp_failure_cb()
3686 	if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {  in p2p_go_neg_resp_failure_cb()
3687 		p2p_go_neg_failed(p2p, p2p->go_neg_peer->status);  in p2p_go_neg_resp_failure_cb()
3693 		dev = p2p_get_device(p2p, addr);  in p2p_go_neg_resp_failure_cb()
3699 	if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)  in p2p_go_neg_resp_failure_cb()
3700 		p2p_continue_find(p2p);  in p2p_go_neg_resp_failure_cb()
3704 static void p2p_go_neg_conf_cb(struct p2p_data *p2p,  in p2p_go_neg_conf_cb()  argument
3709 	p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result);  in p2p_go_neg_conf_cb()
3711 		p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_go_neg_conf_cb()
3712 		p2p_go_neg_failed(p2p, -1);  in p2p_go_neg_conf_cb()
3716 	dev = p2p->go_neg_peer;  in p2p_go_neg_conf_cb()
3726 			p2p_dbg(p2p, "GO Negotiation Confirm retry %d",  in p2p_go_neg_conf_cb()
3728 			p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;  in p2p_go_neg_conf_cb()
3729 			if (p2p_send_action(p2p, dev->go_neg_conf_freq,  in p2p_go_neg_conf_cb()
3731 					    p2p->cfg->dev_addr,  in p2p_go_neg_conf_cb()
3739 			p2p_dbg(p2p, "Failed to re-send Action frame");  in p2p_go_neg_conf_cb()
3757 …p2p_dbg(p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack w…  in p2p_go_neg_conf_cb()
3760 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_go_neg_conf_cb()
3765 	p2p_go_complete(p2p, dev);  in p2p_go_neg_conf_cb()
3769 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,  in p2p_send_action_cb()  argument
3776 	p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR  in p2p_send_action_cb()
3778 		p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),  in p2p_send_action_cb()
3779 		MAC2STR(bssid), result, p2p_state_txt(p2p->state));  in p2p_send_action_cb()
3781 	state = p2p->pending_action_state;  in p2p_send_action_cb()
3782 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_send_action_cb()
3785 		if (p2p->send_action_in_progress) {  in p2p_send_action_cb()
3786 			p2p->send_action_in_progress = 0;  in p2p_send_action_cb()
3787 			p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_send_action_cb()
3791 		p2p_go_neg_req_cb(p2p, success);  in p2p_send_action_cb()
3794 		p2p_go_neg_resp_cb(p2p, success);  in p2p_send_action_cb()
3797 		p2p_go_neg_resp_failure_cb(p2p, success, dst);  in p2p_send_action_cb()
3800 		p2p_go_neg_conf_cb(p2p, result);  in p2p_send_action_cb()
3803 		p2p_sd_cb(p2p, success);  in p2p_send_action_cb()
3806 		p2p_prov_disc_cb(p2p, success);  in p2p_send_action_cb()
3809 		p2p_prov_disc_resp_cb(p2p, success);  in p2p_send_action_cb()
3812 		p2p_invitation_req_cb(p2p, success);  in p2p_send_action_cb()
3815 		p2p_invitation_resp_cb(p2p, success);  in p2p_send_action_cb()
3818 		p2p_dev_disc_req_cb(p2p, success);  in p2p_send_action_cb()
3821 		p2p_dev_disc_resp_cb(p2p, success);  in p2p_send_action_cb()
3824 		p2p_go_disc_req_cb(p2p, success);  in p2p_send_action_cb()
3830 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,  in p2p_listen_cb()  argument
3833 	if (freq == p2p->pending_client_disc_freq) {  in p2p_listen_cb()
3834 		p2p_dbg(p2p, "Client discoverability remain-awake completed");  in p2p_listen_cb()
3835 		p2p->pending_client_disc_freq = 0;  in p2p_listen_cb()
3839 	if (freq != p2p->pending_listen_freq) {  in p2p_listen_cb()
3840 		p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)",  in p2p_listen_cb()
3841 			freq, duration, p2p->pending_listen_freq);  in p2p_listen_cb()
3845 	p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback",  in p2p_listen_cb()
3846 		p2p->pending_listen_sec, p2p->pending_listen_usec,  in p2p_listen_cb()
3847 		p2p->pending_listen_freq);  in p2p_listen_cb()
3848 	p2p->in_listen = 1;  in p2p_listen_cb()
3849 	p2p->drv_in_listen = freq;  in p2p_listen_cb()
3850 	if (p2p->pending_listen_sec || p2p->pending_listen_usec) {  in p2p_listen_cb()
3856 		p2p_set_timeout(p2p, p2p->pending_listen_sec,  in p2p_listen_cb()
3857 				p2p->pending_listen_usec + 20000);  in p2p_listen_cb()
3860 	p2p->pending_listen_freq = 0;  in p2p_listen_cb()
3864 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)  in p2p_listen_end()  argument
3866 	p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq);  in p2p_listen_end()
3867 	p2p->drv_in_listen = 0;  in p2p_listen_end()
3868 	if (p2p->in_listen)  in p2p_listen_end()
3871 	if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer &&  in p2p_listen_end()
3872 	    p2p->pending_listen_freq) {  in p2p_listen_end()
3878 		p2p_dbg(p2p,  in p2p_listen_end()
3880 		p2p_set_timeout(p2p, 0, 100000);  in p2p_listen_end()
3884 	if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {  in p2p_listen_end()
3885 		if (p2p->go_neg_peer->connect_reqs >= 120) {  in p2p_listen_end()
3886 			p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");  in p2p_listen_end()
3887 			p2p_go_neg_failed(p2p, -1);  in p2p_listen_end()
3891 		p2p_set_state(p2p, P2P_CONNECT);  in p2p_listen_end()
3892 		p2p_connect_send(p2p, p2p->go_neg_peer);  in p2p_listen_end()
3894 	} else if (p2p->state == P2P_SEARCH) {  in p2p_listen_end()
3895 		if (p2p->p2p_scan_running) {  in p2p_listen_end()
3904 			p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one");  in p2p_listen_end()
3907 		if (p2p->pending_listen_freq) {  in p2p_listen_end()
3913 			p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop");  in p2p_listen_end()
3914 			p2p_set_timeout(p2p, 0, 100000);  in p2p_listen_end()
3917 		if (p2p->search_delay) {  in p2p_listen_end()
3918 			p2p_dbg(p2p, "Delay search operation by %u ms",  in p2p_listen_end()
3919 				p2p->search_delay);  in p2p_listen_end()
3920 			p2p_set_timeout(p2p, p2p->search_delay / 1000,  in p2p_listen_end()
3921 					(p2p->search_delay % 1000) * 1000);  in p2p_listen_end()
3924 		p2p_search(p2p);  in p2p_listen_end()
3932 static void p2p_timeout_connect(struct p2p_data *p2p)  in p2p_timeout_connect()  argument
3934 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_timeout_connect()
3935 	if (p2p->go_neg_peer &&  in p2p_timeout_connect()
3936 	    (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {  in p2p_timeout_connect()
3937 		p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed");  in p2p_timeout_connect()
3938 		p2p_go_neg_failed(p2p, -1);  in p2p_timeout_connect()
3941 	if (p2p->go_neg_peer &&  in p2p_timeout_connect()
3942 	    (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) &&  in p2p_timeout_connect()
3943 	    p2p->go_neg_peer->connect_reqs < 120) {  in p2p_timeout_connect()
3944 		p2p_dbg(p2p, "Peer expected to wait our response - skip listen");  in p2p_timeout_connect()
3945 		p2p_connect_send(p2p, p2p->go_neg_peer);  in p2p_timeout_connect()
3948 	if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) {  in p2p_timeout_connect()
3949 		p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)");  in p2p_timeout_connect()
3950 		p2p_set_state(p2p, P2P_CONNECT_LISTEN);  in p2p_timeout_connect()
3951 		p2p_set_timeout(p2p, 0, 30000);  in p2p_timeout_connect()
3954 	p2p_set_state(p2p, P2P_CONNECT_LISTEN);  in p2p_timeout_connect()
3955 	p2p_listen_in_find(p2p, 0);  in p2p_timeout_connect()
3959 static void p2p_timeout_connect_listen(struct p2p_data *p2p)  in p2p_timeout_connect_listen()  argument
3961 	if (p2p->go_neg_peer) {  in p2p_timeout_connect_listen()
3962 		if (p2p->drv_in_listen) {  in p2p_timeout_connect_listen()
3963 			p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete");  in p2p_timeout_connect_listen()
3967 		if (p2p->go_neg_peer->connect_reqs >= 120) {  in p2p_timeout_connect_listen()
3968 			p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response");  in p2p_timeout_connect_listen()
3969 			p2p_go_neg_failed(p2p, -1);  in p2p_timeout_connect_listen()
3973 		p2p_set_state(p2p, P2P_CONNECT);  in p2p_timeout_connect_listen()
3974 		p2p_connect_send(p2p, p2p->go_neg_peer);  in p2p_timeout_connect_listen()
3976 		p2p_set_state(p2p, P2P_IDLE);  in p2p_timeout_connect_listen()
3980 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)  in p2p_timeout_wait_peer_connect()  argument
3982 	p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);  in p2p_timeout_wait_peer_connect()
3984 	if (p2p->cfg->is_concurrent_session_active &&  in p2p_timeout_wait_peer_connect()
3985 	    p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx))  in p2p_timeout_wait_peer_connect()
3986 		p2p_set_timeout(p2p, 0, 500000);  in p2p_timeout_wait_peer_connect()
3988 		p2p_set_timeout(p2p, 0, 200000);  in p2p_timeout_wait_peer_connect()
3992 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)  in p2p_timeout_wait_peer_idle()  argument
3994 	struct p2p_device *dev = p2p->go_neg_peer;  in p2p_timeout_wait_peer_idle()
3997 		p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait");  in p2p_timeout_wait_peer_idle()
4001 	p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation");  in p2p_timeout_wait_peer_idle()
4002 	p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_timeout_wait_peer_idle()
4003 	p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);  in p2p_timeout_wait_peer_idle()
4004 	p2p_listen_in_find(p2p, 0);  in p2p_timeout_wait_peer_idle()
4008 static void p2p_timeout_sd_during_find(struct p2p_data *p2p)  in p2p_timeout_sd_during_find()  argument
4010 	p2p_dbg(p2p, "Service Discovery Query timeout");  in p2p_timeout_sd_during_find()
4011 	if (p2p->sd_peer) {  in p2p_timeout_sd_during_find()
4012 		p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_timeout_sd_during_find()
4013 		p2p->sd_peer = NULL;  in p2p_timeout_sd_during_find()
4015 	p2p_continue_find(p2p);  in p2p_timeout_sd_during_find()
4019 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)  in p2p_timeout_prov_disc_during_find()  argument
4021 	p2p_dbg(p2p, "Provision Discovery Request timeout");  in p2p_timeout_prov_disc_during_find()
4022 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_timeout_prov_disc_during_find()
4023 	p2p_continue_find(p2p);  in p2p_timeout_prov_disc_during_find()
4027 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)  in p2p_timeout_prov_disc_req()  argument
4032 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_timeout_prov_disc_req()
4039 	if (!p2p->user_initiated_pd)  in p2p_timeout_prov_disc_req()
4042 	p2p_dbg(p2p, "User initiated Provision Discovery Request timeout");  in p2p_timeout_prov_disc_req()
4044 	if (p2p->pd_retries) {  in p2p_timeout_prov_disc_req()
4045 		p2p->pd_retries--;  in p2p_timeout_prov_disc_req()
4046 		p2p_retry_pd(p2p);  in p2p_timeout_prov_disc_req()
4051 		dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {  in p2p_timeout_prov_disc_req()
4052 			if (os_memcmp(p2p->pending_pd_devaddr,  in p2p_timeout_prov_disc_req()
4060 		if (p2p->p2ps_prov) {  in p2p_timeout_prov_disc_req()
4061 			adv_id = p2p->p2ps_prov->adv_id;  in p2p_timeout_prov_disc_req()
4062 			adv_mac = p2p->p2ps_prov->adv_mac;  in p2p_timeout_prov_disc_req()
4065 		if (p2p->cfg->prov_disc_fail)  in p2p_timeout_prov_disc_req()
4066 			p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,  in p2p_timeout_prov_disc_req()
4067 						 p2p->pending_pd_devaddr,  in p2p_timeout_prov_disc_req()
4072 		p2p_reset_pending_pd(p2p);  in p2p_timeout_prov_disc_req()
4077 static void p2p_timeout_invite(struct p2p_data *p2p)  in p2p_timeout_invite()  argument
4079 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);  in p2p_timeout_invite()
4080 	p2p_set_state(p2p, P2P_INVITE_LISTEN);  in p2p_timeout_invite()
4081 	if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {  in p2p_timeout_invite()
4086 		p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel");  in p2p_timeout_invite()
4087 		p2p_set_timeout(p2p, 0, 100000);  in p2p_timeout_invite()
4090 	p2p_listen_in_find(p2p, 0);  in p2p_timeout_invite()
4094 static void p2p_timeout_invite_listen(struct p2p_data *p2p)  in p2p_timeout_invite_listen()  argument
4096 	if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {  in p2p_timeout_invite_listen()
4097 		p2p_set_state(p2p, P2P_INVITE);  in p2p_timeout_invite_listen()
4098 		p2p_invite_send(p2p, p2p->invite_peer,  in p2p_timeout_invite_listen()
4099 				p2p->invite_go_dev_addr, p2p->invite_dev_pw_id);  in p2p_timeout_invite_listen()
4101 		if (p2p->invite_peer) {  in p2p_timeout_invite_listen()
4102 			p2p_dbg(p2p, "Invitation Request retry limit reached");  in p2p_timeout_invite_listen()
4103 			if (p2p->cfg->invitation_result)  in p2p_timeout_invite_listen()
4104 				p2p->cfg->invitation_result(  in p2p_timeout_invite_listen()
4105 					p2p->cfg->cb_ctx, -1, NULL, NULL,  in p2p_timeout_invite_listen()
4106 					p2p->invite_peer->info.p2p_device_addr,  in p2p_timeout_invite_listen()
4109 		p2p_set_state(p2p, P2P_IDLE);  in p2p_timeout_invite_listen()
4116 	struct p2p_data *p2p = eloop_ctx;  in p2p_state_timeout()  local
4118 	p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state));  in p2p_state_timeout()
4120 	p2p->in_listen = 0;  in p2p_state_timeout()
4121 	if (p2p->drv_in_listen) {  in p2p_state_timeout()
4122 		p2p_dbg(p2p, "Driver is still in listen state - stop it");  in p2p_state_timeout()
4123 		p2p->cfg->stop_listen(p2p->cfg->cb_ctx);  in p2p_state_timeout()
4126 	switch (p2p->state) {  in p2p_state_timeout()
4129 		if (p2p->pending_action_state == P2P_PENDING_PD)  in p2p_state_timeout()
4130 			p2p_timeout_prov_disc_req(p2p);  in p2p_state_timeout()
4134 		if (p2p->pending_action_state == P2P_PENDING_PD)  in p2p_state_timeout()
4135 			p2p_timeout_prov_disc_req(p2p);  in p2p_state_timeout()
4136 		if (p2p->search_delay && !p2p->in_search_delay) {  in p2p_state_timeout()
4137 			p2p_dbg(p2p, "Delay search operation by %u ms",  in p2p_state_timeout()
4138 				p2p->search_delay);  in p2p_state_timeout()
4139 			p2p->in_search_delay = 1;  in p2p_state_timeout()
4140 			p2p_set_timeout(p2p, p2p->search_delay / 1000,  in p2p_state_timeout()
4141 					(p2p->search_delay % 1000) * 1000);  in p2p_state_timeout()
4144 		p2p->in_search_delay = 0;  in p2p_state_timeout()
4145 		p2p_search(p2p);  in p2p_state_timeout()
4148 		p2p_timeout_connect(p2p);  in p2p_state_timeout()
4151 		p2p_timeout_connect_listen(p2p);  in p2p_state_timeout()
4157 		if (p2p->pending_action_state == P2P_PENDING_PD)  in p2p_state_timeout()
4158 			p2p_timeout_prov_disc_req(p2p);  in p2p_state_timeout()
4160 		if (p2p->ext_listen_only) {  in p2p_state_timeout()
4161 			p2p_dbg(p2p, "Extended Listen Timing - Listen State completed");  in p2p_state_timeout()
4162 			p2p->ext_listen_only = 0;  in p2p_state_timeout()
4163 			p2p_set_state(p2p, P2P_IDLE);  in p2p_state_timeout()
4167 		p2p_timeout_wait_peer_connect(p2p);  in p2p_state_timeout()
4170 		p2p_timeout_wait_peer_idle(p2p);  in p2p_state_timeout()
4173 		p2p_timeout_sd_during_find(p2p);  in p2p_state_timeout()
4178 		p2p_timeout_prov_disc_during_find(p2p);  in p2p_state_timeout()
4181 		p2p_timeout_invite(p2p);  in p2p_state_timeout()
4184 		p2p_timeout_invite_listen(p2p);  in p2p_state_timeout()
4190 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)  in p2p_reject()  argument
4194 	dev = p2p_get_device(p2p, peer_addr);  in p2p_reject()
4195 	p2p_dbg(p2p, "Local request to reject connection attempts by peer "  in p2p_reject()
4198 		p2p_dbg(p2p, "Peer " MACSTR " unknown", MAC2STR(peer_addr));  in p2p_reject()
4243 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p,  in p2p_get_peer_info()  argument
4249 		dev = p2p_get_device(p2p, addr);  in p2p_get_peer_info()
4251 		dev = dl_list_first(&p2p->devices, struct p2p_device, list);  in p2p_get_peer_info()
4255 		if (&dev->list == &p2p->devices)  in p2p_get_peer_info()
4393 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr)  in p2p_peer_known()  argument
4395 	return p2p_get_device(p2p, addr) != NULL;  in p2p_peer_known()
4399 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)  in p2p_set_client_discoverability()  argument
4402 		p2p_dbg(p2p, "Client discoverability enabled");  in p2p_set_client_discoverability()
4403 		p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;  in p2p_set_client_discoverability()
4405 		p2p_dbg(p2p, "Client discoverability disabled");  in p2p_set_client_discoverability()
4406 		p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;  in p2p_set_client_discoverability()
4447 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,  in p2p_presence_req()  argument
4454 	p2p_dbg(p2p, "Send Presence Request to GO " MACSTR  in p2p_presence_req()
4465 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_presence_req()
4466 	if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,  in p2p_presence_req()
4469 		p2p_dbg(p2p, "Failed to send Action frame");  in p2p_presence_req()
4502 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,  in p2p_process_presence_req()  argument
4515 	p2p_dbg(p2p, "Received P2P Action - P2P Presence Request");  in p2p_process_presence_req()
4517 	for (g = 0; g < p2p->num_groups; g++) {  in p2p_process_presence_req()
4518 		if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]),  in p2p_process_presence_req()
4520 			group = p2p->groups[g];  in p2p_process_presence_req()
4525 		p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group "  in p2p_process_presence_req()
4531 		p2p_dbg(p2p, "Failed to parse P2P Presence Request");  in p2p_process_presence_req()
4538 		p2p_dbg(p2p, "No NoA attribute in P2P Presence Request");  in p2p_process_presence_req()
4546 	if (p2p->cfg->get_noa)  in p2p_process_presence_req()
4547 		noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,  in p2p_process_presence_req()
4559 	p2p->pending_action_state = P2P_NO_PENDING_ACTION;  in p2p_process_presence_req()
4560 	if (p2p_send_action(p2p, rx_freq, sa, da, da,  in p2p_process_presence_req()
4562 		p2p_dbg(p2p, "Failed to send Action frame");  in p2p_process_presence_req()
4568 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,  in p2p_process_presence_resp()  argument
4573 	p2p_dbg(p2p, "Received P2P Action - P2P Presence Response");  in p2p_process_presence_resp()
4576 		p2p_dbg(p2p, "Failed to parse P2P Presence Response");  in p2p_process_presence_resp()
4581 		p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response");  in p2p_process_presence_resp()
4586 	if (p2p->cfg->presence_resp) {  in p2p_process_presence_resp()
4587 		p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status,  in p2p_process_presence_resp()
4592 		p2p_dbg(p2p, "P2P Presence Request was rejected: status %u",  in p2p_process_presence_resp()
4598 	p2p_dbg(p2p, "P2P Presence Request was accepted");  in p2p_process_presence_resp()
4608 	struct p2p_data *p2p = eloop_ctx;  in p2p_ext_listen_timeout()  local
4610 	if (p2p->ext_listen_interval) {  in p2p_ext_listen_timeout()
4612 		eloop_register_timeout(p2p->ext_listen_interval_sec,  in p2p_ext_listen_timeout()
4613 				       p2p->ext_listen_interval_usec,  in p2p_ext_listen_timeout()
4614 				       p2p_ext_listen_timeout, p2p, NULL);  in p2p_ext_listen_timeout()
4617 	if ((p2p->cfg->is_p2p_in_progress &&  in p2p_ext_listen_timeout()
4618 	     p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) ||  in p2p_ext_listen_timeout()
4619 	    (p2p->pending_action_state == P2P_PENDING_PD &&  in p2p_ext_listen_timeout()
4620 	     p2p->pd_retries > 0)) {  in p2p_ext_listen_timeout()
4621 		p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)",  in p2p_ext_listen_timeout()
4622 			p2p_state_txt(p2p->state));  in p2p_ext_listen_timeout()
4626 	if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {  in p2p_ext_listen_timeout()
4633 		p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");  in p2p_ext_listen_timeout()
4634 		p2p->ext_listen_only = 0;  in p2p_ext_listen_timeout()
4635 		p2p_set_state(p2p, P2P_IDLE);  in p2p_ext_listen_timeout()
4638 	if (p2p->state != P2P_IDLE) {  in p2p_ext_listen_timeout()
4639 		p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state));  in p2p_ext_listen_timeout()
4643 	p2p_dbg(p2p, "Extended Listen timeout");  in p2p_ext_listen_timeout()
4644 	p2p->ext_listen_only = 1;  in p2p_ext_listen_timeout()
4645 	if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {  in p2p_ext_listen_timeout()
4646 		p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing");  in p2p_ext_listen_timeout()
4647 		p2p->ext_listen_only = 0;  in p2p_ext_listen_timeout()
4652 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,  in p2p_ext_listen()  argument
4657 		p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u",  in p2p_ext_listen()
4662 	eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);  in p2p_ext_listen()
4665 		p2p_dbg(p2p, "Disabling Extended Listen Timing");  in p2p_ext_listen()
4666 		p2p->ext_listen_period = 0;  in p2p_ext_listen()
4667 		p2p->ext_listen_interval = 0;  in p2p_ext_listen()
4671 	p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec",  in p2p_ext_listen()
4673 	p2p->ext_listen_period = period;  in p2p_ext_listen()
4674 	p2p->ext_listen_interval = interval;  in p2p_ext_listen()
4675 	p2p->ext_listen_interval_sec = interval / 1000;  in p2p_ext_listen()
4676 	p2p->ext_listen_interval_usec = (interval % 1000) * 1000;  in p2p_ext_listen()
4678 	eloop_register_timeout(p2p->ext_listen_interval_sec,  in p2p_ext_listen()
4679 			       p2p->ext_listen_interval_usec,  in p2p_ext_listen()
4680 			       p2p_ext_listen_timeout, p2p, NULL);  in p2p_ext_listen()
4686 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,  in p2p_deauth_notif()  argument
4702 	p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR  in p2p_deauth_notif()
4710 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,  in p2p_disassoc_notif()  argument
4726 	p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR  in p2p_disassoc_notif()
4734 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)  in p2p_set_managed_oper()  argument
4737 		p2p_dbg(p2p, "Managed P2P Device operations enabled");  in p2p_set_managed_oper()
4738 		p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;  in p2p_set_managed_oper()
4740 		p2p_dbg(p2p, "Managed P2P Device operations disabled");  in p2p_set_managed_oper()
4741 		p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;  in p2p_set_managed_oper()
4746 int p2p_config_get_random_social(struct p2p_config *p2p, u8 *op_class,  in p2p_config_get_random_social()  argument
4751 	return p2p_channel_random_social(&p2p->channels, op_class, op_channel,  in p2p_config_get_random_social()
4756 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel,  in p2p_set_listen_channel()  argument
4766 	if (p2p->cfg->channel_forced && forced == 0) {  in p2p_set_listen_channel()
4767 		p2p_dbg(p2p,  in p2p_set_listen_channel()
4772 	p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u",  in p2p_set_listen_channel()
4775 	if (p2p->state == P2P_IDLE) {  in p2p_set_listen_channel()
4776 		p2p->cfg->reg_class = reg_class;  in p2p_set_listen_channel()
4777 		p2p->cfg->channel = channel;  in p2p_set_listen_channel()
4778 		p2p->cfg->channel_forced = forced;  in p2p_set_listen_channel()
4780 		p2p_dbg(p2p, "Defer setting listen channel");  in p2p_set_listen_channel()
4781 		p2p->pending_reg_class = reg_class;  in p2p_set_listen_channel()
4782 		p2p->pending_channel = channel;  in p2p_set_listen_channel()
4783 		p2p->pending_channel_forced = forced;  in p2p_set_listen_channel()
4790 u8 p2p_get_listen_channel(struct p2p_data *p2p)  in p2p_get_listen_channel()  argument
4792 	return p2p->cfg->channel;  in p2p_get_listen_channel()
4796 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)  in p2p_set_ssid_postfix()  argument
4798 	p2p_dbg(p2p, "New SSID postfix: %s", wpa_ssid_txt(postfix, len));  in p2p_set_ssid_postfix()
4800 		p2p->cfg->ssid_postfix_len = 0;  in p2p_set_ssid_postfix()
4803 	if (len > sizeof(p2p->cfg->ssid_postfix))  in p2p_set_ssid_postfix()
4805 	os_memcpy(p2p->cfg->ssid_postfix, postfix, len);  in p2p_set_ssid_postfix()
4806 	p2p->cfg->ssid_postfix_len = len;  in p2p_set_ssid_postfix()
4811 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,  in p2p_set_oper_channel()  argument
4817 	p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u",  in p2p_set_oper_channel()
4819 	p2p->cfg->op_reg_class = op_reg_class;  in p2p_set_oper_channel()
4820 	p2p->cfg->op_channel = op_channel;  in p2p_set_oper_channel()
4821 	p2p->cfg->cfg_op_channel = cfg_op_channel;  in p2p_set_oper_channel()
4826 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,  in p2p_set_pref_chan()  argument
4839 	os_free(p2p->cfg->pref_chan);  in p2p_set_pref_chan()
4840 	p2p->cfg->pref_chan = n;  in p2p_set_pref_chan()
4841 	p2p->cfg->num_pref_chan = num_pref_chan;  in p2p_set_pref_chan()
4847 int p2p_set_no_go_freq(struct p2p_data *p2p,  in p2p_set_no_go_freq()  argument
4853 		os_free(p2p->no_go_freq.range);  in p2p_set_no_go_freq()
4854 		p2p->no_go_freq.range = NULL;  in p2p_set_no_go_freq()
4855 		p2p->no_go_freq.num = 0;  in p2p_set_no_go_freq()
4863 	os_free(p2p->no_go_freq.range);  in p2p_set_no_go_freq()
4864 	p2p->no_go_freq.range = tmp;  in p2p_set_no_go_freq()
4865 	p2p->no_go_freq.num = list->num;  in p2p_set_no_go_freq()
4866 	p2p_dbg(p2p, "Updated no GO chan list");  in p2p_set_no_go_freq()
4872 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,  in p2p_get_interface_addr()  argument
4875 	struct p2p_device *dev = p2p_get_device(p2p, dev_addr);  in p2p_get_interface_addr()
4883 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,  in p2p_get_dev_addr()  argument
4886 	struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);  in p2p_get_dev_addr()
4894 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)  in p2p_set_peer_filter()  argument
4896 	os_memcpy(p2p->peer_filter, addr, ETH_ALEN);  in p2p_set_peer_filter()
4897 	if (is_zero_ether_addr(p2p->peer_filter))  in p2p_set_peer_filter()
4898 		p2p_dbg(p2p, "Disable peer filter");  in p2p_set_peer_filter()
4900 		p2p_dbg(p2p, "Enable peer filter for " MACSTR,  in p2p_set_peer_filter()
4901 			MAC2STR(p2p->peer_filter));  in p2p_set_peer_filter()
4905 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)  in p2p_set_cross_connect()  argument
4907 	p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled");  in p2p_set_cross_connect()
4908 	if (p2p->cross_connect == enabled)  in p2p_set_cross_connect()
4910 	p2p->cross_connect = enabled;  in p2p_set_cross_connect()
4915 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)  in p2p_get_oper_freq()  argument
4917 	struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);  in p2p_get_oper_freq()
4926 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)  in p2p_set_intra_bss_dist()  argument
4928 	p2p_dbg(p2p, "Intra BSS distribution %s",  in p2p_set_intra_bss_dist()
4930 	p2p->cfg->p2p_intra_bss = enabled;  in p2p_set_intra_bss_dist()
4934 void p2p_update_channel_list(struct p2p_data *p2p,  in p2p_update_channel_list()  argument
4938 	p2p_dbg(p2p, "Update channel list");  in p2p_update_channel_list()
4939 	os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));  in p2p_update_channel_list()
4940 	p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);  in p2p_update_channel_list()
4941 	os_memcpy(&p2p->cfg->cli_channels, cli_chan,  in p2p_update_channel_list()
4943 	p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);  in p2p_update_channel_list()
4947 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,  in p2p_send_action()  argument
4953 	res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,  in p2p_send_action()
4955 	if (res == 0 && scheduled && p2p->in_listen && freq > 0 &&  in p2p_send_action()
4956 	    p2p->drv_in_listen > 0 &&  in p2p_send_action()
4957 	    (unsigned int) p2p->drv_in_listen != freq) {  in p2p_send_action()
4958 		p2p_dbg(p2p,  in p2p_send_action()
4960 			p2p->drv_in_listen, freq);  in p2p_send_action()
4961 		p2p_stop_listen_for_freq(p2p, freq);  in p2p_send_action()
4967 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,  in p2p_set_best_channels()  argument
4970 	p2p_dbg(p2p, "Best channel: 2.4 GHz: %d,  5 GHz: %d,  overall: %d",  in p2p_set_best_channels()
4972 	p2p->best_freq_24 = freq_24;  in p2p_set_best_channels()
4973 	p2p->best_freq_5 = freq_5;  in p2p_set_best_channels()
4974 	p2p->best_freq_overall = freq_overall;  in p2p_set_best_channels()
4978 void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq)  in p2p_set_own_freq_preference()  argument
4980 	p2p_dbg(p2p, "Own frequency preference: %d MHz", freq);  in p2p_set_own_freq_preference()
4981 	p2p->own_freq_preference = freq;  in p2p_set_own_freq_preference()
4985 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)  in p2p_get_go_neg_peer()  argument
4987 	if (p2p == NULL || p2p->go_neg_peer == NULL)  in p2p_get_go_neg_peer()
4989 	return p2p->go_neg_peer->info.p2p_device_addr;  in p2p_get_go_neg_peer()
4994 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)  in p2p_get_peer_found()  argument
4999 		dev = p2p_get_device(p2p, addr);  in p2p_get_peer_found()
5013 				if (!dev || &dev->list == &p2p->devices)  in p2p_get_peer_found()
5018 		dev = dl_list_first(&p2p->devices, struct p2p_device, list);  in p2p_get_peer_found()
5025 			if (!dev || &dev->list == &p2p->devices)  in p2p_get_peer_found()
5034 int p2p_in_progress(struct p2p_data *p2p)  in p2p_in_progress()  argument
5036 	if (p2p == NULL)  in p2p_in_progress()
5038 	if (p2p->state == P2P_SEARCH)  in p2p_in_progress()
5040 	return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;  in p2p_in_progress()
5044 void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout,  in p2p_set_config_timeout()  argument
5047 	if (p2p) {  in p2p_set_config_timeout()
5048 		p2p->go_timeout = go_timeout;  in p2p_set_config_timeout()
5049 		p2p->client_timeout = client_timeout;  in p2p_set_config_timeout()
5056 static void p2p_update_wfd_ie_groups(struct p2p_data *p2p)  in p2p_update_wfd_ie_groups()  argument
5061 	for (g = 0; g < p2p->num_groups; g++) {  in p2p_update_wfd_ie_groups()
5062 		group = p2p->groups[g];  in p2p_update_wfd_ie_groups()
5068 int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_beacon()  argument
5070 	wpabuf_free(p2p->wfd_ie_beacon);  in p2p_set_wfd_ie_beacon()
5071 	p2p->wfd_ie_beacon = ie;  in p2p_set_wfd_ie_beacon()
5072 	p2p_update_wfd_ie_groups(p2p);  in p2p_set_wfd_ie_beacon()
5077 int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_probe_req()  argument
5079 	wpabuf_free(p2p->wfd_ie_probe_req);  in p2p_set_wfd_ie_probe_req()
5080 	p2p->wfd_ie_probe_req = ie;  in p2p_set_wfd_ie_probe_req()
5085 int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_probe_resp()  argument
5087 	wpabuf_free(p2p->wfd_ie_probe_resp);  in p2p_set_wfd_ie_probe_resp()
5088 	p2p->wfd_ie_probe_resp = ie;  in p2p_set_wfd_ie_probe_resp()
5089 	p2p_update_wfd_ie_groups(p2p);  in p2p_set_wfd_ie_probe_resp()
5094 int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_assoc_req()  argument
5096 	wpabuf_free(p2p->wfd_ie_assoc_req);  in p2p_set_wfd_ie_assoc_req()
5097 	p2p->wfd_ie_assoc_req = ie;  in p2p_set_wfd_ie_assoc_req()
5102 int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_invitation()  argument
5104 	wpabuf_free(p2p->wfd_ie_invitation);  in p2p_set_wfd_ie_invitation()
5105 	p2p->wfd_ie_invitation = ie;  in p2p_set_wfd_ie_invitation()
5110 int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_prov_disc_req()  argument
5112 	wpabuf_free(p2p->wfd_ie_prov_disc_req);  in p2p_set_wfd_ie_prov_disc_req()
5113 	p2p->wfd_ie_prov_disc_req = ie;  in p2p_set_wfd_ie_prov_disc_req()
5118 int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_prov_disc_resp()  argument
5120 	wpabuf_free(p2p->wfd_ie_prov_disc_resp);  in p2p_set_wfd_ie_prov_disc_resp()
5121 	p2p->wfd_ie_prov_disc_resp = ie;  in p2p_set_wfd_ie_prov_disc_resp()
5126 int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie)  in p2p_set_wfd_ie_go_neg()  argument
5128 	wpabuf_free(p2p->wfd_ie_go_neg);  in p2p_set_wfd_ie_go_neg()
5129 	p2p->wfd_ie_go_neg = ie;  in p2p_set_wfd_ie_go_neg()
5134 int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)  in p2p_set_wfd_dev_info()  argument
5136 	wpabuf_free(p2p->wfd_dev_info);  in p2p_set_wfd_dev_info()
5138 		p2p->wfd_dev_info = wpabuf_dup(elem);  in p2p_set_wfd_dev_info()
5139 		if (p2p->wfd_dev_info == NULL)  in p2p_set_wfd_dev_info()
5142 		p2p->wfd_dev_info = NULL;  in p2p_set_wfd_dev_info()
5148 int p2p_set_wfd_r2_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)  in p2p_set_wfd_r2_dev_info()  argument
5150 	wpabuf_free(p2p->wfd_r2_dev_info);  in p2p_set_wfd_r2_dev_info()
5152 		p2p->wfd_r2_dev_info = wpabuf_dup(elem);  in p2p_set_wfd_r2_dev_info()
5153 		if (p2p->wfd_r2_dev_info == NULL)  in p2p_set_wfd_r2_dev_info()
5156 		p2p->wfd_r2_dev_info = NULL;  in p2p_set_wfd_r2_dev_info()
5162 int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem)  in p2p_set_wfd_assoc_bssid()  argument
5164 	wpabuf_free(p2p->wfd_assoc_bssid);  in p2p_set_wfd_assoc_bssid()
5166 		p2p->wfd_assoc_bssid = wpabuf_dup(elem);  in p2p_set_wfd_assoc_bssid()
5167 		if (p2p->wfd_assoc_bssid == NULL)  in p2p_set_wfd_assoc_bssid()
5170 		p2p->wfd_assoc_bssid = NULL;  in p2p_set_wfd_assoc_bssid()
5176 int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p,  in p2p_set_wfd_coupled_sink_info()  argument
5179 	wpabuf_free(p2p->wfd_coupled_sink_info);  in p2p_set_wfd_coupled_sink_info()
5181 		p2p->wfd_coupled_sink_info = wpabuf_dup(elem);  in p2p_set_wfd_coupled_sink_info()
5182 		if (p2p->wfd_coupled_sink_info == NULL)  in p2p_set_wfd_coupled_sink_info()
5185 		p2p->wfd_coupled_sink_info = NULL;  in p2p_set_wfd_coupled_sink_info()
5193 int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int,  in p2p_set_disc_int()  argument
5199 	p2p->min_disc_int = min_disc_int;  in p2p_set_disc_int()
5200 	p2p->max_disc_int = max_disc_int;  in p2p_set_disc_int()
5201 	p2p->max_disc_tu = max_disc_tu;  in p2p_set_disc_int()
5202 	p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d",  in p2p_set_disc_int()
5209 void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...)  in p2p_dbg()  argument
5214 	if (!p2p->cfg->debug_print)  in p2p_dbg()
5221 	p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf);  in p2p_dbg()
5225 void p2p_info(struct p2p_data *p2p, const char *fmt, ...)  in p2p_info()  argument
5230 	if (!p2p->cfg->debug_print)  in p2p_info()
5237 	p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf);  in p2p_info()
5241 void p2p_err(struct p2p_data *p2p, const char *fmt, ...)  in p2p_err()  argument
5246 	if (!p2p->cfg->debug_print)  in p2p_err()
5253 	p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf);  in p2p_err()
5257 void p2p_loop_on_known_peers(struct p2p_data *p2p,  in p2p_loop_on_known_peers()  argument
5264 	dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {  in p2p_loop_on_known_peers()
5272 static struct wpabuf * p2p_build_nfc_handover(struct p2p_data *p2p,  in p2p_build_nfc_handover()  argument
5285 	op_class = p2p->cfg->reg_class;  in p2p_build_nfc_handover()
5286 	channel = p2p->cfg->channel;  in p2p_build_nfc_handover()
5288 	p2p_buf_add_capability(buf, p2p->dev_capab &  in p2p_build_nfc_handover()
5290 	p2p_buf_add_device_info(buf, p2p, NULL);  in p2p_build_nfc_handover()
5292 	if (p2p->num_groups > 0) {  in p2p_build_nfc_handover()
5293 		int freq = p2p_group_get_freq(p2p->groups[0]);  in p2p_build_nfc_handover()
5296 			p2p_dbg(p2p,  in p2p_build_nfc_handover()
5305 			p2p_dbg(p2p,  in p2p_build_nfc_handover()
5313 	p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class,  in p2p_build_nfc_handover()
5316 	if (p2p->num_groups > 0) {  in p2p_build_nfc_handover()
5318 		p2p_buf_add_group_info(p2p->groups[0], buf, 5);  in p2p_build_nfc_handover()
5319 		p2p_group_buf_add_id(p2p->groups[0], buf);  in p2p_build_nfc_handover()
5334 struct wpabuf * p2p_build_nfc_handover_req(struct p2p_data *p2p,  in p2p_build_nfc_handover_req()  argument
5339 	return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,  in p2p_build_nfc_handover_req()
5344 struct wpabuf * p2p_build_nfc_handover_sel(struct p2p_data *p2p,  in p2p_build_nfc_handover_sel()  argument
5349 	return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,  in p2p_build_nfc_handover_sel()
5354 int p2p_process_nfc_connection_handover(struct p2p_data *p2p,  in p2p_process_nfc_connection_handover()  argument
5367 		p2p_dbg(p2p, "Failed to parse WSC/P2P attributes from NFC");  in p2p_process_nfc_connection_handover()
5377 		p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");  in p2p_process_nfc_connection_handover()
5388 	dev = p2p_create_device(p2p, p2p_dev_addr);  in p2p_process_nfc_connection_handover()
5398 	p2p_copy_wps_info(p2p, dev, 0, &msg);  in p2p_process_nfc_connection_handover()
5401 		p2p_dbg(p2p, "OOB GO Negotiation Channel attribute not included");  in p2p_process_nfc_connection_handover()
5413 		p2p_dbg(p2p, "Unknown peer OOB GO Neg channel");  in p2p_process_nfc_connection_handover()
5420 		p2p_dbg(p2p, "Peer OOB GO operating channel: %u MHz", freq);  in p2p_process_nfc_connection_handover()
5423 		p2p_dbg(p2p, "Peer (client) OOB GO operating channel: %u MHz",  in p2p_process_nfc_connection_handover()
5427 		p2p_dbg(p2p, "Peer OOB GO Neg channel: %u MHz", freq);  in p2p_process_nfc_connection_handover()
5431 		freq = p2p_channel_to_freq(p2p->cfg->reg_class,  in p2p_process_nfc_connection_handover()
5432 					   p2p->cfg->channel);  in p2p_process_nfc_connection_handover()
5434 			p2p_dbg(p2p, "Own listen channel not known");  in p2p_process_nfc_connection_handover()
5438 		p2p_dbg(p2p, "Use own Listen channel as OOB GO Neg channel: %u MHz", freq);  in p2p_process_nfc_connection_handover()
5450 		p2p_dbg(p2p, "Do not report rejected device");  in p2p_process_nfc_connection_handover()
5456 		p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info,  in p2p_process_nfc_connection_handover()
5462 	if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0)  in p2p_process_nfc_connection_handover()
5469 	} else if (p2p->num_groups > 0)  in p2p_process_nfc_connection_handover()
5480 void p2p_set_authorized_oob_dev_pw_id(struct p2p_data *p2p, u16 dev_pw_id,  in p2p_set_authorized_oob_dev_pw_id()  argument
5485 	p2p->authorized_oob_dev_pw_id = dev_pw_id;  in p2p_set_authorized_oob_dev_pw_id()
5487 		p2p_dbg(p2p, "NFC OOB Password unauthorized for static handover");  in p2p_set_authorized_oob_dev_pw_id()
5491 	p2p_dbg(p2p, "NFC OOB Password (id=%u) authorized for static handover",  in p2p_set_authorized_oob_dev_pw_id()
5494 	p2p->go_intent = go_intent;  in p2p_set_authorized_oob_dev_pw_id()
5495 	os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);  in p2p_set_authorized_oob_dev_pw_id()
5501 int p2p_set_passphrase_len(struct p2p_data *p2p, unsigned int len)  in p2p_set_passphrase_len()  argument
5505 	p2p->cfg->passphrase_len = len;  in p2p_set_passphrase_len()
5510 void p2p_set_vendor_elems(struct p2p_data *p2p, struct wpabuf **vendor_elem)  in p2p_set_vendor_elems()  argument
5512 	p2p->vendor_elem = vendor_elem;  in p2p_set_vendor_elems()
5518 	struct p2p_data *p2p = eloop_ctx;  in p2p_go_neg_wait_timeout()  local
5520 	p2p_dbg(p2p,  in p2p_go_neg_wait_timeout()
5522 	p2p_go_neg_failed(p2p, -1);  in p2p_go_neg_wait_timeout()
5526 void p2p_set_own_pref_freq_list(struct p2p_data *p2p,  in p2p_set_own_pref_freq_list()  argument
5534 	p2p->num_pref_freq = size;  in p2p_set_own_pref_freq_list()
5536 		p2p->pref_freq_list[i] = pref_freq_list[i];  in p2p_set_own_pref_freq_list()
5537 		p2p_dbg(p2p, "Own preferred frequency list[%u]=%u MHz",  in p2p_set_own_pref_freq_list()
5538 			i, p2p->pref_freq_list[i]);  in p2p_set_own_pref_freq_list()
5543 void p2p_set_override_pref_op_chan(struct p2p_data *p2p, u8 op_class,  in p2p_set_override_pref_op_chan()  argument
5546 	p2p->override_pref_op_class = op_class;  in p2p_set_override_pref_op_chan()
5547 	p2p->override_pref_channel = chan;  in p2p_set_override_pref_op_chan()
5551 struct wpabuf * p2p_build_probe_resp_template(struct p2p_data *p2p,  in p2p_build_probe_resp_template()  argument
5558 	ies = p2p_build_probe_resp_ies(p2p, NULL, 0);  in p2p_build_probe_resp_template()
5571 	ret = p2p_build_probe_resp_buf(p2p, buf, ies, addr, freq);  in p2p_build_probe_resp_template()