Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1 | /* |
| 2 | * wpa_supplicant - Radio Measurements |
| 3 | * Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi> |
| 4 | * |
| 5 | * This software may be distributed under the terms of the BSD license. |
| 6 | * See README for more details. |
| 7 | */ |
| 8 | |
| 9 | #include "includes.h" |
| 10 | |
| 11 | #include "utils/common.h" |
| 12 | #include "utils/eloop.h" |
| 13 | #include "common/ieee802_11_common.h" |
| 14 | #include "wpa_supplicant_i.h" |
| 15 | #include "driver_i.h" |
| 16 | #include "bss.h" |
| 17 | #include "scan.h" |
| 18 | #include "p2p_supplicant.h" |
| 19 | |
| 20 | |
| 21 | static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx) |
| 22 | { |
| 23 | struct rrm_data *rrm = data; |
| 24 | |
| 25 | if (!rrm->notify_neighbor_rep) { |
| 26 | wpa_printf(MSG_ERROR, |
| 27 | "RRM: Unexpected neighbor report timeout"); |
| 28 | return; |
| 29 | } |
| 30 | |
| 31 | wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE"); |
| 32 | rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL); |
| 33 | |
| 34 | rrm->notify_neighbor_rep = NULL; |
| 35 | rrm->neighbor_rep_cb_ctx = NULL; |
| 36 | } |
| 37 | |
| 38 | |
| 39 | /* |
| 40 | * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant |
| 41 | * @wpa_s: Pointer to wpa_supplicant |
| 42 | */ |
| 43 | void wpas_rrm_reset(struct wpa_supplicant *wpa_s) |
| 44 | { |
| 45 | wpa_s->rrm.rrm_used = 0; |
| 46 | |
| 47 | eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm, |
| 48 | NULL); |
| 49 | if (wpa_s->rrm.notify_neighbor_rep) |
| 50 | wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL); |
| 51 | wpa_s->rrm.next_neighbor_rep_token = 1; |
| 52 | wpas_clear_beacon_rep_data(wpa_s); |
| 53 | } |
| 54 | |
| 55 | |
| 56 | /* |
| 57 | * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report |
| 58 | * @wpa_s: Pointer to wpa_supplicant |
| 59 | * @report: Neighbor report buffer, prefixed by a 1-byte dialog token |
| 60 | * @report_len: Length of neighbor report buffer |
| 61 | */ |
| 62 | void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s, |
| 63 | const u8 *report, size_t report_len) |
| 64 | { |
| 65 | struct wpabuf *neighbor_rep; |
| 66 | |
| 67 | wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len); |
| 68 | if (report_len < 1) |
| 69 | return; |
| 70 | |
| 71 | if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) { |
| 72 | wpa_printf(MSG_DEBUG, |
| 73 | "RRM: Discarding neighbor report with token %d (expected %d)", |
| 74 | report[0], wpa_s->rrm.next_neighbor_rep_token - 1); |
| 75 | return; |
| 76 | } |
| 77 | |
| 78 | eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm, |
| 79 | NULL); |
| 80 | |
| 81 | if (!wpa_s->rrm.notify_neighbor_rep) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 82 | wpa_msg(wpa_s, MSG_INFO, "RRM: Unexpected neighbor report"); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 83 | return; |
| 84 | } |
| 85 | |
| 86 | /* skipping the first byte, which is only an id (dialog token) */ |
| 87 | neighbor_rep = wpabuf_alloc(report_len - 1); |
| 88 | if (!neighbor_rep) { |
| 89 | wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL); |
| 90 | return; |
| 91 | } |
| 92 | wpabuf_put_data(neighbor_rep, report + 1, report_len - 1); |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 93 | wpa_dbg(wpa_s, MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)", |
| 94 | report[0]); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 95 | wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx, |
| 96 | neighbor_rep); |
| 97 | wpa_s->rrm.notify_neighbor_rep = NULL; |
| 98 | wpa_s->rrm.neighbor_rep_cb_ctx = NULL; |
| 99 | } |
| 100 | |
| 101 | |
| 102 | #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS) |
| 103 | /* Workaround different, undefined for Windows, error codes used here */ |
Hai Shalom | c356592 | 2019-10-28 11:58:20 -0700 | [diff] [blame] | 104 | #ifndef ENOTCONN |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 105 | #define ENOTCONN -1 |
Hai Shalom | c356592 | 2019-10-28 11:58:20 -0700 | [diff] [blame] | 106 | #endif |
| 107 | #ifndef EOPNOTSUPP |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 108 | #define EOPNOTSUPP -1 |
Hai Shalom | c356592 | 2019-10-28 11:58:20 -0700 | [diff] [blame] | 109 | #endif |
| 110 | #ifndef ECANCELED |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 111 | #define ECANCELED -1 |
| 112 | #endif |
Hai Shalom | c356592 | 2019-10-28 11:58:20 -0700 | [diff] [blame] | 113 | #endif |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 114 | |
| 115 | /* Measurement Request element + Location Subject + Maximum Age subelement */ |
| 116 | #define MEASURE_REQUEST_LCI_LEN (3 + 1 + 4) |
| 117 | /* Measurement Request element + Location Civic Request */ |
| 118 | #define MEASURE_REQUEST_CIVIC_LEN (3 + 5) |
| 119 | |
| 120 | |
| 121 | /** |
| 122 | * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP |
| 123 | * @wpa_s: Pointer to wpa_supplicant |
| 124 | * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE |
| 125 | * is sent in the request. |
| 126 | * @lci: if set, neighbor request will include LCI request |
| 127 | * @civic: if set, neighbor request will include civic location request |
| 128 | * @cb: Callback function to be called once the requested report arrives, or |
| 129 | * timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds. |
| 130 | * In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's |
| 131 | * the requester's responsibility to free it. |
| 132 | * In the latter case NULL will be sent in 'neighbor_rep'. |
| 133 | * @cb_ctx: Context value to send the callback function |
| 134 | * Returns: 0 in case of success, negative error code otherwise |
| 135 | * |
| 136 | * In case there is a previous request which has not been answered yet, the |
| 137 | * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT. |
| 138 | * Request must contain a callback function. |
| 139 | */ |
| 140 | int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s, |
| 141 | const struct wpa_ssid_value *ssid, |
| 142 | int lci, int civic, |
| 143 | void (*cb)(void *ctx, |
| 144 | struct wpabuf *neighbor_rep), |
| 145 | void *cb_ctx) |
| 146 | { |
| 147 | struct wpabuf *buf; |
| 148 | const u8 *rrm_ie; |
| 149 | |
| 150 | if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 151 | wpa_dbg(wpa_s, MSG_DEBUG, "RRM: No connection, no RRM."); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 152 | return -ENOTCONN; |
| 153 | } |
| 154 | |
| 155 | if (!wpa_s->rrm.rrm_used) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 156 | wpa_dbg(wpa_s, MSG_DEBUG, "RRM: No RRM in current connection."); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 157 | return -EOPNOTSUPP; |
| 158 | } |
| 159 | |
| 160 | rrm_ie = wpa_bss_get_ie(wpa_s->current_bss, |
| 161 | WLAN_EID_RRM_ENABLED_CAPABILITIES); |
| 162 | if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) || |
| 163 | !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 164 | wpa_dbg(wpa_s, MSG_DEBUG, |
| 165 | "RRM: No network support for Neighbor Report."); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 166 | return -EOPNOTSUPP; |
| 167 | } |
| 168 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 169 | /* Refuse if there's a live request */ |
| 170 | if (wpa_s->rrm.notify_neighbor_rep) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 171 | wpa_dbg(wpa_s, MSG_DEBUG, |
| 172 | "RRM: Currently handling previous Neighbor Report."); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 173 | return -EBUSY; |
| 174 | } |
| 175 | |
| 176 | /* 3 = action category + action code + dialog token */ |
| 177 | buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0) + |
| 178 | (lci ? 2 + MEASURE_REQUEST_LCI_LEN : 0) + |
| 179 | (civic ? 2 + MEASURE_REQUEST_CIVIC_LEN : 0)); |
| 180 | if (buf == NULL) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 181 | wpa_dbg(wpa_s, MSG_DEBUG, |
| 182 | "RRM: Failed to allocate Neighbor Report Request"); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 183 | return -ENOMEM; |
| 184 | } |
| 185 | |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 186 | wpa_dbg(wpa_s, MSG_DEBUG, |
| 187 | "RRM: Neighbor report request (for %s), token=%d", |
| 188 | (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""), |
| 189 | wpa_s->rrm.next_neighbor_rep_token); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 190 | |
| 191 | wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT); |
| 192 | wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST); |
| 193 | wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token); |
| 194 | if (ssid) { |
| 195 | wpabuf_put_u8(buf, WLAN_EID_SSID); |
| 196 | wpabuf_put_u8(buf, ssid->ssid_len); |
| 197 | wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len); |
| 198 | } |
| 199 | |
| 200 | if (lci) { |
| 201 | /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */ |
| 202 | wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST); |
| 203 | wpabuf_put_u8(buf, MEASURE_REQUEST_LCI_LEN); |
| 204 | |
| 205 | /* |
| 206 | * Measurement token; nonzero number that is unique among the |
| 207 | * Measurement Request elements in a particular frame. |
| 208 | */ |
| 209 | wpabuf_put_u8(buf, 1); /* Measurement Token */ |
| 210 | |
| 211 | /* |
| 212 | * Parallel, Enable, Request, and Report bits are 0, Duration is |
| 213 | * reserved. |
| 214 | */ |
| 215 | wpabuf_put_u8(buf, 0); /* Measurement Request Mode */ |
| 216 | wpabuf_put_u8(buf, MEASURE_TYPE_LCI); /* Measurement Type */ |
| 217 | |
| 218 | /* IEEE P802.11-REVmc/D5.0 9.4.2.21.10 - LCI request */ |
| 219 | /* Location Subject */ |
| 220 | wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE); |
| 221 | |
| 222 | /* Optional Subelements */ |
| 223 | /* |
| 224 | * IEEE P802.11-REVmc/D5.0 Figure 9-170 |
| 225 | * The Maximum Age subelement is required, otherwise the AP can |
| 226 | * send only data that was determined after receiving the |
| 227 | * request. Setting it here to unlimited age. |
| 228 | */ |
| 229 | wpabuf_put_u8(buf, LCI_REQ_SUBELEM_MAX_AGE); |
| 230 | wpabuf_put_u8(buf, 2); |
| 231 | wpabuf_put_le16(buf, 0xffff); |
| 232 | } |
| 233 | |
| 234 | if (civic) { |
| 235 | /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */ |
| 236 | wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST); |
| 237 | wpabuf_put_u8(buf, MEASURE_REQUEST_CIVIC_LEN); |
| 238 | |
| 239 | /* |
| 240 | * Measurement token; nonzero number that is unique among the |
| 241 | * Measurement Request elements in a particular frame. |
| 242 | */ |
| 243 | wpabuf_put_u8(buf, 2); /* Measurement Token */ |
| 244 | |
| 245 | /* |
| 246 | * Parallel, Enable, Request, and Report bits are 0, Duration is |
| 247 | * reserved. |
| 248 | */ |
| 249 | wpabuf_put_u8(buf, 0); /* Measurement Request Mode */ |
| 250 | /* Measurement Type */ |
| 251 | wpabuf_put_u8(buf, MEASURE_TYPE_LOCATION_CIVIC); |
| 252 | |
| 253 | /* IEEE P802.11-REVmc/D5.0 9.4.2.21.14: |
| 254 | * Location Civic request */ |
| 255 | /* Location Subject */ |
| 256 | wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE); |
| 257 | wpabuf_put_u8(buf, 0); /* Civic Location Type: IETF RFC 4776 */ |
| 258 | /* Location Service Interval Units: Seconds */ |
| 259 | wpabuf_put_u8(buf, 0); |
| 260 | /* Location Service Interval: 0 - Only one report is requested |
| 261 | */ |
| 262 | wpabuf_put_le16(buf, 0); |
| 263 | /* No optional subelements */ |
| 264 | } |
| 265 | |
| 266 | wpa_s->rrm.next_neighbor_rep_token++; |
| 267 | |
| 268 | if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid, |
| 269 | wpa_s->own_addr, wpa_s->bssid, |
| 270 | wpabuf_head(buf), wpabuf_len(buf), 0) < 0) { |
Ahmed ElArabawy | 0ff61c5 | 2019-12-26 12:38:39 -0800 | [diff] [blame] | 271 | wpa_dbg(wpa_s, MSG_DEBUG, |
| 272 | "RRM: Failed to send Neighbor Report Request"); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 273 | wpabuf_free(buf); |
| 274 | return -ECANCELED; |
| 275 | } |
| 276 | |
| 277 | wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx; |
| 278 | wpa_s->rrm.notify_neighbor_rep = cb; |
| 279 | eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0, |
| 280 | wpas_rrm_neighbor_rep_timeout_handler, |
| 281 | &wpa_s->rrm, NULL); |
| 282 | |
| 283 | wpabuf_free(buf); |
| 284 | return 0; |
| 285 | } |
| 286 | |
| 287 | |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 288 | static int wpas_rrm_report_elem(struct wpabuf **buf, u8 token, u8 mode, u8 type, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 289 | const u8 *data, size_t data_len) |
| 290 | { |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 291 | if (wpabuf_resize(buf, 5 + data_len)) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 292 | return -1; |
| 293 | |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 294 | wpabuf_put_u8(*buf, WLAN_EID_MEASURE_REPORT); |
| 295 | wpabuf_put_u8(*buf, 3 + data_len); |
| 296 | wpabuf_put_u8(*buf, token); |
| 297 | wpabuf_put_u8(*buf, mode); |
| 298 | wpabuf_put_u8(*buf, type); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 299 | |
| 300 | if (data_len) |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 301 | wpabuf_put_data(*buf, data, data_len); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 302 | |
| 303 | return 0; |
| 304 | } |
| 305 | |
| 306 | |
| 307 | static int |
| 308 | wpas_rrm_build_lci_report(struct wpa_supplicant *wpa_s, |
| 309 | const struct rrm_measurement_request_element *req, |
| 310 | struct wpabuf **buf) |
| 311 | { |
| 312 | u8 subject; |
| 313 | u16 max_age = 0; |
| 314 | struct os_reltime t, diff; |
| 315 | unsigned long diff_l; |
| 316 | const u8 *subelem; |
| 317 | const u8 *request = req->variable; |
| 318 | size_t len = req->len - 3; |
| 319 | |
| 320 | if (len < 1) |
| 321 | return -1; |
| 322 | |
| 323 | if (!wpa_s->lci) |
| 324 | goto reject; |
| 325 | |
| 326 | subject = *request++; |
| 327 | len--; |
| 328 | |
| 329 | wpa_printf(MSG_DEBUG, "Measurement request location subject=%u", |
| 330 | subject); |
| 331 | |
| 332 | if (subject != LOCATION_SUBJECT_REMOTE) { |
| 333 | wpa_printf(MSG_INFO, |
| 334 | "Not building LCI report - bad location subject"); |
| 335 | return 0; |
| 336 | } |
| 337 | |
| 338 | /* Subelements are formatted exactly like elements */ |
| 339 | wpa_hexdump(MSG_DEBUG, "LCI request subelements", request, len); |
| 340 | subelem = get_ie(request, len, LCI_REQ_SUBELEM_MAX_AGE); |
| 341 | if (subelem && subelem[1] == 2) |
| 342 | max_age = WPA_GET_LE16(subelem + 2); |
| 343 | |
| 344 | if (os_get_reltime(&t)) |
| 345 | goto reject; |
| 346 | |
| 347 | os_reltime_sub(&t, &wpa_s->lci_time, &diff); |
| 348 | /* LCI age is calculated in 10th of a second units. */ |
| 349 | diff_l = diff.sec * 10 + diff.usec / 100000; |
| 350 | |
| 351 | if (max_age != 0xffff && max_age < diff_l) |
| 352 | goto reject; |
| 353 | |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 354 | if (wpas_rrm_report_elem(buf, req->token, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 355 | MEASUREMENT_REPORT_MODE_ACCEPT, req->type, |
| 356 | wpabuf_head_u8(wpa_s->lci), |
| 357 | wpabuf_len(wpa_s->lci)) < 0) { |
| 358 | wpa_printf(MSG_DEBUG, "Failed to add LCI report element"); |
| 359 | return -1; |
| 360 | } |
| 361 | |
| 362 | return 0; |
| 363 | |
| 364 | reject: |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 365 | if (!is_multicast_ether_addr(wpa_s->rrm.dst_addr) && |
| 366 | wpas_rrm_report_elem(buf, req->token, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 367 | MEASUREMENT_REPORT_MODE_REJECT_INCAPABLE, |
| 368 | req->type, NULL, 0) < 0) { |
| 369 | wpa_printf(MSG_DEBUG, "RRM: Failed to add report element"); |
| 370 | return -1; |
| 371 | } |
| 372 | |
| 373 | return 0; |
| 374 | } |
| 375 | |
| 376 | |
| 377 | static void wpas_rrm_send_msr_report_mpdu(struct wpa_supplicant *wpa_s, |
| 378 | const u8 *data, size_t len) |
| 379 | { |
| 380 | struct wpabuf *report = wpabuf_alloc(len + 3); |
| 381 | |
| 382 | if (!report) |
| 383 | return; |
| 384 | |
| 385 | wpabuf_put_u8(report, WLAN_ACTION_RADIO_MEASUREMENT); |
| 386 | wpabuf_put_u8(report, WLAN_RRM_RADIO_MEASUREMENT_REPORT); |
| 387 | wpabuf_put_u8(report, wpa_s->rrm.token); |
| 388 | |
| 389 | wpabuf_put_data(report, data, len); |
| 390 | |
| 391 | if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid, |
| 392 | wpa_s->own_addr, wpa_s->bssid, |
| 393 | wpabuf_head(report), wpabuf_len(report), 0)) { |
| 394 | wpa_printf(MSG_ERROR, |
| 395 | "RRM: Radio measurement report failed: Sending Action frame failed"); |
| 396 | } |
| 397 | |
| 398 | wpabuf_free(report); |
| 399 | } |
| 400 | |
| 401 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 402 | static int wpas_rrm_beacon_rep_update_last_frame(u8 *pos, size_t len) |
| 403 | { |
| 404 | struct rrm_measurement_report_element *msr_rep; |
| 405 | u8 *end = pos + len; |
| 406 | u8 *msr_rep_end; |
Hai Shalom | 5f92bc9 | 2019-04-18 11:54:11 -0700 | [diff] [blame] | 407 | struct rrm_measurement_beacon_report *rep = NULL; |
| 408 | u8 *subelem; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 409 | |
Hai Shalom | 5f92bc9 | 2019-04-18 11:54:11 -0700 | [diff] [blame] | 410 | /* Find the last beacon report element */ |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 411 | while (end - pos >= (int) sizeof(*msr_rep)) { |
| 412 | msr_rep = (struct rrm_measurement_report_element *) pos; |
| 413 | msr_rep_end = pos + msr_rep->len + 2; |
| 414 | |
| 415 | if (msr_rep->eid != WLAN_EID_MEASURE_REPORT || |
| 416 | msr_rep_end > end) { |
| 417 | /* Should not happen. This indicates a bug. */ |
| 418 | wpa_printf(MSG_ERROR, |
| 419 | "RRM: non-measurement report element in measurement report frame"); |
| 420 | return -1; |
| 421 | } |
| 422 | |
Hai Shalom | 5f92bc9 | 2019-04-18 11:54:11 -0700 | [diff] [blame] | 423 | if (msr_rep->type == MEASURE_TYPE_BEACON) |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 424 | rep = (struct rrm_measurement_beacon_report *) |
| 425 | msr_rep->variable; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 426 | |
| 427 | pos += pos[1] + 2; |
| 428 | } |
| 429 | |
Hai Shalom | 5f92bc9 | 2019-04-18 11:54:11 -0700 | [diff] [blame] | 430 | if (!rep) |
| 431 | return 0; |
| 432 | |
| 433 | subelem = rep->variable; |
| 434 | while (subelem + 2 < msr_rep_end && |
| 435 | subelem[0] != WLAN_BEACON_REPORT_SUBELEM_LAST_INDICATION) |
| 436 | subelem += 2 + subelem[1]; |
| 437 | |
| 438 | if (subelem + 2 < msr_rep_end && |
| 439 | subelem[0] == WLAN_BEACON_REPORT_SUBELEM_LAST_INDICATION && |
| 440 | subelem[1] == 1 && |
| 441 | subelem + BEACON_REPORT_LAST_INDICATION_SUBELEM_LEN <= end) |
| 442 | subelem[2] = 1; |
| 443 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 444 | return 0; |
| 445 | } |
| 446 | |
| 447 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 448 | static void wpas_rrm_send_msr_report(struct wpa_supplicant *wpa_s, |
| 449 | struct wpabuf *buf) |
| 450 | { |
| 451 | int len = wpabuf_len(buf); |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 452 | u8 *pos = wpabuf_mhead_u8(buf), *next = pos; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 453 | |
| 454 | #define MPDU_REPORT_LEN (int) (IEEE80211_MAX_MMPDU_SIZE - IEEE80211_HDRLEN - 3) |
| 455 | |
| 456 | while (len) { |
| 457 | int send_len = (len > MPDU_REPORT_LEN) ? next - pos : len; |
| 458 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 459 | if (send_len == len) |
| 460 | wpas_rrm_beacon_rep_update_last_frame(pos, len); |
| 461 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 462 | if (send_len == len || |
| 463 | (send_len + next[1] + 2) > MPDU_REPORT_LEN) { |
| 464 | wpas_rrm_send_msr_report_mpdu(wpa_s, pos, send_len); |
| 465 | len -= send_len; |
| 466 | pos = next; |
| 467 | } |
| 468 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 469 | if (len) |
| 470 | next += next[1] + 2; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 471 | } |
| 472 | #undef MPDU_REPORT_LEN |
| 473 | } |
| 474 | |
| 475 | |
| 476 | static int wpas_add_channel(u8 op_class, u8 chan, u8 num_primary_channels, |
| 477 | int *freqs) |
| 478 | { |
| 479 | size_t i; |
| 480 | |
| 481 | for (i = 0; i < num_primary_channels; i++) { |
| 482 | u8 primary_chan = chan - (2 * num_primary_channels - 2) + i * 4; |
| 483 | |
| 484 | freqs[i] = ieee80211_chan_to_freq(NULL, op_class, primary_chan); |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 485 | /* ieee80211_chan_to_freq() is not really meant for this |
| 486 | * conversion of 20 MHz primary channel numbers for wider VHT |
| 487 | * channels, so handle those as special cases here for now. */ |
| 488 | if (freqs[i] < 0 && |
| 489 | (op_class == 128 || op_class == 129 || op_class == 130)) |
| 490 | freqs[i] = 5000 + 5 * primary_chan; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 491 | if (freqs[i] < 0) { |
| 492 | wpa_printf(MSG_DEBUG, |
| 493 | "Beacon Report: Invalid channel %u", |
| 494 | chan); |
| 495 | return -1; |
| 496 | } |
| 497 | } |
| 498 | |
| 499 | return 0; |
| 500 | } |
| 501 | |
| 502 | |
| 503 | static int * wpas_add_channels(const struct oper_class_map *op, |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 504 | struct hostapd_hw_modes *mode, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 505 | const u8 *channels, const u8 size) |
| 506 | { |
| 507 | int *freqs, *next_freq; |
| 508 | u8 num_primary_channels, i; |
| 509 | u8 num_chans; |
| 510 | |
| 511 | num_chans = channels ? size : |
| 512 | (op->max_chan - op->min_chan) / op->inc + 1; |
| 513 | |
| 514 | if (op->bw == BW80 || op->bw == BW80P80) |
| 515 | num_primary_channels = 4; |
| 516 | else if (op->bw == BW160) |
| 517 | num_primary_channels = 8; |
Sunil Ravi | 99c035e | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 518 | else if (op->bw == BW320) |
| 519 | num_primary_channels = 16; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 520 | else |
| 521 | num_primary_channels = 1; |
| 522 | |
| 523 | /* one extra place for the zero-terminator */ |
| 524 | freqs = os_calloc(num_chans * num_primary_channels + 1, sizeof(*freqs)); |
| 525 | if (!freqs) { |
| 526 | wpa_printf(MSG_ERROR, |
| 527 | "Beacon Report: Failed to allocate freqs array"); |
| 528 | return NULL; |
| 529 | } |
| 530 | |
| 531 | next_freq = freqs; |
| 532 | for (i = 0; i < num_chans; i++) { |
| 533 | u8 chan = channels ? channels[i] : op->min_chan + i * op->inc; |
Hai Shalom | c356592 | 2019-10-28 11:58:20 -0700 | [diff] [blame] | 534 | enum chan_allowed res = verify_channel(mode, op->op_class, chan, |
| 535 | op->bw); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 536 | |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 537 | if (res == NOT_ALLOWED) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 538 | continue; |
| 539 | |
| 540 | if (wpas_add_channel(op->op_class, chan, num_primary_channels, |
| 541 | next_freq) < 0) { |
| 542 | os_free(freqs); |
| 543 | return NULL; |
| 544 | } |
| 545 | |
| 546 | next_freq += num_primary_channels; |
| 547 | } |
| 548 | |
| 549 | if (!freqs[0]) { |
| 550 | os_free(freqs); |
| 551 | return NULL; |
| 552 | } |
| 553 | |
| 554 | return freqs; |
| 555 | } |
| 556 | |
| 557 | |
| 558 | static int * wpas_op_class_freqs(const struct oper_class_map *op, |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 559 | struct hostapd_hw_modes *mode) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 560 | { |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 561 | u8 channels_80mhz_5ghz[] = { 42, 58, 106, 122, 138, 155, 171 }; |
| 562 | u8 channels_160mhz_5ghz[] = { 50, 114, 163 }; |
| 563 | u8 channels_80mhz_6ghz[] = { 7, 23, 39, 55, 71, 87, 103, 119, 135, 151, |
| 564 | 167, 183, 199, 215 }; |
| 565 | u8 channels_160mhz_6ghz[] = { 15, 47, 79, 111, 143, 175, 207 }; |
Sunil Ravi | 99c035e | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 566 | u8 channels_320mhz_6ghz[] = { 31, 63, 95, 127, 159, 191 }; |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 567 | const u8 *channels = NULL; |
| 568 | size_t num_chan = 0; |
| 569 | bool is_6ghz = is_6ghz_op_class(op->op_class); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 570 | |
| 571 | /* |
| 572 | * When adding all channels in the operating class, 80 + 80 MHz |
| 573 | * operating classes are like 80 MHz channels because we add all valid |
| 574 | * channels anyway. |
| 575 | */ |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 576 | if (op->bw == BW80 || op->bw == BW80P80) { |
| 577 | channels = is_6ghz ? channels_80mhz_6ghz : channels_80mhz_5ghz; |
| 578 | num_chan = is_6ghz ? ARRAY_SIZE(channels_80mhz_6ghz) : |
| 579 | ARRAY_SIZE(channels_80mhz_5ghz); |
| 580 | } else if (op->bw == BW160) { |
| 581 | channels = is_6ghz ? channels_160mhz_6ghz : |
| 582 | channels_160mhz_5ghz; |
| 583 | num_chan = is_6ghz ? ARRAY_SIZE(channels_160mhz_6ghz) : |
| 584 | ARRAY_SIZE(channels_160mhz_5ghz); |
Sunil Ravi | 99c035e | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 585 | } else if (op->bw == BW320) { |
| 586 | channels = channels_320mhz_6ghz; |
| 587 | num_chan = ARRAY_SIZE(channels_320mhz_6ghz); |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 588 | } |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 589 | |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 590 | return wpas_add_channels(op, mode, channels, num_chan); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 591 | } |
| 592 | |
| 593 | |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 594 | static int * wpas_channel_report_freqs(struct wpa_supplicant *wpa_s, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 595 | const char *country, const u8 *subelems, |
| 596 | size_t len) |
| 597 | { |
| 598 | int *freqs = NULL, *new_freqs; |
| 599 | const u8 *end = subelems + len; |
| 600 | |
| 601 | while (end - subelems > 2) { |
| 602 | const struct oper_class_map *op; |
| 603 | const u8 *ap_chan_elem, *pos; |
| 604 | u8 left; |
| 605 | struct hostapd_hw_modes *mode; |
| 606 | |
| 607 | ap_chan_elem = get_ie(subelems, end - subelems, |
| 608 | WLAN_BEACON_REQUEST_SUBELEM_AP_CHANNEL); |
| 609 | if (!ap_chan_elem) |
| 610 | break; |
| 611 | pos = ap_chan_elem + 2; |
| 612 | left = ap_chan_elem[1]; |
| 613 | if (left < 1) |
| 614 | break; |
| 615 | subelems = ap_chan_elem + 2 + left; |
| 616 | |
| 617 | op = get_oper_class(country, *pos); |
| 618 | if (!op) { |
| 619 | wpa_printf(MSG_DEBUG, |
| 620 | "Beacon request: unknown operating class in AP Channel Report subelement %u", |
| 621 | *pos); |
| 622 | goto out; |
| 623 | } |
| 624 | pos++; |
| 625 | left--; |
| 626 | |
Hai Shalom | fdcde76 | 2020-04-02 11:19:20 -0700 | [diff] [blame] | 627 | mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, op->mode, |
| 628 | is_6ghz_op_class(op->op_class)); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 629 | if (!mode) |
| 630 | continue; |
| 631 | |
| 632 | /* |
| 633 | * For 80 + 80 MHz operating classes, this AP Channel Report |
| 634 | * element should be followed by another element specifying |
| 635 | * the second 80 MHz channel. For now just add this 80 MHz |
| 636 | * channel, the second 80 MHz channel will be added when the |
| 637 | * next element is parsed. |
| 638 | * TODO: Verify that this AP Channel Report element is followed |
| 639 | * by a corresponding AP Channel Report element as specified in |
| 640 | * IEEE Std 802.11-2016, 11.11.9.1. |
| 641 | */ |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 642 | new_freqs = wpas_add_channels(op, mode, pos, left); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 643 | if (new_freqs) |
| 644 | int_array_concat(&freqs, new_freqs); |
| 645 | |
| 646 | os_free(new_freqs); |
| 647 | } |
| 648 | |
| 649 | return freqs; |
| 650 | out: |
| 651 | os_free(freqs); |
| 652 | return NULL; |
| 653 | } |
| 654 | |
| 655 | |
| 656 | static int * wpas_beacon_request_freqs(struct wpa_supplicant *wpa_s, |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 657 | u8 op_class, u8 chan, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 658 | const u8 *subelems, size_t len) |
| 659 | { |
| 660 | int *freqs = NULL, *ext_freqs = NULL; |
| 661 | struct hostapd_hw_modes *mode; |
| 662 | const char *country = NULL; |
| 663 | const struct oper_class_map *op; |
| 664 | const u8 *elem; |
| 665 | |
| 666 | if (!wpa_s->current_bss) |
| 667 | return NULL; |
| 668 | elem = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_COUNTRY); |
| 669 | if (elem && elem[1] >= 2) |
| 670 | country = (const char *) (elem + 2); |
| 671 | |
| 672 | op = get_oper_class(country, op_class); |
| 673 | if (!op) { |
| 674 | wpa_printf(MSG_DEBUG, |
| 675 | "Beacon request: invalid operating class %d", |
| 676 | op_class); |
| 677 | return NULL; |
| 678 | } |
| 679 | |
Hai Shalom | fdcde76 | 2020-04-02 11:19:20 -0700 | [diff] [blame] | 680 | mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, op->mode, |
| 681 | is_6ghz_op_class(op->op_class)); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 682 | if (!mode) |
| 683 | return NULL; |
| 684 | |
| 685 | switch (chan) { |
| 686 | case 0: |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 687 | freqs = wpas_op_class_freqs(op, mode); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 688 | if (!freqs) |
| 689 | return NULL; |
| 690 | break; |
| 691 | case 255: |
| 692 | /* freqs will be added from AP channel subelements */ |
| 693 | break; |
| 694 | default: |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 695 | freqs = wpas_add_channels(op, mode, &chan, 1); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 696 | if (!freqs) |
| 697 | return NULL; |
| 698 | break; |
| 699 | } |
| 700 | |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 701 | ext_freqs = wpas_channel_report_freqs(wpa_s, country, subelems, len); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 702 | if (ext_freqs) { |
| 703 | int_array_concat(&freqs, ext_freqs); |
| 704 | os_free(ext_freqs); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 705 | int_array_sort_unique(freqs); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 706 | } |
| 707 | |
| 708 | return freqs; |
| 709 | } |
| 710 | |
| 711 | |
Hai Shalom | fdcde76 | 2020-04-02 11:19:20 -0700 | [diff] [blame] | 712 | int wpas_get_op_chan_phy(int freq, const u8 *ies, size_t ies_len, |
| 713 | u8 *op_class, u8 *chan, u8 *phy_type) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 714 | { |
| 715 | const u8 *ie; |
| 716 | int sec_chan = 0, vht = 0; |
| 717 | struct ieee80211_ht_operation *ht_oper = NULL; |
| 718 | struct ieee80211_vht_operation *vht_oper = NULL; |
| 719 | u8 seg0, seg1; |
| 720 | |
| 721 | ie = get_ie(ies, ies_len, WLAN_EID_HT_OPERATION); |
| 722 | if (ie && ie[1] >= sizeof(struct ieee80211_ht_operation)) { |
| 723 | u8 sec_chan_offset; |
| 724 | |
| 725 | ht_oper = (struct ieee80211_ht_operation *) (ie + 2); |
| 726 | sec_chan_offset = ht_oper->ht_param & |
| 727 | HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK; |
| 728 | if (sec_chan_offset == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE) |
| 729 | sec_chan = 1; |
| 730 | else if (sec_chan_offset == |
| 731 | HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW) |
| 732 | sec_chan = -1; |
| 733 | } |
| 734 | |
| 735 | ie = get_ie(ies, ies_len, WLAN_EID_VHT_OPERATION); |
| 736 | if (ie && ie[1] >= sizeof(struct ieee80211_vht_operation)) { |
| 737 | vht_oper = (struct ieee80211_vht_operation *) (ie + 2); |
| 738 | |
| 739 | switch (vht_oper->vht_op_info_chwidth) { |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 740 | case CHANWIDTH_80MHZ: |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 741 | seg0 = vht_oper->vht_op_info_chan_center_freq_seg0_idx; |
| 742 | seg1 = vht_oper->vht_op_info_chan_center_freq_seg1_idx; |
| 743 | if (seg1 && abs(seg1 - seg0) == 8) |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 744 | vht = CONF_OPER_CHWIDTH_160MHZ; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 745 | else if (seg1) |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 746 | vht = CONF_OPER_CHWIDTH_80P80MHZ; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 747 | else |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 748 | vht = CONF_OPER_CHWIDTH_80MHZ; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 749 | break; |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 750 | case CHANWIDTH_160MHZ: |
| 751 | vht = CONF_OPER_CHWIDTH_160MHZ; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 752 | break; |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 753 | case CHANWIDTH_80P80MHZ: |
| 754 | vht = CONF_OPER_CHWIDTH_80P80MHZ; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 755 | break; |
| 756 | default: |
Sunil | 8cd6f4d | 2022-06-28 18:40:46 +0000 | [diff] [blame] | 757 | vht = CONF_OPER_CHWIDTH_USE_HT; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 758 | break; |
| 759 | } |
| 760 | } |
| 761 | |
| 762 | if (ieee80211_freq_to_channel_ext(freq, sec_chan, vht, op_class, |
| 763 | chan) == NUM_HOSTAPD_MODES) { |
| 764 | wpa_printf(MSG_DEBUG, |
| 765 | "Cannot determine operating class and channel"); |
| 766 | return -1; |
| 767 | } |
| 768 | |
| 769 | *phy_type = ieee80211_get_phy_type(freq, ht_oper != NULL, |
| 770 | vht_oper != NULL); |
| 771 | if (*phy_type == PHY_TYPE_UNSPECIFIED) { |
| 772 | wpa_printf(MSG_DEBUG, "Cannot determine phy type"); |
| 773 | return -1; |
| 774 | } |
| 775 | |
| 776 | return 0; |
| 777 | } |
| 778 | |
| 779 | |
| 780 | static int wpas_beacon_rep_add_frame_body(struct bitfield *eids, |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 781 | struct bitfield *ext_eids, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 782 | enum beacon_report_detail detail, |
| 783 | struct wpa_bss *bss, u8 *buf, |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 784 | size_t buf_len, const u8 **ies_buf, |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 785 | size_t *ie_len, int add_fixed) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 786 | { |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 787 | const u8 *ies = *ies_buf; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 788 | size_t ies_len = *ie_len; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 789 | u8 *pos = buf; |
| 790 | int rem_len; |
| 791 | |
| 792 | rem_len = 255 - sizeof(struct rrm_measurement_beacon_report) - |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 793 | sizeof(struct rrm_measurement_report_element) - 2 - |
| 794 | REPORTED_FRAME_BODY_SUBELEM_LEN; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 795 | |
| 796 | if (detail > BEACON_REPORT_DETAIL_ALL_FIELDS_AND_ELEMENTS) { |
| 797 | wpa_printf(MSG_DEBUG, |
| 798 | "Beacon Request: Invalid reporting detail: %d", |
| 799 | detail); |
| 800 | return -1; |
| 801 | } |
| 802 | |
| 803 | if (detail == BEACON_REPORT_DETAIL_NONE) |
| 804 | return 0; |
| 805 | |
| 806 | /* |
| 807 | * Minimal frame body subelement size: EID(1) + length(1) + TSF(8) + |
| 808 | * beacon interval(2) + capabilities(2) = 14 bytes |
| 809 | */ |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 810 | if (add_fixed && buf_len < 14) |
| 811 | return -1; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 812 | |
| 813 | *pos++ = WLAN_BEACON_REPORT_SUBELEM_FRAME_BODY; |
| 814 | /* The length will be filled later */ |
| 815 | pos++; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 816 | |
| 817 | if (add_fixed) { |
| 818 | WPA_PUT_LE64(pos, bss->tsf); |
| 819 | pos += sizeof(bss->tsf); |
| 820 | WPA_PUT_LE16(pos, bss->beacon_int); |
| 821 | pos += 2; |
| 822 | WPA_PUT_LE16(pos, bss->caps); |
| 823 | pos += 2; |
| 824 | } |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 825 | |
| 826 | rem_len -= pos - buf; |
| 827 | |
| 828 | /* |
| 829 | * According to IEEE Std 802.11-2016, 9.4.2.22.7, if the reported frame |
| 830 | * body subelement causes the element to exceed the maximum element |
| 831 | * size, the subelement is truncated so that the last IE is a complete |
| 832 | * IE. So even when required to report all IEs, add elements one after |
| 833 | * the other and stop once there is no more room in the measurement |
| 834 | * element. |
| 835 | */ |
| 836 | while (ies_len > 2 && 2U + ies[1] <= ies_len && rem_len > 0) { |
| 837 | if (detail == BEACON_REPORT_DETAIL_ALL_FIELDS_AND_ELEMENTS || |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 838 | (eids && bitfield_is_set(eids, ies[0])) || |
| 839 | (ext_eids && ies[0] == WLAN_EID_EXTENSION && ies[1] && |
| 840 | bitfield_is_set(ext_eids, ies[2]))) { |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 841 | u8 elen = ies[1]; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 842 | |
| 843 | if (2 + elen > buf + buf_len - pos || |
| 844 | 2 + elen > rem_len) |
| 845 | break; |
| 846 | |
| 847 | *pos++ = ies[0]; |
| 848 | *pos++ = elen; |
| 849 | os_memcpy(pos, ies + 2, elen); |
| 850 | pos += elen; |
| 851 | rem_len -= 2 + elen; |
| 852 | } |
| 853 | |
| 854 | ies_len -= 2 + ies[1]; |
| 855 | ies += 2 + ies[1]; |
| 856 | } |
| 857 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 858 | *ie_len = ies_len; |
| 859 | *ies_buf = ies; |
| 860 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 861 | /* Now the length is known */ |
| 862 | buf[1] = pos - buf - 2; |
| 863 | return pos - buf; |
| 864 | } |
| 865 | |
| 866 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 867 | static int wpas_add_beacon_rep_elem(struct beacon_rep_data *data, |
| 868 | struct wpa_bss *bss, |
| 869 | struct wpabuf **wpa_buf, |
| 870 | struct rrm_measurement_beacon_report *rep, |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 871 | const u8 **ie, size_t *ie_len, u8 idx) |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 872 | { |
| 873 | int ret; |
| 874 | u8 *buf, *pos; |
| 875 | u32 subelems_len = REPORTED_FRAME_BODY_SUBELEM_LEN + |
| 876 | (data->last_indication ? |
| 877 | BEACON_REPORT_LAST_INDICATION_SUBELEM_LEN : 0); |
| 878 | |
| 879 | /* Maximum element length: Beacon Report element + Reported Frame Body |
| 880 | * subelement + all IEs of the reported Beacon frame + Reported Frame |
| 881 | * Body Fragment ID subelement */ |
| 882 | buf = os_malloc(sizeof(*rep) + 14 + *ie_len + subelems_len); |
| 883 | if (!buf) |
| 884 | return -1; |
| 885 | |
| 886 | os_memcpy(buf, rep, sizeof(*rep)); |
| 887 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 888 | ret = wpas_beacon_rep_add_frame_body(data->eids, data->ext_eids, |
| 889 | data->report_detail, |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 890 | bss, buf + sizeof(*rep), |
| 891 | 14 + *ie_len, ie, ie_len, |
| 892 | idx == 0); |
| 893 | if (ret < 0) |
| 894 | goto out; |
| 895 | |
| 896 | pos = buf + ret + sizeof(*rep); |
| 897 | pos[0] = WLAN_BEACON_REPORT_SUBELEM_FRAME_BODY_FRAGMENT_ID; |
| 898 | pos[1] = 2; |
| 899 | |
| 900 | /* |
| 901 | * Only one Beacon Report Measurement is supported at a time, so |
| 902 | * the Beacon Report ID can always be set to 1. |
| 903 | */ |
| 904 | pos[2] = 1; |
| 905 | |
| 906 | /* Fragment ID Number (bits 0..6) and More Frame Body Fragments (bit 7) |
| 907 | */ |
| 908 | pos[3] = idx; |
| 909 | if (data->report_detail != BEACON_REPORT_DETAIL_NONE && *ie_len) |
| 910 | pos[3] |= REPORTED_FRAME_BODY_MORE_FRAGMENTS; |
| 911 | else |
| 912 | pos[3] &= ~REPORTED_FRAME_BODY_MORE_FRAGMENTS; |
| 913 | |
| 914 | pos += REPORTED_FRAME_BODY_SUBELEM_LEN; |
| 915 | |
| 916 | if (data->last_indication) { |
| 917 | pos[0] = WLAN_BEACON_REPORT_SUBELEM_LAST_INDICATION; |
| 918 | pos[1] = 1; |
| 919 | |
| 920 | /* This field will be updated later if this is the last frame */ |
| 921 | pos[2] = 0; |
| 922 | } |
| 923 | |
| 924 | ret = wpas_rrm_report_elem(wpa_buf, data->token, |
| 925 | MEASUREMENT_REPORT_MODE_ACCEPT, |
| 926 | MEASURE_TYPE_BEACON, buf, |
| 927 | ret + sizeof(*rep) + subelems_len); |
| 928 | out: |
| 929 | os_free(buf); |
| 930 | return ret; |
| 931 | } |
| 932 | |
| 933 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 934 | static int wpas_add_beacon_rep(struct wpa_supplicant *wpa_s, |
| 935 | struct wpabuf **wpa_buf, struct wpa_bss *bss, |
| 936 | u64 start, u64 parent_tsf) |
| 937 | { |
| 938 | struct beacon_rep_data *data = &wpa_s->beacon_rep_data; |
Hai Shalom | 6084025 | 2021-02-19 19:02:11 -0800 | [diff] [blame] | 939 | const u8 *ies = wpa_bss_ie_ptr(bss); |
| 940 | const u8 *pos = ies; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 941 | size_t ies_len = bss->ie_len ? bss->ie_len : bss->beacon_ie_len; |
| 942 | struct rrm_measurement_beacon_report rep; |
| 943 | u8 idx = 0; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 944 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 945 | if (!ether_addr_equal(data->bssid, broadcast_ether_addr) && |
| 946 | !ether_addr_equal(data->bssid, bss->bssid)) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 947 | return 0; |
| 948 | |
| 949 | if (data->ssid_len && |
| 950 | (data->ssid_len != bss->ssid_len || |
| 951 | os_memcmp(data->ssid, bss->ssid, bss->ssid_len) != 0)) |
| 952 | return 0; |
| 953 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 954 | if (wpas_get_op_chan_phy(bss->freq, ies, ies_len, &rep.op_class, |
| 955 | &rep.channel, &rep.report_info) < 0) |
| 956 | return 0; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 957 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 958 | rep.start_time = host_to_le64(start); |
| 959 | rep.duration = host_to_le16(data->scan_params.duration); |
| 960 | rep.rcpi = rssi_to_rcpi(bss->level); |
| 961 | rep.rsni = 255; /* 255 indicates that RSNI is not available */ |
| 962 | os_memcpy(rep.bssid, bss->bssid, ETH_ALEN); |
| 963 | rep.antenna_id = 0; /* unknown */ |
| 964 | rep.parent_tsf = host_to_le32(parent_tsf); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 965 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 966 | do { |
| 967 | int ret; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 968 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 969 | ret = wpas_add_beacon_rep_elem(data, bss, wpa_buf, &rep, |
| 970 | &pos, &ies_len, idx++); |
| 971 | if (ret) |
| 972 | return ret; |
| 973 | } while (data->report_detail != BEACON_REPORT_DETAIL_NONE && |
| 974 | ies_len >= 2); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 975 | |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 976 | return 0; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 977 | } |
| 978 | |
| 979 | |
| 980 | static int wpas_beacon_rep_no_results(struct wpa_supplicant *wpa_s, |
| 981 | struct wpabuf **buf) |
| 982 | { |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 983 | return wpas_rrm_report_elem(buf, wpa_s->beacon_rep_data.token, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 984 | MEASUREMENT_REPORT_MODE_ACCEPT, |
| 985 | MEASURE_TYPE_BEACON, NULL, 0); |
| 986 | } |
| 987 | |
| 988 | |
| 989 | static void wpas_beacon_rep_table(struct wpa_supplicant *wpa_s, |
| 990 | struct wpabuf **buf) |
| 991 | { |
| 992 | size_t i; |
| 993 | |
| 994 | for (i = 0; i < wpa_s->last_scan_res_used; i++) { |
| 995 | if (wpas_add_beacon_rep(wpa_s, buf, wpa_s->last_scan_res[i], |
| 996 | 0, 0) < 0) |
| 997 | break; |
| 998 | } |
| 999 | |
| 1000 | if (!(*buf)) |
| 1001 | wpas_beacon_rep_no_results(wpa_s, buf); |
| 1002 | |
| 1003 | wpa_hexdump_buf(MSG_DEBUG, "RRM: Radio Measurement report", *buf); |
| 1004 | } |
| 1005 | |
| 1006 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1007 | void wpas_rrm_refuse_request(struct wpa_supplicant *wpa_s) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1008 | { |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1009 | if (!is_multicast_ether_addr(wpa_s->rrm.dst_addr)) { |
| 1010 | struct wpabuf *buf = NULL; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1011 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1012 | if (wpas_rrm_report_elem(&buf, wpa_s->beacon_rep_data.token, |
| 1013 | MEASUREMENT_REPORT_MODE_REJECT_REFUSED, |
| 1014 | MEASURE_TYPE_BEACON, NULL, 0)) { |
| 1015 | wpa_printf(MSG_ERROR, "RRM: Memory allocation failed"); |
| 1016 | wpabuf_free(buf); |
| 1017 | return; |
| 1018 | } |
| 1019 | |
| 1020 | wpas_rrm_send_msr_report(wpa_s, buf); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1021 | wpabuf_free(buf); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1022 | } |
| 1023 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1024 | wpas_clear_beacon_rep_data(wpa_s); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1025 | } |
| 1026 | |
| 1027 | |
| 1028 | static void wpas_rrm_scan_timeout(void *eloop_ctx, void *timeout_ctx) |
| 1029 | { |
| 1030 | struct wpa_supplicant *wpa_s = eloop_ctx; |
| 1031 | struct wpa_driver_scan_params *params = |
| 1032 | &wpa_s->beacon_rep_data.scan_params; |
| 1033 | u16 prev_duration = params->duration; |
| 1034 | |
| 1035 | if (!wpa_s->current_bss) |
| 1036 | return; |
| 1037 | |
| 1038 | if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_SUPPORT_SET_SCAN_DWELL) && |
| 1039 | params->duration) { |
| 1040 | wpa_printf(MSG_DEBUG, |
| 1041 | "RRM: Cannot set scan duration due to missing driver support"); |
| 1042 | params->duration = 0; |
| 1043 | } |
| 1044 | os_get_reltime(&wpa_s->beacon_rep_scan); |
| 1045 | if (wpa_s->scanning || wpas_p2p_in_progress(wpa_s) || |
Sunil Ravi | 2a14cf1 | 2023-11-21 00:54:38 +0000 | [diff] [blame] | 1046 | wpa_supplicant_trigger_scan(wpa_s, params, true, false)) |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1047 | wpas_rrm_refuse_request(wpa_s); |
| 1048 | params->duration = prev_duration; |
| 1049 | } |
| 1050 | |
| 1051 | |
| 1052 | static int wpas_rm_handle_beacon_req_subelem(struct wpa_supplicant *wpa_s, |
| 1053 | struct beacon_rep_data *data, |
| 1054 | u8 sid, u8 slen, const u8 *subelem) |
| 1055 | { |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1056 | struct bitfield *eids; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1057 | u8 report_info, i; |
| 1058 | |
| 1059 | switch (sid) { |
| 1060 | case WLAN_BEACON_REQUEST_SUBELEM_SSID: |
| 1061 | if (!slen) { |
| 1062 | wpa_printf(MSG_DEBUG, |
| 1063 | "SSID subelement with zero length - wildcard SSID"); |
| 1064 | break; |
| 1065 | } |
| 1066 | |
| 1067 | if (slen > SSID_MAX_LEN) { |
| 1068 | wpa_printf(MSG_DEBUG, |
| 1069 | "Invalid SSID subelement length: %u", slen); |
| 1070 | return -1; |
| 1071 | } |
| 1072 | |
| 1073 | data->ssid_len = slen; |
| 1074 | os_memcpy(data->ssid, subelem, data->ssid_len); |
| 1075 | break; |
| 1076 | case WLAN_BEACON_REQUEST_SUBELEM_INFO: |
| 1077 | if (slen != 2) { |
| 1078 | wpa_printf(MSG_DEBUG, |
| 1079 | "Invalid reporting information subelement length: %u", |
| 1080 | slen); |
| 1081 | return -1; |
| 1082 | } |
| 1083 | |
| 1084 | report_info = subelem[0]; |
| 1085 | if (report_info != 0) { |
| 1086 | wpa_printf(MSG_DEBUG, |
| 1087 | "reporting information=%u is not supported", |
| 1088 | report_info); |
| 1089 | return 0; |
| 1090 | } |
| 1091 | break; |
| 1092 | case WLAN_BEACON_REQUEST_SUBELEM_DETAIL: |
| 1093 | if (slen != 1) { |
| 1094 | wpa_printf(MSG_DEBUG, |
| 1095 | "Invalid reporting detail subelement length: %u", |
| 1096 | slen); |
| 1097 | return -1; |
| 1098 | } |
| 1099 | |
| 1100 | data->report_detail = subelem[0]; |
| 1101 | if (data->report_detail > |
| 1102 | BEACON_REPORT_DETAIL_ALL_FIELDS_AND_ELEMENTS) { |
| 1103 | wpa_printf(MSG_DEBUG, "Invalid reporting detail: %u", |
| 1104 | subelem[0]); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1105 | return -1; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1106 | } |
| 1107 | |
| 1108 | break; |
| 1109 | case WLAN_BEACON_REQUEST_SUBELEM_REQUEST: |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1110 | case WLAN_BEACON_REQUEST_SUBELEM_EXT_REQUEST: |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1111 | if (data->report_detail != |
| 1112 | BEACON_REPORT_DETAIL_REQUESTED_ONLY) { |
| 1113 | wpa_printf(MSG_DEBUG, |
| 1114 | "Beacon request: request subelement is present but report detail is %u", |
| 1115 | data->report_detail); |
| 1116 | return -1; |
| 1117 | } |
| 1118 | |
| 1119 | if (!slen) { |
| 1120 | wpa_printf(MSG_DEBUG, |
| 1121 | "Invalid request subelement length: %u", |
| 1122 | slen); |
| 1123 | return -1; |
| 1124 | } |
| 1125 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1126 | if (sid == WLAN_BEACON_REQUEST_SUBELEM_EXT_REQUEST) { |
| 1127 | if (slen < 2) { |
| 1128 | wpa_printf(MSG_DEBUG, |
| 1129 | "Invalid extended request"); |
| 1130 | return -1; |
| 1131 | } |
| 1132 | if (subelem[0] != WLAN_EID_EXTENSION) { |
| 1133 | wpa_printf(MSG_DEBUG, |
| 1134 | "Skip unknown Requested Element ID %u in Extended Request subelement", |
| 1135 | subelem[0]); |
| 1136 | break; |
| 1137 | } |
| 1138 | |
| 1139 | /* Skip the Requested Element ID field */ |
| 1140 | subelem++; |
| 1141 | slen--; |
| 1142 | } |
| 1143 | |
| 1144 | if ((sid == WLAN_BEACON_REQUEST_SUBELEM_REQUEST && |
| 1145 | data->eids) || |
| 1146 | (sid == WLAN_BEACON_REQUEST_SUBELEM_EXT_REQUEST && |
| 1147 | data->ext_eids)) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1148 | wpa_printf(MSG_DEBUG, |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1149 | "Beacon Request: Request sub elements appear more than once"); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1150 | return -1; |
| 1151 | } |
| 1152 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1153 | eids = bitfield_alloc(255); |
| 1154 | if (!eids) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1155 | wpa_printf(MSG_DEBUG, "Failed to allocate EIDs bitmap"); |
| 1156 | return -1; |
| 1157 | } |
| 1158 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1159 | if (sid == WLAN_BEACON_REQUEST_SUBELEM_REQUEST) |
| 1160 | data->eids = eids; |
| 1161 | else |
| 1162 | data->ext_eids = eids; |
| 1163 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1164 | for (i = 0; i < slen; i++) |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1165 | bitfield_set(eids, subelem[i]); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1166 | break; |
| 1167 | case WLAN_BEACON_REQUEST_SUBELEM_AP_CHANNEL: |
| 1168 | /* Skip - it will be processed when freqs are added */ |
| 1169 | break; |
Hai Shalom | 74f70d4 | 2019-02-11 14:42:39 -0800 | [diff] [blame] | 1170 | case WLAN_BEACON_REQUEST_SUBELEM_LAST_INDICATION: |
| 1171 | if (slen != 1) { |
| 1172 | wpa_printf(MSG_DEBUG, |
| 1173 | "Beacon request: Invalid last indication request subelement length: %u", |
| 1174 | slen); |
| 1175 | return -1; |
| 1176 | } |
| 1177 | |
| 1178 | data->last_indication = subelem[0]; |
| 1179 | break; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1180 | default: |
| 1181 | wpa_printf(MSG_DEBUG, |
| 1182 | "Beacon request: Unknown subelement id %u", sid); |
| 1183 | break; |
| 1184 | } |
| 1185 | |
| 1186 | return 1; |
| 1187 | } |
| 1188 | |
| 1189 | |
| 1190 | /** |
| 1191 | * Returns 0 if the next element can be processed, 1 if some operation was |
| 1192 | * triggered, and -1 if processing failed (i.e., the element is in invalid |
| 1193 | * format or an internal error occurred). |
| 1194 | */ |
| 1195 | static int |
| 1196 | wpas_rm_handle_beacon_req(struct wpa_supplicant *wpa_s, |
| 1197 | u8 elem_token, int duration_mandatory, |
| 1198 | const struct rrm_measurement_beacon_request *req, |
| 1199 | size_t len, struct wpabuf **buf) |
| 1200 | { |
| 1201 | struct beacon_rep_data *data = &wpa_s->beacon_rep_data; |
| 1202 | struct wpa_driver_scan_params *params = &data->scan_params; |
| 1203 | const u8 *subelems; |
| 1204 | size_t elems_len; |
| 1205 | u16 rand_interval; |
| 1206 | u32 interval_usec; |
| 1207 | u32 _rand; |
| 1208 | int ret = 0, res; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1209 | u8 reject_mode; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1210 | |
| 1211 | if (len < sizeof(*req)) |
| 1212 | return -1; |
| 1213 | |
| 1214 | if (req->mode != BEACON_REPORT_MODE_PASSIVE && |
| 1215 | req->mode != BEACON_REPORT_MODE_ACTIVE && |
| 1216 | req->mode != BEACON_REPORT_MODE_TABLE) |
| 1217 | return 0; |
| 1218 | |
| 1219 | subelems = req->variable; |
| 1220 | elems_len = len - sizeof(*req); |
| 1221 | rand_interval = le_to_host16(req->rand_interval); |
| 1222 | |
Dmitry Shmidt | ebd93af | 2017-02-21 13:40:44 -0800 | [diff] [blame] | 1223 | os_free(params->freqs); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1224 | os_memset(params, 0, sizeof(*params)); |
| 1225 | |
| 1226 | data->token = elem_token; |
| 1227 | |
| 1228 | /* default reporting detail is all fixed length fields and all |
| 1229 | * elements */ |
| 1230 | data->report_detail = BEACON_REPORT_DETAIL_ALL_FIELDS_AND_ELEMENTS; |
| 1231 | os_memcpy(data->bssid, req->bssid, ETH_ALEN); |
| 1232 | |
| 1233 | while (elems_len >= 2) { |
| 1234 | if (subelems[1] > elems_len - 2) { |
| 1235 | wpa_printf(MSG_DEBUG, |
| 1236 | "Beacon Request: Truncated subelement"); |
| 1237 | ret = -1; |
| 1238 | goto out; |
| 1239 | } |
| 1240 | |
| 1241 | res = wpas_rm_handle_beacon_req_subelem( |
| 1242 | wpa_s, data, subelems[0], subelems[1], &subelems[2]); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1243 | if (res < 0) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1244 | ret = res; |
| 1245 | goto out; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1246 | } else if (!res) { |
| 1247 | reject_mode = MEASUREMENT_REPORT_MODE_REJECT_INCAPABLE; |
| 1248 | goto out_reject; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1249 | } |
| 1250 | |
| 1251 | elems_len -= 2 + subelems[1]; |
| 1252 | subelems += 2 + subelems[1]; |
| 1253 | } |
| 1254 | |
| 1255 | if (req->mode == BEACON_REPORT_MODE_TABLE) { |
| 1256 | wpas_beacon_rep_table(wpa_s, buf); |
| 1257 | goto out; |
| 1258 | } |
| 1259 | |
Sunil Ravi | a04bd25 | 2022-05-02 22:54:18 -0700 | [diff] [blame] | 1260 | params->freqs = wpas_beacon_request_freqs(wpa_s, req->oper_class, |
| 1261 | req->channel, req->variable, |
| 1262 | len - sizeof(*req)); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1263 | if (!params->freqs) { |
| 1264 | wpa_printf(MSG_DEBUG, "Beacon request: No valid channels"); |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1265 | reject_mode = MEASUREMENT_REPORT_MODE_REJECT_REFUSED; |
| 1266 | goto out_reject; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1267 | } |
| 1268 | |
| 1269 | params->duration = le_to_host16(req->duration); |
| 1270 | params->duration_mandatory = duration_mandatory; |
| 1271 | if (!params->duration) { |
| 1272 | wpa_printf(MSG_DEBUG, "Beacon request: Duration is 0"); |
| 1273 | ret = -1; |
| 1274 | goto out; |
| 1275 | } |
| 1276 | |
| 1277 | params->only_new_results = 1; |
| 1278 | |
| 1279 | if (req->mode == BEACON_REPORT_MODE_ACTIVE) { |
| 1280 | params->ssids[params->num_ssids].ssid = data->ssid; |
| 1281 | params->ssids[params->num_ssids++].ssid_len = data->ssid_len; |
| 1282 | } |
| 1283 | |
| 1284 | if (os_get_random((u8 *) &_rand, sizeof(_rand)) < 0) |
| 1285 | _rand = os_random(); |
| 1286 | interval_usec = (_rand % (rand_interval + 1)) * 1024; |
| 1287 | eloop_register_timeout(0, interval_usec, wpas_rrm_scan_timeout, wpa_s, |
| 1288 | NULL); |
| 1289 | return 1; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1290 | out_reject: |
| 1291 | if (!is_multicast_ether_addr(wpa_s->rrm.dst_addr) && |
| 1292 | wpas_rrm_report_elem(buf, elem_token, reject_mode, |
| 1293 | MEASURE_TYPE_BEACON, NULL, 0) < 0) { |
| 1294 | wpa_printf(MSG_DEBUG, "RRM: Failed to add report element"); |
| 1295 | ret = -1; |
| 1296 | } |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1297 | out: |
| 1298 | wpas_clear_beacon_rep_data(wpa_s); |
| 1299 | return ret; |
| 1300 | } |
| 1301 | |
| 1302 | |
| 1303 | static int |
| 1304 | wpas_rrm_handle_msr_req_element( |
| 1305 | struct wpa_supplicant *wpa_s, |
| 1306 | const struct rrm_measurement_request_element *req, |
| 1307 | struct wpabuf **buf) |
| 1308 | { |
| 1309 | int duration_mandatory; |
| 1310 | |
| 1311 | wpa_printf(MSG_DEBUG, "Measurement request type %d token %d", |
| 1312 | req->type, req->token); |
| 1313 | |
| 1314 | if (req->mode & MEASUREMENT_REQUEST_MODE_ENABLE) { |
| 1315 | /* Enable bit is not supported for now */ |
| 1316 | wpa_printf(MSG_DEBUG, "RRM: Enable bit not supported, ignore"); |
| 1317 | return 0; |
| 1318 | } |
| 1319 | |
| 1320 | if ((req->mode & MEASUREMENT_REQUEST_MODE_PARALLEL) && |
| 1321 | req->type > MEASURE_TYPE_RPI_HIST) { |
| 1322 | /* Parallel measurements are not supported for now */ |
| 1323 | wpa_printf(MSG_DEBUG, |
| 1324 | "RRM: Parallel measurements are not supported, reject"); |
| 1325 | goto reject; |
| 1326 | } |
| 1327 | |
| 1328 | duration_mandatory = |
| 1329 | !!(req->mode & MEASUREMENT_REQUEST_MODE_DURATION_MANDATORY); |
| 1330 | |
| 1331 | switch (req->type) { |
| 1332 | case MEASURE_TYPE_LCI: |
| 1333 | return wpas_rrm_build_lci_report(wpa_s, req, buf); |
| 1334 | case MEASURE_TYPE_BEACON: |
| 1335 | if (duration_mandatory && |
| 1336 | !(wpa_s->drv_rrm_flags & |
| 1337 | WPA_DRIVER_FLAGS_SUPPORT_SET_SCAN_DWELL)) { |
| 1338 | wpa_printf(MSG_DEBUG, |
| 1339 | "RRM: Driver does not support dwell time configuration - reject beacon report with mandatory duration"); |
| 1340 | goto reject; |
| 1341 | } |
| 1342 | return wpas_rm_handle_beacon_req(wpa_s, req->token, |
| 1343 | duration_mandatory, |
| 1344 | (const void *) req->variable, |
| 1345 | req->len - 3, buf); |
| 1346 | default: |
| 1347 | wpa_printf(MSG_INFO, |
| 1348 | "RRM: Unsupported radio measurement type %u", |
| 1349 | req->type); |
| 1350 | break; |
| 1351 | } |
| 1352 | |
| 1353 | reject: |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1354 | if (!is_multicast_ether_addr(wpa_s->rrm.dst_addr) && |
| 1355 | wpas_rrm_report_elem(buf, req->token, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1356 | MEASUREMENT_REPORT_MODE_REJECT_INCAPABLE, |
| 1357 | req->type, NULL, 0) < 0) { |
| 1358 | wpa_printf(MSG_DEBUG, "RRM: Failed to add report element"); |
| 1359 | return -1; |
| 1360 | } |
| 1361 | |
| 1362 | return 0; |
| 1363 | } |
| 1364 | |
| 1365 | |
| 1366 | static struct wpabuf * |
| 1367 | wpas_rrm_process_msr_req_elems(struct wpa_supplicant *wpa_s, const u8 *pos, |
| 1368 | size_t len) |
| 1369 | { |
| 1370 | struct wpabuf *buf = NULL; |
| 1371 | |
| 1372 | while (len) { |
| 1373 | const struct rrm_measurement_request_element *req; |
| 1374 | int res; |
| 1375 | |
| 1376 | if (len < 2) { |
| 1377 | wpa_printf(MSG_DEBUG, "RRM: Truncated element"); |
| 1378 | goto out; |
| 1379 | } |
| 1380 | |
| 1381 | req = (const struct rrm_measurement_request_element *) pos; |
| 1382 | if (req->eid != WLAN_EID_MEASURE_REQUEST) { |
| 1383 | wpa_printf(MSG_DEBUG, |
| 1384 | "RRM: Expected Measurement Request element, but EID is %u", |
| 1385 | req->eid); |
| 1386 | goto out; |
| 1387 | } |
| 1388 | |
| 1389 | if (req->len < 3) { |
| 1390 | wpa_printf(MSG_DEBUG, "RRM: Element length too short"); |
| 1391 | goto out; |
| 1392 | } |
| 1393 | |
| 1394 | if (req->len > len - 2) { |
| 1395 | wpa_printf(MSG_DEBUG, "RRM: Element length too long"); |
| 1396 | goto out; |
| 1397 | } |
| 1398 | |
| 1399 | res = wpas_rrm_handle_msr_req_element(wpa_s, req, &buf); |
| 1400 | if (res < 0) |
| 1401 | goto out; |
| 1402 | |
| 1403 | pos += req->len + 2; |
| 1404 | len -= req->len + 2; |
| 1405 | } |
| 1406 | |
| 1407 | return buf; |
| 1408 | |
| 1409 | out: |
| 1410 | wpabuf_free(buf); |
| 1411 | return NULL; |
| 1412 | } |
| 1413 | |
| 1414 | |
| 1415 | void wpas_rrm_handle_radio_measurement_request(struct wpa_supplicant *wpa_s, |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1416 | const u8 *src, const u8 *dst, |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1417 | const u8 *frame, size_t len) |
| 1418 | { |
| 1419 | struct wpabuf *report; |
| 1420 | |
| 1421 | if (wpa_s->wpa_state != WPA_COMPLETED) { |
| 1422 | wpa_printf(MSG_INFO, |
| 1423 | "RRM: Ignoring radio measurement request: Not associated"); |
| 1424 | return; |
| 1425 | } |
| 1426 | |
| 1427 | if (!wpa_s->rrm.rrm_used) { |
| 1428 | wpa_printf(MSG_INFO, |
| 1429 | "RRM: Ignoring radio measurement request: Not RRM network"); |
| 1430 | return; |
| 1431 | } |
| 1432 | |
| 1433 | if (len < 3) { |
| 1434 | wpa_printf(MSG_INFO, |
| 1435 | "RRM: Ignoring too short radio measurement request"); |
| 1436 | return; |
| 1437 | } |
| 1438 | |
| 1439 | wpa_s->rrm.token = *frame; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1440 | os_memcpy(wpa_s->rrm.dst_addr, dst, ETH_ALEN); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1441 | |
| 1442 | /* Number of repetitions is not supported */ |
| 1443 | |
| 1444 | report = wpas_rrm_process_msr_req_elems(wpa_s, frame + 3, len - 3); |
| 1445 | if (!report) |
| 1446 | return; |
| 1447 | |
| 1448 | wpas_rrm_send_msr_report(wpa_s, report); |
| 1449 | wpabuf_free(report); |
| 1450 | } |
| 1451 | |
| 1452 | |
| 1453 | void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s, |
| 1454 | const u8 *src, |
| 1455 | const u8 *frame, size_t len, |
| 1456 | int rssi) |
| 1457 | { |
| 1458 | struct wpabuf *buf; |
| 1459 | const struct rrm_link_measurement_request *req; |
| 1460 | struct rrm_link_measurement_report report; |
| 1461 | |
| 1462 | if (wpa_s->wpa_state != WPA_COMPLETED) { |
| 1463 | wpa_printf(MSG_INFO, |
| 1464 | "RRM: Ignoring link measurement request. Not associated"); |
| 1465 | return; |
| 1466 | } |
| 1467 | |
| 1468 | if (!wpa_s->rrm.rrm_used) { |
| 1469 | wpa_printf(MSG_INFO, |
| 1470 | "RRM: Ignoring link measurement request. Not RRM network"); |
| 1471 | return; |
| 1472 | } |
| 1473 | |
| 1474 | if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) { |
| 1475 | wpa_printf(MSG_INFO, |
| 1476 | "RRM: Measurement report failed. TX power insertion not supported"); |
| 1477 | return; |
| 1478 | } |
| 1479 | |
| 1480 | req = (const struct rrm_link_measurement_request *) frame; |
| 1481 | if (len < sizeof(*req)) { |
| 1482 | wpa_printf(MSG_INFO, |
| 1483 | "RRM: Link measurement report failed. Request too short"); |
| 1484 | return; |
| 1485 | } |
| 1486 | |
| 1487 | os_memset(&report, 0, sizeof(report)); |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 1488 | report.dialog_token = req->dialog_token; |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1489 | report.tpc.eid = WLAN_EID_TPC_REPORT; |
| 1490 | report.tpc.len = 2; |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 1491 | /* Note: The driver is expected to update report.tpc.tx_power and |
| 1492 | * report.tpc.link_margin subfields when sending out this frame. |
| 1493 | * Similarly, the driver would need to update report.rx_ant_id and |
| 1494 | * report.tx_ant_id subfields. */ |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1495 | report.rsni = 255; /* 255 indicates that RSNI is not available */ |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1496 | report.rcpi = rssi_to_rcpi(rssi); |
| 1497 | |
| 1498 | /* action_category + action_code */ |
| 1499 | buf = wpabuf_alloc(2 + sizeof(report)); |
| 1500 | if (buf == NULL) { |
| 1501 | wpa_printf(MSG_ERROR, |
| 1502 | "RRM: Link measurement report failed. Buffer allocation failed"); |
| 1503 | return; |
| 1504 | } |
| 1505 | |
| 1506 | wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT); |
| 1507 | wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT); |
| 1508 | wpabuf_put_data(buf, &report, sizeof(report)); |
Paul Stewart | 092955c | 2017-02-06 09:13:09 -0800 | [diff] [blame] | 1509 | wpa_hexdump_buf(MSG_DEBUG, "RRM: Link measurement report", buf); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1510 | |
| 1511 | if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src, |
| 1512 | wpa_s->own_addr, wpa_s->bssid, |
| 1513 | wpabuf_head(buf), wpabuf_len(buf), 0)) { |
| 1514 | wpa_printf(MSG_ERROR, |
| 1515 | "RRM: Link measurement report failed. Send action failed"); |
| 1516 | } |
| 1517 | wpabuf_free(buf); |
| 1518 | } |
| 1519 | |
| 1520 | |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1521 | static bool wpas_beacon_rep_scan_match(struct wpa_supplicant *wpa_s, |
| 1522 | const u8 *bssid) |
| 1523 | { |
| 1524 | u8 i; |
| 1525 | |
| 1526 | if (!wpa_s->valid_links) |
| 1527 | return ether_addr_equal(wpa_s->current_bss->bssid, bssid); |
| 1528 | |
Sunil Ravi | 99c035e | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1529 | for_each_link(wpa_s->valid_links, i) { |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1530 | if (ether_addr_equal(wpa_s->links[i].bssid, bssid)) |
| 1531 | return true; |
| 1532 | } |
| 1533 | |
| 1534 | wpa_printf(MSG_DEBUG, "RRM: MLD: no match for TSF BSSID=" MACSTR, |
| 1535 | MAC2STR(bssid)); |
| 1536 | |
| 1537 | return false; |
| 1538 | } |
| 1539 | |
| 1540 | |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1541 | int wpas_beacon_rep_scan_process(struct wpa_supplicant *wpa_s, |
| 1542 | struct wpa_scan_results *scan_res, |
| 1543 | struct scan_info *info) |
| 1544 | { |
| 1545 | size_t i = 0; |
| 1546 | struct wpabuf *buf = NULL; |
| 1547 | |
| 1548 | if (!wpa_s->beacon_rep_data.token) |
| 1549 | return 0; |
| 1550 | |
| 1551 | if (!wpa_s->current_bss) |
| 1552 | goto out; |
| 1553 | |
| 1554 | /* If the measurement was aborted, don't report partial results */ |
| 1555 | if (info->aborted) |
| 1556 | goto out; |
| 1557 | |
| 1558 | wpa_printf(MSG_DEBUG, "RRM: TSF BSSID: " MACSTR " current BSS: " MACSTR, |
| 1559 | MAC2STR(info->scan_start_tsf_bssid), |
| 1560 | MAC2STR(wpa_s->current_bss->bssid)); |
| 1561 | if ((wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT) && |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1562 | !wpas_beacon_rep_scan_match(wpa_s, info->scan_start_tsf_bssid)) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1563 | wpa_printf(MSG_DEBUG, |
| 1564 | "RRM: Ignore scan results due to mismatching TSF BSSID"); |
| 1565 | goto out; |
| 1566 | } |
| 1567 | |
| 1568 | for (i = 0; i < scan_res->num; i++) { |
| 1569 | struct wpa_bss *bss = |
| 1570 | wpa_bss_get_bssid(wpa_s, scan_res->res[i]->bssid); |
| 1571 | |
| 1572 | if (!bss) |
| 1573 | continue; |
| 1574 | |
| 1575 | if ((wpa_s->drv_rrm_flags & |
| 1576 | WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT) && |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1577 | !wpas_beacon_rep_scan_match(wpa_s, |
| 1578 | scan_res->res[i]->tsf_bssid)) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1579 | wpa_printf(MSG_DEBUG, |
| 1580 | "RRM: Ignore scan result for " MACSTR |
| 1581 | " due to mismatching TSF BSSID" MACSTR, |
| 1582 | MAC2STR(scan_res->res[i]->bssid), |
| 1583 | MAC2STR(scan_res->res[i]->tsf_bssid)); |
| 1584 | continue; |
| 1585 | } |
| 1586 | |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1587 | /* |
| 1588 | * Don't report results that were not received during the |
| 1589 | * current measurement. |
| 1590 | */ |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1591 | if (!(wpa_s->drv_rrm_flags & |
| 1592 | WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT)) { |
| 1593 | struct os_reltime update_time, diff; |
| 1594 | |
| 1595 | /* For now, allow 8 ms older results due to some |
| 1596 | * unknown issue with cfg80211 BSS table updates during |
| 1597 | * a scan with the current BSS. |
| 1598 | * TODO: Fix this more properly to avoid having to have |
| 1599 | * this type of hacks in place. */ |
| 1600 | calculate_update_time(&scan_res->fetch_time, |
| 1601 | scan_res->res[i]->age, |
| 1602 | &update_time); |
| 1603 | os_reltime_sub(&wpa_s->beacon_rep_scan, |
| 1604 | &update_time, &diff); |
| 1605 | if (os_reltime_before(&update_time, |
| 1606 | &wpa_s->beacon_rep_scan) && |
| 1607 | (diff.sec || diff.usec >= 8000)) { |
| 1608 | wpa_printf(MSG_DEBUG, |
| 1609 | "RRM: Ignore scan result for " MACSTR |
| 1610 | " due to old update (age(ms) %u, calculated age %u.%06u seconds)", |
| 1611 | MAC2STR(scan_res->res[i]->bssid), |
| 1612 | scan_res->res[i]->age, |
| 1613 | (unsigned int) diff.sec, |
| 1614 | (unsigned int) diff.usec); |
| 1615 | continue; |
| 1616 | } |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1617 | } else if (info->scan_start_tsf > |
| 1618 | scan_res->res[i]->parent_tsf) { |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1619 | continue; |
Dmitry Shmidt | d2986c2 | 2017-10-23 14:22:09 -0700 | [diff] [blame] | 1620 | } |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1621 | |
| 1622 | if (wpas_add_beacon_rep(wpa_s, &buf, bss, info->scan_start_tsf, |
| 1623 | scan_res->res[i]->parent_tsf) < 0) |
| 1624 | break; |
| 1625 | } |
| 1626 | |
| 1627 | if (!buf && wpas_beacon_rep_no_results(wpa_s, &buf)) |
| 1628 | goto out; |
| 1629 | |
| 1630 | wpa_hexdump_buf(MSG_DEBUG, "RRM: Radio Measurement report", buf); |
| 1631 | |
| 1632 | wpas_rrm_send_msr_report(wpa_s, buf); |
| 1633 | wpabuf_free(buf); |
| 1634 | |
| 1635 | out: |
| 1636 | wpas_clear_beacon_rep_data(wpa_s); |
| 1637 | return 1; |
| 1638 | } |
| 1639 | |
| 1640 | |
| 1641 | void wpas_clear_beacon_rep_data(struct wpa_supplicant *wpa_s) |
| 1642 | { |
| 1643 | struct beacon_rep_data *data = &wpa_s->beacon_rep_data; |
| 1644 | |
| 1645 | eloop_cancel_timeout(wpas_rrm_scan_timeout, wpa_s, NULL); |
| 1646 | bitfield_free(data->eids); |
Sunil Ravi | b0ac25f | 2024-07-12 01:42:03 +0000 | [diff] [blame] | 1647 | bitfield_free(data->ext_eids); |
Dmitry Shmidt | 2933359 | 2017-01-09 12:27:11 -0800 | [diff] [blame] | 1648 | os_free(data->scan_params.freqs); |
| 1649 | os_memset(data, 0, sizeof(*data)); |
| 1650 | } |