Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Wi-Fi Direct - P2P module |
| 3 | * Copyright (c) 2009-2010, Atheros Communications |
| 4 | * |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 5 | * This software may be distributed under the terms of the BSD license. |
| 6 | * See README for more details. |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include "includes.h" |
| 10 | |
Jimmy Chen | 1b737ee | 2020-11-20 01:24:12 +0800 | [diff] [blame] | 11 | #include <log/log.h> |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 12 | #include "common.h" |
| 13 | #include "eloop.h" |
Dmitry Shmidt | 9c17526 | 2016-03-03 10:20:07 -0800 | [diff] [blame] | 14 | #include "common/defs.h" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 15 | #include "common/ieee802_11_defs.h" |
| 16 | #include "common/ieee802_11_common.h" |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 17 | #include "common/wpa_ctrl.h" |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 18 | #include "crypto/sha256.h" |
| 19 | #include "crypto/crypto.h" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 20 | #include "wps/wps_i.h" |
| 21 | #include "p2p_i.h" |
| 22 | #include "p2p.h" |
| 23 | |
| 24 | |
| 25 | static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx); |
| 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, |
| 28 | const u8 *sa, const u8 *data, size_t len, |
| 29 | int rx_freq); |
| 30 | static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, |
| 31 | const u8 *sa, const u8 *data, |
| 32 | size_t len); |
| 33 | static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx); |
| 34 | static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx); |
| 35 | |
| 36 | |
| 37 | /* |
| 38 | * p2p_scan recovery timeout |
| 39 | * |
| 40 | * Many drivers are using 30 second timeout on scan results. Allow a bit larger |
| 41 | * timeout for this to avoid hitting P2P timeout unnecessarily. |
| 42 | */ |
| 43 | #define P2P_SCAN_TIMEOUT 35 |
| 44 | |
| 45 | /** |
| 46 | * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer |
| 47 | * entries will be removed |
| 48 | */ |
Dmitry Shmidt | 2093d06 | 2014-01-17 10:58:50 -0800 | [diff] [blame] | 49 | #ifndef P2P_PEER_EXPIRATION_AGE |
| 50 | #define P2P_PEER_EXPIRATION_AGE 60 |
Dmitry Shmidt | 1846323 | 2014-01-24 12:29:41 -0800 | [diff] [blame] | 51 | #endif /* P2P_PEER_EXPIRATION_AGE */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 52 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 53 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 54 | void p2p_expire_peers(struct p2p_data *p2p) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 55 | { |
| 56 | struct p2p_device *dev, *n; |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 57 | struct os_reltime now; |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 58 | size_t i; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 59 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 60 | os_get_reltime(&now); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 61 | dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) { |
| 62 | if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec) |
| 63 | continue; |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 64 | |
Dmitry Shmidt | 9e3f8ee | 2014-01-17 10:52:01 -0800 | [diff] [blame] | 65 | if (dev == p2p->go_neg_peer) { |
| 66 | /* |
| 67 | * GO Negotiation is in progress with the peer, so |
| 68 | * don't expire the peer entry until GO Negotiation |
| 69 | * fails or times out. |
| 70 | */ |
| 71 | continue; |
| 72 | } |
| 73 | |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 74 | if (p2p->cfg->go_connected && |
| 75 | p2p->cfg->go_connected(p2p->cfg->cb_ctx, |
| 76 | dev->info.p2p_device_addr)) { |
| 77 | /* |
| 78 | * We are connected as a client to a group in which the |
| 79 | * peer is the GO, so do not expire the peer entry. |
| 80 | */ |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 81 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 82 | continue; |
| 83 | } |
| 84 | |
| 85 | for (i = 0; i < p2p->num_groups; i++) { |
| 86 | if (p2p_group_is_client_connected( |
| 87 | p2p->groups[i], dev->info.p2p_device_addr)) |
| 88 | break; |
| 89 | } |
| 90 | if (i < p2p->num_groups) { |
| 91 | /* |
| 92 | * The peer is connected as a client in a group where |
| 93 | * we are the GO, so do not expire the peer entry. |
| 94 | */ |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 95 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 96 | continue; |
| 97 | } |
| 98 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 99 | p2p_dbg(p2p, "Expiring old peer entry " MACSTR, |
| 100 | MAC2STR(dev->info.p2p_device_addr)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 101 | dl_list_del(&dev->list); |
| 102 | p2p_device_free(p2p, dev); |
| 103 | } |
| 104 | } |
| 105 | |
| 106 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 107 | static const char * p2p_state_txt(int state) |
| 108 | { |
| 109 | switch (state) { |
| 110 | case P2P_IDLE: |
| 111 | return "IDLE"; |
| 112 | case P2P_SEARCH: |
| 113 | return "SEARCH"; |
| 114 | case P2P_CONNECT: |
| 115 | return "CONNECT"; |
| 116 | case P2P_CONNECT_LISTEN: |
| 117 | return "CONNECT_LISTEN"; |
| 118 | case P2P_GO_NEG: |
| 119 | return "GO_NEG"; |
| 120 | case P2P_LISTEN_ONLY: |
| 121 | return "LISTEN_ONLY"; |
| 122 | case P2P_WAIT_PEER_CONNECT: |
| 123 | return "WAIT_PEER_CONNECT"; |
| 124 | case P2P_WAIT_PEER_IDLE: |
| 125 | return "WAIT_PEER_IDLE"; |
| 126 | case P2P_SD_DURING_FIND: |
| 127 | return "SD_DURING_FIND"; |
| 128 | case P2P_PROVISIONING: |
| 129 | return "PROVISIONING"; |
| 130 | case P2P_PD_DURING_FIND: |
| 131 | return "PD_DURING_FIND"; |
| 132 | case P2P_INVITE: |
| 133 | return "INVITE"; |
| 134 | case P2P_INVITE_LISTEN: |
| 135 | return "INVITE_LISTEN"; |
| 136 | default: |
| 137 | return "?"; |
| 138 | } |
| 139 | } |
| 140 | |
| 141 | |
Dmitry Shmidt | b7b4d0e | 2013-08-26 12:09:05 -0700 | [diff] [blame] | 142 | const char * p2p_get_state_txt(struct p2p_data *p2p) |
| 143 | { |
| 144 | return p2p_state_txt(p2p->state); |
| 145 | } |
| 146 | |
| 147 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 148 | struct p2ps_advertisement * p2p_get_p2ps_adv_list(struct p2p_data *p2p) |
| 149 | { |
| 150 | return p2p ? p2p->p2ps_adv_list : NULL; |
| 151 | } |
| 152 | |
| 153 | |
| 154 | void p2p_set_intended_addr(struct p2p_data *p2p, const u8 *intended_addr) |
| 155 | { |
| 156 | if (p2p && intended_addr) |
| 157 | os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN); |
| 158 | } |
| 159 | |
| 160 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 161 | u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr) |
| 162 | { |
| 163 | struct p2p_device *dev = NULL; |
| 164 | |
| 165 | if (!addr || !p2p) |
| 166 | return 0; |
| 167 | |
| 168 | dev = p2p_get_device(p2p, addr); |
| 169 | if (dev) |
| 170 | return dev->wps_prov_info; |
| 171 | else |
| 172 | return 0; |
| 173 | } |
| 174 | |
| 175 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 176 | void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr) |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 177 | { |
| 178 | struct p2p_device *dev = NULL; |
| 179 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 180 | if (!addr || !p2p) |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 181 | return; |
| 182 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 183 | dev = p2p_get_device(p2p, addr); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 184 | if (dev) |
| 185 | dev->wps_prov_info = 0; |
| 186 | } |
| 187 | |
| 188 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 189 | void p2p_set_state(struct p2p_data *p2p, int new_state) |
| 190 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 191 | p2p_dbg(p2p, "State %s -> %s", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 192 | p2p_state_txt(p2p->state), p2p_state_txt(new_state)); |
| 193 | p2p->state = new_state; |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 194 | |
| 195 | if (new_state == P2P_IDLE && p2p->pending_channel) { |
| 196 | p2p_dbg(p2p, "Apply change in listen channel"); |
| 197 | p2p->cfg->reg_class = p2p->pending_reg_class; |
| 198 | p2p->cfg->channel = p2p->pending_channel; |
| 199 | p2p->pending_reg_class = 0; |
| 200 | p2p->pending_channel = 0; |
| 201 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 202 | } |
| 203 | |
| 204 | |
| 205 | void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec) |
| 206 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 207 | p2p_dbg(p2p, "Set timeout (state=%s): %u.%06u sec", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 208 | p2p_state_txt(p2p->state), sec, usec); |
| 209 | eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); |
| 210 | eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL); |
| 211 | } |
| 212 | |
| 213 | |
| 214 | void p2p_clear_timeout(struct p2p_data *p2p) |
| 215 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 216 | p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 217 | eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); |
| 218 | } |
| 219 | |
| 220 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 221 | void p2p_go_neg_failed(struct p2p_data *p2p, int status) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 222 | { |
| 223 | struct p2p_go_neg_results res; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 224 | struct p2p_device *peer = p2p->go_neg_peer; |
| 225 | |
| 226 | if (!peer) |
| 227 | return; |
| 228 | |
| 229 | eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); |
| 230 | if (p2p->state != P2P_SEARCH) { |
| 231 | /* |
| 232 | * Clear timeouts related to GO Negotiation if no new p2p_find |
| 233 | * has been started. |
| 234 | */ |
| 235 | p2p_clear_timeout(p2p); |
| 236 | p2p_set_state(p2p, P2P_IDLE); |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 237 | } |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 238 | |
| 239 | peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; |
| 240 | peer->wps_method = WPS_NOT_READY; |
| 241 | peer->oob_pw_id = 0; |
| 242 | wpabuf_free(peer->go_neg_conf); |
| 243 | peer->go_neg_conf = NULL; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 244 | p2p->go_neg_peer = NULL; |
| 245 | |
| 246 | os_memset(&res, 0, sizeof(res)); |
| 247 | res.status = status; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 248 | os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN); |
| 249 | os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 250 | p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); |
| 251 | } |
| 252 | |
| 253 | |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 254 | static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 255 | { |
| 256 | unsigned int r, tu; |
| 257 | int freq; |
| 258 | struct wpabuf *ies; |
| 259 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 260 | p2p_dbg(p2p, "Starting short listen state (state=%s)", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 261 | p2p_state_txt(p2p->state)); |
| 262 | |
Dmitry Shmidt | 3c57b3f | 2014-05-22 15:13:07 -0700 | [diff] [blame] | 263 | if (p2p->pending_listen_freq) { |
| 264 | /* We have a pending p2p_listen request */ |
| 265 | p2p_dbg(p2p, "p2p_listen command pending already"); |
| 266 | return; |
| 267 | } |
| 268 | |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 269 | freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 270 | if (freq < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 271 | p2p_dbg(p2p, "Unknown regulatory class/channel"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 272 | return; |
| 273 | } |
| 274 | |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 275 | if (os_get_random((u8 *) &r, sizeof(r)) < 0) |
| 276 | r = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 277 | tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) + |
| 278 | p2p->min_disc_int) * 100; |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 279 | if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu) |
| 280 | tu = p2p->max_disc_tu; |
| 281 | if (!dev_disc && tu < 100) |
| 282 | tu = 100; /* Need to wait in non-device discovery use cases */ |
| 283 | if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen) |
| 284 | tu = p2p->cfg->max_listen * 1000 / 1024; |
| 285 | |
| 286 | if (tu == 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 287 | p2p_dbg(p2p, "Skip listen state since duration was 0 TU"); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 288 | p2p_set_timeout(p2p, 0, 0); |
| 289 | return; |
| 290 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 291 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 292 | ies = p2p_build_probe_resp_ies(p2p, NULL, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 293 | if (ies == NULL) |
| 294 | return; |
| 295 | |
Dmitry Shmidt | 3c57b3f | 2014-05-22 15:13:07 -0700 | [diff] [blame] | 296 | p2p->pending_listen_freq = freq; |
| 297 | p2p->pending_listen_sec = 0; |
| 298 | p2p->pending_listen_usec = 1024 * tu; |
| 299 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 300 | if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000, |
| 301 | ies) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 302 | p2p_dbg(p2p, "Failed to start listen mode"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 303 | p2p->pending_listen_freq = 0; |
| 304 | } |
| 305 | wpabuf_free(ies); |
| 306 | } |
| 307 | |
| 308 | |
| 309 | int p2p_listen(struct p2p_data *p2p, unsigned int timeout) |
| 310 | { |
| 311 | int freq; |
| 312 | struct wpabuf *ies; |
| 313 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 314 | p2p_dbg(p2p, "Going to listen(only) state"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 315 | |
Dmitry Shmidt | 3c57b3f | 2014-05-22 15:13:07 -0700 | [diff] [blame] | 316 | if (p2p->pending_listen_freq) { |
| 317 | /* We have a pending p2p_listen request */ |
| 318 | p2p_dbg(p2p, "p2p_listen command pending already"); |
| 319 | return -1; |
| 320 | } |
| 321 | |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 322 | freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 323 | if (freq < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 324 | p2p_dbg(p2p, "Unknown regulatory class/channel"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 325 | return -1; |
| 326 | } |
| 327 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 328 | p2p->pending_listen_sec = timeout / 1000; |
| 329 | p2p->pending_listen_usec = (timeout % 1000) * 1000; |
| 330 | |
| 331 | if (p2p->p2p_scan_running) { |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 332 | if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 333 | p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen"); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 334 | return 0; |
| 335 | } |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 336 | p2p_dbg(p2p, "p2p_scan running - delay start of listen state"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 337 | p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN; |
| 338 | return 0; |
| 339 | } |
| 340 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 341 | ies = p2p_build_probe_resp_ies(p2p, NULL, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 342 | if (ies == NULL) |
| 343 | return -1; |
| 344 | |
Dmitry Shmidt | 3c57b3f | 2014-05-22 15:13:07 -0700 | [diff] [blame] | 345 | p2p->pending_listen_freq = freq; |
| 346 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 347 | if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 348 | p2p_dbg(p2p, "Failed to start listen mode"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 349 | p2p->pending_listen_freq = 0; |
| 350 | wpabuf_free(ies); |
| 351 | return -1; |
| 352 | } |
| 353 | wpabuf_free(ies); |
| 354 | |
| 355 | p2p_set_state(p2p, P2P_LISTEN_ONLY); |
| 356 | |
| 357 | return 0; |
| 358 | } |
| 359 | |
| 360 | |
| 361 | static void p2p_device_clear_reported(struct p2p_data *p2p) |
| 362 | { |
| 363 | struct p2p_device *dev; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 364 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 365 | dev->flags &= ~P2P_DEV_REPORTED; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 366 | dev->sd_reqs = 0; |
| 367 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | |
| 371 | /** |
| 372 | * p2p_get_device - Fetch a peer entry |
| 373 | * @p2p: P2P module context from p2p_init() |
| 374 | * @addr: P2P Device Address of the peer |
| 375 | * Returns: Pointer to the device entry or %NULL if not found |
| 376 | */ |
| 377 | struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr) |
| 378 | { |
| 379 | struct p2p_device *dev; |
| 380 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 381 | if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0) |
| 382 | return dev; |
| 383 | } |
| 384 | return NULL; |
| 385 | } |
| 386 | |
| 387 | |
| 388 | /** |
| 389 | * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address |
| 390 | * @p2p: P2P module context from p2p_init() |
| 391 | * @addr: P2P Interface Address of the peer |
| 392 | * Returns: Pointer to the device entry or %NULL if not found |
| 393 | */ |
| 394 | struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p, |
| 395 | const u8 *addr) |
| 396 | { |
| 397 | struct p2p_device *dev; |
| 398 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 399 | if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0) |
| 400 | return dev; |
| 401 | } |
| 402 | return NULL; |
| 403 | } |
| 404 | |
| 405 | |
| 406 | /** |
| 407 | * p2p_create_device - Create a peer entry |
| 408 | * @p2p: P2P module context from p2p_init() |
| 409 | * @addr: P2P Device Address of the peer |
| 410 | * Returns: Pointer to the device entry or %NULL on failure |
| 411 | * |
| 412 | * If there is already an entry for the peer, it will be returned instead of |
| 413 | * creating a new one. |
| 414 | */ |
| 415 | static struct p2p_device * p2p_create_device(struct p2p_data *p2p, |
| 416 | const u8 *addr) |
| 417 | { |
| 418 | struct p2p_device *dev, *oldest = NULL; |
| 419 | size_t count = 0; |
| 420 | |
| 421 | dev = p2p_get_device(p2p, addr); |
| 422 | if (dev) |
| 423 | return dev; |
| 424 | |
| 425 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 426 | count++; |
| 427 | if (oldest == NULL || |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 428 | os_reltime_before(&dev->last_seen, &oldest->last_seen)) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 429 | oldest = dev; |
| 430 | } |
| 431 | if (count + 1 > p2p->cfg->max_peers && oldest) { |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 432 | p2p_dbg(p2p, |
| 433 | "Remove oldest peer entry to make room for a new peer " |
| 434 | MACSTR, MAC2STR(oldest->info.p2p_device_addr)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 435 | dl_list_del(&oldest->list); |
| 436 | p2p_device_free(p2p, oldest); |
| 437 | } |
| 438 | |
| 439 | dev = os_zalloc(sizeof(*dev)); |
| 440 | if (dev == NULL) |
| 441 | return NULL; |
| 442 | dl_list_add(&p2p->devices, &dev->list); |
| 443 | os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN); |
| 444 | |
| 445 | return dev; |
| 446 | } |
| 447 | |
| 448 | |
| 449 | static void p2p_copy_client_info(struct p2p_device *dev, |
| 450 | struct p2p_client_info *cli) |
| 451 | { |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 452 | p2p_copy_filter_devname(dev->info.device_name, |
| 453 | sizeof(dev->info.device_name), |
| 454 | cli->dev_name, cli->dev_name_len); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 455 | dev->info.dev_capab = cli->dev_capab; |
| 456 | dev->info.config_methods = cli->config_methods; |
| 457 | os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8); |
| 458 | dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types; |
Jimmy Chen | 1b737ee | 2020-11-20 01:24:12 +0800 | [diff] [blame] | 459 | if (dev->info.wps_sec_dev_type_list_len > WPS_SEC_DEV_TYPE_MAX_LEN) { |
| 460 | android_errorWriteLog(0x534e4554, "172937525"); |
Jimmy Chen | e12b697 | 2020-11-09 11:43:12 +0200 | [diff] [blame] | 461 | dev->info.wps_sec_dev_type_list_len = WPS_SEC_DEV_TYPE_MAX_LEN; |
Jimmy Chen | 1b737ee | 2020-11-20 01:24:12 +0800 | [diff] [blame] | 462 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 463 | os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types, |
| 464 | dev->info.wps_sec_dev_type_list_len); |
| 465 | } |
| 466 | |
| 467 | |
| 468 | static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr, |
| 469 | const u8 *go_interface_addr, int freq, |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 470 | const u8 *gi, size_t gi_len, |
| 471 | struct os_reltime *rx_time) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 472 | { |
| 473 | struct p2p_group_info info; |
| 474 | size_t c; |
| 475 | struct p2p_device *dev; |
| 476 | |
| 477 | if (gi == NULL) |
| 478 | return 0; |
| 479 | |
| 480 | if (p2p_group_info_parse(gi, gi_len, &info) < 0) |
| 481 | return -1; |
| 482 | |
| 483 | /* |
| 484 | * Clear old data for this group; if the devices are still in the |
| 485 | * group, the information will be restored in the loop following this. |
| 486 | */ |
| 487 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 488 | if (os_memcmp(dev->member_in_go_iface, go_interface_addr, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 489 | ETH_ALEN) == 0) { |
| 490 | os_memset(dev->member_in_go_iface, 0, ETH_ALEN); |
| 491 | os_memset(dev->member_in_go_dev, 0, ETH_ALEN); |
| 492 | } |
| 493 | } |
| 494 | |
| 495 | for (c = 0; c < info.num_clients; c++) { |
| 496 | struct p2p_client_info *cli = &info.client[c]; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 497 | if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr, |
| 498 | ETH_ALEN) == 0) |
| 499 | continue; /* ignore our own entry */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 500 | dev = p2p_get_device(p2p, cli->p2p_device_addr); |
| 501 | if (dev) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 502 | if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 503 | P2P_DEV_PROBE_REQ_ONLY)) { |
| 504 | /* |
| 505 | * Update information since we have not |
| 506 | * received this directly from the client. |
| 507 | */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 508 | p2p_copy_client_info(dev, cli); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 509 | } else { |
| 510 | /* |
| 511 | * Need to update P2P Client Discoverability |
| 512 | * flag since it is valid only in P2P Group |
| 513 | * Info attribute. |
| 514 | */ |
| 515 | dev->info.dev_capab &= |
| 516 | ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 517 | dev->info.dev_capab |= |
| 518 | cli->dev_capab & |
| 519 | P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 520 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 521 | if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { |
| 522 | dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; |
| 523 | } |
| 524 | } else { |
| 525 | dev = p2p_create_device(p2p, cli->p2p_device_addr); |
| 526 | if (dev == NULL) |
| 527 | continue; |
| 528 | dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY; |
| 529 | p2p_copy_client_info(dev, cli); |
| 530 | dev->oper_freq = freq; |
| 531 | p2p->cfg->dev_found(p2p->cfg->cb_ctx, |
| 532 | dev->info.p2p_device_addr, |
| 533 | &dev->info, 1); |
| 534 | dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; |
| 535 | } |
| 536 | |
| 537 | os_memcpy(dev->interface_addr, cli->p2p_interface_addr, |
| 538 | ETH_ALEN); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 539 | os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 540 | os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN); |
| 541 | os_memcpy(dev->member_in_go_iface, go_interface_addr, |
| 542 | ETH_ALEN); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 543 | dev->flags |= P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 544 | } |
| 545 | |
| 546 | return 0; |
| 547 | } |
| 548 | |
| 549 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 550 | static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev, |
| 551 | int probe_req, const struct p2p_message *msg) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 552 | { |
| 553 | os_memcpy(dev->info.device_name, msg->device_name, |
| 554 | sizeof(dev->info.device_name)); |
| 555 | |
| 556 | if (msg->manufacturer && |
| 557 | msg->manufacturer_len < sizeof(dev->info.manufacturer)) { |
| 558 | os_memset(dev->info.manufacturer, 0, |
| 559 | sizeof(dev->info.manufacturer)); |
| 560 | os_memcpy(dev->info.manufacturer, msg->manufacturer, |
| 561 | msg->manufacturer_len); |
| 562 | } |
| 563 | |
| 564 | if (msg->model_name && |
| 565 | msg->model_name_len < sizeof(dev->info.model_name)) { |
| 566 | os_memset(dev->info.model_name, 0, |
| 567 | sizeof(dev->info.model_name)); |
| 568 | os_memcpy(dev->info.model_name, msg->model_name, |
| 569 | msg->model_name_len); |
| 570 | } |
| 571 | |
| 572 | if (msg->model_number && |
| 573 | msg->model_number_len < sizeof(dev->info.model_number)) { |
| 574 | os_memset(dev->info.model_number, 0, |
| 575 | sizeof(dev->info.model_number)); |
| 576 | os_memcpy(dev->info.model_number, msg->model_number, |
| 577 | msg->model_number_len); |
| 578 | } |
| 579 | |
| 580 | if (msg->serial_number && |
| 581 | msg->serial_number_len < sizeof(dev->info.serial_number)) { |
| 582 | os_memset(dev->info.serial_number, 0, |
| 583 | sizeof(dev->info.serial_number)); |
| 584 | os_memcpy(dev->info.serial_number, msg->serial_number, |
| 585 | msg->serial_number_len); |
| 586 | } |
| 587 | |
| 588 | if (msg->pri_dev_type) |
| 589 | os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type, |
| 590 | sizeof(dev->info.pri_dev_type)); |
| 591 | else if (msg->wps_pri_dev_type) |
| 592 | os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type, |
| 593 | sizeof(dev->info.pri_dev_type)); |
| 594 | |
| 595 | if (msg->wps_sec_dev_type_list) { |
| 596 | os_memcpy(dev->info.wps_sec_dev_type_list, |
| 597 | msg->wps_sec_dev_type_list, |
| 598 | msg->wps_sec_dev_type_list_len); |
| 599 | dev->info.wps_sec_dev_type_list_len = |
| 600 | msg->wps_sec_dev_type_list_len; |
| 601 | } |
| 602 | |
| 603 | if (msg->capability) { |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 604 | /* |
| 605 | * P2P Client Discoverability bit is reserved in all frames |
| 606 | * that use this function, so do not change its value here. |
| 607 | */ |
| 608 | dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 609 | dev->info.dev_capab |= msg->capability[0] & |
| 610 | ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 611 | dev->info.group_capab = msg->capability[1]; |
| 612 | } |
| 613 | |
| 614 | if (msg->ext_listen_timing) { |
| 615 | dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing); |
| 616 | dev->ext_listen_interval = |
| 617 | WPA_GET_LE16(msg->ext_listen_timing + 2); |
| 618 | } |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 619 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 620 | if (!probe_req) { |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 621 | u16 new_config_methods; |
| 622 | new_config_methods = msg->config_methods ? |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 623 | msg->config_methods : msg->wps_config_methods; |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 624 | if (new_config_methods && |
| 625 | dev->info.config_methods != new_config_methods) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 626 | p2p_dbg(p2p, "Update peer " MACSTR |
| 627 | " config_methods 0x%x -> 0x%x", |
| 628 | MAC2STR(dev->info.p2p_device_addr), |
| 629 | dev->info.config_methods, |
| 630 | new_config_methods); |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 631 | dev->info.config_methods = new_config_methods; |
| 632 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 633 | } |
| 634 | } |
| 635 | |
| 636 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 637 | static void p2p_update_peer_vendor_elems(struct p2p_device *dev, const u8 *ies, |
| 638 | size_t ies_len) |
| 639 | { |
| 640 | const u8 *pos, *end; |
| 641 | u8 id, len; |
| 642 | |
| 643 | wpabuf_free(dev->info.vendor_elems); |
| 644 | dev->info.vendor_elems = NULL; |
| 645 | |
| 646 | end = ies + ies_len; |
| 647 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 648 | for (pos = ies; end - pos > 1; pos += len) { |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 649 | id = *pos++; |
| 650 | len = *pos++; |
| 651 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 652 | if (len > end - pos) |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 653 | break; |
| 654 | |
| 655 | if (id != WLAN_EID_VENDOR_SPECIFIC || len < 3) |
| 656 | continue; |
| 657 | |
| 658 | if (len >= 4) { |
| 659 | u32 type = WPA_GET_BE32(pos); |
| 660 | |
| 661 | if (type == WPA_IE_VENDOR_TYPE || |
| 662 | type == WMM_IE_VENDOR_TYPE || |
| 663 | type == WPS_IE_VENDOR_TYPE || |
| 664 | type == P2P_IE_VENDOR_TYPE || |
| 665 | type == WFD_IE_VENDOR_TYPE) |
| 666 | continue; |
| 667 | } |
| 668 | |
| 669 | /* Unknown vendor element - make raw IE data available */ |
| 670 | if (wpabuf_resize(&dev->info.vendor_elems, 2 + len) < 0) |
| 671 | break; |
| 672 | wpabuf_put_data(dev->info.vendor_elems, pos - 2, 2 + len); |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 673 | if (wpabuf_size(dev->info.vendor_elems) > 2000) |
| 674 | break; |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 675 | } |
| 676 | } |
| 677 | |
| 678 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 679 | static int p2p_compare_wfd_info(struct p2p_device *dev, |
| 680 | const struct p2p_message *msg) |
| 681 | { |
| 682 | if (dev->info.wfd_subelems && msg->wfd_subelems) { |
| 683 | if (dev->info.wfd_subelems->used != msg->wfd_subelems->used) |
| 684 | return 1; |
| 685 | |
| 686 | return os_memcmp(dev->info.wfd_subelems->buf, |
| 687 | msg->wfd_subelems->buf, |
| 688 | dev->info.wfd_subelems->used); |
| 689 | } |
| 690 | if (dev->info.wfd_subelems || msg->wfd_subelems) |
| 691 | return 1; |
| 692 | |
| 693 | return 0; |
| 694 | } |
| 695 | |
| 696 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 697 | /** |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 698 | * p2p_add_device - Add peer entries based on scan results or P2P frames |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 699 | * @p2p: P2P module context from p2p_init() |
| 700 | * @addr: Source address of Beacon or Probe Response frame (may be either |
| 701 | * P2P Device Address or P2P Interface Address) |
| 702 | * @level: Signal level (signal strength of the received frame from the peer) |
| 703 | * @freq: Frequency on which the Beacon or Probe Response frame was received |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 704 | * @rx_time: Time when the result was received |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 705 | * @ies: IEs from the Beacon or Probe Response frame |
| 706 | * @ies_len: Length of ies buffer in octets |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 707 | * @scan_res: Whether this was based on scan results |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 708 | * Returns: 0 on success, -1 on failure |
| 709 | * |
| 710 | * If the scan result is for a GO, the clients in the group will also be added |
| 711 | * to the peer table. This function can also be used with some other frames |
| 712 | * like Provision Discovery Request that contains P2P Capability and P2P Device |
| 713 | * Info attributes. |
| 714 | */ |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 715 | int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 716 | struct os_reltime *rx_time, int level, const u8 *ies, |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 717 | size_t ies_len, int scan_res) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 718 | { |
| 719 | struct p2p_device *dev; |
| 720 | struct p2p_message msg; |
| 721 | const u8 *p2p_dev_addr; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 722 | int wfd_changed; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 723 | int dev_name_changed; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 724 | int i; |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 725 | struct os_reltime time_now; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 726 | |
| 727 | os_memset(&msg, 0, sizeof(msg)); |
| 728 | if (p2p_parse_ies(ies, ies_len, &msg)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 729 | p2p_dbg(p2p, "Failed to parse P2P IE for a device entry"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 730 | p2p_parse_free(&msg); |
| 731 | return -1; |
| 732 | } |
| 733 | |
| 734 | if (msg.p2p_device_addr) |
| 735 | p2p_dev_addr = msg.p2p_device_addr; |
| 736 | else if (msg.device_id) |
| 737 | p2p_dev_addr = msg.device_id; |
| 738 | else { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 739 | p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 740 | p2p_parse_free(&msg); |
| 741 | return -1; |
| 742 | } |
| 743 | |
| 744 | if (!is_zero_ether_addr(p2p->peer_filter) && |
| 745 | os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 746 | p2p_dbg(p2p, "Do not add peer filter for " MACSTR |
| 747 | " due to peer filter", MAC2STR(p2p_dev_addr)); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 748 | p2p_parse_free(&msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 749 | return 0; |
| 750 | } |
| 751 | |
| 752 | dev = p2p_create_device(p2p, p2p_dev_addr); |
| 753 | if (dev == NULL) { |
| 754 | p2p_parse_free(&msg); |
| 755 | return -1; |
| 756 | } |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 757 | |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 758 | if (rx_time == NULL) { |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 759 | os_get_reltime(&time_now); |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 760 | rx_time = &time_now; |
| 761 | } |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 762 | |
| 763 | /* |
| 764 | * Update the device entry only if the new peer |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 765 | * entry is newer than the one previously stored, or if |
| 766 | * the device was previously seen as a P2P Client in a group |
| 767 | * and the new entry isn't older than a threshold. |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 768 | */ |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 769 | if (dev->last_seen.sec > 0 && |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 770 | os_reltime_before(rx_time, &dev->last_seen) && |
| 771 | (!(dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT) || |
| 772 | os_reltime_expired(&dev->last_seen, rx_time, |
| 773 | P2P_DEV_GROUP_CLIENT_RESP_THRESHOLD))) { |
| 774 | p2p_dbg(p2p, |
| 775 | "Do not update peer entry based on old frame (rx_time=%u.%06u last_seen=%u.%06u flags=0x%x)", |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 776 | (unsigned int) rx_time->sec, |
| 777 | (unsigned int) rx_time->usec, |
| 778 | (unsigned int) dev->last_seen.sec, |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 779 | (unsigned int) dev->last_seen.usec, |
| 780 | dev->flags); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 781 | p2p_parse_free(&msg); |
| 782 | return -1; |
| 783 | } |
| 784 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 785 | os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime)); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 786 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 787 | dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY | |
| 788 | P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 789 | |
| 790 | if (os_memcmp(addr, p2p_dev_addr, ETH_ALEN) != 0) |
| 791 | os_memcpy(dev->interface_addr, addr, ETH_ALEN); |
| 792 | if (msg.ssid && |
Jouni Malinen | fdb708a | 2015-04-07 11:32:11 +0300 | [diff] [blame] | 793 | msg.ssid[1] <= sizeof(dev->oper_ssid) && |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 794 | (msg.ssid[1] != P2P_WILDCARD_SSID_LEN || |
| 795 | os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) |
| 796 | != 0)) { |
| 797 | os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]); |
| 798 | dev->oper_ssid_len = msg.ssid[1]; |
| 799 | } |
| 800 | |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 801 | wpabuf_free(dev->info.p2ps_instance); |
| 802 | dev->info.p2ps_instance = NULL; |
| 803 | if (msg.adv_service_instance && msg.adv_service_instance_len) |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 804 | dev->info.p2ps_instance = wpabuf_alloc_copy( |
| 805 | msg.adv_service_instance, msg.adv_service_instance_len); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 806 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 807 | if (freq >= 2412 && freq <= 2484 && msg.ds_params && |
| 808 | *msg.ds_params >= 1 && *msg.ds_params <= 14) { |
| 809 | int ds_freq; |
| 810 | if (*msg.ds_params == 14) |
| 811 | ds_freq = 2484; |
| 812 | else |
| 813 | ds_freq = 2407 + *msg.ds_params * 5; |
| 814 | if (freq != ds_freq) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 815 | p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 816 | freq, ds_freq); |
| 817 | freq = ds_freq; |
| 818 | } |
| 819 | } |
| 820 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 821 | if (dev->listen_freq && dev->listen_freq != freq && scan_res) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 822 | p2p_dbg(p2p, "Update Listen frequency based on scan results (" |
| 823 | MACSTR " %d -> %d MHz (DS param %d)", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 824 | MAC2STR(dev->info.p2p_device_addr), dev->listen_freq, |
| 825 | freq, msg.ds_params ? *msg.ds_params : -1); |
| 826 | } |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 827 | if (scan_res) { |
| 828 | dev->listen_freq = freq; |
| 829 | if (msg.group_info) |
| 830 | dev->oper_freq = freq; |
| 831 | } |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 832 | dev->info.level = level; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 833 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 834 | dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name, |
| 835 | WPS_DEV_NAME_MAX_LEN) != 0; |
| 836 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 837 | p2p_copy_wps_info(p2p, dev, 0, &msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 838 | |
| 839 | for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { |
| 840 | wpabuf_free(dev->info.wps_vendor_ext[i]); |
| 841 | dev->info.wps_vendor_ext[i] = NULL; |
| 842 | } |
| 843 | |
| 844 | for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { |
| 845 | if (msg.wps_vendor_ext[i] == NULL) |
| 846 | break; |
| 847 | dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy( |
| 848 | msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]); |
| 849 | if (dev->info.wps_vendor_ext[i] == NULL) |
| 850 | break; |
| 851 | } |
| 852 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 853 | wfd_changed = p2p_compare_wfd_info(dev, &msg); |
| 854 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 855 | if (wfd_changed) { |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 856 | wpabuf_free(dev->info.wfd_subelems); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 857 | if (msg.wfd_subelems) |
| 858 | dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); |
| 859 | else |
| 860 | dev->info.wfd_subelems = NULL; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 861 | } |
| 862 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 863 | if (scan_res) { |
| 864 | p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq, |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 865 | msg.group_info, msg.group_info_len, |
| 866 | rx_time); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 867 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 868 | |
| 869 | p2p_parse_free(&msg); |
| 870 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 871 | p2p_update_peer_vendor_elems(dev, ies, ies_len); |
| 872 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 873 | if (dev->flags & P2P_DEV_REPORTED && !wfd_changed && |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 874 | !dev_name_changed && |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 875 | (!msg.adv_service_instance || |
| 876 | (dev->flags & P2P_DEV_P2PS_REPORTED))) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 877 | return 0; |
| 878 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 879 | p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)", |
| 880 | freq, (unsigned int) rx_time->sec, |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 881 | (unsigned int) rx_time->usec); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 882 | if (dev->flags & P2P_DEV_USER_REJECTED) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 883 | p2p_dbg(p2p, "Do not report rejected device"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 884 | return 0; |
| 885 | } |
| 886 | |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 887 | if (dev->info.config_methods == 0 && |
| 888 | (freq == 2412 || freq == 2437 || freq == 2462)) { |
| 889 | /* |
| 890 | * If we have only seen a Beacon frame from a GO, we do not yet |
| 891 | * know what WPS config methods it supports. Since some |
| 892 | * applications use config_methods value from P2P-DEVICE-FOUND |
| 893 | * events, postpone reporting this peer until we've fully |
| 894 | * discovered its capabilities. |
| 895 | * |
| 896 | * At least for now, do this only if the peer was detected on |
| 897 | * one of the social channels since that peer can be easily be |
| 898 | * found again and there are no limitations of having to use |
| 899 | * passive scan on this channels, so this can be done through |
| 900 | * Probe Response frame that includes the config_methods |
| 901 | * information. |
| 902 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 903 | p2p_dbg(p2p, "Do not report peer " MACSTR |
| 904 | " with unknown config methods", MAC2STR(addr)); |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 905 | return 0; |
| 906 | } |
| 907 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 908 | p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, |
| 909 | !(dev->flags & P2P_DEV_REPORTED_ONCE)); |
| 910 | dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; |
| 911 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 912 | if (msg.adv_service_instance) |
| 913 | dev->flags |= P2P_DEV_P2PS_REPORTED; |
| 914 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 915 | return 0; |
| 916 | } |
| 917 | |
| 918 | |
| 919 | static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev) |
| 920 | { |
| 921 | int i; |
| 922 | |
Dmitry Shmidt | 497c1d5 | 2011-07-21 15:19:46 -0700 | [diff] [blame] | 923 | if (p2p->go_neg_peer == dev) { |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 924 | /* |
| 925 | * If GO Negotiation is in progress, report that it has failed. |
| 926 | */ |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 927 | p2p_go_neg_failed(p2p, -1); |
Dmitry Shmidt | 497c1d5 | 2011-07-21 15:19:46 -0700 | [diff] [blame] | 928 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 929 | if (p2p->invite_peer == dev) |
| 930 | p2p->invite_peer = NULL; |
| 931 | if (p2p->sd_peer == dev) |
| 932 | p2p->sd_peer = NULL; |
| 933 | if (p2p->pending_client_disc_go == dev) |
| 934 | p2p->pending_client_disc_go = NULL; |
| 935 | |
Dmitry Shmidt | c55524a | 2011-07-07 11:18:38 -0700 | [diff] [blame] | 936 | /* dev_lost() device, but only if it was previously dev_found() */ |
| 937 | if (dev->flags & P2P_DEV_REPORTED_ONCE) |
| 938 | p2p->cfg->dev_lost(p2p->cfg->cb_ctx, |
| 939 | dev->info.p2p_device_addr); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 940 | |
| 941 | for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { |
| 942 | wpabuf_free(dev->info.wps_vendor_ext[i]); |
| 943 | dev->info.wps_vendor_ext[i] = NULL; |
| 944 | } |
| 945 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 946 | wpabuf_free(dev->info.wfd_subelems); |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 947 | wpabuf_free(dev->info.vendor_elems); |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 948 | wpabuf_free(dev->go_neg_conf); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 949 | wpabuf_free(dev->info.p2ps_instance); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 950 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 951 | os_free(dev); |
| 952 | } |
| 953 | |
| 954 | |
| 955 | static int p2p_get_next_prog_freq(struct p2p_data *p2p) |
| 956 | { |
| 957 | struct p2p_channels *c; |
| 958 | struct p2p_reg_class *cla; |
| 959 | size_t cl, ch; |
| 960 | int found = 0; |
| 961 | u8 reg_class; |
| 962 | u8 channel; |
| 963 | int freq; |
| 964 | |
| 965 | c = &p2p->cfg->channels; |
| 966 | for (cl = 0; cl < c->reg_classes; cl++) { |
| 967 | cla = &c->reg_class[cl]; |
| 968 | if (cla->reg_class != p2p->last_prog_scan_class) |
| 969 | continue; |
| 970 | for (ch = 0; ch < cla->channels; ch++) { |
| 971 | if (cla->channel[ch] == p2p->last_prog_scan_chan) { |
| 972 | found = 1; |
| 973 | break; |
| 974 | } |
| 975 | } |
| 976 | if (found) |
| 977 | break; |
| 978 | } |
| 979 | |
| 980 | if (!found) { |
| 981 | /* Start from beginning */ |
| 982 | reg_class = c->reg_class[0].reg_class; |
| 983 | channel = c->reg_class[0].channel[0]; |
| 984 | } else { |
| 985 | /* Pick the next channel */ |
| 986 | ch++; |
| 987 | if (ch == cla->channels) { |
| 988 | cl++; |
| 989 | if (cl == c->reg_classes) |
| 990 | cl = 0; |
| 991 | ch = 0; |
| 992 | } |
| 993 | reg_class = c->reg_class[cl].reg_class; |
| 994 | channel = c->reg_class[cl].channel[ch]; |
| 995 | } |
| 996 | |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 997 | freq = p2p_channel_to_freq(reg_class, channel); |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 998 | p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 999 | reg_class, channel, freq); |
| 1000 | p2p->last_prog_scan_class = reg_class; |
| 1001 | p2p->last_prog_scan_chan = channel; |
| 1002 | |
| 1003 | if (freq == 2412 || freq == 2437 || freq == 2462) |
| 1004 | return 0; /* No need to add social channels */ |
| 1005 | return freq; |
| 1006 | } |
| 1007 | |
| 1008 | |
| 1009 | static void p2p_search(struct p2p_data *p2p) |
| 1010 | { |
| 1011 | int freq = 0; |
| 1012 | enum p2p_scan_type type; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1013 | u16 pw_id = DEV_PW_DEFAULT; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 1014 | int res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1015 | |
| 1016 | if (p2p->drv_in_listen) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1017 | p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1018 | return; |
| 1019 | } |
| 1020 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
| 1021 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1022 | if (p2p->find_pending_full && |
| 1023 | (p2p->find_type == P2P_FIND_PROGRESSIVE || |
| 1024 | p2p->find_type == P2P_FIND_START_WITH_FULL)) { |
| 1025 | type = P2P_SCAN_FULL; |
| 1026 | p2p_dbg(p2p, "Starting search (pending full scan)"); |
| 1027 | p2p->find_pending_full = 0; |
| 1028 | } else if ((p2p->find_type == P2P_FIND_PROGRESSIVE && |
| 1029 | (freq = p2p_get_next_prog_freq(p2p)) > 0) || |
| 1030 | (p2p->find_type == P2P_FIND_START_WITH_FULL && |
| 1031 | (freq = p2p->find_specified_freq) > 0)) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1032 | type = P2P_SCAN_SOCIAL_PLUS_ONE; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1033 | p2p_dbg(p2p, "Starting search (+ freq %u)", freq); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1034 | } else { |
| 1035 | type = P2P_SCAN_SOCIAL; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1036 | p2p_dbg(p2p, "Starting search"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1037 | } |
| 1038 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 1039 | res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq, |
| 1040 | p2p->num_req_dev_types, p2p->req_dev_types, |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1041 | p2p->find_dev_id, pw_id, p2p->include_6ghz); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 1042 | if (res < 0) { |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1043 | p2p_dbg(p2p, "Scan request schedule failed"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1044 | p2p_continue_find(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1045 | } |
| 1046 | } |
| 1047 | |
| 1048 | |
| 1049 | static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx) |
| 1050 | { |
| 1051 | struct p2p_data *p2p = eloop_ctx; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1052 | p2p_dbg(p2p, "Find timeout -> stop"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1053 | p2p_stop_find(p2p); |
| 1054 | } |
| 1055 | |
| 1056 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1057 | void p2p_notify_scan_trigger_status(struct p2p_data *p2p, int status) |
| 1058 | { |
| 1059 | if (status != 0) { |
| 1060 | p2p_dbg(p2p, "Scan request failed"); |
| 1061 | /* Do continue find even for the first p2p_find_scan */ |
| 1062 | p2p_continue_find(p2p); |
| 1063 | } else { |
| 1064 | p2p_dbg(p2p, "Running p2p_scan"); |
| 1065 | p2p->p2p_scan_running = 1; |
| 1066 | eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); |
| 1067 | eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout, |
| 1068 | p2p, NULL); |
| 1069 | } |
| 1070 | } |
| 1071 | |
| 1072 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1073 | static int p2p_run_after_scan(struct p2p_data *p2p) |
| 1074 | { |
| 1075 | struct p2p_device *dev; |
| 1076 | enum p2p_after_scan op; |
| 1077 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1078 | op = p2p->start_after_scan; |
| 1079 | p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; |
| 1080 | switch (op) { |
| 1081 | case P2P_AFTER_SCAN_NOTHING: |
| 1082 | break; |
| 1083 | case P2P_AFTER_SCAN_LISTEN: |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1084 | p2p_dbg(p2p, "Start previously requested Listen state"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1085 | p2p_listen(p2p, p2p->pending_listen_sec * 1000 + |
| 1086 | p2p->pending_listen_usec / 1000); |
| 1087 | return 1; |
| 1088 | case P2P_AFTER_SCAN_CONNECT: |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1089 | p2p_dbg(p2p, "Start previously requested connect with " MACSTR, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1090 | MAC2STR(p2p->after_scan_peer)); |
| 1091 | dev = p2p_get_device(p2p, p2p->after_scan_peer); |
| 1092 | if (dev == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1093 | p2p_dbg(p2p, "Peer not known anymore"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1094 | break; |
| 1095 | } |
| 1096 | p2p_connect_send(p2p, dev); |
| 1097 | return 1; |
| 1098 | } |
| 1099 | |
| 1100 | return 0; |
| 1101 | } |
| 1102 | |
| 1103 | |
| 1104 | static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx) |
| 1105 | { |
| 1106 | struct p2p_data *p2p = eloop_ctx; |
| 1107 | int running; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1108 | p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1109 | running = p2p->p2p_scan_running; |
| 1110 | /* Make sure we recover from missed scan results callback */ |
| 1111 | p2p->p2p_scan_running = 0; |
| 1112 | |
| 1113 | if (running) |
| 1114 | p2p_run_after_scan(p2p); |
| 1115 | } |
| 1116 | |
| 1117 | |
| 1118 | static void p2p_free_req_dev_types(struct p2p_data *p2p) |
| 1119 | { |
| 1120 | p2p->num_req_dev_types = 0; |
| 1121 | os_free(p2p->req_dev_types); |
| 1122 | p2p->req_dev_types = NULL; |
| 1123 | } |
| 1124 | |
| 1125 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1126 | static int p2ps_gen_hash(struct p2p_data *p2p, const char *str, u8 *hash) |
| 1127 | { |
| 1128 | u8 buf[SHA256_MAC_LEN]; |
| 1129 | char str_buf[256]; |
| 1130 | const u8 *adv_array; |
| 1131 | size_t i, adv_len; |
| 1132 | |
| 1133 | if (!str || !hash) |
| 1134 | return 0; |
| 1135 | |
| 1136 | if (!str[0]) { |
| 1137 | os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN); |
| 1138 | return 1; |
| 1139 | } |
| 1140 | |
| 1141 | adv_array = (u8 *) str_buf; |
| 1142 | adv_len = os_strlen(str); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1143 | if (adv_len >= sizeof(str_buf)) |
| 1144 | return 0; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1145 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 1146 | for (i = 0; i < adv_len; i++) { |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1147 | if (str[i] >= 'A' && str[i] <= 'Z') |
| 1148 | str_buf[i] = str[i] - 'A' + 'a'; |
| 1149 | else |
| 1150 | str_buf[i] = str[i]; |
| 1151 | } |
| 1152 | |
| 1153 | if (sha256_vector(1, &adv_array, &adv_len, buf)) |
| 1154 | return 0; |
| 1155 | |
| 1156 | os_memcpy(hash, buf, P2PS_HASH_LEN); |
| 1157 | return 1; |
| 1158 | } |
| 1159 | |
| 1160 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1161 | int p2p_find(struct p2p_data *p2p, unsigned int timeout, |
| 1162 | enum p2p_discovery_type type, |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 1163 | unsigned int num_req_dev_types, const u8 *req_dev_types, |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1164 | const u8 *dev_id, unsigned int search_delay, |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1165 | u8 seek_count, const char **seek, int freq, bool include_6ghz) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1166 | { |
| 1167 | int res; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 1168 | struct os_reltime start; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1169 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1170 | p2p_dbg(p2p, "Starting find (type=%d)", type); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1171 | if (p2p->p2p_scan_running) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1172 | p2p_dbg(p2p, "p2p_scan is already running"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1173 | } |
| 1174 | |
| 1175 | p2p_free_req_dev_types(p2p); |
| 1176 | if (req_dev_types && num_req_dev_types) { |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1177 | p2p->req_dev_types = os_memdup(req_dev_types, |
| 1178 | num_req_dev_types * |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1179 | WPS_DEV_TYPE_LEN); |
| 1180 | if (p2p->req_dev_types == NULL) |
| 1181 | return -1; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1182 | p2p->num_req_dev_types = num_req_dev_types; |
| 1183 | } |
| 1184 | |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 1185 | if (dev_id) { |
| 1186 | os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN); |
| 1187 | p2p->find_dev_id = p2p->find_dev_id_buf; |
| 1188 | } else |
| 1189 | p2p->find_dev_id = NULL; |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1190 | p2p->include_6ghz = p2p_wfd_enabled(p2p) && include_6ghz; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1191 | if (seek_count == 0 || !seek) { |
| 1192 | /* Not an ASP search */ |
| 1193 | p2p->p2ps_seek = 0; |
| 1194 | } else if (seek_count == 1 && seek && (!seek[0] || !seek[0][0])) { |
| 1195 | /* |
| 1196 | * An empty seek string means no hash values, but still an ASP |
| 1197 | * search. |
| 1198 | */ |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1199 | p2p_dbg(p2p, "ASP search"); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1200 | p2p->p2ps_seek_count = 0; |
| 1201 | p2p->p2ps_seek = 1; |
| 1202 | } else if (seek && seek_count <= P2P_MAX_QUERY_HASH) { |
| 1203 | u8 buf[P2PS_HASH_LEN]; |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1204 | int i, count = 0; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1205 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1206 | for (i = 0; i < seek_count; i++) { |
| 1207 | if (!p2ps_gen_hash(p2p, seek[i], buf)) |
| 1208 | continue; |
| 1209 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1210 | p2p_dbg(p2p, "Seek service %s hash " MACSTR, |
| 1211 | seek[i], MAC2STR(buf)); |
| 1212 | os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN], |
| 1213 | buf, P2PS_HASH_LEN); |
| 1214 | count++; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1215 | } |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1216 | |
| 1217 | p2p->p2ps_seek_count = count; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1218 | p2p->p2ps_seek = 1; |
| 1219 | } else { |
| 1220 | p2p->p2ps_seek_count = 0; |
| 1221 | p2p->p2ps_seek = 1; |
| 1222 | } |
| 1223 | |
| 1224 | /* Special case to perform wildcard search */ |
| 1225 | if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) { |
| 1226 | p2p->p2ps_seek_count = 1; |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1227 | os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash, |
| 1228 | P2PS_HASH_LEN); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1229 | } |
| 1230 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1231 | p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; |
| 1232 | p2p_clear_timeout(p2p); |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 1233 | if (p2p->pending_listen_freq) { |
| 1234 | p2p_dbg(p2p, "Clear pending_listen_freq for p2p_find"); |
| 1235 | p2p->pending_listen_freq = 0; |
| 1236 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1237 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1238 | p2p->find_pending_full = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1239 | p2p->find_type = type; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1240 | if (freq != 2412 && freq != 2437 && freq != 2462 && freq != 60480) |
| 1241 | p2p->find_specified_freq = freq; |
| 1242 | else |
| 1243 | p2p->find_specified_freq = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1244 | p2p_device_clear_reported(p2p); |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 1245 | os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1246 | p2p_set_state(p2p, P2P_SEARCH); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 1247 | p2p->search_delay = search_delay; |
| 1248 | p2p->in_search_delay = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1249 | eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1250 | p2p->last_p2p_find_timeout = timeout; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1251 | if (timeout) |
| 1252 | eloop_register_timeout(timeout, 0, p2p_find_timeout, |
| 1253 | p2p, NULL); |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 1254 | os_get_reltime(&start); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1255 | switch (type) { |
| 1256 | case P2P_FIND_START_WITH_FULL: |
Dmitry Shmidt | 203eadb | 2015-03-05 14:16:04 -0800 | [diff] [blame] | 1257 | if (freq > 0) { |
| 1258 | /* |
| 1259 | * Start with the specified channel and then move to |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1260 | * scans for social channels and this specific channel. |
Dmitry Shmidt | 203eadb | 2015-03-05 14:16:04 -0800 | [diff] [blame] | 1261 | */ |
| 1262 | res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, |
| 1263 | P2P_SCAN_SPECIFIC, freq, |
| 1264 | p2p->num_req_dev_types, |
| 1265 | p2p->req_dev_types, dev_id, |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1266 | DEV_PW_DEFAULT, |
| 1267 | p2p->include_6ghz); |
Dmitry Shmidt | 203eadb | 2015-03-05 14:16:04 -0800 | [diff] [blame] | 1268 | break; |
| 1269 | } |
| 1270 | /* fall through */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1271 | case P2P_FIND_PROGRESSIVE: |
| 1272 | res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0, |
| 1273 | p2p->num_req_dev_types, |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1274 | p2p->req_dev_types, dev_id, |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1275 | DEV_PW_DEFAULT, p2p->include_6ghz); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1276 | break; |
| 1277 | case P2P_FIND_ONLY_SOCIAL: |
| 1278 | res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0, |
| 1279 | p2p->num_req_dev_types, |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1280 | p2p->req_dev_types, dev_id, |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1281 | DEV_PW_DEFAULT, p2p->include_6ghz); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1282 | break; |
| 1283 | default: |
| 1284 | return -1; |
| 1285 | } |
| 1286 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 1287 | if (!res) |
| 1288 | p2p->find_start = start; |
| 1289 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1290 | if (res != 0 && p2p->p2p_scan_running) { |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 1291 | p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running"); |
| 1292 | /* wait for the previous p2p_scan to complete */ |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1293 | if (type == P2P_FIND_PROGRESSIVE || |
| 1294 | (type == P2P_FIND_START_WITH_FULL && freq == 0)) |
| 1295 | p2p->find_pending_full = 1; |
Dmitry Shmidt | 96be622 | 2014-02-13 10:16:51 -0800 | [diff] [blame] | 1296 | res = 0; /* do not report failure */ |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1297 | } else if (res != 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1298 | p2p_dbg(p2p, "Failed to start p2p_scan"); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1299 | p2p_set_state(p2p, P2P_IDLE); |
| 1300 | eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1301 | } |
| 1302 | |
| 1303 | return res; |
| 1304 | } |
| 1305 | |
| 1306 | |
| 1307 | void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq) |
| 1308 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1309 | p2p_dbg(p2p, "Stopping find"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1310 | eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); |
| 1311 | p2p_clear_timeout(p2p); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1312 | if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND) |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1313 | p2p->cfg->find_stopped(p2p->cfg->cb_ctx); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1314 | |
| 1315 | p2p->p2ps_seek_count = 0; |
| 1316 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1317 | p2p_set_state(p2p, P2P_IDLE); |
| 1318 | p2p_free_req_dev_types(p2p); |
| 1319 | p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 1320 | if (p2p->go_neg_peer) |
| 1321 | p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1322 | p2p->go_neg_peer = NULL; |
| 1323 | p2p->sd_peer = NULL; |
| 1324 | p2p->invite_peer = NULL; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1325 | p2p_stop_listen_for_freq(p2p, freq); |
Dmitry Shmidt | 7f65602 | 2015-02-25 14:36:37 -0800 | [diff] [blame] | 1326 | p2p->send_action_in_progress = 0; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1327 | } |
| 1328 | |
| 1329 | |
| 1330 | void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq) |
| 1331 | { |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1332 | if (freq > 0 && |
| 1333 | ((p2p->drv_in_listen == freq && p2p->in_listen) || |
| 1334 | p2p->pending_listen_freq == (unsigned int) freq)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1335 | p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1336 | return; |
| 1337 | } |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1338 | if (p2p->in_listen) { |
| 1339 | p2p->in_listen = 0; |
| 1340 | p2p_clear_timeout(p2p); |
| 1341 | } |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1342 | if (p2p->drv_in_listen) { |
| 1343 | /* |
| 1344 | * The driver may not deliver callback to p2p_listen_end() |
| 1345 | * when the operation gets canceled, so clear the internal |
| 1346 | * variable that is tracking driver state. |
| 1347 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1348 | p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1349 | p2p->drv_in_listen = 0; |
| 1350 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1351 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
| 1352 | } |
| 1353 | |
| 1354 | |
Dmitry Shmidt | 391c59f | 2013-09-03 12:16:28 -0700 | [diff] [blame] | 1355 | void p2p_stop_listen(struct p2p_data *p2p) |
| 1356 | { |
| 1357 | if (p2p->state != P2P_LISTEN_ONLY) { |
| 1358 | p2p_dbg(p2p, "Skip stop_listen since not in listen_only state."); |
| 1359 | return; |
| 1360 | } |
| 1361 | |
| 1362 | p2p_stop_listen_for_freq(p2p, 0); |
| 1363 | p2p_set_state(p2p, P2P_IDLE); |
| 1364 | } |
| 1365 | |
| 1366 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1367 | void p2p_stop_find(struct p2p_data *p2p) |
| 1368 | { |
Dmitry Shmidt | 3c57b3f | 2014-05-22 15:13:07 -0700 | [diff] [blame] | 1369 | p2p->pending_listen_freq = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1370 | p2p_stop_find_for_freq(p2p, 0); |
| 1371 | } |
| 1372 | |
| 1373 | |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1374 | static int p2p_prepare_channel_pref(struct p2p_data *p2p, |
| 1375 | unsigned int force_freq, |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1376 | unsigned int pref_freq, int go) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1377 | { |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1378 | u8 op_class, op_channel; |
| 1379 | unsigned int freq = force_freq ? force_freq : pref_freq; |
| 1380 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1381 | p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d", |
| 1382 | force_freq, pref_freq, go); |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1383 | if (p2p_freq_to_channel(freq, &op_class, &op_channel) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1384 | p2p_dbg(p2p, "Unsupported frequency %u MHz", freq); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1385 | return -1; |
| 1386 | } |
| 1387 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1388 | if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) && |
| 1389 | (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class, |
| 1390 | op_channel))) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1391 | p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P", |
| 1392 | freq, op_class, op_channel); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1393 | return -1; |
| 1394 | } |
| 1395 | |
| 1396 | p2p->op_reg_class = op_class; |
| 1397 | p2p->op_channel = op_channel; |
| 1398 | |
| 1399 | if (force_freq) { |
| 1400 | p2p->channels.reg_classes = 1; |
| 1401 | p2p->channels.reg_class[0].channels = 1; |
| 1402 | p2p->channels.reg_class[0].reg_class = p2p->op_reg_class; |
| 1403 | p2p->channels.reg_class[0].channel[0] = p2p->op_channel; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1404 | } else { |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1405 | p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, |
| 1406 | p2p->allow_6ghz); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1407 | } |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1408 | |
| 1409 | return 0; |
| 1410 | } |
| 1411 | |
| 1412 | |
| 1413 | static void p2p_prepare_channel_best(struct p2p_data *p2p) |
| 1414 | { |
| 1415 | u8 op_class, op_channel; |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 1416 | const int op_classes_5ghz[] = { 124, 125, 115, 0 }; |
Dmitry Shmidt | a0d265f | 2013-11-19 13:13:41 -0800 | [diff] [blame] | 1417 | const int op_classes_ht40[] = { 126, 127, 116, 117, 0 }; |
Dmitry Shmidt | e0e48dc | 2013-11-18 12:00:06 -0800 | [diff] [blame] | 1418 | const int op_classes_vht[] = { 128, 0 }; |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 1419 | const int op_classes_edmg[] = { 181, 182, 183, 0 }; |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1420 | const int op_classes_6ghz[] = { 131, 0 }; |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1421 | |
Dmitry Shmidt | b7b4d0e | 2013-08-26 12:09:05 -0700 | [diff] [blame] | 1422 | p2p_dbg(p2p, "Prepare channel best"); |
| 1423 | |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1424 | if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 && |
| 1425 | p2p_supported_freq(p2p, p2p->best_freq_overall) && |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1426 | p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel) |
| 1427 | == 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1428 | p2p_dbg(p2p, "Select best overall channel as operating channel preference"); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1429 | p2p->op_reg_class = op_class; |
| 1430 | p2p->op_channel = op_channel; |
| 1431 | } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 && |
| 1432 | p2p_supported_freq(p2p, p2p->best_freq_5) && |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1433 | p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel) |
| 1434 | == 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1435 | p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference"); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1436 | p2p->op_reg_class = op_class; |
| 1437 | p2p->op_channel = op_channel; |
| 1438 | } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 && |
| 1439 | p2p_supported_freq(p2p, p2p->best_freq_24) && |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1440 | p2p_freq_to_channel(p2p->best_freq_24, &op_class, |
| 1441 | &op_channel) == 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1442 | p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference"); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1443 | p2p->op_reg_class = op_class; |
| 1444 | p2p->op_channel = op_channel; |
Dmitry Shmidt | b7b4d0e | 2013-08-26 12:09:05 -0700 | [diff] [blame] | 1445 | } else if (p2p->cfg->num_pref_chan > 0 && |
| 1446 | p2p_channels_includes(&p2p->cfg->channels, |
| 1447 | p2p->cfg->pref_chan[0].op_class, |
| 1448 | p2p->cfg->pref_chan[0].chan)) { |
| 1449 | p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference"); |
| 1450 | p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class; |
| 1451 | p2p->op_channel = p2p->cfg->pref_chan[0].chan; |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 1452 | } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_edmg, |
| 1453 | &p2p->op_reg_class, &p2p->op_channel) == |
| 1454 | 0) { |
| 1455 | p2p_dbg(p2p, "Select possible EDMG channel (op_class %u channel %u) as operating channel preference", |
| 1456 | p2p->op_reg_class, p2p->op_channel); |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1457 | } else if (p2p->allow_6ghz && |
| 1458 | (p2p_channel_select(&p2p->cfg->channels, op_classes_6ghz, |
| 1459 | &p2p->op_reg_class, &p2p->op_channel) == |
| 1460 | 0)) { |
| 1461 | p2p_dbg(p2p, "Select possible 6 GHz channel (op_class %u channel %u) as operating channel preference", |
| 1462 | p2p->op_reg_class, p2p->op_channel); |
Dmitry Shmidt | e0e48dc | 2013-11-18 12:00:06 -0800 | [diff] [blame] | 1463 | } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht, |
| 1464 | &p2p->op_reg_class, &p2p->op_channel) == |
| 1465 | 0) { |
| 1466 | p2p_dbg(p2p, "Select possible VHT channel (op_class %u channel %u) as operating channel preference", |
| 1467 | p2p->op_reg_class, p2p->op_channel); |
| 1468 | } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40, |
| 1469 | &p2p->op_reg_class, &p2p->op_channel) == |
| 1470 | 0) { |
| 1471 | p2p_dbg(p2p, "Select possible HT40 channel (op_class %u channel %u) as operating channel preference", |
| 1472 | p2p->op_reg_class, p2p->op_channel); |
| 1473 | } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz, |
| 1474 | &p2p->op_reg_class, &p2p->op_channel) == |
| 1475 | 0) { |
| 1476 | p2p_dbg(p2p, "Select possible 5 GHz channel (op_class %u channel %u) as operating channel preference", |
| 1477 | p2p->op_reg_class, p2p->op_channel); |
Dmitry Shmidt | d11f019 | 2014-03-24 12:09:47 -0700 | [diff] [blame] | 1478 | } else if (p2p_channels_includes(&p2p->cfg->channels, |
| 1479 | p2p->cfg->op_reg_class, |
| 1480 | p2p->cfg->op_channel)) { |
Dmitry Shmidt | b7b4d0e | 2013-08-26 12:09:05 -0700 | [diff] [blame] | 1481 | p2p_dbg(p2p, "Select pre-configured channel as operating channel preference"); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1482 | p2p->op_reg_class = p2p->cfg->op_reg_class; |
| 1483 | p2p->op_channel = p2p->cfg->op_channel; |
Dmitry Shmidt | d11f019 | 2014-03-24 12:09:47 -0700 | [diff] [blame] | 1484 | } else if (p2p_channel_random_social(&p2p->cfg->channels, |
| 1485 | &p2p->op_reg_class, |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 1486 | &p2p->op_channel, |
| 1487 | NULL, NULL) == 0) { |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 1488 | p2p_dbg(p2p, "Select random available social channel (op_class %u channel %u) as operating channel preference", |
| 1489 | p2p->op_reg_class, p2p->op_channel); |
Dmitry Shmidt | d11f019 | 2014-03-24 12:09:47 -0700 | [diff] [blame] | 1490 | } else { |
| 1491 | /* Select any random available channel from the first available |
| 1492 | * operating class */ |
| 1493 | p2p_channel_select(&p2p->cfg->channels, NULL, |
| 1494 | &p2p->op_reg_class, |
| 1495 | &p2p->op_channel); |
| 1496 | p2p_dbg(p2p, "Select random available channel %d from operating class %d as operating channel preference", |
| 1497 | p2p->op_channel, p2p->op_reg_class); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1498 | } |
| 1499 | |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1500 | p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, p2p->allow_6ghz); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1501 | } |
| 1502 | |
| 1503 | |
| 1504 | /** |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 1505 | * p2p_prepare_channel - Select operating channel for GO Negotiation or P2PS PD |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1506 | * @p2p: P2P module context from p2p_init() |
| 1507 | * @dev: Selected peer device |
| 1508 | * @force_freq: Forced frequency in MHz or 0 if not forced |
| 1509 | * @pref_freq: Preferred frequency in MHz or 0 if no preference |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1510 | * @go: Whether the local end will be forced to be GO |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1511 | * Returns: 0 on success, -1 on failure (channel not supported for P2P) |
| 1512 | * |
| 1513 | * This function is used to do initial operating channel selection for GO |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 1514 | * Negotiation prior to having received peer information or for P2PS PD |
| 1515 | * signalling. The selected channel may be further optimized in |
| 1516 | * p2p_reselect_channel() once the peer information is available. |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1517 | */ |
Dmitry Shmidt | 7a5e50a | 2013-03-05 12:37:16 -0800 | [diff] [blame] | 1518 | int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev, |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1519 | unsigned int force_freq, unsigned int pref_freq, int go) |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1520 | { |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1521 | p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d", |
| 1522 | force_freq, pref_freq, go); |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1523 | if (force_freq || pref_freq) { |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1524 | if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq, go) < |
| 1525 | 0) |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1526 | return -1; |
| 1527 | } else { |
| 1528 | p2p_prepare_channel_best(p2p); |
| 1529 | } |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1530 | p2p_channels_dump(p2p, "prepared channels", &p2p->channels); |
| 1531 | if (go) |
| 1532 | p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq); |
| 1533 | else if (!force_freq) |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1534 | p2p_channels_union_inplace(&p2p->channels, |
| 1535 | &p2p->cfg->cli_channels); |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1536 | p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels); |
| 1537 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1538 | p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1539 | p2p->op_reg_class, p2p->op_channel, |
| 1540 | force_freq ? " (forced)" : ""); |
| 1541 | |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1542 | if (force_freq) |
| 1543 | dev->flags |= P2P_DEV_FORCE_FREQ; |
| 1544 | else |
| 1545 | dev->flags &= ~P2P_DEV_FORCE_FREQ; |
| 1546 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1547 | return 0; |
| 1548 | } |
| 1549 | |
| 1550 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1551 | static void p2p_set_dev_persistent(struct p2p_device *dev, |
| 1552 | int persistent_group) |
| 1553 | { |
| 1554 | switch (persistent_group) { |
| 1555 | case 0: |
| 1556 | dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP | |
| 1557 | P2P_DEV_PREFER_PERSISTENT_RECONN); |
| 1558 | break; |
| 1559 | case 1: |
| 1560 | dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP; |
| 1561 | dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN; |
| 1562 | break; |
| 1563 | case 2: |
| 1564 | dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP | |
| 1565 | P2P_DEV_PREFER_PERSISTENT_RECONN; |
| 1566 | break; |
| 1567 | } |
| 1568 | } |
| 1569 | |
| 1570 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1571 | int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr, |
| 1572 | enum p2p_wps_method wps_method, |
| 1573 | int go_intent, const u8 *own_interface_addr, |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1574 | unsigned int force_freq, int persistent_group, |
| 1575 | const u8 *force_ssid, size_t force_ssid_len, |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1576 | int pd_before_go_neg, unsigned int pref_freq, u16 oob_pw_id) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1577 | { |
| 1578 | struct p2p_device *dev; |
| 1579 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1580 | p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1581 | " GO Intent=%d Intended Interface Address=" MACSTR |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1582 | " wps_method=%d persistent_group=%d pd_before_go_neg=%d " |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1583 | "oob_pw_id=%u allow_6ghz=%d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1584 | MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1585 | wps_method, persistent_group, pd_before_go_neg, oob_pw_id, |
| 1586 | p2p->allow_6ghz); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1587 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1588 | dev = p2p_get_device(p2p, peer_addr); |
| 1589 | if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1590 | p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1591 | MAC2STR(peer_addr)); |
| 1592 | return -1; |
| 1593 | } |
| 1594 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1595 | if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, |
| 1596 | go_intent == 15) < 0) |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1597 | return -1; |
| 1598 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1599 | if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) { |
| 1600 | if (!(dev->info.dev_capab & |
| 1601 | P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1602 | p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1603 | " that is in a group and is not discoverable", |
| 1604 | MAC2STR(peer_addr)); |
| 1605 | return -1; |
| 1606 | } |
| 1607 | if (dev->oper_freq <= 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1608 | p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1609 | " with incomplete information", |
| 1610 | MAC2STR(peer_addr)); |
| 1611 | return -1; |
| 1612 | } |
| 1613 | |
| 1614 | /* |
| 1615 | * First, try to connect directly. If the peer does not |
| 1616 | * acknowledge frames, assume it is sleeping and use device |
| 1617 | * discoverability via the GO at that point. |
| 1618 | */ |
| 1619 | } |
| 1620 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1621 | p2p->ssid_set = 0; |
| 1622 | if (force_ssid) { |
| 1623 | wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", |
| 1624 | force_ssid, force_ssid_len); |
| 1625 | os_memcpy(p2p->ssid, force_ssid, force_ssid_len); |
| 1626 | p2p->ssid_len = force_ssid_len; |
| 1627 | p2p->ssid_set = 1; |
| 1628 | } |
| 1629 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1630 | dev->flags &= ~P2P_DEV_NOT_YET_READY; |
| 1631 | dev->flags &= ~P2P_DEV_USER_REJECTED; |
| 1632 | dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; |
| 1633 | dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1634 | if (pd_before_go_neg) |
| 1635 | dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG; |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1636 | else { |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1637 | dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG; |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1638 | /* |
Dmitry Shmidt | 9cdf1b9 | 2013-02-27 12:58:50 -0800 | [diff] [blame] | 1639 | * Assign dialog token and tie breaker here to use the same |
| 1640 | * values in each retry within the same GO Negotiation exchange. |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1641 | */ |
| 1642 | dev->dialog_token++; |
| 1643 | if (dev->dialog_token == 0) |
| 1644 | dev->dialog_token = 1; |
Dmitry Shmidt | 9cdf1b9 | 2013-02-27 12:58:50 -0800 | [diff] [blame] | 1645 | dev->tie_breaker = p2p->next_tie_breaker; |
| 1646 | p2p->next_tie_breaker = !p2p->next_tie_breaker; |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1647 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1648 | dev->connect_reqs = 0; |
| 1649 | dev->go_neg_req_sent = 0; |
| 1650 | dev->go_state = UNKNOWN_GO; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1651 | p2p_set_dev_persistent(dev, persistent_group); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1652 | p2p->go_intent = go_intent; |
| 1653 | os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); |
| 1654 | |
| 1655 | if (p2p->state != P2P_IDLE) |
| 1656 | p2p_stop_find(p2p); |
| 1657 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1658 | dev->wps_method = wps_method; |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1659 | dev->oob_pw_id = oob_pw_id; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1660 | dev->status = P2P_SC_SUCCESS; |
| 1661 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1662 | if (p2p->p2p_scan_running) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1663 | p2p_dbg(p2p, "p2p_scan running - delay connect send"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1664 | p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT; |
| 1665 | os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN); |
| 1666 | return 0; |
| 1667 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1668 | |
| 1669 | return p2p_connect_send(p2p, dev); |
| 1670 | } |
| 1671 | |
| 1672 | |
| 1673 | int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr, |
| 1674 | enum p2p_wps_method wps_method, |
| 1675 | int go_intent, const u8 *own_interface_addr, |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1676 | unsigned int force_freq, int persistent_group, |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 1677 | const u8 *force_ssid, size_t force_ssid_len, |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1678 | unsigned int pref_freq, u16 oob_pw_id) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1679 | { |
| 1680 | struct p2p_device *dev; |
| 1681 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1682 | p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1683 | " GO Intent=%d Intended Interface Address=" MACSTR |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1684 | " wps_method=%d persistent_group=%d oob_pw_id=%u allow_6ghz=%d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1685 | MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 1686 | wps_method, persistent_group, oob_pw_id, p2p->allow_6ghz); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1687 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1688 | dev = p2p_get_device(p2p, peer_addr); |
| 1689 | if (dev == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1690 | p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1691 | MAC2STR(peer_addr)); |
| 1692 | return -1; |
| 1693 | } |
| 1694 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1695 | if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent == |
| 1696 | 15) < 0) |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 1697 | return -1; |
| 1698 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 1699 | p2p->ssid_set = 0; |
| 1700 | if (force_ssid) { |
| 1701 | wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", |
| 1702 | force_ssid, force_ssid_len); |
| 1703 | os_memcpy(p2p->ssid, force_ssid, force_ssid_len); |
| 1704 | p2p->ssid_len = force_ssid_len; |
| 1705 | p2p->ssid_set = 1; |
| 1706 | } |
| 1707 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1708 | dev->flags &= ~P2P_DEV_NOT_YET_READY; |
| 1709 | dev->flags &= ~P2P_DEV_USER_REJECTED; |
| 1710 | dev->go_neg_req_sent = 0; |
| 1711 | dev->go_state = UNKNOWN_GO; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1712 | p2p_set_dev_persistent(dev, persistent_group); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1713 | p2p->go_intent = go_intent; |
| 1714 | os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); |
| 1715 | |
| 1716 | dev->wps_method = wps_method; |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1717 | dev->oob_pw_id = oob_pw_id; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1718 | dev->status = P2P_SC_SUCCESS; |
| 1719 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1720 | return 0; |
| 1721 | } |
| 1722 | |
| 1723 | |
| 1724 | void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr, |
| 1725 | struct p2p_device *dev, struct p2p_message *msg) |
| 1726 | { |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 1727 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1728 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1729 | p2p_copy_wps_info(p2p, dev, 0, msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1730 | |
| 1731 | if (msg->listen_channel) { |
| 1732 | int freq; |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1733 | freq = p2p_channel_to_freq(msg->listen_channel[3], |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1734 | msg->listen_channel[4]); |
| 1735 | if (freq < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1736 | p2p_dbg(p2p, "Unknown peer Listen channel: " |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1737 | "country=%c%c(0x%02x) reg_class=%u channel=%u", |
| 1738 | msg->listen_channel[0], |
| 1739 | msg->listen_channel[1], |
| 1740 | msg->listen_channel[2], |
| 1741 | msg->listen_channel[3], |
| 1742 | msg->listen_channel[4]); |
| 1743 | } else { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1744 | p2p_dbg(p2p, "Update peer " MACSTR |
| 1745 | " Listen channel: %u -> %u MHz", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1746 | MAC2STR(dev->info.p2p_device_addr), |
| 1747 | dev->listen_freq, freq); |
| 1748 | dev->listen_freq = freq; |
| 1749 | } |
| 1750 | } |
| 1751 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 1752 | if (msg->wfd_subelems) { |
| 1753 | wpabuf_free(dev->info.wfd_subelems); |
| 1754 | dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems); |
| 1755 | } |
| 1756 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1757 | if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { |
| 1758 | dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1759 | p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1760 | } else { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1761 | p2p_dbg(p2p, "Created device entry based on GO Neg Req: " |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1762 | MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' " |
| 1763 | "listen_freq=%d", |
| 1764 | MAC2STR(dev->info.p2p_device_addr), |
| 1765 | dev->info.dev_capab, dev->info.group_capab, |
| 1766 | dev->info.device_name, dev->listen_freq); |
| 1767 | } |
| 1768 | |
| 1769 | dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY; |
| 1770 | |
| 1771 | if (dev->flags & P2P_DEV_USER_REJECTED) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1772 | p2p_dbg(p2p, "Do not report rejected device"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1773 | return; |
| 1774 | } |
| 1775 | |
| 1776 | p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, |
| 1777 | !(dev->flags & P2P_DEV_REPORTED_ONCE)); |
| 1778 | dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; |
| 1779 | } |
| 1780 | |
| 1781 | |
| 1782 | void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len) |
| 1783 | { |
| 1784 | os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); |
| 1785 | p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2); |
| 1786 | os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2], |
| 1787 | p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len); |
| 1788 | *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len; |
| 1789 | } |
| 1790 | |
| 1791 | |
| 1792 | int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params) |
| 1793 | { |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 1794 | if (p2p->ssid_set) { |
| 1795 | os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len); |
| 1796 | params->ssid_len = p2p->ssid_len; |
| 1797 | } else { |
| 1798 | p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len); |
| 1799 | } |
| 1800 | p2p->ssid_set = 0; |
| 1801 | |
Jimmy Chen | 6d7e390 | 2018-11-20 10:15:16 +0800 | [diff] [blame] | 1802 | if (p2p->passphrase_set) { |
| 1803 | os_memcpy(params->passphrase, p2p->passphrase, os_strlen(p2p->passphrase)); |
| 1804 | } else { |
| 1805 | p2p_random(params->passphrase, p2p->cfg->passphrase_len); |
| 1806 | } |
| 1807 | p2p->passphrase_set = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1808 | return 0; |
| 1809 | } |
| 1810 | |
| 1811 | |
| 1812 | void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer) |
| 1813 | { |
| 1814 | struct p2p_go_neg_results res; |
| 1815 | int go = peer->go_state == LOCAL_GO; |
| 1816 | struct p2p_channels intersection; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1817 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1818 | p2p_dbg(p2p, "GO Negotiation with " MACSTR " completed (%s will be GO)", |
| 1819 | MAC2STR(peer->info.p2p_device_addr), go ? "local end" : "peer"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1820 | |
| 1821 | os_memset(&res, 0, sizeof(res)); |
| 1822 | res.role_go = go; |
| 1823 | os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN); |
| 1824 | os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN); |
| 1825 | res.wps_method = peer->wps_method; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1826 | if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) { |
| 1827 | if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN) |
| 1828 | res.persistent_group = 2; |
| 1829 | else |
| 1830 | res.persistent_group = 1; |
| 1831 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1832 | |
| 1833 | if (go) { |
| 1834 | /* Setup AP mode for WPS provisioning */ |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 1835 | res.freq = p2p_channel_to_freq(p2p->op_reg_class, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1836 | p2p->op_channel); |
| 1837 | os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); |
| 1838 | res.ssid_len = p2p->ssid_len; |
Dmitry Shmidt | 2271d3f | 2014-06-23 12:16:31 -0700 | [diff] [blame] | 1839 | p2p_random(res.passphrase, p2p->cfg->passphrase_len); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1840 | } else { |
| 1841 | res.freq = peer->oper_freq; |
| 1842 | if (p2p->ssid_len) { |
| 1843 | os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); |
| 1844 | res.ssid_len = p2p->ssid_len; |
| 1845 | } |
| 1846 | } |
| 1847 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1848 | p2p_channels_dump(p2p, "own channels", &p2p->channels); |
| 1849 | p2p_channels_dump(p2p, "peer channels", &peer->channels); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1850 | p2p_channels_intersect(&p2p->channels, &peer->channels, |
| 1851 | &intersection); |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 1852 | if (go) { |
| 1853 | p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq); |
| 1854 | p2p_channels_dump(p2p, "intersection after no-GO removal", |
| 1855 | &intersection); |
| 1856 | } |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 1857 | |
| 1858 | p2p_channels_to_freqs(&intersection, res.freq_list, |
| 1859 | P2P_MAX_CHANNELS); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1860 | |
| 1861 | res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout; |
| 1862 | |
| 1863 | p2p_clear_timeout(p2p); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1864 | p2p->ssid_set = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1865 | peer->go_neg_req_sent = 0; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1866 | peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1867 | peer->wps_method = WPS_NOT_READY; |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 1868 | peer->oob_pw_id = 0; |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 1869 | wpabuf_free(peer->go_neg_conf); |
| 1870 | peer->go_neg_conf = NULL; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1871 | |
| 1872 | p2p_set_state(p2p, P2P_PROVISIONING); |
| 1873 | p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); |
| 1874 | } |
| 1875 | |
| 1876 | |
| 1877 | static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa, |
| 1878 | const u8 *data, size_t len, int rx_freq) |
| 1879 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1880 | p2p_dbg(p2p, "RX P2P Public Action from " MACSTR, MAC2STR(sa)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1881 | wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len); |
| 1882 | |
| 1883 | if (len < 1) |
| 1884 | return; |
| 1885 | |
| 1886 | switch (data[0]) { |
| 1887 | case P2P_GO_NEG_REQ: |
| 1888 | p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq); |
| 1889 | break; |
| 1890 | case P2P_GO_NEG_RESP: |
| 1891 | p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq); |
| 1892 | break; |
| 1893 | case P2P_GO_NEG_CONF: |
| 1894 | p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1); |
| 1895 | break; |
| 1896 | case P2P_INVITATION_REQ: |
| 1897 | p2p_process_invitation_req(p2p, sa, data + 1, len - 1, |
| 1898 | rx_freq); |
| 1899 | break; |
| 1900 | case P2P_INVITATION_RESP: |
| 1901 | p2p_process_invitation_resp(p2p, sa, data + 1, len - 1); |
| 1902 | break; |
| 1903 | case P2P_PROV_DISC_REQ: |
| 1904 | p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq); |
| 1905 | break; |
| 1906 | case P2P_PROV_DISC_RESP: |
| 1907 | p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1); |
| 1908 | break; |
| 1909 | case P2P_DEV_DISC_REQ: |
| 1910 | p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq); |
| 1911 | break; |
| 1912 | case P2P_DEV_DISC_RESP: |
| 1913 | p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1); |
| 1914 | break; |
| 1915 | default: |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1916 | p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1917 | data[0]); |
| 1918 | break; |
| 1919 | } |
| 1920 | } |
| 1921 | |
| 1922 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 1923 | static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da, |
| 1924 | const u8 *sa, const u8 *bssid, const u8 *data, |
| 1925 | size_t len, int freq) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1926 | { |
| 1927 | if (len < 1) |
| 1928 | return; |
| 1929 | |
| 1930 | switch (data[0]) { |
| 1931 | case WLAN_PA_VENDOR_SPECIFIC: |
| 1932 | data++; |
| 1933 | len--; |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1934 | if (len < 4) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1935 | return; |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1936 | if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1937 | return; |
| 1938 | |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1939 | data += 4; |
| 1940 | len -= 4; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1941 | |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1942 | p2p_rx_p2p_action(p2p, sa, data, len, freq); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1943 | break; |
| 1944 | case WLAN_PA_GAS_INITIAL_REQ: |
| 1945 | p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq); |
| 1946 | break; |
| 1947 | case WLAN_PA_GAS_INITIAL_RESP: |
| 1948 | p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq); |
| 1949 | break; |
| 1950 | case WLAN_PA_GAS_COMEBACK_REQ: |
| 1951 | p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq); |
| 1952 | break; |
| 1953 | case WLAN_PA_GAS_COMEBACK_RESP: |
| 1954 | p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq); |
| 1955 | break; |
| 1956 | } |
| 1957 | } |
| 1958 | |
| 1959 | |
| 1960 | void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa, |
| 1961 | const u8 *bssid, u8 category, |
| 1962 | const u8 *data, size_t len, int freq) |
| 1963 | { |
| 1964 | if (category == WLAN_ACTION_PUBLIC) { |
| 1965 | p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq); |
| 1966 | return; |
| 1967 | } |
| 1968 | |
| 1969 | if (category != WLAN_ACTION_VENDOR_SPECIFIC) |
| 1970 | return; |
| 1971 | |
| 1972 | if (len < 4) |
| 1973 | return; |
| 1974 | |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1975 | if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1976 | return; |
Dmitry Shmidt | a38abf9 | 2014-03-06 13:38:44 -0800 | [diff] [blame] | 1977 | data += 4; |
| 1978 | len -= 4; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1979 | |
| 1980 | /* P2P action frame */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1981 | p2p_dbg(p2p, "RX P2P Action from " MACSTR, MAC2STR(sa)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1982 | wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len); |
| 1983 | |
| 1984 | if (len < 1) |
| 1985 | return; |
| 1986 | switch (data[0]) { |
| 1987 | case P2P_NOA: |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 1988 | p2p_dbg(p2p, "Received P2P Action - Notice of Absence"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 1989 | /* TODO */ |
| 1990 | break; |
| 1991 | case P2P_PRESENCE_REQ: |
| 1992 | p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq); |
| 1993 | break; |
| 1994 | case P2P_PRESENCE_RESP: |
| 1995 | p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1); |
| 1996 | break; |
| 1997 | case P2P_GO_DISC_REQ: |
| 1998 | p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq); |
| 1999 | break; |
| 2000 | default: |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2001 | p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2002 | break; |
| 2003 | } |
| 2004 | } |
| 2005 | |
| 2006 | |
| 2007 | static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx) |
| 2008 | { |
| 2009 | struct p2p_data *p2p = eloop_ctx; |
| 2010 | if (p2p->go_neg_peer == NULL) |
| 2011 | return; |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 2012 | if (p2p->pending_listen_freq) { |
| 2013 | p2p_dbg(p2p, "Clear pending_listen_freq for p2p_go_neg_start"); |
| 2014 | p2p->pending_listen_freq = 0; |
| 2015 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2016 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
| 2017 | p2p->go_neg_peer->status = P2P_SC_SUCCESS; |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 2018 | /* |
| 2019 | * Set new timeout to make sure a previously set one does not expire |
| 2020 | * too quickly while waiting for the GO Negotiation to complete. |
| 2021 | */ |
| 2022 | p2p_set_timeout(p2p, 0, 500000); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2023 | p2p_connect_send(p2p, p2p->go_neg_peer); |
| 2024 | } |
| 2025 | |
| 2026 | |
| 2027 | static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx) |
| 2028 | { |
| 2029 | struct p2p_data *p2p = eloop_ctx; |
| 2030 | if (p2p->invite_peer == NULL) |
| 2031 | return; |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 2032 | if (p2p->pending_listen_freq) { |
| 2033 | p2p_dbg(p2p, "Clear pending_listen_freq for p2p_invite_start"); |
| 2034 | p2p->pending_listen_freq = 0; |
| 2035 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2036 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 2037 | p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr, |
| 2038 | p2p->invite_dev_pw_id); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2039 | } |
| 2040 | |
| 2041 | |
| 2042 | static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr, |
| 2043 | const u8 *ie, size_t ie_len) |
| 2044 | { |
| 2045 | struct p2p_message msg; |
| 2046 | struct p2p_device *dev; |
| 2047 | |
| 2048 | os_memset(&msg, 0, sizeof(msg)); |
| 2049 | if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL) |
| 2050 | { |
| 2051 | p2p_parse_free(&msg); |
| 2052 | return; /* not a P2P probe */ |
| 2053 | } |
| 2054 | |
| 2055 | if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN || |
| 2056 | os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) |
| 2057 | != 0) { |
| 2058 | /* The Probe Request is not part of P2P Device Discovery. It is |
| 2059 | * not known whether the source address of the frame is the P2P |
| 2060 | * Device Address or P2P Interface Address. Do not add a new |
| 2061 | * peer entry based on this frames. |
| 2062 | */ |
| 2063 | p2p_parse_free(&msg); |
| 2064 | return; |
| 2065 | } |
| 2066 | |
| 2067 | dev = p2p_get_device(p2p, addr); |
| 2068 | if (dev) { |
Dmitry Shmidt | 9c17526 | 2016-03-03 10:20:07 -0800 | [diff] [blame] | 2069 | if (msg.listen_channel) { |
| 2070 | int freq; |
| 2071 | |
| 2072 | if (dev->country[0] == 0) |
| 2073 | os_memcpy(dev->country, msg.listen_channel, 3); |
| 2074 | |
| 2075 | freq = p2p_channel_to_freq(msg.listen_channel[3], |
| 2076 | msg.listen_channel[4]); |
| 2077 | |
| 2078 | if (freq > 0 && dev->listen_freq != freq) { |
| 2079 | p2p_dbg(p2p, |
| 2080 | "Updated peer " MACSTR " Listen channel (Probe Request): %d -> %d MHz", |
| 2081 | MAC2STR(addr), dev->listen_freq, freq); |
| 2082 | dev->listen_freq = freq; |
| 2083 | } |
| 2084 | } |
| 2085 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 2086 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2087 | p2p_parse_free(&msg); |
| 2088 | return; /* already known */ |
| 2089 | } |
| 2090 | |
| 2091 | dev = p2p_create_device(p2p, addr); |
| 2092 | if (dev == NULL) { |
| 2093 | p2p_parse_free(&msg); |
| 2094 | return; |
| 2095 | } |
| 2096 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 2097 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2098 | dev->flags |= P2P_DEV_PROBE_REQ_ONLY; |
| 2099 | |
| 2100 | if (msg.listen_channel) { |
| 2101 | os_memcpy(dev->country, msg.listen_channel, 3); |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 2102 | dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3], |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2103 | msg.listen_channel[4]); |
| 2104 | } |
| 2105 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2106 | p2p_copy_wps_info(p2p, dev, 1, &msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2107 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2108 | if (msg.wfd_subelems) { |
| 2109 | wpabuf_free(dev->info.wfd_subelems); |
| 2110 | dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); |
| 2111 | } |
| 2112 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2113 | p2p_parse_free(&msg); |
| 2114 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2115 | p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2116 | " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d", |
| 2117 | MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab, |
| 2118 | dev->info.group_capab, dev->info.device_name, |
| 2119 | dev->listen_freq); |
| 2120 | } |
| 2121 | |
| 2122 | |
| 2123 | struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p, |
| 2124 | const u8 *addr, |
| 2125 | struct p2p_message *msg) |
| 2126 | { |
| 2127 | struct p2p_device *dev; |
| 2128 | |
| 2129 | dev = p2p_get_device(p2p, addr); |
| 2130 | if (dev) { |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 2131 | os_get_reltime(&dev->last_seen); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2132 | return dev; /* already known */ |
| 2133 | } |
| 2134 | |
| 2135 | dev = p2p_create_device(p2p, addr); |
| 2136 | if (dev == NULL) |
| 2137 | return NULL; |
| 2138 | |
| 2139 | p2p_add_dev_info(p2p, addr, dev, msg); |
| 2140 | |
| 2141 | return dev; |
| 2142 | } |
| 2143 | |
| 2144 | |
| 2145 | static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type) |
| 2146 | { |
| 2147 | if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0) |
| 2148 | return 1; |
| 2149 | if (os_memcmp(dev_type, req_dev_type, 2) == 0 && |
| 2150 | WPA_GET_BE32(&req_dev_type[2]) == 0 && |
| 2151 | WPA_GET_BE16(&req_dev_type[6]) == 0) |
| 2152 | return 1; /* Category match with wildcard OUI/sub-category */ |
| 2153 | return 0; |
| 2154 | } |
| 2155 | |
| 2156 | |
| 2157 | int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[], |
| 2158 | size_t num_req_dev_type) |
| 2159 | { |
| 2160 | size_t i; |
| 2161 | for (i = 0; i < num_req_dev_type; i++) { |
| 2162 | if (dev_type_match(dev_type, req_dev_type[i])) |
| 2163 | return 1; |
| 2164 | } |
| 2165 | return 0; |
| 2166 | } |
| 2167 | |
| 2168 | |
| 2169 | /** |
| 2170 | * p2p_match_dev_type - Match local device type with requested type |
| 2171 | * @p2p: P2P module context from p2p_init() |
| 2172 | * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs) |
| 2173 | * Returns: 1 on match, 0 on mismatch |
| 2174 | * |
| 2175 | * This function can be used to match the Requested Device Type attribute in |
| 2176 | * WPS IE with the local device types for deciding whether to reply to a Probe |
| 2177 | * Request frame. |
| 2178 | */ |
| 2179 | int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps) |
| 2180 | { |
| 2181 | struct wps_parse_attr attr; |
| 2182 | size_t i; |
| 2183 | |
| 2184 | if (wps_parse_msg(wps, &attr)) |
| 2185 | return 1; /* assume no Requested Device Type attributes */ |
| 2186 | |
| 2187 | if (attr.num_req_dev_type == 0) |
| 2188 | return 1; /* no Requested Device Type attributes -> match */ |
| 2189 | |
| 2190 | if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type, |
| 2191 | attr.num_req_dev_type)) |
| 2192 | return 1; /* Own Primary Device Type matches */ |
| 2193 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 2194 | for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2195 | if (dev_type_list_match(p2p->cfg->sec_dev_type[i], |
| 2196 | attr.req_dev_type, |
| 2197 | attr.num_req_dev_type)) |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 2198 | return 1; /* Own Secondary Device Type matches */ |
| 2199 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2200 | |
| 2201 | /* No matching device type found */ |
| 2202 | return 0; |
| 2203 | } |
| 2204 | |
| 2205 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2206 | struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p, |
| 2207 | const u8 *query_hash, |
| 2208 | u8 query_count) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2209 | { |
| 2210 | struct wpabuf *buf; |
| 2211 | u8 *len; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2212 | int pw_id = -1; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2213 | size_t extra = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2214 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2215 | #ifdef CONFIG_WIFI_DISPLAY |
| 2216 | if (p2p->wfd_ie_probe_resp) |
| 2217 | extra = wpabuf_len(p2p->wfd_ie_probe_resp); |
| 2218 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 2219 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 2220 | if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]) |
| 2221 | extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]); |
| 2222 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2223 | if (query_count) |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2224 | extra += MAX_SVC_ADV_IE_LEN; |
| 2225 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2226 | buf = wpabuf_alloc(1000 + extra); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2227 | if (buf == NULL) |
| 2228 | return NULL; |
| 2229 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2230 | if (p2p->go_neg_peer) { |
| 2231 | /* Advertise immediate availability of WPS credential */ |
| 2232 | pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method); |
| 2233 | } |
| 2234 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 2235 | if (p2p_build_wps_ie(p2p, buf, pw_id, 1) < 0) { |
| 2236 | p2p_dbg(p2p, "Failed to build WPS IE for Probe Response"); |
| 2237 | wpabuf_free(buf); |
| 2238 | return NULL; |
| 2239 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2240 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2241 | #ifdef CONFIG_WIFI_DISPLAY |
| 2242 | if (p2p->wfd_ie_probe_resp) |
| 2243 | wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp); |
| 2244 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 2245 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 2246 | if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]) |
| 2247 | wpabuf_put_buf(buf, |
| 2248 | p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]); |
| 2249 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2250 | /* P2P IE */ |
| 2251 | len = p2p_buf_add_ie_hdr(buf); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2252 | p2p_buf_add_capability(buf, p2p->dev_capab & |
| 2253 | ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2254 | if (p2p->ext_listen_interval) |
| 2255 | p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period, |
| 2256 | p2p->ext_listen_interval); |
| 2257 | p2p_buf_add_device_info(buf, p2p, NULL); |
| 2258 | p2p_buf_update_ie_hdr(buf, len); |
| 2259 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2260 | if (query_count) { |
| 2261 | p2p_buf_add_service_instance(buf, p2p, query_count, query_hash, |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2262 | p2p->p2ps_adv_list); |
| 2263 | } |
| 2264 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2265 | return buf; |
| 2266 | } |
| 2267 | |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 2268 | static int p2p_build_probe_resp_buf(struct p2p_data *p2p, struct wpabuf *buf, |
| 2269 | struct wpabuf *ies, |
| 2270 | const u8 *addr, int rx_freq) |
| 2271 | { |
| 2272 | struct ieee80211_mgmt *resp; |
| 2273 | u8 channel, op_class; |
| 2274 | |
| 2275 | resp = wpabuf_put(buf, offsetof(struct ieee80211_mgmt, |
| 2276 | u.probe_resp.variable)); |
| 2277 | |
| 2278 | resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) | |
| 2279 | (WLAN_FC_STYPE_PROBE_RESP << 4)); |
| 2280 | os_memcpy(resp->da, addr, ETH_ALEN); |
| 2281 | os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN); |
| 2282 | os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN); |
| 2283 | resp->u.probe_resp.beacon_int = host_to_le16(100); |
| 2284 | /* hardware or low-level driver will setup seq_ctrl and timestamp */ |
| 2285 | resp->u.probe_resp.capab_info = |
| 2286 | host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE | |
| 2287 | WLAN_CAPABILITY_PRIVACY | |
| 2288 | WLAN_CAPABILITY_SHORT_SLOT_TIME); |
| 2289 | |
| 2290 | wpabuf_put_u8(buf, WLAN_EID_SSID); |
| 2291 | wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN); |
| 2292 | wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); |
| 2293 | |
| 2294 | wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES); |
| 2295 | wpabuf_put_u8(buf, 8); |
| 2296 | wpabuf_put_u8(buf, (60 / 5) | 0x80); |
| 2297 | wpabuf_put_u8(buf, 90 / 5); |
| 2298 | wpabuf_put_u8(buf, (120 / 5) | 0x80); |
| 2299 | wpabuf_put_u8(buf, 180 / 5); |
| 2300 | wpabuf_put_u8(buf, (240 / 5) | 0x80); |
| 2301 | wpabuf_put_u8(buf, 360 / 5); |
| 2302 | wpabuf_put_u8(buf, 480 / 5); |
| 2303 | wpabuf_put_u8(buf, 540 / 5); |
| 2304 | |
| 2305 | if (!rx_freq) { |
| 2306 | channel = p2p->cfg->channel; |
| 2307 | } else if (p2p_freq_to_channel(rx_freq, &op_class, &channel)) { |
| 2308 | p2p_err(p2p, "Failed to convert freq to channel"); |
| 2309 | return -1; |
| 2310 | } |
| 2311 | |
| 2312 | wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS); |
| 2313 | wpabuf_put_u8(buf, 1); |
| 2314 | wpabuf_put_u8(buf, channel); |
| 2315 | |
| 2316 | wpabuf_put_buf(buf, ies); |
| 2317 | |
| 2318 | return 0; |
| 2319 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2320 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2321 | static int p2p_service_find_asp(struct p2p_data *p2p, const u8 *hash) |
| 2322 | { |
| 2323 | struct p2ps_advertisement *adv_data; |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2324 | int any_wfa; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2325 | |
| 2326 | p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list); |
| 2327 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2328 | /* Wildcard org.wi-fi.wfds matches any WFA spec defined service */ |
| 2329 | any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2330 | |
| 2331 | adv_data = p2p->p2ps_adv_list; |
| 2332 | while (adv_data) { |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2333 | if (os_memcmp(hash, adv_data->hash, P2PS_HASH_LEN) == 0) |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2334 | return 1; /* exact hash match */ |
| 2335 | if (any_wfa && |
| 2336 | os_strncmp(adv_data->svc_name, P2PS_WILD_HASH_STR, |
| 2337 | os_strlen(P2PS_WILD_HASH_STR)) == 0) |
| 2338 | return 1; /* WFA service match */ |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2339 | adv_data = adv_data->next; |
| 2340 | } |
| 2341 | |
| 2342 | return 0; |
| 2343 | } |
| 2344 | |
| 2345 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2346 | static enum p2p_probe_req_status |
| 2347 | p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst, |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2348 | const u8 *bssid, const u8 *ie, size_t ie_len, |
| 2349 | unsigned int rx_freq) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2350 | { |
| 2351 | struct ieee802_11_elems elems; |
| 2352 | struct wpabuf *buf; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2353 | struct p2p_message msg; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2354 | struct wpabuf *ies; |
| 2355 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2356 | if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) == |
| 2357 | ParseFailed) { |
| 2358 | /* Ignore invalid Probe Request frames */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2359 | p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2360 | return P2P_PREQ_MALFORMED; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2361 | } |
| 2362 | |
| 2363 | if (elems.p2p == NULL) { |
| 2364 | /* not a P2P probe - ignore it */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2365 | p2p_dbg(p2p, "Not a P2P probe - ignore it"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2366 | return P2P_PREQ_NOT_P2P; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2367 | } |
| 2368 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2369 | if (dst && !is_broadcast_ether_addr(dst) && |
| 2370 | os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) { |
| 2371 | /* Not sent to the broadcast address or our P2P Device Address |
| 2372 | */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2373 | p2p_dbg(p2p, "Probe Req DA " MACSTR " not ours - ignore it", |
| 2374 | MAC2STR(dst)); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2375 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2376 | } |
| 2377 | |
| 2378 | if (bssid && !is_broadcast_ether_addr(bssid)) { |
| 2379 | /* Not sent to the Wildcard BSSID */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2380 | p2p_dbg(p2p, "Probe Req BSSID " MACSTR " not wildcard - ignore it", |
| 2381 | MAC2STR(bssid)); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2382 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2383 | } |
| 2384 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2385 | if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN || |
| 2386 | os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) != |
| 2387 | 0) { |
| 2388 | /* not using P2P Wildcard SSID - ignore */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2389 | p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2390 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2391 | } |
| 2392 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2393 | if (supp_rates_11b_only(&elems)) { |
| 2394 | /* Indicates support for 11b rates only */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2395 | p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2396 | return P2P_PREQ_NOT_P2P; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2397 | } |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2398 | |
| 2399 | os_memset(&msg, 0, sizeof(msg)); |
| 2400 | if (p2p_parse_ies(ie, ie_len, &msg) < 0) { |
| 2401 | /* Could not parse P2P attributes */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2402 | p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2403 | return P2P_PREQ_NOT_P2P; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2404 | } |
| 2405 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2406 | if (msg.service_hash && msg.service_hash_count) { |
| 2407 | const u8 *hash = msg.service_hash; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2408 | u8 i; |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2409 | int p2ps_svc_found = 0; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2410 | |
Dmitry Shmidt | 4171258 | 2015-06-29 11:02:15 -0700 | [diff] [blame] | 2411 | p2p_dbg(p2p, "in_listen=%d drv_in_listen=%d when received P2PS Probe Request at %u MHz; own Listen channel %u, pending listen freq %u MHz", |
| 2412 | p2p->in_listen, p2p->drv_in_listen, rx_freq, |
| 2413 | p2p->cfg->channel, p2p->pending_listen_freq); |
| 2414 | |
| 2415 | if (!p2p->in_listen && !p2p->drv_in_listen && |
| 2416 | p2p->pending_listen_freq && rx_freq && |
| 2417 | rx_freq != p2p->pending_listen_freq) { |
| 2418 | p2p_dbg(p2p, "Do not reply to Probe Request frame that was received on %u MHz while waiting to start Listen state on %u MHz", |
| 2419 | rx_freq, p2p->pending_listen_freq); |
| 2420 | p2p_parse_free(&msg); |
| 2421 | return P2P_PREQ_NOT_LISTEN; |
| 2422 | } |
| 2423 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2424 | for (i = 0; i < msg.service_hash_count; i++) { |
| 2425 | if (p2p_service_find_asp(p2p, hash)) { |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2426 | p2p_dbg(p2p, "Service Hash match found: " |
| 2427 | MACSTR, MAC2STR(hash)); |
| 2428 | p2ps_svc_found = 1; |
| 2429 | break; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2430 | } |
| 2431 | hash += P2PS_HASH_LEN; |
| 2432 | } |
| 2433 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2434 | /* Probed hash unknown */ |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2435 | if (!p2ps_svc_found) { |
| 2436 | p2p_dbg(p2p, "No Service Hash match found"); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2437 | p2p_parse_free(&msg); |
| 2438 | return P2P_PREQ_NOT_PROCESSED; |
| 2439 | } |
| 2440 | } else { |
| 2441 | /* This is not a P2PS Probe Request */ |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2442 | p2p_dbg(p2p, "No P2PS Hash in Probe Request"); |
| 2443 | |
| 2444 | if (!p2p->in_listen || !p2p->drv_in_listen) { |
| 2445 | /* not in Listen state - ignore Probe Request */ |
| 2446 | p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request", |
| 2447 | p2p->in_listen, p2p->drv_in_listen); |
| 2448 | p2p_parse_free(&msg); |
| 2449 | return P2P_PREQ_NOT_LISTEN; |
| 2450 | } |
| 2451 | } |
| 2452 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2453 | if (msg.device_id && |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2454 | os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) { |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2455 | /* Device ID did not match */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2456 | p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR " did not match - ignore it", |
| 2457 | MAC2STR(msg.device_id)); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2458 | p2p_parse_free(&msg); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2459 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2460 | } |
| 2461 | |
| 2462 | /* Check Requested Device Type match */ |
| 2463 | if (msg.wps_attributes && |
| 2464 | !p2p_match_dev_type(p2p, msg.wps_attributes)) { |
| 2465 | /* No match with Requested Device Type */ |
Hai Shalom | 021b0b5 | 2019-04-10 11:17:58 -0700 | [diff] [blame] | 2466 | p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it"); |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2467 | p2p_parse_free(&msg); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2468 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 2469 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2470 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2471 | if (!p2p->cfg->send_probe_resp) { |
| 2472 | /* Response generated elsewhere */ |
Dmitry Shmidt | ec58b16 | 2014-02-19 12:44:18 -0800 | [diff] [blame] | 2473 | p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response"); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2474 | p2p_parse_free(&msg); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2475 | return P2P_PREQ_NOT_PROCESSED; |
| 2476 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2477 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2478 | p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2479 | |
| 2480 | /* |
| 2481 | * We do not really have a specific BSS that this frame is advertising, |
| 2482 | * so build a frame that has some information in valid format. This is |
| 2483 | * really only used for discovery purposes, not to learn exact BSS |
| 2484 | * parameters. |
| 2485 | */ |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2486 | ies = p2p_build_probe_resp_ies(p2p, msg.service_hash, |
| 2487 | msg.service_hash_count); |
| 2488 | p2p_parse_free(&msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2489 | if (ies == NULL) |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2490 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2491 | |
| 2492 | buf = wpabuf_alloc(200 + wpabuf_len(ies)); |
| 2493 | if (buf == NULL) { |
| 2494 | wpabuf_free(ies); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2495 | return P2P_PREQ_NOT_PROCESSED; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2496 | } |
| 2497 | |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 2498 | if (p2p_build_probe_resp_buf(p2p, buf, ies, addr, rx_freq)) { |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2499 | wpabuf_free(ies); |
| 2500 | wpabuf_free(buf); |
| 2501 | return P2P_PREQ_NOT_PROCESSED; |
| 2502 | } |
| 2503 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2504 | wpabuf_free(ies); |
| 2505 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2506 | p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2507 | |
| 2508 | wpabuf_free(buf); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2509 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2510 | return P2P_PREQ_PROCESSED; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2511 | } |
| 2512 | |
| 2513 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2514 | enum p2p_probe_req_status |
| 2515 | p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst, |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2516 | const u8 *bssid, const u8 *ie, size_t ie_len, |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 2517 | unsigned int rx_freq, int p2p_lo_started) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2518 | { |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2519 | enum p2p_probe_req_status res; |
| 2520 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2521 | p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len); |
| 2522 | |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 2523 | if (p2p_lo_started) { |
| 2524 | p2p_dbg(p2p, |
| 2525 | "Probe Response is offloaded, do not reply Probe Request"); |
| 2526 | return P2P_PREQ_PROCESSED; |
| 2527 | } |
| 2528 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2529 | res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len, rx_freq); |
| 2530 | if (res != P2P_PREQ_PROCESSED && res != P2P_PREQ_NOT_PROCESSED) |
| 2531 | return res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2532 | |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2533 | /* |
| 2534 | * Activate a pending GO Negotiation/Invite flow if a received Probe |
| 2535 | * Request frame is from an expected peer. Some devices may share the |
| 2536 | * same address for P2P and non-P2P STA running simultaneously. The |
| 2537 | * P2P_PREQ_PROCESSED and P2P_PREQ_NOT_PROCESSED p2p_reply_probe() |
| 2538 | * return values verified above ensure we are handling a Probe Request |
| 2539 | * frame from a P2P peer. |
| 2540 | */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2541 | if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) && |
| 2542 | p2p->go_neg_peer && |
| 2543 | os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN) |
Dmitry Shmidt | 9cdf1b9 | 2013-02-27 12:58:50 -0800 | [diff] [blame] | 2544 | == 0 && |
| 2545 | !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2546 | /* Received a Probe Request from GO Negotiation peer */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2547 | p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout"); |
Dmitry Shmidt | 9cdf1b9 | 2013-02-27 12:58:50 -0800 | [diff] [blame] | 2548 | eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2549 | eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2550 | return res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2551 | } |
| 2552 | |
| 2553 | if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) && |
| 2554 | p2p->invite_peer && |
Dmitry Shmidt | 3c47937 | 2014-02-04 10:50:36 -0800 | [diff] [blame] | 2555 | (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) && |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2556 | os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN) |
| 2557 | == 0) { |
| 2558 | /* Received a Probe Request from Invite peer */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2559 | p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout"); |
Dmitry Shmidt | 7f93d6f | 2014-02-21 11:22:49 -0800 | [diff] [blame] | 2560 | eloop_cancel_timeout(p2p_invite_start, p2p, NULL); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2561 | eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 2562 | return res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2563 | } |
| 2564 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2565 | return res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2566 | } |
| 2567 | |
| 2568 | |
| 2569 | static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid, |
| 2570 | u8 *buf, size_t len, struct wpabuf *p2p_ie) |
| 2571 | { |
| 2572 | struct wpabuf *tmp; |
| 2573 | u8 *lpos; |
| 2574 | size_t tmplen; |
| 2575 | int res; |
| 2576 | u8 group_capab; |
Dmitry Shmidt | 05df46a | 2015-05-19 11:02:01 -0700 | [diff] [blame] | 2577 | struct p2p_message msg; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2578 | |
| 2579 | if (p2p_ie == NULL) |
| 2580 | return 0; /* WLAN AP is not a P2P manager */ |
| 2581 | |
Dmitry Shmidt | 05df46a | 2015-05-19 11:02:01 -0700 | [diff] [blame] | 2582 | os_memset(&msg, 0, sizeof(msg)); |
| 2583 | if (p2p_parse_p2p_ie(p2p_ie, &msg) < 0) |
| 2584 | return 0; |
| 2585 | |
| 2586 | p2p_dbg(p2p, "BSS P2P manageability %s", |
| 2587 | msg.manageability ? "enabled" : "disabled"); |
| 2588 | |
| 2589 | if (!msg.manageability) |
| 2590 | return 0; |
| 2591 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2592 | /* |
| 2593 | * (Re)Association Request - P2P IE |
| 2594 | * P2P Capability attribute (shall be present) |
| 2595 | * P2P Interface attribute (present if concurrent device and |
| 2596 | * P2P Management is enabled) |
| 2597 | */ |
| 2598 | tmp = wpabuf_alloc(200); |
| 2599 | if (tmp == NULL) |
| 2600 | return -1; |
| 2601 | |
| 2602 | lpos = p2p_buf_add_ie_hdr(tmp); |
| 2603 | group_capab = 0; |
| 2604 | if (p2p->num_groups > 0) { |
| 2605 | group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER; |
| 2606 | if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && |
| 2607 | (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) && |
| 2608 | p2p->cross_connect) |
| 2609 | group_capab |= P2P_GROUP_CAPAB_CROSS_CONN; |
| 2610 | } |
| 2611 | p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab); |
| 2612 | if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && |
| 2613 | (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED)) |
| 2614 | p2p_buf_add_p2p_interface(tmp, p2p); |
| 2615 | p2p_buf_update_ie_hdr(tmp, lpos); |
| 2616 | |
| 2617 | tmplen = wpabuf_len(tmp); |
| 2618 | if (tmplen > len) |
| 2619 | res = -1; |
| 2620 | else { |
| 2621 | os_memcpy(buf, wpabuf_head(tmp), tmplen); |
| 2622 | res = tmplen; |
| 2623 | } |
| 2624 | wpabuf_free(tmp); |
| 2625 | |
| 2626 | return res; |
| 2627 | } |
| 2628 | |
| 2629 | |
| 2630 | int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf, |
| 2631 | size_t len, int p2p_group, struct wpabuf *p2p_ie) |
| 2632 | { |
| 2633 | struct wpabuf *tmp; |
| 2634 | u8 *lpos; |
| 2635 | struct p2p_device *peer; |
| 2636 | size_t tmplen; |
| 2637 | int res; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2638 | size_t extra = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2639 | |
| 2640 | if (!p2p_group) |
| 2641 | return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie); |
| 2642 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2643 | #ifdef CONFIG_WIFI_DISPLAY |
| 2644 | if (p2p->wfd_ie_assoc_req) |
| 2645 | extra = wpabuf_len(p2p->wfd_ie_assoc_req); |
| 2646 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 2647 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 2648 | if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]) |
| 2649 | extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]); |
| 2650 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2651 | /* |
| 2652 | * (Re)Association Request - P2P IE |
| 2653 | * P2P Capability attribute (shall be present) |
| 2654 | * Extended Listen Timing (may be present) |
| 2655 | * P2P Device Info attribute (shall be present) |
| 2656 | */ |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2657 | tmp = wpabuf_alloc(200 + extra); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2658 | if (tmp == NULL) |
| 2659 | return -1; |
| 2660 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 2661 | #ifdef CONFIG_WIFI_DISPLAY |
| 2662 | if (p2p->wfd_ie_assoc_req) |
| 2663 | wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req); |
| 2664 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 2665 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 2666 | if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]) |
| 2667 | wpabuf_put_buf(tmp, |
| 2668 | p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]); |
| 2669 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2670 | peer = bssid ? p2p_get_device(p2p, bssid) : NULL; |
| 2671 | |
| 2672 | lpos = p2p_buf_add_ie_hdr(tmp); |
| 2673 | p2p_buf_add_capability(tmp, p2p->dev_capab, 0); |
| 2674 | if (p2p->ext_listen_interval) |
| 2675 | p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period, |
| 2676 | p2p->ext_listen_interval); |
| 2677 | p2p_buf_add_device_info(tmp, p2p, peer); |
| 2678 | p2p_buf_update_ie_hdr(tmp, lpos); |
| 2679 | |
| 2680 | tmplen = wpabuf_len(tmp); |
| 2681 | if (tmplen > len) |
| 2682 | res = -1; |
| 2683 | else { |
| 2684 | os_memcpy(buf, wpabuf_head(tmp), tmplen); |
| 2685 | res = tmplen; |
| 2686 | } |
| 2687 | wpabuf_free(tmp); |
| 2688 | |
| 2689 | return res; |
| 2690 | } |
| 2691 | |
| 2692 | |
| 2693 | int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end) |
| 2694 | { |
| 2695 | struct wpabuf *p2p_ie; |
| 2696 | int ret; |
| 2697 | |
| 2698 | p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE); |
| 2699 | if (p2p_ie == NULL) |
| 2700 | return 0; |
| 2701 | |
| 2702 | ret = p2p_attr_text(p2p_ie, buf, end); |
| 2703 | wpabuf_free(p2p_ie); |
| 2704 | return ret; |
| 2705 | } |
| 2706 | |
| 2707 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2708 | struct p2ps_advertisement * |
| 2709 | p2p_service_p2ps_id(struct p2p_data *p2p, u32 adv_id) |
| 2710 | { |
| 2711 | struct p2ps_advertisement *adv_data; |
| 2712 | |
| 2713 | if (!p2p) |
| 2714 | return NULL; |
| 2715 | |
| 2716 | adv_data = p2p->p2ps_adv_list; |
| 2717 | while (adv_data) { |
| 2718 | if (adv_data->id == adv_id) |
| 2719 | return adv_data; |
| 2720 | adv_data = adv_data->next; |
| 2721 | } |
| 2722 | |
| 2723 | return NULL; |
| 2724 | } |
| 2725 | |
| 2726 | |
| 2727 | int p2p_service_del_asp(struct p2p_data *p2p, u32 adv_id) |
| 2728 | { |
| 2729 | struct p2ps_advertisement *adv_data; |
| 2730 | struct p2ps_advertisement **prior; |
| 2731 | |
| 2732 | if (!p2p) |
| 2733 | return -1; |
| 2734 | |
| 2735 | adv_data = p2p->p2ps_adv_list; |
| 2736 | prior = &p2p->p2ps_adv_list; |
| 2737 | while (adv_data) { |
| 2738 | if (adv_data->id == adv_id) { |
| 2739 | p2p_dbg(p2p, "Delete ASP adv_id=0x%x", adv_id); |
| 2740 | *prior = adv_data->next; |
| 2741 | os_free(adv_data); |
| 2742 | return 0; |
| 2743 | } |
| 2744 | prior = &adv_data->next; |
| 2745 | adv_data = adv_data->next; |
| 2746 | } |
| 2747 | |
| 2748 | return -1; |
| 2749 | } |
| 2750 | |
| 2751 | |
| 2752 | int p2p_service_add_asp(struct p2p_data *p2p, int auto_accept, u32 adv_id, |
| 2753 | const char *adv_str, u8 svc_state, u16 config_methods, |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 2754 | const char *svc_info, const u8 *cpt_priority) |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2755 | { |
| 2756 | struct p2ps_advertisement *adv_data, *tmp, **prev; |
| 2757 | u8 buf[P2PS_HASH_LEN]; |
| 2758 | size_t adv_data_len, adv_len, info_len = 0; |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 2759 | int i; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2760 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 2761 | if (!p2p || !adv_str || !adv_str[0] || !cpt_priority) |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2762 | return -1; |
| 2763 | |
| 2764 | if (!(config_methods & p2p->cfg->config_methods)) { |
| 2765 | p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x", |
| 2766 | config_methods, p2p->cfg->config_methods); |
| 2767 | return -1; |
| 2768 | } |
| 2769 | |
| 2770 | if (!p2ps_gen_hash(p2p, adv_str, buf)) |
| 2771 | return -1; |
| 2772 | |
| 2773 | if (svc_info) |
| 2774 | info_len = os_strlen(svc_info); |
| 2775 | adv_len = os_strlen(adv_str); |
| 2776 | adv_data_len = sizeof(struct p2ps_advertisement) + adv_len + 1 + |
| 2777 | info_len + 1; |
| 2778 | |
| 2779 | adv_data = os_zalloc(adv_data_len); |
| 2780 | if (!adv_data) |
| 2781 | return -1; |
| 2782 | |
| 2783 | os_memcpy(adv_data->hash, buf, P2PS_HASH_LEN); |
| 2784 | adv_data->id = adv_id; |
| 2785 | adv_data->state = svc_state; |
| 2786 | adv_data->config_methods = config_methods & p2p->cfg->config_methods; |
| 2787 | adv_data->auto_accept = (u8) auto_accept; |
| 2788 | os_memcpy(adv_data->svc_name, adv_str, adv_len); |
| 2789 | |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 2790 | for (i = 0; cpt_priority[i] && i < P2PS_FEATURE_CAPAB_CPT_MAX; i++) { |
| 2791 | adv_data->cpt_priority[i] = cpt_priority[i]; |
| 2792 | adv_data->cpt_mask |= cpt_priority[i]; |
| 2793 | } |
| 2794 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2795 | if (svc_info && info_len) { |
| 2796 | adv_data->svc_info = &adv_data->svc_name[adv_len + 1]; |
| 2797 | os_memcpy(adv_data->svc_info, svc_info, info_len); |
| 2798 | } |
| 2799 | |
| 2800 | /* |
| 2801 | * Group Advertisements by service string. They do not need to be |
| 2802 | * sorted, but groups allow easier Probe Response instance grouping |
| 2803 | */ |
| 2804 | tmp = p2p->p2ps_adv_list; |
| 2805 | prev = &p2p->p2ps_adv_list; |
| 2806 | while (tmp) { |
| 2807 | if (tmp->id == adv_data->id) { |
| 2808 | if (os_strcmp(tmp->svc_name, adv_data->svc_name) != 0) { |
| 2809 | os_free(adv_data); |
| 2810 | return -1; |
| 2811 | } |
| 2812 | adv_data->next = tmp->next; |
| 2813 | *prev = adv_data; |
| 2814 | os_free(tmp); |
| 2815 | goto inserted; |
| 2816 | } else { |
| 2817 | if (os_strcmp(tmp->svc_name, adv_data->svc_name) == 0) { |
| 2818 | adv_data->next = tmp->next; |
| 2819 | tmp->next = adv_data; |
| 2820 | goto inserted; |
| 2821 | } |
| 2822 | } |
| 2823 | prev = &tmp->next; |
| 2824 | tmp = tmp->next; |
| 2825 | } |
| 2826 | |
| 2827 | /* No svc_name match found */ |
| 2828 | adv_data->next = p2p->p2ps_adv_list; |
| 2829 | p2p->p2ps_adv_list = adv_data; |
| 2830 | |
| 2831 | inserted: |
| 2832 | p2p_dbg(p2p, |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 2833 | "Added ASP advertisement adv_id=0x%x config_methods=0x%x svc_state=0x%x adv_str='%s' cpt_mask=0x%x", |
| 2834 | adv_id, adv_data->config_methods, svc_state, adv_str, |
| 2835 | adv_data->cpt_mask); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2836 | |
| 2837 | return 0; |
| 2838 | } |
| 2839 | |
| 2840 | |
Dmitry Shmidt | dda10c2 | 2015-03-24 16:05:01 -0700 | [diff] [blame] | 2841 | void p2p_service_flush_asp(struct p2p_data *p2p) |
| 2842 | { |
| 2843 | struct p2ps_advertisement *adv, *prev; |
| 2844 | |
| 2845 | if (!p2p) |
| 2846 | return; |
| 2847 | |
| 2848 | adv = p2p->p2ps_adv_list; |
| 2849 | while (adv) { |
| 2850 | prev = adv; |
| 2851 | adv = adv->next; |
| 2852 | os_free(prev); |
| 2853 | } |
| 2854 | |
| 2855 | p2p->p2ps_adv_list = NULL; |
Dmitry Shmidt | 9839ecd | 2016-11-07 11:05:47 -0800 | [diff] [blame] | 2856 | p2ps_prov_free(p2p); |
Dmitry Shmidt | dda10c2 | 2015-03-24 16:05:01 -0700 | [diff] [blame] | 2857 | p2p_dbg(p2p, "All ASP advertisements flushed"); |
| 2858 | } |
| 2859 | |
| 2860 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2861 | int p2p_parse_dev_addr_in_p2p_ie(struct wpabuf *p2p_ie, u8 *dev_addr) |
| 2862 | { |
| 2863 | struct p2p_message msg; |
| 2864 | |
| 2865 | os_memset(&msg, 0, sizeof(msg)); |
| 2866 | if (p2p_parse_p2p_ie(p2p_ie, &msg)) |
| 2867 | return -1; |
| 2868 | |
| 2869 | if (msg.p2p_device_addr) { |
| 2870 | os_memcpy(dev_addr, msg.p2p_device_addr, ETH_ALEN); |
| 2871 | return 0; |
| 2872 | } else if (msg.device_id) { |
| 2873 | os_memcpy(dev_addr, msg.device_id, ETH_ALEN); |
| 2874 | return 0; |
| 2875 | } |
| 2876 | return -1; |
| 2877 | } |
| 2878 | |
| 2879 | |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 2880 | int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr) |
| 2881 | { |
| 2882 | struct wpabuf *p2p_ie; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2883 | int ret; |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 2884 | |
| 2885 | p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, |
| 2886 | P2P_IE_VENDOR_TYPE); |
| 2887 | if (p2p_ie == NULL) |
| 2888 | return -1; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2889 | ret = p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr); |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 2890 | wpabuf_free(p2p_ie); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2891 | return ret; |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 2892 | } |
| 2893 | |
| 2894 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2895 | static void p2p_clear_go_neg(struct p2p_data *p2p) |
| 2896 | { |
| 2897 | p2p->go_neg_peer = NULL; |
| 2898 | p2p_clear_timeout(p2p); |
| 2899 | p2p_set_state(p2p, P2P_IDLE); |
| 2900 | } |
| 2901 | |
| 2902 | |
| 2903 | void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr) |
| 2904 | { |
| 2905 | if (p2p->go_neg_peer == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2906 | p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2907 | return; /* No pending Group Formation */ |
| 2908 | } |
| 2909 | |
| 2910 | if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) != |
| 2911 | 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2912 | p2p_dbg(p2p, "Ignore WPS registration success notification for " |
| 2913 | MACSTR " (GO Negotiation peer " MACSTR ")", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2914 | MAC2STR(mac_addr), |
| 2915 | MAC2STR(p2p->go_neg_peer->intended_addr)); |
| 2916 | return; /* Ignore unexpected peer address */ |
| 2917 | } |
| 2918 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2919 | p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2920 | MAC2STR(mac_addr)); |
| 2921 | |
| 2922 | p2p_clear_go_neg(p2p); |
| 2923 | } |
| 2924 | |
| 2925 | |
| 2926 | void p2p_group_formation_failed(struct p2p_data *p2p) |
| 2927 | { |
| 2928 | if (p2p->go_neg_peer == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2929 | p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2930 | return; /* No pending Group Formation */ |
| 2931 | } |
| 2932 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 2933 | p2p_dbg(p2p, "Group Formation failed with " MACSTR, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2934 | MAC2STR(p2p->go_neg_peer->intended_addr)); |
| 2935 | |
| 2936 | p2p_clear_go_neg(p2p); |
| 2937 | } |
| 2938 | |
| 2939 | |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 2940 | bool is_p2p_6ghz_disabled(struct p2p_data *p2p) |
| 2941 | { |
| 2942 | if (p2p) |
| 2943 | return p2p->cfg->p2p_6ghz_disable; |
| 2944 | return false; |
| 2945 | } |
| 2946 | |
| 2947 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2948 | struct p2p_data * p2p_init(const struct p2p_config *cfg) |
| 2949 | { |
| 2950 | struct p2p_data *p2p; |
| 2951 | |
Dmitry Shmidt | 2271d3f | 2014-06-23 12:16:31 -0700 | [diff] [blame] | 2952 | if (cfg->max_peers < 1 || |
| 2953 | cfg->passphrase_len < 8 || cfg->passphrase_len > 63) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2954 | return NULL; |
| 2955 | |
| 2956 | p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg)); |
| 2957 | if (p2p == NULL) |
| 2958 | return NULL; |
| 2959 | p2p->cfg = (struct p2p_config *) (p2p + 1); |
| 2960 | os_memcpy(p2p->cfg, cfg, sizeof(*cfg)); |
| 2961 | if (cfg->dev_name) |
| 2962 | p2p->cfg->dev_name = os_strdup(cfg->dev_name); |
| 2963 | if (cfg->manufacturer) |
| 2964 | p2p->cfg->manufacturer = os_strdup(cfg->manufacturer); |
| 2965 | if (cfg->model_name) |
| 2966 | p2p->cfg->model_name = os_strdup(cfg->model_name); |
| 2967 | if (cfg->model_number) |
| 2968 | p2p->cfg->model_number = os_strdup(cfg->model_number); |
| 2969 | if (cfg->serial_number) |
| 2970 | p2p->cfg->serial_number = os_strdup(cfg->serial_number); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 2971 | if (cfg->pref_chan) { |
| 2972 | p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan * |
| 2973 | sizeof(struct p2p_channel)); |
| 2974 | if (p2p->cfg->pref_chan) { |
| 2975 | os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan, |
| 2976 | cfg->num_pref_chan * |
| 2977 | sizeof(struct p2p_channel)); |
| 2978 | } else |
| 2979 | p2p->cfg->num_pref_chan = 0; |
| 2980 | } |
| 2981 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 2982 | p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash); |
| 2983 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2984 | p2p->min_disc_int = 1; |
| 2985 | p2p->max_disc_int = 3; |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 2986 | p2p->max_disc_tu = -1; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2987 | |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 2988 | if (os_get_random(&p2p->next_tie_breaker, 1) < 0) |
| 2989 | p2p->next_tie_breaker = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 2990 | p2p->next_tie_breaker &= 0x01; |
| 2991 | if (cfg->sd_request) |
| 2992 | p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY; |
| 2993 | p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE; |
| 2994 | if (cfg->concurrent_operations) |
| 2995 | p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER; |
| 2996 | p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 2997 | |
| 2998 | dl_list_init(&p2p->devices); |
| 2999 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3000 | p2p->go_timeout = 100; |
| 3001 | p2p->client_timeout = 20; |
Dmitry Shmidt | 13ca8d8 | 2014-02-20 10:18:40 -0800 | [diff] [blame] | 3002 | p2p->num_p2p_sd_queries = 0; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3003 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 3004 | p2p_dbg(p2p, "initialized"); |
| 3005 | p2p_channels_dump(p2p, "channels", &p2p->cfg->channels); |
| 3006 | p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels); |
| 3007 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3008 | return p2p; |
| 3009 | } |
| 3010 | |
| 3011 | |
| 3012 | void p2p_deinit(struct p2p_data *p2p) |
| 3013 | { |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3014 | #ifdef CONFIG_WIFI_DISPLAY |
| 3015 | wpabuf_free(p2p->wfd_ie_beacon); |
| 3016 | wpabuf_free(p2p->wfd_ie_probe_req); |
| 3017 | wpabuf_free(p2p->wfd_ie_probe_resp); |
| 3018 | wpabuf_free(p2p->wfd_ie_assoc_req); |
| 3019 | wpabuf_free(p2p->wfd_ie_invitation); |
| 3020 | wpabuf_free(p2p->wfd_ie_prov_disc_req); |
| 3021 | wpabuf_free(p2p->wfd_ie_prov_disc_resp); |
| 3022 | wpabuf_free(p2p->wfd_ie_go_neg); |
| 3023 | wpabuf_free(p2p->wfd_dev_info); |
| 3024 | wpabuf_free(p2p->wfd_assoc_bssid); |
| 3025 | wpabuf_free(p2p->wfd_coupled_sink_info); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 3026 | wpabuf_free(p2p->wfd_r2_dev_info); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3027 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 3028 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3029 | eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); |
Dmitry Shmidt | 9cdf1b9 | 2013-02-27 12:58:50 -0800 | [diff] [blame] | 3030 | eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3031 | eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3032 | p2p_flush(p2p); |
| 3033 | p2p_free_req_dev_types(p2p); |
| 3034 | os_free(p2p->cfg->dev_name); |
| 3035 | os_free(p2p->cfg->manufacturer); |
| 3036 | os_free(p2p->cfg->model_name); |
| 3037 | os_free(p2p->cfg->model_number); |
| 3038 | os_free(p2p->cfg->serial_number); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3039 | os_free(p2p->cfg->pref_chan); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3040 | os_free(p2p->groups); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 3041 | p2ps_prov_free(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3042 | wpabuf_free(p2p->sd_resp); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3043 | p2p_remove_wps_vendor_extensions(p2p); |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 3044 | os_free(p2p->no_go_freq.range); |
Dmitry Shmidt | dda10c2 | 2015-03-24 16:05:01 -0700 | [diff] [blame] | 3045 | p2p_service_flush_asp(p2p); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3046 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3047 | os_free(p2p); |
| 3048 | } |
| 3049 | |
| 3050 | |
| 3051 | void p2p_flush(struct p2p_data *p2p) |
| 3052 | { |
| 3053 | struct p2p_device *dev, *prev; |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 3054 | |
| 3055 | p2p_ext_listen(p2p, 0, 0); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3056 | p2p_stop_find(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3057 | dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device, |
| 3058 | list) { |
| 3059 | dl_list_del(&dev->list); |
| 3060 | p2p_device_free(p2p, dev); |
| 3061 | } |
| 3062 | p2p_free_sd_queries(p2p); |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 3063 | p2p->ssid_set = 0; |
Dmitry Shmidt | 9839ecd | 2016-11-07 11:05:47 -0800 | [diff] [blame] | 3064 | p2ps_prov_free(p2p); |
| 3065 | p2p_reset_pending_pd(p2p); |
Dmitry Shmidt | ebd93af | 2017-02-21 13:40:44 -0800 | [diff] [blame] | 3066 | p2p->override_pref_op_class = 0; |
| 3067 | p2p->override_pref_channel = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3068 | } |
| 3069 | |
| 3070 | |
| 3071 | int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr) |
| 3072 | { |
| 3073 | struct p2p_device *dev; |
| 3074 | |
| 3075 | dev = p2p_get_device(p2p, addr); |
| 3076 | if (dev == NULL) |
| 3077 | return -1; |
| 3078 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3079 | p2p_dbg(p2p, "Unauthorizing " MACSTR, MAC2STR(addr)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3080 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3081 | if (p2p->go_neg_peer == dev) { |
| 3082 | eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3083 | p2p->go_neg_peer = NULL; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3084 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3085 | |
| 3086 | dev->wps_method = WPS_NOT_READY; |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 3087 | dev->oob_pw_id = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3088 | dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; |
| 3089 | dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; |
| 3090 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3091 | return 0; |
| 3092 | } |
| 3093 | |
| 3094 | |
| 3095 | int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name) |
| 3096 | { |
| 3097 | os_free(p2p->cfg->dev_name); |
| 3098 | if (dev_name) { |
| 3099 | p2p->cfg->dev_name = os_strdup(dev_name); |
| 3100 | if (p2p->cfg->dev_name == NULL) |
| 3101 | return -1; |
| 3102 | } else |
| 3103 | p2p->cfg->dev_name = NULL; |
| 3104 | return 0; |
| 3105 | } |
| 3106 | |
| 3107 | |
| 3108 | int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer) |
| 3109 | { |
| 3110 | os_free(p2p->cfg->manufacturer); |
| 3111 | p2p->cfg->manufacturer = NULL; |
| 3112 | if (manufacturer) { |
| 3113 | p2p->cfg->manufacturer = os_strdup(manufacturer); |
| 3114 | if (p2p->cfg->manufacturer == NULL) |
| 3115 | return -1; |
| 3116 | } |
| 3117 | |
| 3118 | return 0; |
| 3119 | } |
| 3120 | |
| 3121 | |
| 3122 | int p2p_set_model_name(struct p2p_data *p2p, const char *model_name) |
| 3123 | { |
| 3124 | os_free(p2p->cfg->model_name); |
| 3125 | p2p->cfg->model_name = NULL; |
| 3126 | if (model_name) { |
| 3127 | p2p->cfg->model_name = os_strdup(model_name); |
| 3128 | if (p2p->cfg->model_name == NULL) |
| 3129 | return -1; |
| 3130 | } |
| 3131 | |
| 3132 | return 0; |
| 3133 | } |
| 3134 | |
| 3135 | |
| 3136 | int p2p_set_model_number(struct p2p_data *p2p, const char *model_number) |
| 3137 | { |
| 3138 | os_free(p2p->cfg->model_number); |
| 3139 | p2p->cfg->model_number = NULL; |
| 3140 | if (model_number) { |
| 3141 | p2p->cfg->model_number = os_strdup(model_number); |
| 3142 | if (p2p->cfg->model_number == NULL) |
| 3143 | return -1; |
| 3144 | } |
| 3145 | |
| 3146 | return 0; |
| 3147 | } |
| 3148 | |
| 3149 | |
| 3150 | int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number) |
| 3151 | { |
| 3152 | os_free(p2p->cfg->serial_number); |
| 3153 | p2p->cfg->serial_number = NULL; |
| 3154 | if (serial_number) { |
| 3155 | p2p->cfg->serial_number = os_strdup(serial_number); |
| 3156 | if (p2p->cfg->serial_number == NULL) |
| 3157 | return -1; |
| 3158 | } |
| 3159 | |
| 3160 | return 0; |
| 3161 | } |
| 3162 | |
| 3163 | |
| 3164 | void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods) |
| 3165 | { |
| 3166 | p2p->cfg->config_methods = config_methods; |
| 3167 | } |
| 3168 | |
| 3169 | |
| 3170 | void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid) |
| 3171 | { |
| 3172 | os_memcpy(p2p->cfg->uuid, uuid, 16); |
| 3173 | } |
| 3174 | |
| 3175 | |
| 3176 | int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type) |
| 3177 | { |
| 3178 | os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8); |
| 3179 | return 0; |
| 3180 | } |
| 3181 | |
| 3182 | |
| 3183 | int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8], |
| 3184 | size_t num_dev_types) |
| 3185 | { |
| 3186 | if (num_dev_types > P2P_SEC_DEVICE_TYPES) |
| 3187 | num_dev_types = P2P_SEC_DEVICE_TYPES; |
| 3188 | p2p->cfg->num_sec_dev_types = num_dev_types; |
| 3189 | os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8); |
| 3190 | return 0; |
| 3191 | } |
| 3192 | |
| 3193 | |
| 3194 | void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p) |
| 3195 | { |
| 3196 | int i; |
| 3197 | |
| 3198 | for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { |
| 3199 | wpabuf_free(p2p->wps_vendor_ext[i]); |
| 3200 | p2p->wps_vendor_ext[i] = NULL; |
| 3201 | } |
| 3202 | } |
| 3203 | |
| 3204 | |
| 3205 | int p2p_add_wps_vendor_extension(struct p2p_data *p2p, |
| 3206 | const struct wpabuf *vendor_ext) |
| 3207 | { |
| 3208 | int i; |
| 3209 | |
| 3210 | if (vendor_ext == NULL) |
| 3211 | return -1; |
| 3212 | |
| 3213 | for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { |
| 3214 | if (p2p->wps_vendor_ext[i] == NULL) |
| 3215 | break; |
| 3216 | } |
| 3217 | if (i >= P2P_MAX_WPS_VENDOR_EXT) |
| 3218 | return -1; |
| 3219 | |
| 3220 | p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext); |
| 3221 | if (p2p->wps_vendor_ext[i] == NULL) |
| 3222 | return -1; |
| 3223 | |
| 3224 | return 0; |
| 3225 | } |
| 3226 | |
| 3227 | |
| 3228 | int p2p_set_country(struct p2p_data *p2p, const char *country) |
| 3229 | { |
| 3230 | os_memcpy(p2p->cfg->country, country, 3); |
| 3231 | return 0; |
| 3232 | } |
| 3233 | |
| 3234 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3235 | static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev) |
| 3236 | { |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3237 | int res; |
| 3238 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3239 | if (dev->sd_pending_bcast_queries == 0) { |
| 3240 | /* Initialize with total number of registered broadcast |
| 3241 | * SD queries. */ |
| 3242 | dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries; |
| 3243 | } |
| 3244 | |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3245 | res = p2p_start_sd(p2p, dev); |
| 3246 | if (res == -2) |
| 3247 | return -2; |
| 3248 | if (res == 0) |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3249 | return 1; |
| 3250 | |
| 3251 | if (dev->req_config_methods && |
| 3252 | !(dev->flags & P2P_DEV_PD_FOR_JOIN)) { |
| 3253 | p2p_dbg(p2p, "Send pending Provision Discovery Request to " |
| 3254 | MACSTR " (config methods 0x%x)", |
| 3255 | MAC2STR(dev->info.p2p_device_addr), |
| 3256 | dev->req_config_methods); |
| 3257 | if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0) |
| 3258 | return 1; |
| 3259 | } |
| 3260 | |
| 3261 | return 0; |
| 3262 | } |
| 3263 | |
| 3264 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3265 | void p2p_continue_find(struct p2p_data *p2p) |
| 3266 | { |
| 3267 | struct p2p_device *dev; |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3268 | int found, res; |
Dmitry Shmidt | 13ca8d8 | 2014-02-20 10:18:40 -0800 | [diff] [blame] | 3269 | |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3270 | p2p_set_state(p2p, P2P_SEARCH); |
| 3271 | |
| 3272 | /* Continue from the device following the last iteration */ |
| 3273 | found = 0; |
| 3274 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 3275 | if (dev == p2p->last_p2p_find_oper) { |
| 3276 | found = 1; |
| 3277 | continue; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3278 | } |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3279 | if (!found) |
| 3280 | continue; |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3281 | res = p2p_pre_find_operation(p2p, dev); |
| 3282 | if (res > 0) { |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3283 | p2p->last_p2p_find_oper = dev; |
| 3284 | return; |
| 3285 | } |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3286 | if (res == -2) |
| 3287 | goto skip_sd; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3288 | } |
| 3289 | |
| 3290 | /* |
| 3291 | * Wrap around to the beginning of the list and continue until the last |
| 3292 | * iteration device. |
| 3293 | */ |
| 3294 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3295 | res = p2p_pre_find_operation(p2p, dev); |
| 3296 | if (res > 0) { |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3297 | p2p->last_p2p_find_oper = dev; |
| 3298 | return; |
| 3299 | } |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3300 | if (res == -2) |
| 3301 | goto skip_sd; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3302 | if (dev == p2p->last_p2p_find_oper) |
| 3303 | break; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3304 | } |
| 3305 | |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3306 | skip_sd: |
| 3307 | os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 3308 | p2p_listen_in_find(p2p, 1); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3309 | } |
| 3310 | |
| 3311 | |
| 3312 | static void p2p_sd_cb(struct p2p_data *p2p, int success) |
| 3313 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3314 | p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3315 | success); |
| 3316 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3317 | |
| 3318 | if (!success) { |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3319 | if (p2p->sd_peer) { |
| 3320 | if (is_zero_ether_addr(p2p->sd_query_no_ack)) { |
| 3321 | os_memcpy(p2p->sd_query_no_ack, |
| 3322 | p2p->sd_peer->info.p2p_device_addr, |
| 3323 | ETH_ALEN); |
| 3324 | p2p_dbg(p2p, |
| 3325 | "First SD Query no-ACK in this search iteration: " |
| 3326 | MACSTR, MAC2STR(p2p->sd_query_no_ack)); |
| 3327 | } |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3328 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3329 | } |
Dmitry Shmidt | 13ca8d8 | 2014-02-20 10:18:40 -0800 | [diff] [blame] | 3330 | p2p->sd_peer = NULL; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3331 | if (p2p->state != P2P_IDLE) |
| 3332 | p2p_continue_find(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3333 | return; |
| 3334 | } |
| 3335 | |
| 3336 | if (p2p->sd_peer == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3337 | p2p_dbg(p2p, "No SD peer entry known"); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3338 | if (p2p->state != P2P_IDLE) |
| 3339 | p2p_continue_find(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3340 | return; |
| 3341 | } |
| 3342 | |
Dmitry Shmidt | 807291d | 2015-01-27 13:40:23 -0800 | [diff] [blame] | 3343 | if (p2p->sd_query && p2p->sd_query->for_all_peers) { |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 3344 | /* Update the pending broadcast SD query count for this device |
| 3345 | */ |
| 3346 | p2p->sd_peer->sd_pending_bcast_queries--; |
| 3347 | |
| 3348 | /* |
| 3349 | * If there are no pending broadcast queries for this device, |
| 3350 | * mark it as done (-1). |
| 3351 | */ |
| 3352 | if (p2p->sd_peer->sd_pending_bcast_queries == 0) |
| 3353 | p2p->sd_peer->sd_pending_bcast_queries = -1; |
| 3354 | } |
| 3355 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3356 | /* Wait for response from the peer */ |
| 3357 | p2p_set_state(p2p, P2P_SD_DURING_FIND); |
| 3358 | p2p_set_timeout(p2p, 0, 200000); |
| 3359 | } |
| 3360 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3361 | |
| 3362 | /** |
| 3363 | * p2p_retry_pd - Retry any pending provision disc requests in IDLE state |
| 3364 | * @p2p: P2P module context from p2p_init() |
| 3365 | */ |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 3366 | static void p2p_retry_pd(struct p2p_data *p2p) |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3367 | { |
| 3368 | struct p2p_device *dev; |
| 3369 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3370 | /* |
| 3371 | * Retry the prov disc req attempt only for the peer that the user had |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 3372 | * requested. |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3373 | */ |
| 3374 | |
| 3375 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 3376 | if (os_memcmp(p2p->pending_pd_devaddr, |
| 3377 | dev->info.p2p_device_addr, ETH_ALEN) != 0) |
| 3378 | continue; |
| 3379 | if (!dev->req_config_methods) |
| 3380 | continue; |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3381 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3382 | p2p_dbg(p2p, "Send pending Provision Discovery Request to " |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3383 | MACSTR " (config methods 0x%x)", |
| 3384 | MAC2STR(dev->info.p2p_device_addr), |
| 3385 | dev->req_config_methods); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 3386 | p2p_send_prov_disc_req(p2p, dev, |
Dmitry Shmidt | 051af73 | 2013-10-22 13:52:46 -0700 | [diff] [blame] | 3387 | dev->flags & P2P_DEV_PD_FOR_JOIN, |
| 3388 | p2p->pd_force_freq); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3389 | return; |
| 3390 | } |
| 3391 | } |
| 3392 | |
| 3393 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3394 | static void p2p_prov_disc_cb(struct p2p_data *p2p, int success) |
| 3395 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3396 | p2p_dbg(p2p, "Provision Discovery Request TX callback: success=%d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3397 | success); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3398 | |
| 3399 | /* |
| 3400 | * Postpone resetting the pending action state till after we actually |
| 3401 | * time out. This allows us to take some action like notifying any |
| 3402 | * interested parties about no response to the request. |
| 3403 | * |
| 3404 | * When the timer (below) goes off we check in IDLE, SEARCH, or |
| 3405 | * LISTEN_ONLY state, which are the only allowed states to issue a PD |
| 3406 | * requests in, if this was still pending and then raise notification. |
| 3407 | */ |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3408 | |
| 3409 | if (!success) { |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3410 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3411 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3412 | if (p2p->user_initiated_pd && |
| 3413 | (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY)) |
| 3414 | { |
| 3415 | /* Retry request from timeout to avoid busy loops */ |
| 3416 | p2p->pending_action_state = P2P_PENDING_PD; |
| 3417 | p2p_set_timeout(p2p, 0, 50000); |
| 3418 | } else if (p2p->state != P2P_IDLE) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3419 | p2p_continue_find(p2p); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3420 | else if (p2p->user_initiated_pd) { |
| 3421 | p2p->pending_action_state = P2P_PENDING_PD; |
| 3422 | p2p_set_timeout(p2p, 0, 300000); |
| 3423 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3424 | return; |
| 3425 | } |
| 3426 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3427 | /* |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 3428 | * If after PD Request the peer doesn't expect to receive PD Response |
| 3429 | * the PD Request ACK indicates a completion of the current PD. This |
| 3430 | * happens only on the advertiser side sending the follow-on PD Request |
| 3431 | * with the status different than 12 (Success: accepted by user). |
| 3432 | */ |
| 3433 | if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker && |
| 3434 | p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) { |
| 3435 | p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK"); |
| 3436 | |
| 3437 | if (p2p->send_action_in_progress) { |
| 3438 | p2p->send_action_in_progress = 0; |
| 3439 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 3440 | } |
| 3441 | |
| 3442 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3443 | |
| 3444 | if (p2p->cfg->p2ps_prov_complete) { |
| 3445 | p2p->cfg->p2ps_prov_complete( |
| 3446 | p2p->cfg->cb_ctx, |
| 3447 | p2p->p2ps_prov->status, |
| 3448 | p2p->p2ps_prov->adv_mac, |
| 3449 | p2p->p2ps_prov->adv_mac, |
| 3450 | p2p->p2ps_prov->session_mac, |
| 3451 | NULL, p2p->p2ps_prov->adv_id, |
| 3452 | p2p->p2ps_prov->session_id, |
| 3453 | 0, 0, NULL, 0, 0, 0, |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3454 | NULL, NULL, 0, 0, NULL, 0); |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 3455 | } |
| 3456 | |
| 3457 | if (p2p->user_initiated_pd) |
| 3458 | p2p_reset_pending_pd(p2p); |
| 3459 | |
| 3460 | p2ps_prov_free(p2p); |
| 3461 | return; |
| 3462 | } |
| 3463 | |
| 3464 | /* |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 3465 | * This postponing, of resetting pending_action_state, needs to be |
| 3466 | * done only for user initiated PD requests and not internal ones. |
| 3467 | */ |
| 3468 | if (p2p->user_initiated_pd) |
| 3469 | p2p->pending_action_state = P2P_PENDING_PD; |
| 3470 | else |
| 3471 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3472 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3473 | /* Wait for response from the peer */ |
| 3474 | if (p2p->state == P2P_SEARCH) |
| 3475 | p2p_set_state(p2p, P2P_PD_DURING_FIND); |
| 3476 | p2p_set_timeout(p2p, 0, 200000); |
| 3477 | } |
| 3478 | |
| 3479 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3480 | static void p2p_prov_disc_resp_cb(struct p2p_data *p2p, int success) |
| 3481 | { |
| 3482 | p2p_dbg(p2p, "Provision Discovery Response TX callback: success=%d", |
| 3483 | success); |
| 3484 | |
| 3485 | if (p2p->send_action_in_progress) { |
| 3486 | p2p->send_action_in_progress = 0; |
| 3487 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 3488 | } |
| 3489 | |
| 3490 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3491 | |
Jimmy Chen | 5ef7aad | 2019-10-15 15:45:26 +0800 | [diff] [blame] | 3492 | if (!success) { |
| 3493 | if (p2p->state == P2P_SEARCH) |
| 3494 | p2p_continue_find(p2p); |
Hai Shalom | 81f62d8 | 2019-07-22 12:10:00 -0700 | [diff] [blame] | 3495 | return; |
Jimmy Chen | 5ef7aad | 2019-10-15 15:45:26 +0800 | [diff] [blame] | 3496 | } |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3497 | |
| 3498 | if (!p2p->cfg->prov_disc_resp_cb || |
Jimmy Chen | 5ef7aad | 2019-10-15 15:45:26 +0800 | [diff] [blame] | 3499 | p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1) { |
| 3500 | if (p2p->state == P2P_SEARCH) |
| 3501 | p2p_continue_find(p2p); |
Hai Shalom | 81f62d8 | 2019-07-22 12:10:00 -0700 | [diff] [blame] | 3502 | return; |
Jimmy Chen | 5ef7aad | 2019-10-15 15:45:26 +0800 | [diff] [blame] | 3503 | } |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3504 | |
| 3505 | p2p_dbg(p2p, |
| 3506 | "Post-Provision Discovery operations started - do not try to continue other P2P operations"); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3507 | } |
| 3508 | |
| 3509 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3510 | int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq, |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 3511 | struct os_reltime *rx_time, int level, const u8 *ies, |
Dmitry Shmidt | a54fa5f | 2013-01-15 13:53:35 -0800 | [diff] [blame] | 3512 | size_t ies_len) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3513 | { |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 3514 | if (os_reltime_before(rx_time, &p2p->find_start)) { |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 3515 | /* |
| 3516 | * The driver may have cached (e.g., in cfg80211 BSS table) the |
| 3517 | * scan results for relatively long time. To avoid reporting |
| 3518 | * stale information, update P2P peers only based on results |
| 3519 | * that have based on frames received after the last p2p_find |
| 3520 | * operation was started. |
| 3521 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3522 | p2p_dbg(p2p, "Ignore old scan result for " MACSTR |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3523 | " (rx_time=%u.%06u find_start=%u.%06u)", |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 3524 | MAC2STR(bssid), (unsigned int) rx_time->sec, |
Dmitry Shmidt | de47be7 | 2016-01-07 12:52:55 -0800 | [diff] [blame] | 3525 | (unsigned int) rx_time->usec, |
| 3526 | (unsigned int) p2p->find_start.sec, |
| 3527 | (unsigned int) p2p->find_start.usec); |
Dmitry Shmidt | f862328 | 2013-02-20 14:34:59 -0800 | [diff] [blame] | 3528 | return 0; |
| 3529 | } |
| 3530 | |
| 3531 | p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3532 | |
| 3533 | return 0; |
| 3534 | } |
| 3535 | |
| 3536 | |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 3537 | void p2p_scan_res_handled(struct p2p_data *p2p, unsigned int delay) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3538 | { |
| 3539 | if (!p2p->p2p_scan_running) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3540 | p2p_dbg(p2p, "p2p_scan was not running, but scan results received"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3541 | } |
| 3542 | p2p->p2p_scan_running = 0; |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 3543 | |
| 3544 | /* Use this delay only when p2p_find doesn't set it */ |
| 3545 | if (!p2p->search_delay) |
| 3546 | p2p->search_delay = delay; |
| 3547 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3548 | eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); |
| 3549 | |
| 3550 | if (p2p_run_after_scan(p2p)) |
| 3551 | return; |
| 3552 | if (p2p->state == P2P_SEARCH) |
| 3553 | p2p_continue_find(p2p); |
| 3554 | } |
| 3555 | |
| 3556 | |
Dmitry Shmidt | 9c17526 | 2016-03-03 10:20:07 -0800 | [diff] [blame] | 3557 | void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id, |
| 3558 | unsigned int bands) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3559 | { |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3560 | u8 dev_capab; |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3561 | u8 *len; |
| 3562 | |
| 3563 | #ifdef CONFIG_WIFI_DISPLAY |
| 3564 | if (p2p->wfd_ie_probe_req) |
| 3565 | wpabuf_put_buf(ies, p2p->wfd_ie_probe_req); |
| 3566 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 3567 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 3568 | if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]) |
| 3569 | wpabuf_put_buf(ies, |
| 3570 | p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]); |
| 3571 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3572 | len = p2p_buf_add_ie_hdr(ies); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3573 | |
| 3574 | dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 3575 | |
| 3576 | /* P2PS requires Probe Request frames to include SD bit */ |
| 3577 | if (p2p->p2ps_seek && p2p->p2ps_seek_count) |
| 3578 | dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY; |
| 3579 | |
| 3580 | p2p_buf_add_capability(ies, dev_capab, 0); |
| 3581 | |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 3582 | if (dev_id) |
| 3583 | p2p_buf_add_device_id(ies, dev_id); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3584 | if (p2p->cfg->reg_class && p2p->cfg->channel) |
| 3585 | p2p_buf_add_listen_channel(ies, p2p->cfg->country, |
| 3586 | p2p->cfg->reg_class, |
| 3587 | p2p->cfg->channel); |
| 3588 | if (p2p->ext_listen_interval) |
| 3589 | p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period, |
| 3590 | p2p->ext_listen_interval); |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3591 | |
Dmitry Shmidt | 9c17526 | 2016-03-03 10:20:07 -0800 | [diff] [blame] | 3592 | if (bands & BAND_60_GHZ) |
| 3593 | p2p_buf_add_device_info(ies, p2p, NULL); |
| 3594 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3595 | if (p2p->p2ps_seek && p2p->p2ps_seek_count) |
| 3596 | p2p_buf_add_service_hash(ies, p2p); |
| 3597 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3598 | /* TODO: p2p_buf_add_operating_channel() if GO */ |
| 3599 | p2p_buf_update_ie_hdr(ies, len); |
| 3600 | } |
| 3601 | |
| 3602 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 3603 | size_t p2p_scan_ie_buf_len(struct p2p_data *p2p) |
| 3604 | { |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3605 | size_t len = 100; |
| 3606 | |
| 3607 | #ifdef CONFIG_WIFI_DISPLAY |
| 3608 | if (p2p && p2p->wfd_ie_probe_req) |
| 3609 | len += wpabuf_len(p2p->wfd_ie_probe_req); |
| 3610 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 3611 | |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 3612 | if (p2p && p2p->vendor_elem && |
| 3613 | p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]) |
| 3614 | len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]); |
| 3615 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3616 | return len; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 3617 | } |
| 3618 | |
| 3619 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3620 | int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end) |
| 3621 | { |
| 3622 | return p2p_attr_text(p2p_ie, buf, end); |
| 3623 | } |
| 3624 | |
| 3625 | |
| 3626 | static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success) |
| 3627 | { |
| 3628 | struct p2p_device *dev = p2p->go_neg_peer; |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3629 | int timeout; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3630 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3631 | p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3632 | |
| 3633 | if (dev == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3634 | p2p_dbg(p2p, "No pending GO Negotiation"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3635 | return; |
| 3636 | } |
| 3637 | |
| 3638 | if (success) { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3639 | if (dev->flags & P2P_DEV_USER_REJECTED) { |
| 3640 | p2p_set_state(p2p, P2P_IDLE); |
| 3641 | return; |
| 3642 | } |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3643 | } else if (dev->go_neg_req_sent) { |
| 3644 | /* Cancel the increment from p2p_connect_send() on failure */ |
Dmitry Shmidt | 98f9e76 | 2012-05-30 11:18:46 -0700 | [diff] [blame] | 3645 | dev->go_neg_req_sent--; |
| 3646 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3647 | |
| 3648 | if (!success && |
| 3649 | (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) && |
| 3650 | !is_zero_ether_addr(dev->member_in_go_dev)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3651 | p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability through its GO", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3652 | MAC2STR(dev->info.p2p_device_addr)); |
| 3653 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 3654 | p2p_send_dev_disc_req(p2p, dev); |
| 3655 | return; |
| 3656 | } |
| 3657 | |
| 3658 | /* |
| 3659 | * Use P2P find, if needed, to find the other device from its listen |
| 3660 | * channel. |
| 3661 | */ |
| 3662 | p2p_set_state(p2p, P2P_CONNECT); |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3663 | timeout = success ? 500000 : 100000; |
| 3664 | if (!success && p2p->go_neg_peer && |
| 3665 | (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) { |
| 3666 | unsigned int r; |
| 3667 | /* |
| 3668 | * Peer is expected to wait our response and we will skip the |
| 3669 | * listen phase. Add some randomness to the wait time here to |
| 3670 | * make it less likely to hit cases where we could end up in |
| 3671 | * sync with peer not listening. |
| 3672 | */ |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 3673 | if (os_get_random((u8 *) &r, sizeof(r)) < 0) |
| 3674 | r = 0; |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3675 | timeout += r % 100000; |
| 3676 | } |
| 3677 | p2p_set_timeout(p2p, 0, timeout); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3678 | } |
| 3679 | |
| 3680 | |
| 3681 | static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success) |
| 3682 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3683 | p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3684 | success); |
| 3685 | if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3686 | p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3687 | return; |
| 3688 | } |
| 3689 | p2p_set_state(p2p, P2P_CONNECT); |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3690 | p2p_set_timeout(p2p, 0, 500000); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3691 | } |
| 3692 | |
| 3693 | |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 3694 | static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success, |
| 3695 | const u8 *addr) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3696 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3697 | p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3698 | if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) { |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3699 | p2p_go_neg_failed(p2p, p2p->go_neg_peer->status); |
Dmitry Shmidt | 203eadb | 2015-03-05 14:16:04 -0800 | [diff] [blame] | 3700 | return; |
| 3701 | } |
| 3702 | |
| 3703 | if (success) { |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 3704 | struct p2p_device *dev; |
| 3705 | dev = p2p_get_device(p2p, addr); |
| 3706 | if (dev && |
Dmitry Shmidt | 34c1202 | 2015-03-05 14:11:20 -0800 | [diff] [blame] | 3707 | dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 3708 | dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3709 | } |
Dmitry Shmidt | 203eadb | 2015-03-05 14:16:04 -0800 | [diff] [blame] | 3710 | |
| 3711 | if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND) |
| 3712 | p2p_continue_find(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3713 | } |
| 3714 | |
| 3715 | |
| 3716 | static void p2p_go_neg_conf_cb(struct p2p_data *p2p, |
| 3717 | enum p2p_send_action_result result) |
| 3718 | { |
| 3719 | struct p2p_device *dev; |
| 3720 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3721 | p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3722 | if (result == P2P_SEND_ACTION_FAILED) { |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 3723 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3724 | p2p_go_neg_failed(p2p, -1); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3725 | return; |
| 3726 | } |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 3727 | |
| 3728 | dev = p2p->go_neg_peer; |
| 3729 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3730 | if (result == P2P_SEND_ACTION_NO_ACK) { |
| 3731 | /* |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 3732 | * Retry GO Negotiation Confirmation |
| 3733 | * P2P_GO_NEG_CNF_MAX_RETRY_COUNT times if we did not receive |
| 3734 | * ACK for confirmation. |
| 3735 | */ |
| 3736 | if (dev && dev->go_neg_conf && |
| 3737 | dev->go_neg_conf_sent <= P2P_GO_NEG_CNF_MAX_RETRY_COUNT) { |
| 3738 | p2p_dbg(p2p, "GO Negotiation Confirm retry %d", |
| 3739 | dev->go_neg_conf_sent); |
| 3740 | p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM; |
| 3741 | if (p2p_send_action(p2p, dev->go_neg_conf_freq, |
| 3742 | dev->info.p2p_device_addr, |
| 3743 | p2p->cfg->dev_addr, |
| 3744 | dev->info.p2p_device_addr, |
| 3745 | wpabuf_head(dev->go_neg_conf), |
| 3746 | wpabuf_len(dev->go_neg_conf), 0) >= |
| 3747 | 0) { |
| 3748 | dev->go_neg_conf_sent++; |
| 3749 | return; |
| 3750 | } |
| 3751 | p2p_dbg(p2p, "Failed to re-send Action frame"); |
| 3752 | |
| 3753 | /* |
| 3754 | * Continue with the assumption that the first attempt |
| 3755 | * went through and just the ACK frame was lost. |
| 3756 | */ |
| 3757 | } |
| 3758 | |
| 3759 | /* |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3760 | * It looks like the TX status for GO Negotiation Confirm is |
| 3761 | * often showing failure even when the peer has actually |
| 3762 | * received the frame. Since the peer may change channels |
| 3763 | * immediately after having received the frame, we may not see |
| 3764 | * an Ack for retries, so just dropping a single frame may |
| 3765 | * trigger this. To allow the group formation to succeed if the |
| 3766 | * peer did indeed receive the frame, continue regardless of |
| 3767 | * the TX status. |
| 3768 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3769 | p2p_dbg(p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack was not reported"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3770 | } |
| 3771 | |
Dmitry Shmidt | 413dde7 | 2014-04-11 10:23:22 -0700 | [diff] [blame] | 3772 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 3773 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3774 | if (dev == NULL) |
| 3775 | return; |
| 3776 | |
| 3777 | p2p_go_complete(p2p, dev); |
| 3778 | } |
| 3779 | |
| 3780 | |
| 3781 | void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst, |
| 3782 | const u8 *src, const u8 *bssid, |
| 3783 | enum p2p_send_action_result result) |
| 3784 | { |
| 3785 | enum p2p_pending_action_state state; |
| 3786 | int success; |
| 3787 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3788 | p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3789 | " src=" MACSTR " bssid=" MACSTR " result=%d p2p_state=%s)", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3790 | p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src), |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3791 | MAC2STR(bssid), result, p2p_state_txt(p2p->state)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3792 | success = result == P2P_SEND_ACTION_SUCCESS; |
| 3793 | state = p2p->pending_action_state; |
| 3794 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 3795 | switch (state) { |
| 3796 | case P2P_NO_PENDING_ACTION: |
Dmitry Shmidt | 4582d2a | 2014-02-28 11:14:23 -0800 | [diff] [blame] | 3797 | if (p2p->send_action_in_progress) { |
| 3798 | p2p->send_action_in_progress = 0; |
| 3799 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 3800 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3801 | break; |
| 3802 | case P2P_PENDING_GO_NEG_REQUEST: |
| 3803 | p2p_go_neg_req_cb(p2p, success); |
| 3804 | break; |
| 3805 | case P2P_PENDING_GO_NEG_RESPONSE: |
| 3806 | p2p_go_neg_resp_cb(p2p, success); |
| 3807 | break; |
| 3808 | case P2P_PENDING_GO_NEG_RESPONSE_FAILURE: |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 3809 | p2p_go_neg_resp_failure_cb(p2p, success, dst); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3810 | break; |
| 3811 | case P2P_PENDING_GO_NEG_CONFIRM: |
| 3812 | p2p_go_neg_conf_cb(p2p, result); |
| 3813 | break; |
| 3814 | case P2P_PENDING_SD: |
| 3815 | p2p_sd_cb(p2p, success); |
| 3816 | break; |
| 3817 | case P2P_PENDING_PD: |
| 3818 | p2p_prov_disc_cb(p2p, success); |
| 3819 | break; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 3820 | case P2P_PENDING_PD_RESPONSE: |
| 3821 | p2p_prov_disc_resp_cb(p2p, success); |
| 3822 | break; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3823 | case P2P_PENDING_INVITATION_REQUEST: |
| 3824 | p2p_invitation_req_cb(p2p, success); |
| 3825 | break; |
| 3826 | case P2P_PENDING_INVITATION_RESPONSE: |
| 3827 | p2p_invitation_resp_cb(p2p, success); |
| 3828 | break; |
| 3829 | case P2P_PENDING_DEV_DISC_REQUEST: |
| 3830 | p2p_dev_disc_req_cb(p2p, success); |
| 3831 | break; |
| 3832 | case P2P_PENDING_DEV_DISC_RESPONSE: |
| 3833 | p2p_dev_disc_resp_cb(p2p, success); |
| 3834 | break; |
| 3835 | case P2P_PENDING_GO_DISC_REQ: |
| 3836 | p2p_go_disc_req_cb(p2p, success); |
| 3837 | break; |
| 3838 | } |
| 3839 | } |
| 3840 | |
| 3841 | |
| 3842 | void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq, |
| 3843 | unsigned int duration) |
| 3844 | { |
| 3845 | if (freq == p2p->pending_client_disc_freq) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3846 | p2p_dbg(p2p, "Client discoverability remain-awake completed"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3847 | p2p->pending_client_disc_freq = 0; |
| 3848 | return; |
| 3849 | } |
| 3850 | |
| 3851 | if (freq != p2p->pending_listen_freq) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3852 | p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3853 | freq, duration, p2p->pending_listen_freq); |
| 3854 | return; |
| 3855 | } |
| 3856 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3857 | p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3858 | p2p->pending_listen_sec, p2p->pending_listen_usec, |
| 3859 | p2p->pending_listen_freq); |
| 3860 | p2p->in_listen = 1; |
| 3861 | p2p->drv_in_listen = freq; |
| 3862 | if (p2p->pending_listen_sec || p2p->pending_listen_usec) { |
| 3863 | /* |
| 3864 | * Add 20 msec extra wait to avoid race condition with driver |
| 3865 | * remain-on-channel end event, i.e., give driver more time to |
| 3866 | * complete the operation before our timeout expires. |
| 3867 | */ |
| 3868 | p2p_set_timeout(p2p, p2p->pending_listen_sec, |
| 3869 | p2p->pending_listen_usec + 20000); |
| 3870 | } |
| 3871 | |
| 3872 | p2p->pending_listen_freq = 0; |
| 3873 | } |
| 3874 | |
| 3875 | |
| 3876 | int p2p_listen_end(struct p2p_data *p2p, unsigned int freq) |
| 3877 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3878 | p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3879 | p2p->drv_in_listen = 0; |
| 3880 | if (p2p->in_listen) |
| 3881 | return 0; /* Internal timeout will trigger the next step */ |
| 3882 | |
Roshan Pius | 3a1667e | 2018-07-03 15:17:14 -0700 | [diff] [blame] | 3883 | if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer && |
| 3884 | p2p->pending_listen_freq) { |
| 3885 | /* |
| 3886 | * Better wait a bit if the driver is unable to start |
| 3887 | * offchannel operation for some reason to continue with |
| 3888 | * P2P_WAIT_PEER_(IDLE/CONNECT) state transitions. |
| 3889 | */ |
| 3890 | p2p_dbg(p2p, |
| 3891 | "Listen operation did not seem to start - delay idle phase to avoid busy loop"); |
| 3892 | p2p_set_timeout(p2p, 0, 100000); |
| 3893 | return 1; |
| 3894 | } |
| 3895 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3896 | if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) { |
| 3897 | if (p2p->go_neg_peer->connect_reqs >= 120) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3898 | p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response"); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3899 | p2p_go_neg_failed(p2p, -1); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3900 | return 0; |
| 3901 | } |
| 3902 | |
| 3903 | p2p_set_state(p2p, P2P_CONNECT); |
| 3904 | p2p_connect_send(p2p, p2p->go_neg_peer); |
| 3905 | return 1; |
| 3906 | } else if (p2p->state == P2P_SEARCH) { |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 3907 | if (p2p->p2p_scan_running) { |
| 3908 | /* |
| 3909 | * Search is already in progress. This can happen if |
| 3910 | * an Action frame RX is reported immediately after |
| 3911 | * the end of a remain-on-channel operation and the |
| 3912 | * response frame to that is sent using an offchannel |
| 3913 | * operation while in p2p_find. Avoid an attempt to |
| 3914 | * restart a scan here. |
| 3915 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3916 | p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one"); |
Dmitry Shmidt | c5ec7f5 | 2012-03-06 16:33:24 -0800 | [diff] [blame] | 3917 | return 1; |
| 3918 | } |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3919 | if (p2p->pending_listen_freq) { |
| 3920 | /* |
| 3921 | * Better wait a bit if the driver is unable to start |
| 3922 | * offchannel operation for some reason. p2p_search() |
| 3923 | * will be started from internal timeout. |
| 3924 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3925 | p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop"); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3926 | p2p_set_timeout(p2p, 0, 100000); |
| 3927 | return 1; |
| 3928 | } |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3929 | if (p2p->search_delay) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3930 | p2p_dbg(p2p, "Delay search operation by %u ms", |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 3931 | p2p->search_delay); |
| 3932 | p2p_set_timeout(p2p, p2p->search_delay / 1000, |
| 3933 | (p2p->search_delay % 1000) * 1000); |
| 3934 | return 1; |
| 3935 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3936 | p2p_search(p2p); |
| 3937 | return 1; |
| 3938 | } |
| 3939 | |
| 3940 | return 0; |
| 3941 | } |
| 3942 | |
| 3943 | |
| 3944 | static void p2p_timeout_connect(struct p2p_data *p2p) |
| 3945 | { |
| 3946 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3947 | if (p2p->go_neg_peer && |
| 3948 | (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3949 | p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed"); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3950 | p2p_go_neg_failed(p2p, -1); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 3951 | return; |
| 3952 | } |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3953 | if (p2p->go_neg_peer && |
| 3954 | (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) && |
| 3955 | p2p->go_neg_peer->connect_reqs < 120) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3956 | p2p_dbg(p2p, "Peer expected to wait our response - skip listen"); |
Dmitry Shmidt | 8c65289 | 2013-03-01 10:14:01 -0800 | [diff] [blame] | 3957 | p2p_connect_send(p2p, p2p->go_neg_peer); |
| 3958 | return; |
| 3959 | } |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 3960 | if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) { |
| 3961 | p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)"); |
| 3962 | p2p_set_state(p2p, P2P_CONNECT_LISTEN); |
| 3963 | p2p_set_timeout(p2p, 0, 30000); |
| 3964 | return; |
| 3965 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3966 | p2p_set_state(p2p, P2P_CONNECT_LISTEN); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 3967 | p2p_listen_in_find(p2p, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3968 | } |
| 3969 | |
| 3970 | |
| 3971 | static void p2p_timeout_connect_listen(struct p2p_data *p2p) |
| 3972 | { |
| 3973 | if (p2p->go_neg_peer) { |
| 3974 | if (p2p->drv_in_listen) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3975 | p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3976 | return; |
| 3977 | } |
| 3978 | |
| 3979 | if (p2p->go_neg_peer->connect_reqs >= 120) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 3980 | p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response"); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 3981 | p2p_go_neg_failed(p2p, -1); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3982 | return; |
| 3983 | } |
| 3984 | |
| 3985 | p2p_set_state(p2p, P2P_CONNECT); |
| 3986 | p2p_connect_send(p2p, p2p->go_neg_peer); |
| 3987 | } else |
| 3988 | p2p_set_state(p2p, P2P_IDLE); |
| 3989 | } |
| 3990 | |
| 3991 | |
| 3992 | static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p) |
| 3993 | { |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 3994 | p2p_set_state(p2p, P2P_WAIT_PEER_IDLE); |
Dmitry Shmidt | 1846323 | 2014-01-24 12:29:41 -0800 | [diff] [blame] | 3995 | |
| 3996 | if (p2p->cfg->is_concurrent_session_active && |
| 3997 | p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx)) |
| 3998 | p2p_set_timeout(p2p, 0, 500000); |
| 3999 | else |
| 4000 | p2p_set_timeout(p2p, 0, 200000); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4001 | } |
| 4002 | |
| 4003 | |
| 4004 | static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p) |
| 4005 | { |
| 4006 | struct p2p_device *dev = p2p->go_neg_peer; |
| 4007 | |
| 4008 | if (dev == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4009 | p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4010 | return; |
| 4011 | } |
| 4012 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4013 | p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation"); |
Hai Shalom | 899fcc7 | 2020-10-19 14:38:18 -0700 | [diff] [blame] | 4014 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 4015 | if (p2p->pending_listen_freq) { |
| 4016 | p2p_dbg(p2p, "Clear pending_listen_freq for %s", __func__); |
| 4017 | p2p->pending_listen_freq = 0; |
| 4018 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4019 | p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 4020 | p2p_listen_in_find(p2p, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4021 | } |
| 4022 | |
| 4023 | |
| 4024 | static void p2p_timeout_sd_during_find(struct p2p_data *p2p) |
| 4025 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4026 | p2p_dbg(p2p, "Service Discovery Query timeout"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4027 | if (p2p->sd_peer) { |
| 4028 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4029 | p2p->sd_peer = NULL; |
| 4030 | } |
| 4031 | p2p_continue_find(p2p); |
| 4032 | } |
| 4033 | |
| 4034 | |
| 4035 | static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p) |
| 4036 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4037 | p2p_dbg(p2p, "Provision Discovery Request timeout"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4038 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 4039 | p2p_continue_find(p2p); |
| 4040 | } |
| 4041 | |
| 4042 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4043 | static void p2p_timeout_prov_disc_req(struct p2p_data *p2p) |
| 4044 | { |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4045 | u32 adv_id = 0; |
| 4046 | u8 *adv_mac = NULL; |
| 4047 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4048 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 4049 | |
| 4050 | /* |
| 4051 | * For user initiated PD requests that we have not gotten any responses |
| 4052 | * for while in IDLE state, we retry them a couple of times before |
| 4053 | * giving up. |
| 4054 | */ |
| 4055 | if (!p2p->user_initiated_pd) |
| 4056 | return; |
| 4057 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4058 | p2p_dbg(p2p, "User initiated Provision Discovery Request timeout"); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4059 | |
| 4060 | if (p2p->pd_retries) { |
| 4061 | p2p->pd_retries--; |
| 4062 | p2p_retry_pd(p2p); |
| 4063 | } else { |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 4064 | struct p2p_device *dev; |
| 4065 | int for_join = 0; |
| 4066 | |
| 4067 | dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { |
| 4068 | if (os_memcmp(p2p->pending_pd_devaddr, |
| 4069 | dev->info.p2p_device_addr, ETH_ALEN) != 0) |
| 4070 | continue; |
| 4071 | if (dev->req_config_methods && |
| 4072 | (dev->flags & P2P_DEV_PD_FOR_JOIN)) |
| 4073 | for_join = 1; |
| 4074 | } |
| 4075 | |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4076 | if (p2p->p2ps_prov) { |
| 4077 | adv_id = p2p->p2ps_prov->adv_id; |
| 4078 | adv_mac = p2p->p2ps_prov->adv_mac; |
| 4079 | } |
| 4080 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4081 | if (p2p->cfg->prov_disc_fail) |
| 4082 | p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, |
| 4083 | p2p->pending_pd_devaddr, |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 4084 | for_join ? |
| 4085 | P2P_PROV_DISC_TIMEOUT_JOIN : |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4086 | P2P_PROV_DISC_TIMEOUT, |
| 4087 | adv_id, adv_mac, NULL); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4088 | p2p_reset_pending_pd(p2p); |
| 4089 | } |
| 4090 | } |
| 4091 | |
| 4092 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4093 | static void p2p_timeout_invite(struct p2p_data *p2p) |
| 4094 | { |
| 4095 | p2p->cfg->send_action_done(p2p->cfg->cb_ctx); |
| 4096 | p2p_set_state(p2p, P2P_INVITE_LISTEN); |
| 4097 | if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) { |
| 4098 | /* |
| 4099 | * Better remain on operating channel instead of listen channel |
| 4100 | * when running a group. |
| 4101 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4102 | p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4103 | p2p_set_timeout(p2p, 0, 100000); |
| 4104 | return; |
| 4105 | } |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 4106 | p2p_listen_in_find(p2p, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4107 | } |
| 4108 | |
| 4109 | |
| 4110 | static void p2p_timeout_invite_listen(struct p2p_data *p2p) |
| 4111 | { |
| 4112 | if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) { |
| 4113 | p2p_set_state(p2p, P2P_INVITE); |
| 4114 | p2p_invite_send(p2p, p2p->invite_peer, |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 4115 | p2p->invite_go_dev_addr, p2p->invite_dev_pw_id); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4116 | } else { |
| 4117 | if (p2p->invite_peer) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4118 | p2p_dbg(p2p, "Invitation Request retry limit reached"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4119 | if (p2p->cfg->invitation_result) |
| 4120 | p2p->cfg->invitation_result( |
Dmitry Shmidt | 700a137 | 2013-03-15 14:14:44 -0700 | [diff] [blame] | 4121 | p2p->cfg->cb_ctx, -1, NULL, NULL, |
Dmitry Shmidt | e0e48dc | 2013-11-18 12:00:06 -0800 | [diff] [blame] | 4122 | p2p->invite_peer->info.p2p_device_addr, |
Dmitry Shmidt | 1590709 | 2014-03-25 10:42:57 -0700 | [diff] [blame] | 4123 | 0, 0); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4124 | } |
| 4125 | p2p_set_state(p2p, P2P_IDLE); |
| 4126 | } |
| 4127 | } |
| 4128 | |
| 4129 | |
| 4130 | static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx) |
| 4131 | { |
| 4132 | struct p2p_data *p2p = eloop_ctx; |
| 4133 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4134 | p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4135 | |
| 4136 | p2p->in_listen = 0; |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4137 | if (p2p->drv_in_listen) { |
| 4138 | p2p_dbg(p2p, "Driver is still in listen state - stop it"); |
| 4139 | p2p->cfg->stop_listen(p2p->cfg->cb_ctx); |
| 4140 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4141 | |
| 4142 | switch (p2p->state) { |
| 4143 | case P2P_IDLE: |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4144 | /* Check if we timed out waiting for PD req */ |
| 4145 | if (p2p->pending_action_state == P2P_PENDING_PD) |
| 4146 | p2p_timeout_prov_disc_req(p2p); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4147 | break; |
| 4148 | case P2P_SEARCH: |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4149 | /* Check if we timed out waiting for PD req */ |
| 4150 | if (p2p->pending_action_state == P2P_PENDING_PD) |
| 4151 | p2p_timeout_prov_disc_req(p2p); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 4152 | if (p2p->search_delay && !p2p->in_search_delay) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4153 | p2p_dbg(p2p, "Delay search operation by %u ms", |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 4154 | p2p->search_delay); |
| 4155 | p2p->in_search_delay = 1; |
| 4156 | p2p_set_timeout(p2p, p2p->search_delay / 1000, |
| 4157 | (p2p->search_delay % 1000) * 1000); |
| 4158 | break; |
| 4159 | } |
| 4160 | p2p->in_search_delay = 0; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4161 | p2p_search(p2p); |
| 4162 | break; |
| 4163 | case P2P_CONNECT: |
| 4164 | p2p_timeout_connect(p2p); |
| 4165 | break; |
| 4166 | case P2P_CONNECT_LISTEN: |
| 4167 | p2p_timeout_connect_listen(p2p); |
| 4168 | break; |
| 4169 | case P2P_GO_NEG: |
| 4170 | break; |
| 4171 | case P2P_LISTEN_ONLY: |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4172 | /* Check if we timed out waiting for PD req */ |
| 4173 | if (p2p->pending_action_state == P2P_PENDING_PD) |
| 4174 | p2p_timeout_prov_disc_req(p2p); |
| 4175 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4176 | if (p2p->ext_listen_only) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4177 | p2p_dbg(p2p, "Extended Listen Timing - Listen State completed"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4178 | p2p->ext_listen_only = 0; |
| 4179 | p2p_set_state(p2p, P2P_IDLE); |
| 4180 | } |
| 4181 | break; |
| 4182 | case P2P_WAIT_PEER_CONNECT: |
| 4183 | p2p_timeout_wait_peer_connect(p2p); |
| 4184 | break; |
| 4185 | case P2P_WAIT_PEER_IDLE: |
| 4186 | p2p_timeout_wait_peer_idle(p2p); |
| 4187 | break; |
| 4188 | case P2P_SD_DURING_FIND: |
| 4189 | p2p_timeout_sd_during_find(p2p); |
| 4190 | break; |
| 4191 | case P2P_PROVISIONING: |
| 4192 | break; |
| 4193 | case P2P_PD_DURING_FIND: |
| 4194 | p2p_timeout_prov_disc_during_find(p2p); |
| 4195 | break; |
| 4196 | case P2P_INVITE: |
| 4197 | p2p_timeout_invite(p2p); |
| 4198 | break; |
| 4199 | case P2P_INVITE_LISTEN: |
| 4200 | p2p_timeout_invite_listen(p2p); |
| 4201 | break; |
| 4202 | } |
| 4203 | } |
| 4204 | |
| 4205 | |
| 4206 | int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr) |
| 4207 | { |
| 4208 | struct p2p_device *dev; |
| 4209 | |
| 4210 | dev = p2p_get_device(p2p, peer_addr); |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4211 | p2p_dbg(p2p, "Local request to reject connection attempts by peer " |
| 4212 | MACSTR, MAC2STR(peer_addr)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4213 | if (dev == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4214 | p2p_dbg(p2p, "Peer " MACSTR " unknown", MAC2STR(peer_addr)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4215 | return -1; |
| 4216 | } |
| 4217 | dev->status = P2P_SC_FAIL_REJECTED_BY_USER; |
| 4218 | dev->flags |= P2P_DEV_USER_REJECTED; |
| 4219 | return 0; |
| 4220 | } |
| 4221 | |
| 4222 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4223 | const char * p2p_wps_method_text(enum p2p_wps_method method) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4224 | { |
| 4225 | switch (method) { |
| 4226 | case WPS_NOT_READY: |
| 4227 | return "not-ready"; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4228 | case WPS_PIN_DISPLAY: |
| 4229 | return "Display"; |
| 4230 | case WPS_PIN_KEYPAD: |
| 4231 | return "Keypad"; |
| 4232 | case WPS_PBC: |
| 4233 | return "PBC"; |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 4234 | case WPS_NFC: |
| 4235 | return "NFC"; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4236 | case WPS_P2PS: |
| 4237 | return "P2PS"; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4238 | } |
| 4239 | |
| 4240 | return "??"; |
| 4241 | } |
| 4242 | |
| 4243 | |
| 4244 | static const char * p2p_go_state_text(enum p2p_go_state go_state) |
| 4245 | { |
| 4246 | switch (go_state) { |
| 4247 | case UNKNOWN_GO: |
| 4248 | return "unknown"; |
| 4249 | case LOCAL_GO: |
| 4250 | return "local"; |
| 4251 | case REMOTE_GO: |
| 4252 | return "remote"; |
| 4253 | } |
| 4254 | |
| 4255 | return "??"; |
| 4256 | } |
| 4257 | |
| 4258 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4259 | const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p, |
| 4260 | const u8 *addr, int next) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4261 | { |
| 4262 | struct p2p_device *dev; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4263 | |
| 4264 | if (addr) |
| 4265 | dev = p2p_get_device(p2p, addr); |
| 4266 | else |
| 4267 | dev = dl_list_first(&p2p->devices, struct p2p_device, list); |
| 4268 | |
| 4269 | if (dev && next) { |
| 4270 | dev = dl_list_first(&dev->list, struct p2p_device, list); |
| 4271 | if (&dev->list == &p2p->devices) |
| 4272 | dev = NULL; |
| 4273 | } |
| 4274 | |
| 4275 | if (dev == NULL) |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4276 | return NULL; |
| 4277 | |
| 4278 | return &dev->info; |
| 4279 | } |
| 4280 | |
| 4281 | |
| 4282 | int p2p_get_peer_info_txt(const struct p2p_peer_info *info, |
| 4283 | char *buf, size_t buflen) |
| 4284 | { |
| 4285 | struct p2p_device *dev; |
| 4286 | int res; |
| 4287 | char *pos, *end; |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 4288 | struct os_reltime now; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4289 | |
| 4290 | if (info == NULL) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4291 | return -1; |
| 4292 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4293 | dev = (struct p2p_device *) (((u8 *) info) - |
| 4294 | offsetof(struct p2p_device, info)); |
| 4295 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4296 | pos = buf; |
| 4297 | end = buf + buflen; |
| 4298 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 4299 | os_get_reltime(&now); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4300 | res = os_snprintf(pos, end - pos, |
| 4301 | "age=%d\n" |
| 4302 | "listen_freq=%d\n" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4303 | "wps_method=%s\n" |
| 4304 | "interface_addr=" MACSTR "\n" |
| 4305 | "member_in_go_dev=" MACSTR "\n" |
| 4306 | "member_in_go_iface=" MACSTR "\n" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4307 | "go_neg_req_sent=%d\n" |
| 4308 | "go_state=%s\n" |
| 4309 | "dialog_token=%u\n" |
| 4310 | "intended_addr=" MACSTR "\n" |
| 4311 | "country=%c%c\n" |
| 4312 | "oper_freq=%d\n" |
| 4313 | "req_config_methods=0x%x\n" |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 4314 | "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4315 | "status=%d\n" |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4316 | "invitation_reqs=%u\n", |
| 4317 | (int) (now.sec - dev->last_seen.sec), |
| 4318 | dev->listen_freq, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4319 | p2p_wps_method_text(dev->wps_method), |
| 4320 | MAC2STR(dev->interface_addr), |
| 4321 | MAC2STR(dev->member_in_go_dev), |
| 4322 | MAC2STR(dev->member_in_go_iface), |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4323 | dev->go_neg_req_sent, |
| 4324 | p2p_go_state_text(dev->go_state), |
| 4325 | dev->dialog_token, |
| 4326 | MAC2STR(dev->intended_addr), |
| 4327 | dev->country[0] ? dev->country[0] : '_', |
| 4328 | dev->country[1] ? dev->country[1] : '_', |
| 4329 | dev->oper_freq, |
| 4330 | dev->req_config_methods, |
| 4331 | dev->flags & P2P_DEV_PROBE_REQ_ONLY ? |
| 4332 | "[PROBE_REQ_ONLY]" : "", |
| 4333 | dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "", |
| 4334 | dev->flags & P2P_DEV_NOT_YET_READY ? |
| 4335 | "[NOT_YET_READY]" : "", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4336 | dev->flags & P2P_DEV_PD_PEER_DISPLAY ? |
| 4337 | "[PD_PEER_DISPLAY]" : "", |
| 4338 | dev->flags & P2P_DEV_PD_PEER_KEYPAD ? |
| 4339 | "[PD_PEER_KEYPAD]" : "", |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4340 | dev->flags & P2P_DEV_PD_PEER_P2PS ? |
| 4341 | "[PD_PEER_P2PS]" : "", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4342 | dev->flags & P2P_DEV_USER_REJECTED ? |
| 4343 | "[USER_REJECTED]" : "", |
| 4344 | dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ? |
| 4345 | "[PEER_WAITING_RESPONSE]" : "", |
| 4346 | dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ? |
| 4347 | "[PREFER_PERSISTENT_GROUP]" : "", |
| 4348 | dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ? |
| 4349 | "[WAIT_GO_NEG_RESPONSE]" : "", |
| 4350 | dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ? |
| 4351 | "[WAIT_GO_NEG_CONFIRM]" : "", |
| 4352 | dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ? |
| 4353 | "[GROUP_CLIENT_ONLY]" : "", |
| 4354 | dev->flags & P2P_DEV_FORCE_FREQ ? |
| 4355 | "[FORCE_FREQ]" : "", |
| 4356 | dev->flags & P2P_DEV_PD_FOR_JOIN ? |
| 4357 | "[PD_FOR_JOIN]" : "", |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 4358 | dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT ? |
| 4359 | "[LAST_SEEN_AS_GROUP_CLIENT]" : "", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4360 | dev->status, |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4361 | dev->invitation_reqs); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4362 | if (os_snprintf_error(end - pos, res)) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4363 | return pos - buf; |
| 4364 | pos += res; |
| 4365 | |
| 4366 | if (dev->ext_listen_period) { |
| 4367 | res = os_snprintf(pos, end - pos, |
| 4368 | "ext_listen_period=%u\n" |
| 4369 | "ext_listen_interval=%u\n", |
| 4370 | dev->ext_listen_period, |
| 4371 | dev->ext_listen_interval); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4372 | if (os_snprintf_error(end - pos, res)) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4373 | return pos - buf; |
| 4374 | pos += res; |
| 4375 | } |
| 4376 | |
| 4377 | if (dev->oper_ssid_len) { |
| 4378 | res = os_snprintf(pos, end - pos, |
| 4379 | "oper_ssid=%s\n", |
| 4380 | wpa_ssid_txt(dev->oper_ssid, |
| 4381 | dev->oper_ssid_len)); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4382 | if (os_snprintf_error(end - pos, res)) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4383 | return pos - buf; |
| 4384 | pos += res; |
| 4385 | } |
| 4386 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 4387 | #ifdef CONFIG_WIFI_DISPLAY |
| 4388 | if (dev->info.wfd_subelems) { |
| 4389 | res = os_snprintf(pos, end - pos, "wfd_subelems="); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4390 | if (os_snprintf_error(end - pos, res)) |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 4391 | return pos - buf; |
| 4392 | pos += res; |
| 4393 | |
| 4394 | pos += wpa_snprintf_hex(pos, end - pos, |
| 4395 | wpabuf_head(dev->info.wfd_subelems), |
| 4396 | wpabuf_len(dev->info.wfd_subelems)); |
| 4397 | |
| 4398 | res = os_snprintf(pos, end - pos, "\n"); |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 4399 | if (os_snprintf_error(end - pos, res)) |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 4400 | return pos - buf; |
| 4401 | pos += res; |
| 4402 | } |
| 4403 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 4404 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4405 | return pos - buf; |
| 4406 | } |
| 4407 | |
| 4408 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 4409 | int p2p_peer_known(struct p2p_data *p2p, const u8 *addr) |
| 4410 | { |
| 4411 | return p2p_get_device(p2p, addr) != NULL; |
| 4412 | } |
| 4413 | |
| 4414 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4415 | void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled) |
| 4416 | { |
| 4417 | if (enabled) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4418 | p2p_dbg(p2p, "Client discoverability enabled"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4419 | p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 4420 | } else { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4421 | p2p_dbg(p2p, "Client discoverability disabled"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4422 | p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; |
| 4423 | } |
| 4424 | } |
| 4425 | |
| 4426 | |
| 4427 | static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1, |
| 4428 | u32 duration2, u32 interval2) |
| 4429 | { |
| 4430 | struct wpabuf *req; |
| 4431 | struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL; |
| 4432 | u8 *len; |
| 4433 | |
| 4434 | req = wpabuf_alloc(100); |
| 4435 | if (req == NULL) |
| 4436 | return NULL; |
| 4437 | |
| 4438 | if (duration1 || interval1) { |
| 4439 | os_memset(&desc1, 0, sizeof(desc1)); |
| 4440 | desc1.count_type = 1; |
| 4441 | desc1.duration = duration1; |
| 4442 | desc1.interval = interval1; |
| 4443 | ptr1 = &desc1; |
| 4444 | |
| 4445 | if (duration2 || interval2) { |
| 4446 | os_memset(&desc2, 0, sizeof(desc2)); |
| 4447 | desc2.count_type = 2; |
| 4448 | desc2.duration = duration2; |
| 4449 | desc2.interval = interval2; |
| 4450 | ptr2 = &desc2; |
| 4451 | } |
| 4452 | } |
| 4453 | |
| 4454 | p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1); |
| 4455 | len = p2p_buf_add_ie_hdr(req); |
| 4456 | p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2); |
| 4457 | p2p_buf_update_ie_hdr(req, len); |
| 4458 | |
| 4459 | return req; |
| 4460 | } |
| 4461 | |
| 4462 | |
| 4463 | int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr, |
| 4464 | const u8 *own_interface_addr, unsigned int freq, |
| 4465 | u32 duration1, u32 interval1, u32 duration2, |
| 4466 | u32 interval2) |
| 4467 | { |
| 4468 | struct wpabuf *req; |
| 4469 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4470 | p2p_dbg(p2p, "Send Presence Request to GO " MACSTR |
| 4471 | " (own interface " MACSTR ") freq=%u dur1=%u int1=%u " |
| 4472 | "dur2=%u int2=%u", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4473 | MAC2STR(go_interface_addr), MAC2STR(own_interface_addr), |
| 4474 | freq, duration1, interval1, duration2, interval2); |
| 4475 | |
| 4476 | req = p2p_build_presence_req(duration1, interval1, duration2, |
| 4477 | interval2); |
| 4478 | if (req == NULL) |
| 4479 | return -1; |
| 4480 | |
| 4481 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 4482 | if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr, |
| 4483 | go_interface_addr, |
| 4484 | wpabuf_head(req), wpabuf_len(req), 200) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4485 | p2p_dbg(p2p, "Failed to send Action frame"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4486 | } |
| 4487 | wpabuf_free(req); |
| 4488 | |
| 4489 | return 0; |
| 4490 | } |
| 4491 | |
| 4492 | |
| 4493 | static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa, |
| 4494 | size_t noa_len, u8 dialog_token) |
| 4495 | { |
| 4496 | struct wpabuf *resp; |
| 4497 | u8 *len; |
| 4498 | |
| 4499 | resp = wpabuf_alloc(100 + noa_len); |
| 4500 | if (resp == NULL) |
| 4501 | return NULL; |
| 4502 | |
| 4503 | p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token); |
| 4504 | len = p2p_buf_add_ie_hdr(resp); |
| 4505 | p2p_buf_add_status(resp, status); |
| 4506 | if (noa) { |
| 4507 | wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE); |
| 4508 | wpabuf_put_le16(resp, noa_len); |
| 4509 | wpabuf_put_data(resp, noa, noa_len); |
| 4510 | } else |
| 4511 | p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL); |
| 4512 | p2p_buf_update_ie_hdr(resp, len); |
| 4513 | |
| 4514 | return resp; |
| 4515 | } |
| 4516 | |
| 4517 | |
| 4518 | static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da, |
| 4519 | const u8 *sa, const u8 *data, size_t len, |
| 4520 | int rx_freq) |
| 4521 | { |
| 4522 | struct p2p_message msg; |
| 4523 | u8 status; |
| 4524 | struct wpabuf *resp; |
| 4525 | size_t g; |
| 4526 | struct p2p_group *group = NULL; |
| 4527 | int parsed = 0; |
| 4528 | u8 noa[50]; |
| 4529 | int noa_len; |
| 4530 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4531 | p2p_dbg(p2p, "Received P2P Action - P2P Presence Request"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4532 | |
| 4533 | for (g = 0; g < p2p->num_groups; g++) { |
| 4534 | if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]), |
| 4535 | ETH_ALEN) == 0) { |
| 4536 | group = p2p->groups[g]; |
| 4537 | break; |
| 4538 | } |
| 4539 | } |
| 4540 | if (group == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4541 | p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group " |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4542 | MACSTR, MAC2STR(da)); |
| 4543 | return; |
| 4544 | } |
| 4545 | |
| 4546 | if (p2p_parse(data, len, &msg) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4547 | p2p_dbg(p2p, "Failed to parse P2P Presence Request"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4548 | status = P2P_SC_FAIL_INVALID_PARAMS; |
| 4549 | goto fail; |
| 4550 | } |
| 4551 | parsed = 1; |
| 4552 | |
| 4553 | if (msg.noa == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4554 | p2p_dbg(p2p, "No NoA attribute in P2P Presence Request"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4555 | status = P2P_SC_FAIL_INVALID_PARAMS; |
| 4556 | goto fail; |
| 4557 | } |
| 4558 | |
| 4559 | status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len); |
| 4560 | |
| 4561 | fail: |
| 4562 | if (p2p->cfg->get_noa) |
| 4563 | noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa, |
| 4564 | sizeof(noa)); |
| 4565 | else |
| 4566 | noa_len = -1; |
| 4567 | resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL, |
| 4568 | noa_len > 0 ? noa_len : 0, |
| 4569 | msg.dialog_token); |
| 4570 | if (parsed) |
| 4571 | p2p_parse_free(&msg); |
| 4572 | if (resp == NULL) |
| 4573 | return; |
| 4574 | |
| 4575 | p2p->pending_action_state = P2P_NO_PENDING_ACTION; |
| 4576 | if (p2p_send_action(p2p, rx_freq, sa, da, da, |
| 4577 | wpabuf_head(resp), wpabuf_len(resp), 200) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4578 | p2p_dbg(p2p, "Failed to send Action frame"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4579 | } |
| 4580 | wpabuf_free(resp); |
| 4581 | } |
| 4582 | |
| 4583 | |
| 4584 | static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, |
| 4585 | const u8 *sa, const u8 *data, size_t len) |
| 4586 | { |
| 4587 | struct p2p_message msg; |
| 4588 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4589 | p2p_dbg(p2p, "Received P2P Action - P2P Presence Response"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4590 | |
| 4591 | if (p2p_parse(data, len, &msg) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4592 | p2p_dbg(p2p, "Failed to parse P2P Presence Response"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4593 | return; |
| 4594 | } |
| 4595 | |
| 4596 | if (msg.status == NULL || msg.noa == NULL) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4597 | p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4598 | p2p_parse_free(&msg); |
| 4599 | return; |
| 4600 | } |
| 4601 | |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 4602 | if (p2p->cfg->presence_resp) { |
| 4603 | p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status, |
| 4604 | msg.noa, msg.noa_len); |
| 4605 | } |
| 4606 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4607 | if (*msg.status) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4608 | p2p_dbg(p2p, "P2P Presence Request was rejected: status %u", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4609 | *msg.status); |
| 4610 | p2p_parse_free(&msg); |
| 4611 | return; |
| 4612 | } |
| 4613 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4614 | p2p_dbg(p2p, "P2P Presence Request was accepted"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4615 | wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA", |
| 4616 | msg.noa, msg.noa_len); |
| 4617 | /* TODO: process NoA */ |
| 4618 | p2p_parse_free(&msg); |
| 4619 | } |
| 4620 | |
| 4621 | |
| 4622 | static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx) |
| 4623 | { |
| 4624 | struct p2p_data *p2p = eloop_ctx; |
| 4625 | |
| 4626 | if (p2p->ext_listen_interval) { |
| 4627 | /* Schedule next extended listen timeout */ |
| 4628 | eloop_register_timeout(p2p->ext_listen_interval_sec, |
| 4629 | p2p->ext_listen_interval_usec, |
| 4630 | p2p_ext_listen_timeout, p2p, NULL); |
| 4631 | } |
| 4632 | |
Dmitry Shmidt | 6dc03bd | 2014-05-16 10:40:13 -0700 | [diff] [blame] | 4633 | if ((p2p->cfg->is_p2p_in_progress && |
| 4634 | p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) || |
| 4635 | (p2p->pending_action_state == P2P_PENDING_PD && |
| 4636 | p2p->pd_retries > 0)) { |
Dmitry Shmidt | 5a1480c | 2014-05-12 09:46:02 -0700 | [diff] [blame] | 4637 | p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)", |
| 4638 | p2p_state_txt(p2p->state)); |
| 4639 | return; |
| 4640 | } |
| 4641 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4642 | if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) { |
| 4643 | /* |
| 4644 | * This should not really happen, but it looks like the Listen |
| 4645 | * command may fail is something else (e.g., a scan) was |
| 4646 | * running at an inconvenient time. As a workaround, allow new |
| 4647 | * Extended Listen operation to be started. |
| 4648 | */ |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4649 | p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4650 | p2p->ext_listen_only = 0; |
| 4651 | p2p_set_state(p2p, P2P_IDLE); |
| 4652 | } |
| 4653 | |
| 4654 | if (p2p->state != P2P_IDLE) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4655 | p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4656 | return; |
| 4657 | } |
| 4658 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4659 | p2p_dbg(p2p, "Extended Listen timeout"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4660 | p2p->ext_listen_only = 1; |
| 4661 | if (p2p_listen(p2p, p2p->ext_listen_period) < 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4662 | p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4663 | p2p->ext_listen_only = 0; |
| 4664 | } |
| 4665 | } |
| 4666 | |
| 4667 | |
| 4668 | int p2p_ext_listen(struct p2p_data *p2p, unsigned int period, |
| 4669 | unsigned int interval) |
| 4670 | { |
| 4671 | if (period > 65535 || interval > 65535 || period > interval || |
| 4672 | (period == 0 && interval > 0) || (period > 0 && interval == 0)) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4673 | p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u", |
| 4674 | period, interval); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4675 | return -1; |
| 4676 | } |
| 4677 | |
| 4678 | eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL); |
| 4679 | |
| 4680 | if (interval == 0) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4681 | p2p_dbg(p2p, "Disabling Extended Listen Timing"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4682 | p2p->ext_listen_period = 0; |
| 4683 | p2p->ext_listen_interval = 0; |
| 4684 | return 0; |
| 4685 | } |
| 4686 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4687 | p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec", |
| 4688 | period, interval); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4689 | p2p->ext_listen_period = period; |
| 4690 | p2p->ext_listen_interval = interval; |
| 4691 | p2p->ext_listen_interval_sec = interval / 1000; |
| 4692 | p2p->ext_listen_interval_usec = (interval % 1000) * 1000; |
| 4693 | |
| 4694 | eloop_register_timeout(p2p->ext_listen_interval_sec, |
| 4695 | p2p->ext_listen_interval_usec, |
| 4696 | p2p_ext_listen_timeout, p2p, NULL); |
| 4697 | |
| 4698 | return 0; |
| 4699 | } |
| 4700 | |
| 4701 | |
| 4702 | void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, |
| 4703 | const u8 *ie, size_t ie_len) |
| 4704 | { |
| 4705 | struct p2p_message msg; |
| 4706 | |
| 4707 | if (bssid == NULL || ie == NULL) |
| 4708 | return; |
| 4709 | |
| 4710 | os_memset(&msg, 0, sizeof(msg)); |
| 4711 | if (p2p_parse_ies(ie, ie_len, &msg)) |
| 4712 | return; |
Dmitry Shmidt | 9767226 | 2014-02-03 13:02:54 -0800 | [diff] [blame] | 4713 | if (msg.minor_reason_code == NULL) { |
| 4714 | p2p_parse_free(&msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4715 | return; |
Dmitry Shmidt | 9767226 | 2014-02-03 13:02:54 -0800 | [diff] [blame] | 4716 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4717 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4718 | p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4719 | " reason_code=%u minor_reason_code=%u", |
| 4720 | MAC2STR(bssid), reason_code, *msg.minor_reason_code); |
| 4721 | |
| 4722 | p2p_parse_free(&msg); |
| 4723 | } |
| 4724 | |
| 4725 | |
| 4726 | void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, |
| 4727 | const u8 *ie, size_t ie_len) |
| 4728 | { |
| 4729 | struct p2p_message msg; |
| 4730 | |
| 4731 | if (bssid == NULL || ie == NULL) |
| 4732 | return; |
| 4733 | |
| 4734 | os_memset(&msg, 0, sizeof(msg)); |
| 4735 | if (p2p_parse_ies(ie, ie_len, &msg)) |
| 4736 | return; |
Dmitry Shmidt | 9767226 | 2014-02-03 13:02:54 -0800 | [diff] [blame] | 4737 | if (msg.minor_reason_code == NULL) { |
| 4738 | p2p_parse_free(&msg); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4739 | return; |
Dmitry Shmidt | 9767226 | 2014-02-03 13:02:54 -0800 | [diff] [blame] | 4740 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4741 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4742 | p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4743 | " reason_code=%u minor_reason_code=%u", |
| 4744 | MAC2STR(bssid), reason_code, *msg.minor_reason_code); |
| 4745 | |
| 4746 | p2p_parse_free(&msg); |
| 4747 | } |
| 4748 | |
| 4749 | |
| 4750 | void p2p_set_managed_oper(struct p2p_data *p2p, int enabled) |
| 4751 | { |
| 4752 | if (enabled) { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4753 | p2p_dbg(p2p, "Managed P2P Device operations enabled"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4754 | p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED; |
| 4755 | } else { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4756 | p2p_dbg(p2p, "Managed P2P Device operations disabled"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4757 | p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED; |
| 4758 | } |
| 4759 | } |
| 4760 | |
| 4761 | |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 4762 | int p2p_config_get_random_social(struct p2p_config *p2p, u8 *op_class, |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 4763 | u8 *op_channel, |
| 4764 | struct wpa_freq_range_list *avoid_list, |
| 4765 | struct wpa_freq_range_list *disallow_list) |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 4766 | { |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 4767 | return p2p_channel_random_social(&p2p->channels, op_class, op_channel, |
| 4768 | avoid_list, disallow_list); |
Dmitry Shmidt | 661b4f7 | 2014-09-29 14:58:27 -0700 | [diff] [blame] | 4769 | } |
| 4770 | |
| 4771 | |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 4772 | int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel, |
| 4773 | u8 forced) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4774 | { |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 4775 | if (p2p_channel_to_freq(reg_class, channel) < 0) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4776 | return -1; |
| 4777 | |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 4778 | /* |
| 4779 | * Listen channel was set in configuration or set by control interface; |
| 4780 | * cannot override it. |
| 4781 | */ |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4782 | if (p2p->cfg->channel_forced && forced == 0) { |
| 4783 | p2p_dbg(p2p, |
| 4784 | "Listen channel was previously configured - do not override based on optimization"); |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 4785 | return -1; |
Dmitry Shmidt | 216983b | 2015-02-06 10:50:36 -0800 | [diff] [blame] | 4786 | } |
| 4787 | |
| 4788 | p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u", |
| 4789 | reg_class, channel); |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 4790 | |
| 4791 | if (p2p->state == P2P_IDLE) { |
| 4792 | p2p->cfg->reg_class = reg_class; |
| 4793 | p2p->cfg->channel = channel; |
| 4794 | p2p->cfg->channel_forced = forced; |
| 4795 | } else { |
| 4796 | p2p_dbg(p2p, "Defer setting listen channel"); |
| 4797 | p2p->pending_reg_class = reg_class; |
| 4798 | p2p->pending_channel = channel; |
| 4799 | p2p->pending_channel_forced = forced; |
| 4800 | } |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4801 | |
| 4802 | return 0; |
| 4803 | } |
| 4804 | |
| 4805 | |
Dmitry Shmidt | 43cb578 | 2014-06-16 16:23:22 -0700 | [diff] [blame] | 4806 | u8 p2p_get_listen_channel(struct p2p_data *p2p) |
| 4807 | { |
| 4808 | return p2p->cfg->channel; |
| 4809 | } |
| 4810 | |
| 4811 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4812 | int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len) |
| 4813 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4814 | p2p_dbg(p2p, "New SSID postfix: %s", wpa_ssid_txt(postfix, len)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4815 | if (postfix == NULL) { |
| 4816 | p2p->cfg->ssid_postfix_len = 0; |
| 4817 | return 0; |
| 4818 | } |
| 4819 | if (len > sizeof(p2p->cfg->ssid_postfix)) |
| 4820 | return -1; |
| 4821 | os_memcpy(p2p->cfg->ssid_postfix, postfix, len); |
| 4822 | p2p->cfg->ssid_postfix_len = len; |
| 4823 | return 0; |
| 4824 | } |
| 4825 | |
| 4826 | |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4827 | int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel, |
| 4828 | int cfg_op_channel) |
| 4829 | { |
Dmitry Shmidt | 4b06059 | 2013-04-29 16:42:49 -0700 | [diff] [blame] | 4830 | if (p2p_channel_to_freq(op_reg_class, op_channel) < 0) |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4831 | return -1; |
| 4832 | |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4833 | p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u", |
| 4834 | op_reg_class, op_channel); |
Jouni Malinen | 75ecf52 | 2011-06-27 15:19:46 -0700 | [diff] [blame] | 4835 | p2p->cfg->op_reg_class = op_reg_class; |
| 4836 | p2p->cfg->op_channel = op_channel; |
| 4837 | p2p->cfg->cfg_op_channel = cfg_op_channel; |
| 4838 | return 0; |
| 4839 | } |
| 4840 | |
| 4841 | |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 4842 | int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan, |
| 4843 | const struct p2p_channel *pref_chan) |
| 4844 | { |
| 4845 | struct p2p_channel *n; |
| 4846 | |
| 4847 | if (pref_chan) { |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 4848 | n = os_memdup(pref_chan, |
| 4849 | num_pref_chan * sizeof(struct p2p_channel)); |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 4850 | if (n == NULL) |
| 4851 | return -1; |
Dmitry Shmidt | 0494959 | 2012-07-19 12:16:46 -0700 | [diff] [blame] | 4852 | } else |
| 4853 | n = NULL; |
| 4854 | |
| 4855 | os_free(p2p->cfg->pref_chan); |
| 4856 | p2p->cfg->pref_chan = n; |
| 4857 | p2p->cfg->num_pref_chan = num_pref_chan; |
| 4858 | |
| 4859 | return 0; |
| 4860 | } |
| 4861 | |
| 4862 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 4863 | int p2p_set_no_go_freq(struct p2p_data *p2p, |
| 4864 | const struct wpa_freq_range_list *list) |
| 4865 | { |
| 4866 | struct wpa_freq_range *tmp; |
| 4867 | |
| 4868 | if (list == NULL || list->num == 0) { |
| 4869 | os_free(p2p->no_go_freq.range); |
| 4870 | p2p->no_go_freq.range = NULL; |
| 4871 | p2p->no_go_freq.num = 0; |
| 4872 | return 0; |
| 4873 | } |
| 4874 | |
| 4875 | tmp = os_calloc(list->num, sizeof(struct wpa_freq_range)); |
| 4876 | if (tmp == NULL) |
| 4877 | return -1; |
| 4878 | os_memcpy(tmp, list->range, list->num * sizeof(struct wpa_freq_range)); |
| 4879 | os_free(p2p->no_go_freq.range); |
| 4880 | p2p->no_go_freq.range = tmp; |
| 4881 | p2p->no_go_freq.num = list->num; |
| 4882 | p2p_dbg(p2p, "Updated no GO chan list"); |
| 4883 | |
| 4884 | return 0; |
| 4885 | } |
| 4886 | |
| 4887 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4888 | int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr, |
| 4889 | u8 *iface_addr) |
| 4890 | { |
| 4891 | struct p2p_device *dev = p2p_get_device(p2p, dev_addr); |
| 4892 | if (dev == NULL || is_zero_ether_addr(dev->interface_addr)) |
| 4893 | return -1; |
| 4894 | os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN); |
| 4895 | return 0; |
| 4896 | } |
| 4897 | |
| 4898 | |
| 4899 | int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr, |
| 4900 | u8 *dev_addr) |
| 4901 | { |
| 4902 | struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); |
| 4903 | if (dev == NULL) |
| 4904 | return -1; |
| 4905 | os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN); |
| 4906 | return 0; |
| 4907 | } |
| 4908 | |
| 4909 | |
| 4910 | void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr) |
| 4911 | { |
| 4912 | os_memcpy(p2p->peer_filter, addr, ETH_ALEN); |
| 4913 | if (is_zero_ether_addr(p2p->peer_filter)) |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4914 | p2p_dbg(p2p, "Disable peer filter"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4915 | else |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4916 | p2p_dbg(p2p, "Enable peer filter for " MACSTR, |
| 4917 | MAC2STR(p2p->peer_filter)); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4918 | } |
| 4919 | |
| 4920 | |
| 4921 | void p2p_set_cross_connect(struct p2p_data *p2p, int enabled) |
| 4922 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4923 | p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4924 | if (p2p->cross_connect == enabled) |
| 4925 | return; |
| 4926 | p2p->cross_connect = enabled; |
| 4927 | /* TODO: may need to tear down any action group where we are GO(?) */ |
| 4928 | } |
| 4929 | |
| 4930 | |
| 4931 | int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr) |
| 4932 | { |
| 4933 | struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); |
| 4934 | if (dev == NULL) |
| 4935 | return -1; |
| 4936 | if (dev->oper_freq <= 0) |
| 4937 | return -1; |
| 4938 | return dev->oper_freq; |
| 4939 | } |
| 4940 | |
| 4941 | |
| 4942 | void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled) |
| 4943 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4944 | p2p_dbg(p2p, "Intra BSS distribution %s", |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4945 | enabled ? "enabled" : "disabled"); |
| 4946 | p2p->cfg->p2p_intra_bss = enabled; |
| 4947 | } |
| 4948 | |
| 4949 | |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 4950 | void p2p_update_channel_list(struct p2p_data *p2p, |
| 4951 | const struct p2p_channels *chan, |
| 4952 | const struct p2p_channels *cli_chan) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4953 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4954 | p2p_dbg(p2p, "Update channel list"); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4955 | os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels)); |
Dmitry Shmidt | 68d0e3e | 2013-10-28 17:59:21 -0700 | [diff] [blame] | 4956 | p2p_channels_dump(p2p, "channels", &p2p->cfg->channels); |
| 4957 | os_memcpy(&p2p->cfg->cli_channels, cli_chan, |
| 4958 | sizeof(struct p2p_channels)); |
| 4959 | p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4960 | } |
| 4961 | |
| 4962 | |
| 4963 | int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst, |
| 4964 | const u8 *src, const u8 *bssid, const u8 *buf, |
| 4965 | size_t len, unsigned int wait_time) |
| 4966 | { |
Hai Shalom | 021b0b5 | 2019-04-10 11:17:58 -0700 | [diff] [blame] | 4967 | int res, scheduled; |
| 4968 | |
Hai Shalom | 021b0b5 | 2019-04-10 11:17:58 -0700 | [diff] [blame] | 4969 | res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid, |
| 4970 | buf, len, wait_time, &scheduled); |
| 4971 | if (res == 0 && scheduled && p2p->in_listen && freq > 0 && |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 4972 | p2p->drv_in_listen > 0 && |
Hai Shalom | 021b0b5 | 2019-04-10 11:17:58 -0700 | [diff] [blame] | 4973 | (unsigned int) p2p->drv_in_listen != freq) { |
| 4974 | p2p_dbg(p2p, |
| 4975 | "Stop listen on %d MHz to allow a frame to be sent immediately on %d MHz", |
| 4976 | p2p->drv_in_listen, freq); |
| 4977 | p2p_stop_listen_for_freq(p2p, freq); |
| 4978 | } |
| 4979 | return res; |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4980 | } |
| 4981 | |
| 4982 | |
| 4983 | void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5, |
| 4984 | int freq_overall) |
| 4985 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4986 | p2p_dbg(p2p, "Best channel: 2.4 GHz: %d, 5 GHz: %d, overall: %d", |
| 4987 | freq_24, freq_5, freq_overall); |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 4988 | p2p->best_freq_24 = freq_24; |
| 4989 | p2p->best_freq_5 = freq_5; |
| 4990 | p2p->best_freq_overall = freq_overall; |
| 4991 | } |
| 4992 | |
| 4993 | |
Dmitry Shmidt | 700a137 | 2013-03-15 14:14:44 -0700 | [diff] [blame] | 4994 | void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq) |
| 4995 | { |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 4996 | p2p_dbg(p2p, "Own frequency preference: %d MHz", freq); |
Dmitry Shmidt | 700a137 | 2013-03-15 14:14:44 -0700 | [diff] [blame] | 4997 | p2p->own_freq_preference = freq; |
| 4998 | } |
| 4999 | |
| 5000 | |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 5001 | const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p) |
| 5002 | { |
| 5003 | if (p2p == NULL || p2p->go_neg_peer == NULL) |
| 5004 | return NULL; |
| 5005 | return p2p->go_neg_peer->info.p2p_device_addr; |
| 5006 | } |
| 5007 | |
| 5008 | |
| 5009 | const struct p2p_peer_info * |
| 5010 | p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next) |
| 5011 | { |
| 5012 | struct p2p_device *dev; |
| 5013 | |
| 5014 | if (addr) { |
| 5015 | dev = p2p_get_device(p2p, addr); |
| 5016 | if (!dev) |
| 5017 | return NULL; |
| 5018 | |
| 5019 | if (!next) { |
| 5020 | if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) |
| 5021 | return NULL; |
| 5022 | |
| 5023 | return &dev->info; |
| 5024 | } else { |
| 5025 | do { |
| 5026 | dev = dl_list_first(&dev->list, |
| 5027 | struct p2p_device, |
| 5028 | list); |
Dmitry Shmidt | 7832adb | 2014-04-29 10:53:02 -0700 | [diff] [blame] | 5029 | if (!dev || &dev->list == &p2p->devices) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 5030 | return NULL; |
| 5031 | } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY); |
| 5032 | } |
| 5033 | } else { |
| 5034 | dev = dl_list_first(&p2p->devices, struct p2p_device, list); |
| 5035 | if (!dev) |
| 5036 | return NULL; |
| 5037 | while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { |
| 5038 | dev = dl_list_first(&dev->list, |
| 5039 | struct p2p_device, |
| 5040 | list); |
Dmitry Shmidt | 7832adb | 2014-04-29 10:53:02 -0700 | [diff] [blame] | 5041 | if (!dev || &dev->list == &p2p->devices) |
Dmitry Shmidt | 8d520ff | 2011-05-09 14:06:53 -0700 | [diff] [blame] | 5042 | return NULL; |
| 5043 | } |
| 5044 | } |
| 5045 | |
| 5046 | return &dev->info; |
| 5047 | } |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 5048 | |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 5049 | |
| 5050 | int p2p_in_progress(struct p2p_data *p2p) |
| 5051 | { |
| 5052 | if (p2p == NULL) |
| 5053 | return 0; |
Dmitry Shmidt | fb79edc | 2014-01-10 10:45:54 -0800 | [diff] [blame] | 5054 | if (p2p->state == P2P_SEARCH) |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 5055 | return 2; |
Dmitry Shmidt | 1f69aa5 | 2012-01-24 16:10:04 -0800 | [diff] [blame] | 5056 | return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING; |
| 5057 | } |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 5058 | |
| 5059 | |
| 5060 | void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout, |
| 5061 | u8 client_timeout) |
| 5062 | { |
| 5063 | if (p2p) { |
| 5064 | p2p->go_timeout = go_timeout; |
| 5065 | p2p->client_timeout = client_timeout; |
| 5066 | } |
| 5067 | } |
| 5068 | |
| 5069 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 5070 | #ifdef CONFIG_WIFI_DISPLAY |
| 5071 | |
| 5072 | static void p2p_update_wfd_ie_groups(struct p2p_data *p2p) |
| 5073 | { |
| 5074 | size_t g; |
| 5075 | struct p2p_group *group; |
| 5076 | |
| 5077 | for (g = 0; g < p2p->num_groups; g++) { |
| 5078 | group = p2p->groups[g]; |
Dmitry Shmidt | b96dad4 | 2013-11-05 10:07:29 -0800 | [diff] [blame] | 5079 | p2p_group_force_beacon_update_ies(group); |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 5080 | } |
| 5081 | } |
| 5082 | |
| 5083 | |
| 5084 | int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie) |
| 5085 | { |
| 5086 | wpabuf_free(p2p->wfd_ie_beacon); |
| 5087 | p2p->wfd_ie_beacon = ie; |
| 5088 | p2p_update_wfd_ie_groups(p2p); |
| 5089 | return 0; |
| 5090 | } |
| 5091 | |
| 5092 | |
| 5093 | int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie) |
| 5094 | { |
| 5095 | wpabuf_free(p2p->wfd_ie_probe_req); |
| 5096 | p2p->wfd_ie_probe_req = ie; |
| 5097 | return 0; |
| 5098 | } |
| 5099 | |
| 5100 | |
| 5101 | int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie) |
| 5102 | { |
| 5103 | wpabuf_free(p2p->wfd_ie_probe_resp); |
| 5104 | p2p->wfd_ie_probe_resp = ie; |
| 5105 | p2p_update_wfd_ie_groups(p2p); |
| 5106 | return 0; |
| 5107 | } |
| 5108 | |
| 5109 | |
| 5110 | int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie) |
| 5111 | { |
| 5112 | wpabuf_free(p2p->wfd_ie_assoc_req); |
| 5113 | p2p->wfd_ie_assoc_req = ie; |
| 5114 | return 0; |
| 5115 | } |
| 5116 | |
| 5117 | |
| 5118 | int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie) |
| 5119 | { |
| 5120 | wpabuf_free(p2p->wfd_ie_invitation); |
| 5121 | p2p->wfd_ie_invitation = ie; |
| 5122 | return 0; |
| 5123 | } |
| 5124 | |
| 5125 | |
| 5126 | int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie) |
| 5127 | { |
| 5128 | wpabuf_free(p2p->wfd_ie_prov_disc_req); |
| 5129 | p2p->wfd_ie_prov_disc_req = ie; |
| 5130 | return 0; |
| 5131 | } |
| 5132 | |
| 5133 | |
| 5134 | int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie) |
| 5135 | { |
| 5136 | wpabuf_free(p2p->wfd_ie_prov_disc_resp); |
| 5137 | p2p->wfd_ie_prov_disc_resp = ie; |
| 5138 | return 0; |
| 5139 | } |
| 5140 | |
| 5141 | |
| 5142 | int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie) |
| 5143 | { |
| 5144 | wpabuf_free(p2p->wfd_ie_go_neg); |
| 5145 | p2p->wfd_ie_go_neg = ie; |
| 5146 | return 0; |
| 5147 | } |
| 5148 | |
| 5149 | |
| 5150 | int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem) |
| 5151 | { |
| 5152 | wpabuf_free(p2p->wfd_dev_info); |
| 5153 | if (elem) { |
| 5154 | p2p->wfd_dev_info = wpabuf_dup(elem); |
| 5155 | if (p2p->wfd_dev_info == NULL) |
| 5156 | return -1; |
| 5157 | } else |
| 5158 | p2p->wfd_dev_info = NULL; |
| 5159 | |
| 5160 | return 0; |
| 5161 | } |
| 5162 | |
| 5163 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 5164 | int p2p_set_wfd_r2_dev_info(struct p2p_data *p2p, const struct wpabuf *elem) |
| 5165 | { |
| 5166 | wpabuf_free(p2p->wfd_r2_dev_info); |
| 5167 | if (elem) { |
| 5168 | p2p->wfd_r2_dev_info = wpabuf_dup(elem); |
| 5169 | if (p2p->wfd_r2_dev_info == NULL) |
| 5170 | return -1; |
| 5171 | } else |
| 5172 | p2p->wfd_r2_dev_info = NULL; |
| 5173 | |
| 5174 | return 0; |
| 5175 | } |
| 5176 | |
| 5177 | |
Dmitry Shmidt | 61d9df3 | 2012-08-29 16:22:06 -0700 | [diff] [blame] | 5178 | int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem) |
| 5179 | { |
| 5180 | wpabuf_free(p2p->wfd_assoc_bssid); |
| 5181 | if (elem) { |
| 5182 | p2p->wfd_assoc_bssid = wpabuf_dup(elem); |
| 5183 | if (p2p->wfd_assoc_bssid == NULL) |
| 5184 | return -1; |
| 5185 | } else |
| 5186 | p2p->wfd_assoc_bssid = NULL; |
| 5187 | |
| 5188 | return 0; |
| 5189 | } |
| 5190 | |
| 5191 | |
| 5192 | int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p, |
| 5193 | const struct wpabuf *elem) |
| 5194 | { |
| 5195 | wpabuf_free(p2p->wfd_coupled_sink_info); |
| 5196 | if (elem) { |
| 5197 | p2p->wfd_coupled_sink_info = wpabuf_dup(elem); |
| 5198 | if (p2p->wfd_coupled_sink_info == NULL) |
| 5199 | return -1; |
| 5200 | } else |
| 5201 | p2p->wfd_coupled_sink_info = NULL; |
| 5202 | |
| 5203 | return 0; |
| 5204 | } |
| 5205 | |
| 5206 | #endif /* CONFIG_WIFI_DISPLAY */ |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 5207 | |
| 5208 | |
| 5209 | int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int, |
| 5210 | int max_disc_tu) |
| 5211 | { |
| 5212 | if (min_disc_int > max_disc_int || min_disc_int < 0 || max_disc_int < 0) |
| 5213 | return -1; |
| 5214 | |
| 5215 | p2p->min_disc_int = min_disc_int; |
| 5216 | p2p->max_disc_int = max_disc_int; |
| 5217 | p2p->max_disc_tu = max_disc_tu; |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 5218 | p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d", |
| 5219 | min_disc_int, max_disc_int, max_disc_tu); |
Dmitry Shmidt | d5e4923 | 2012-12-03 15:08:10 -0800 | [diff] [blame] | 5220 | |
| 5221 | return 0; |
| 5222 | } |
Dmitry Shmidt | b6e9aaf | 2013-05-20 14:49:44 -0700 | [diff] [blame] | 5223 | |
| 5224 | |
| 5225 | void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...) |
| 5226 | { |
| 5227 | va_list ap; |
| 5228 | char buf[500]; |
| 5229 | |
| 5230 | if (!p2p->cfg->debug_print) |
| 5231 | return; |
| 5232 | |
| 5233 | va_start(ap, fmt); |
| 5234 | vsnprintf(buf, sizeof(buf), fmt, ap); |
| 5235 | buf[sizeof(buf) - 1] = '\0'; |
| 5236 | va_end(ap); |
| 5237 | p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf); |
| 5238 | } |
| 5239 | |
| 5240 | |
| 5241 | void p2p_info(struct p2p_data *p2p, const char *fmt, ...) |
| 5242 | { |
| 5243 | va_list ap; |
| 5244 | char buf[500]; |
| 5245 | |
| 5246 | if (!p2p->cfg->debug_print) |
| 5247 | return; |
| 5248 | |
| 5249 | va_start(ap, fmt); |
| 5250 | vsnprintf(buf, sizeof(buf), fmt, ap); |
| 5251 | buf[sizeof(buf) - 1] = '\0'; |
| 5252 | va_end(ap); |
| 5253 | p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf); |
| 5254 | } |
| 5255 | |
| 5256 | |
| 5257 | void p2p_err(struct p2p_data *p2p, const char *fmt, ...) |
| 5258 | { |
| 5259 | va_list ap; |
| 5260 | char buf[500]; |
| 5261 | |
| 5262 | if (!p2p->cfg->debug_print) |
| 5263 | return; |
| 5264 | |
| 5265 | va_start(ap, fmt); |
| 5266 | vsnprintf(buf, sizeof(buf), fmt, ap); |
| 5267 | buf[sizeof(buf) - 1] = '\0'; |
| 5268 | va_end(ap); |
| 5269 | p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf); |
| 5270 | } |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5271 | |
| 5272 | |
Dmitry Shmidt | d30ac60 | 2014-06-30 09:54:22 -0700 | [diff] [blame] | 5273 | void p2p_loop_on_known_peers(struct p2p_data *p2p, |
| 5274 | void (*peer_callback)(struct p2p_peer_info *peer, |
| 5275 | void *user_data), |
| 5276 | void *user_data) |
| 5277 | { |
| 5278 | struct p2p_device *dev, *n; |
| 5279 | |
| 5280 | dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) { |
| 5281 | peer_callback(&dev->info, user_data); |
| 5282 | } |
| 5283 | } |
| 5284 | |
| 5285 | |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5286 | #ifdef CONFIG_WPS_NFC |
| 5287 | |
| 5288 | static struct wpabuf * p2p_build_nfc_handover(struct p2p_data *p2p, |
| 5289 | int client_freq, |
| 5290 | const u8 *go_dev_addr, |
| 5291 | const u8 *ssid, size_t ssid_len) |
| 5292 | { |
| 5293 | struct wpabuf *buf; |
| 5294 | u8 op_class, channel; |
| 5295 | enum p2p_role_indication role = P2P_DEVICE_NOT_IN_GROUP; |
| 5296 | |
| 5297 | buf = wpabuf_alloc(1000); |
| 5298 | if (buf == NULL) |
| 5299 | return NULL; |
| 5300 | |
| 5301 | op_class = p2p->cfg->reg_class; |
| 5302 | channel = p2p->cfg->channel; |
| 5303 | |
| 5304 | p2p_buf_add_capability(buf, p2p->dev_capab & |
| 5305 | ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); |
| 5306 | p2p_buf_add_device_info(buf, p2p, NULL); |
| 5307 | |
| 5308 | if (p2p->num_groups > 0) { |
Dmitry Shmidt | 7832adb | 2014-04-29 10:53:02 -0700 | [diff] [blame] | 5309 | int freq = p2p_group_get_freq(p2p->groups[0]); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5310 | role = P2P_GO_IN_A_GROUP; |
Dmitry Shmidt | 7832adb | 2014-04-29 10:53:02 -0700 | [diff] [blame] | 5311 | if (p2p_freq_to_channel(freq, &op_class, &channel) < 0) { |
| 5312 | p2p_dbg(p2p, |
| 5313 | "Unknown GO operating frequency %d MHz for NFC handover", |
| 5314 | freq); |
| 5315 | wpabuf_free(buf); |
| 5316 | return NULL; |
| 5317 | } |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5318 | } else if (client_freq > 0) { |
| 5319 | role = P2P_CLIENT_IN_A_GROUP; |
Dmitry Shmidt | 7832adb | 2014-04-29 10:53:02 -0700 | [diff] [blame] | 5320 | if (p2p_freq_to_channel(client_freq, &op_class, &channel) < 0) { |
| 5321 | p2p_dbg(p2p, |
| 5322 | "Unknown client operating frequency %d MHz for NFC handover", |
| 5323 | client_freq); |
| 5324 | wpabuf_free(buf); |
| 5325 | return NULL; |
| 5326 | } |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5327 | } |
| 5328 | |
| 5329 | p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class, |
| 5330 | channel, role); |
| 5331 | |
| 5332 | if (p2p->num_groups > 0) { |
| 5333 | /* Limit number of clients to avoid very long message */ |
| 5334 | p2p_buf_add_group_info(p2p->groups[0], buf, 5); |
| 5335 | p2p_group_buf_add_id(p2p->groups[0], buf); |
| 5336 | } else if (client_freq > 0 && |
| 5337 | go_dev_addr && !is_zero_ether_addr(go_dev_addr) && |
| 5338 | ssid && ssid_len > 0) { |
| 5339 | /* |
| 5340 | * Add the optional P2P Group ID to indicate in which group this |
| 5341 | * device is a P2P Client. |
| 5342 | */ |
| 5343 | p2p_buf_add_group_id(buf, go_dev_addr, ssid, ssid_len); |
| 5344 | } |
| 5345 | |
| 5346 | return buf; |
| 5347 | } |
| 5348 | |
| 5349 | |
| 5350 | struct wpabuf * p2p_build_nfc_handover_req(struct p2p_data *p2p, |
| 5351 | int client_freq, |
| 5352 | const u8 *go_dev_addr, |
| 5353 | const u8 *ssid, size_t ssid_len) |
| 5354 | { |
| 5355 | return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid, |
| 5356 | ssid_len); |
| 5357 | } |
| 5358 | |
| 5359 | |
| 5360 | struct wpabuf * p2p_build_nfc_handover_sel(struct p2p_data *p2p, |
| 5361 | int client_freq, |
| 5362 | const u8 *go_dev_addr, |
| 5363 | const u8 *ssid, size_t ssid_len) |
| 5364 | { |
| 5365 | return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid, |
| 5366 | ssid_len); |
| 5367 | } |
| 5368 | |
| 5369 | |
| 5370 | int p2p_process_nfc_connection_handover(struct p2p_data *p2p, |
| 5371 | struct p2p_nfc_params *params) |
| 5372 | { |
| 5373 | struct p2p_message msg; |
| 5374 | struct p2p_device *dev; |
| 5375 | const u8 *p2p_dev_addr; |
| 5376 | int freq; |
| 5377 | enum p2p_role_indication role; |
| 5378 | |
| 5379 | params->next_step = NO_ACTION; |
| 5380 | |
| 5381 | if (p2p_parse_ies_separate(params->wsc_attr, params->wsc_len, |
| 5382 | params->p2p_attr, params->p2p_len, &msg)) { |
| 5383 | p2p_dbg(p2p, "Failed to parse WSC/P2P attributes from NFC"); |
| 5384 | p2p_parse_free(&msg); |
| 5385 | return -1; |
| 5386 | } |
| 5387 | |
| 5388 | if (msg.p2p_device_addr) |
| 5389 | p2p_dev_addr = msg.p2p_device_addr; |
| 5390 | else if (msg.device_id) |
| 5391 | p2p_dev_addr = msg.device_id; |
| 5392 | else { |
| 5393 | p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id"); |
| 5394 | p2p_parse_free(&msg); |
| 5395 | return -1; |
| 5396 | } |
| 5397 | |
| 5398 | if (msg.oob_dev_password) { |
| 5399 | os_memcpy(params->oob_dev_pw, msg.oob_dev_password, |
| 5400 | msg.oob_dev_password_len); |
| 5401 | params->oob_dev_pw_len = msg.oob_dev_password_len; |
| 5402 | } |
| 5403 | |
| 5404 | dev = p2p_create_device(p2p, p2p_dev_addr); |
| 5405 | if (dev == NULL) { |
| 5406 | p2p_parse_free(&msg); |
| 5407 | return -1; |
| 5408 | } |
| 5409 | |
| 5410 | params->peer = &dev->info; |
| 5411 | |
| 5412 | os_get_reltime(&dev->last_seen); |
| 5413 | dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY); |
| 5414 | p2p_copy_wps_info(p2p, dev, 0, &msg); |
| 5415 | |
| 5416 | if (!msg.oob_go_neg_channel) { |
| 5417 | p2p_dbg(p2p, "OOB GO Negotiation Channel attribute not included"); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 5418 | p2p_parse_free(&msg); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5419 | return -1; |
| 5420 | } |
| 5421 | |
| 5422 | if (msg.oob_go_neg_channel[3] == 0 && |
| 5423 | msg.oob_go_neg_channel[4] == 0) |
| 5424 | freq = 0; |
| 5425 | else |
| 5426 | freq = p2p_channel_to_freq(msg.oob_go_neg_channel[3], |
| 5427 | msg.oob_go_neg_channel[4]); |
| 5428 | if (freq < 0) { |
| 5429 | p2p_dbg(p2p, "Unknown peer OOB GO Neg channel"); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 5430 | p2p_parse_free(&msg); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5431 | return -1; |
| 5432 | } |
| 5433 | role = msg.oob_go_neg_channel[5]; |
| 5434 | |
| 5435 | if (role == P2P_GO_IN_A_GROUP) { |
| 5436 | p2p_dbg(p2p, "Peer OOB GO operating channel: %u MHz", freq); |
| 5437 | params->go_freq = freq; |
| 5438 | } else if (role == P2P_CLIENT_IN_A_GROUP) { |
| 5439 | p2p_dbg(p2p, "Peer (client) OOB GO operating channel: %u MHz", |
| 5440 | freq); |
| 5441 | params->go_freq = freq; |
| 5442 | } else |
| 5443 | p2p_dbg(p2p, "Peer OOB GO Neg channel: %u MHz", freq); |
| 5444 | dev->oob_go_neg_freq = freq; |
| 5445 | |
| 5446 | if (!params->sel && role != P2P_GO_IN_A_GROUP) { |
| 5447 | freq = p2p_channel_to_freq(p2p->cfg->reg_class, |
| 5448 | p2p->cfg->channel); |
| 5449 | if (freq < 0) { |
| 5450 | p2p_dbg(p2p, "Own listen channel not known"); |
Dmitry Shmidt | a3dc309 | 2015-06-23 11:21:28 -0700 | [diff] [blame] | 5451 | p2p_parse_free(&msg); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5452 | return -1; |
| 5453 | } |
| 5454 | p2p_dbg(p2p, "Use own Listen channel as OOB GO Neg channel: %u MHz", freq); |
| 5455 | dev->oob_go_neg_freq = freq; |
| 5456 | } |
| 5457 | |
| 5458 | if (msg.group_id) { |
| 5459 | os_memcpy(params->go_dev_addr, msg.group_id, ETH_ALEN); |
| 5460 | params->go_ssid_len = msg.group_id_len - ETH_ALEN; |
| 5461 | os_memcpy(params->go_ssid, msg.group_id + ETH_ALEN, |
| 5462 | params->go_ssid_len); |
| 5463 | } |
| 5464 | |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5465 | if (dev->flags & P2P_DEV_USER_REJECTED) { |
| 5466 | p2p_dbg(p2p, "Do not report rejected device"); |
Dmitry Shmidt | 7175743 | 2014-06-02 13:50:35 -0700 | [diff] [blame] | 5467 | p2p_parse_free(&msg); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5468 | return 0; |
| 5469 | } |
| 5470 | |
| 5471 | if (!(dev->flags & P2P_DEV_REPORTED)) { |
| 5472 | p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info, |
| 5473 | !(dev->flags & P2P_DEV_REPORTED_ONCE)); |
| 5474 | dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; |
| 5475 | } |
Dmitry Shmidt | 7175743 | 2014-06-02 13:50:35 -0700 | [diff] [blame] | 5476 | p2p_parse_free(&msg); |
Dmitry Shmidt | cf32e60 | 2014-01-28 10:57:39 -0800 | [diff] [blame] | 5477 | |
| 5478 | if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0) |
| 5479 | params->next_step = BOTH_GO; |
| 5480 | else if (role == P2P_GO_IN_A_GROUP) |
| 5481 | params->next_step = JOIN_GROUP; |
| 5482 | else if (role == P2P_CLIENT_IN_A_GROUP) { |
| 5483 | dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY; |
| 5484 | params->next_step = PEER_CLIENT; |
| 5485 | } else if (p2p->num_groups > 0) |
| 5486 | params->next_step = AUTH_JOIN; |
| 5487 | else if (params->sel) |
| 5488 | params->next_step = INIT_GO_NEG; |
| 5489 | else |
| 5490 | params->next_step = RESP_GO_NEG; |
| 5491 | |
| 5492 | return 0; |
| 5493 | } |
| 5494 | |
| 5495 | |
| 5496 | void p2p_set_authorized_oob_dev_pw_id(struct p2p_data *p2p, u16 dev_pw_id, |
| 5497 | int go_intent, |
| 5498 | const u8 *own_interface_addr) |
| 5499 | { |
| 5500 | |
| 5501 | p2p->authorized_oob_dev_pw_id = dev_pw_id; |
| 5502 | if (dev_pw_id == 0) { |
| 5503 | p2p_dbg(p2p, "NFC OOB Password unauthorized for static handover"); |
| 5504 | return; |
| 5505 | } |
| 5506 | |
| 5507 | p2p_dbg(p2p, "NFC OOB Password (id=%u) authorized for static handover", |
| 5508 | dev_pw_id); |
| 5509 | |
| 5510 | p2p->go_intent = go_intent; |
| 5511 | os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); |
| 5512 | } |
| 5513 | |
| 5514 | #endif /* CONFIG_WPS_NFC */ |
Dmitry Shmidt | 2271d3f | 2014-06-23 12:16:31 -0700 | [diff] [blame] | 5515 | |
| 5516 | |
| 5517 | int p2p_set_passphrase_len(struct p2p_data *p2p, unsigned int len) |
| 5518 | { |
| 5519 | if (len < 8 || len > 63) |
| 5520 | return -1; |
| 5521 | p2p->cfg->passphrase_len = len; |
| 5522 | return 0; |
| 5523 | } |
Dmitry Shmidt | 2e67f06 | 2014-07-16 09:55:28 -0700 | [diff] [blame] | 5524 | |
| 5525 | |
| 5526 | void p2p_set_vendor_elems(struct p2p_data *p2p, struct wpabuf **vendor_elem) |
| 5527 | { |
| 5528 | p2p->vendor_elem = vendor_elem; |
| 5529 | } |
Dmitry Shmidt | 6c0da2b | 2015-01-05 13:08:17 -0800 | [diff] [blame] | 5530 | |
| 5531 | |
| 5532 | void p2p_go_neg_wait_timeout(void *eloop_ctx, void *timeout_ctx) |
| 5533 | { |
| 5534 | struct p2p_data *p2p = eloop_ctx; |
| 5535 | |
| 5536 | p2p_dbg(p2p, |
| 5537 | "Timeout on waiting peer to become ready for GO Negotiation"); |
| 5538 | p2p_go_neg_failed(p2p, -1); |
| 5539 | } |
Dmitry Shmidt | d80a401 | 2015-11-05 16:35:40 -0800 | [diff] [blame] | 5540 | |
| 5541 | |
| 5542 | void p2p_set_own_pref_freq_list(struct p2p_data *p2p, |
| 5543 | const unsigned int *pref_freq_list, |
| 5544 | unsigned int size) |
| 5545 | { |
| 5546 | unsigned int i; |
| 5547 | |
| 5548 | if (size > P2P_MAX_PREF_CHANNELS) |
| 5549 | size = P2P_MAX_PREF_CHANNELS; |
| 5550 | p2p->num_pref_freq = size; |
| 5551 | for (i = 0; i < size; i++) { |
| 5552 | p2p->pref_freq_list[i] = pref_freq_list[i]; |
| 5553 | p2p_dbg(p2p, "Own preferred frequency list[%u]=%u MHz", |
| 5554 | i, p2p->pref_freq_list[i]); |
| 5555 | } |
| 5556 | } |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 5557 | |
| 5558 | |
Dmitry Shmidt | ebd93af | 2017-02-21 13:40:44 -0800 | [diff] [blame] | 5559 | void p2p_set_override_pref_op_chan(struct p2p_data *p2p, u8 op_class, |
| 5560 | u8 chan) |
| 5561 | { |
| 5562 | p2p->override_pref_op_class = op_class; |
| 5563 | p2p->override_pref_channel = chan; |
| 5564 | } |
| 5565 | |
| 5566 | |
Dmitry Shmidt | 58d12ad | 2016-07-28 10:07:03 -0700 | [diff] [blame] | 5567 | struct wpabuf * p2p_build_probe_resp_template(struct p2p_data *p2p, |
| 5568 | unsigned int freq) |
| 5569 | { |
| 5570 | struct wpabuf *ies, *buf; |
| 5571 | u8 addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; |
| 5572 | int ret; |
| 5573 | |
| 5574 | ies = p2p_build_probe_resp_ies(p2p, NULL, 0); |
| 5575 | if (!ies) { |
| 5576 | wpa_printf(MSG_ERROR, |
| 5577 | "CTRL: Failed to build Probe Response IEs"); |
| 5578 | return NULL; |
| 5579 | } |
| 5580 | |
| 5581 | buf = wpabuf_alloc(200 + wpabuf_len(ies)); |
| 5582 | if (!buf) { |
| 5583 | wpabuf_free(ies); |
| 5584 | return NULL; |
| 5585 | } |
| 5586 | |
| 5587 | ret = p2p_build_probe_resp_buf(p2p, buf, ies, addr, freq); |
| 5588 | wpabuf_free(ies); |
| 5589 | if (ret) { |
| 5590 | wpabuf_free(buf); |
| 5591 | return NULL; |
| 5592 | } |
| 5593 | |
| 5594 | return buf; |
| 5595 | } |
Hai Shalom | a20dcd7 | 2022-02-04 13:43:00 -0800 | [diff] [blame^] | 5596 | |
| 5597 | |
| 5598 | bool p2p_is_peer_6ghz_capab(struct p2p_data *p2p, const u8 *addr) |
| 5599 | { |
| 5600 | struct p2p_device *dev; |
| 5601 | |
| 5602 | dev = p2p_get_device(p2p, addr); |
| 5603 | if (!dev) |
| 5604 | return false; |
| 5605 | |
| 5606 | return !!(dev->info.dev_capab & P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE); |
| 5607 | } |
| 5608 | |
| 5609 | |
| 5610 | void p2p_set_6ghz_dev_capab(struct p2p_data *p2p, bool allow_6ghz) |
| 5611 | { |
| 5612 | p2p->p2p_6ghz_capable = allow_6ghz; |
| 5613 | p2p->allow_6ghz = allow_6ghz; |
| 5614 | p2p_dbg(p2p, "Set 6 GHz capability to %d", allow_6ghz); |
| 5615 | |
| 5616 | if (allow_6ghz) |
| 5617 | p2p->dev_capab |= P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE; |
| 5618 | else |
| 5619 | p2p->dev_capab &= ~P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE; |
| 5620 | } |
| 5621 | |
| 5622 | |
| 5623 | bool is_p2p_6ghz_capable(struct p2p_data *p2p) |
| 5624 | { |
| 5625 | return p2p->p2p_6ghz_capable; |
| 5626 | } |
| 5627 | |
| 5628 | |
| 5629 | bool p2p_wfd_enabled(struct p2p_data *p2p) |
| 5630 | { |
| 5631 | #ifdef CONFIG_WIFI_DISPLAY |
| 5632 | return p2p->wfd_ie_probe_req != NULL; |
| 5633 | #else /* CONFIG_WIFI_DISPLAY */ |
| 5634 | return false; |
| 5635 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 5636 | } |
| 5637 | |
| 5638 | |
| 5639 | bool p2p_peer_wfd_enabled(struct p2p_data *p2p, const u8 *peer_addr) |
| 5640 | { |
| 5641 | #ifdef CONFIG_WIFI_DISPLAY |
| 5642 | struct p2p_device *dev; |
| 5643 | |
| 5644 | dev = p2p_get_device(p2p, peer_addr); |
| 5645 | return dev && dev->info.wfd_subelems != NULL; |
| 5646 | #else /* CONFIG_WIFI_DISPLAY */ |
| 5647 | return false; |
| 5648 | #endif /* CONFIG_WIFI_DISPLAY */ |
| 5649 | } |
| 5650 | |
| 5651 | |
| 5652 | bool is_p2p_allow_6ghz(struct p2p_data *p2p) |
| 5653 | { |
| 5654 | return p2p->allow_6ghz; |
| 5655 | } |
| 5656 | |
| 5657 | |
| 5658 | void set_p2p_allow_6ghz(struct p2p_data *p2p, bool value) |
| 5659 | { |
| 5660 | p2p->allow_6ghz = value; |
| 5661 | } |