Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * cfg80211 scan result handling
4 : : *
5 : : * Copyright 2008 Johannes Berg <johannes@sipsolutions.net>
6 : : * Copyright 2013-2014 Intel Mobile Communications GmbH
7 : : * Copyright 2016 Intel Deutschland GmbH
8 : : * Copyright (C) 2018-2019 Intel Corporation
9 : : */
10 : : #include <linux/kernel.h>
11 : : #include <linux/slab.h>
12 : : #include <linux/module.h>
13 : : #include <linux/netdevice.h>
14 : : #include <linux/wireless.h>
15 : : #include <linux/nl80211.h>
16 : : #include <linux/etherdevice.h>
17 : : #include <net/arp.h>
18 : : #include <net/cfg80211.h>
19 : : #include <net/cfg80211-wext.h>
20 : : #include <net/iw_handler.h>
21 : : #include "core.h"
22 : : #include "nl80211.h"
23 : : #include "wext-compat.h"
24 : : #include "rdev-ops.h"
25 : :
26 : : /**
27 : : * DOC: BSS tree/list structure
28 : : *
29 : : * At the top level, the BSS list is kept in both a list in each
30 : : * registered device (@bss_list) as well as an RB-tree for faster
31 : : * lookup. In the RB-tree, entries can be looked up using their
32 : : * channel, MESHID, MESHCONF (for MBSSes) or channel, BSSID, SSID
33 : : * for other BSSes.
34 : : *
35 : : * Due to the possibility of hidden SSIDs, there's a second level
36 : : * structure, the "hidden_list" and "hidden_beacon_bss" pointer.
37 : : * The hidden_list connects all BSSes belonging to a single AP
38 : : * that has a hidden SSID, and connects beacon and probe response
39 : : * entries. For a probe response entry for a hidden SSID, the
40 : : * hidden_beacon_bss pointer points to the BSS struct holding the
41 : : * beacon's information.
42 : : *
43 : : * Reference counting is done for all these references except for
44 : : * the hidden_list, so that a beacon BSS struct that is otherwise
45 : : * not referenced has one reference for being on the bss_list and
46 : : * one for each probe response entry that points to it using the
47 : : * hidden_beacon_bss pointer. When a BSS struct that has such a
48 : : * pointer is get/put, the refcount update is also propagated to
49 : : * the referenced struct, this ensure that it cannot get removed
50 : : * while somebody is using the probe response version.
51 : : *
52 : : * Note that the hidden_beacon_bss pointer never changes, due to
53 : : * the reference counting. Therefore, no locking is needed for
54 : : * it.
55 : : *
56 : : * Also note that the hidden_beacon_bss pointer is only relevant
57 : : * if the driver uses something other than the IEs, e.g. private
58 : : * data stored stored in the BSS struct, since the beacon IEs are
59 : : * also linked into the probe response struct.
60 : : */
61 : :
62 : : /*
63 : : * Limit the number of BSS entries stored in mac80211. Each one is
64 : : * a bit over 4k at most, so this limits to roughly 4-5M of memory.
65 : : * If somebody wants to really attack this though, they'd likely
66 : : * use small beacons, and only one type of frame, limiting each of
67 : : * the entries to a much smaller size (in order to generate more
68 : : * entries in total, so overhead is bigger.)
69 : : */
70 : : static int bss_entries_limit = 1000;
71 : : module_param(bss_entries_limit, int, 0644);
72 : : MODULE_PARM_DESC(bss_entries_limit,
73 : : "limit to number of scan BSS entries (per wiphy, default 1000)");
74 : :
75 : : #define IEEE80211_SCAN_RESULT_EXPIRE (30 * HZ)
76 : :
77 : 0 : static void bss_free(struct cfg80211_internal_bss *bss)
78 : : {
79 : : struct cfg80211_bss_ies *ies;
80 : :
81 : 0 : if (WARN_ON(atomic_read(&bss->hold)))
82 : 0 : return;
83 : :
84 : 0 : ies = (void *)rcu_access_pointer(bss->pub.beacon_ies);
85 : 0 : if (ies && !bss->pub.hidden_beacon_bss)
86 : 0 : kfree_rcu(ies, rcu_head);
87 : 0 : ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies);
88 : 0 : if (ies)
89 : 0 : kfree_rcu(ies, rcu_head);
90 : :
91 : : /*
92 : : * This happens when the module is removed, it doesn't
93 : : * really matter any more save for completeness
94 : : */
95 : 0 : if (!list_empty(&bss->hidden_list))
96 : : list_del(&bss->hidden_list);
97 : :
98 : 0 : kfree(bss);
99 : : }
100 : :
101 : 0 : static inline void bss_ref_get(struct cfg80211_registered_device *rdev,
102 : : struct cfg80211_internal_bss *bss)
103 : : {
104 : : lockdep_assert_held(&rdev->bss_lock);
105 : :
106 : 0 : bss->refcount++;
107 : 0 : if (bss->pub.hidden_beacon_bss) {
108 : 0 : bss = container_of(bss->pub.hidden_beacon_bss,
109 : : struct cfg80211_internal_bss,
110 : : pub);
111 : 0 : bss->refcount++;
112 : : }
113 : 0 : if (bss->pub.transmitted_bss) {
114 : : bss = container_of(bss->pub.transmitted_bss,
115 : : struct cfg80211_internal_bss,
116 : : pub);
117 : 0 : bss->refcount++;
118 : : }
119 : 0 : }
120 : :
121 : 0 : static inline void bss_ref_put(struct cfg80211_registered_device *rdev,
122 : : struct cfg80211_internal_bss *bss)
123 : : {
124 : : lockdep_assert_held(&rdev->bss_lock);
125 : :
126 : 0 : if (bss->pub.hidden_beacon_bss) {
127 : : struct cfg80211_internal_bss *hbss;
128 : 0 : hbss = container_of(bss->pub.hidden_beacon_bss,
129 : : struct cfg80211_internal_bss,
130 : : pub);
131 : 0 : hbss->refcount--;
132 : 0 : if (hbss->refcount == 0)
133 : 0 : bss_free(hbss);
134 : : }
135 : :
136 : 0 : if (bss->pub.transmitted_bss) {
137 : : struct cfg80211_internal_bss *tbss;
138 : :
139 : 0 : tbss = container_of(bss->pub.transmitted_bss,
140 : : struct cfg80211_internal_bss,
141 : : pub);
142 : 0 : tbss->refcount--;
143 : 0 : if (tbss->refcount == 0)
144 : 0 : bss_free(tbss);
145 : : }
146 : :
147 : 0 : bss->refcount--;
148 : 0 : if (bss->refcount == 0)
149 : 0 : bss_free(bss);
150 : 0 : }
151 : :
152 : 0 : static bool __cfg80211_unlink_bss(struct cfg80211_registered_device *rdev,
153 : : struct cfg80211_internal_bss *bss)
154 : : {
155 : : lockdep_assert_held(&rdev->bss_lock);
156 : :
157 : 0 : if (!list_empty(&bss->hidden_list)) {
158 : : /*
159 : : * don't remove the beacon entry if it has
160 : : * probe responses associated with it
161 : : */
162 : 0 : if (!bss->pub.hidden_beacon_bss)
163 : : return false;
164 : : /*
165 : : * if it's a probe response entry break its
166 : : * link to the other entries in the group
167 : : */
168 : : list_del_init(&bss->hidden_list);
169 : : }
170 : :
171 : 0 : list_del_init(&bss->list);
172 : 0 : list_del_init(&bss->pub.nontrans_list);
173 : 0 : rb_erase(&bss->rbn, &rdev->bss_tree);
174 : 0 : rdev->bss_entries--;
175 : 0 : WARN_ONCE((rdev->bss_entries == 0) ^ list_empty(&rdev->bss_list),
176 : : "rdev bss entries[%d]/list[empty:%d] corruption\n",
177 : : rdev->bss_entries, list_empty(&rdev->bss_list));
178 : 0 : bss_ref_put(rdev, bss);
179 : 0 : return true;
180 : : }
181 : :
182 : 0 : bool cfg80211_is_element_inherited(const struct element *elem,
183 : : const struct element *non_inherit_elem)
184 : : {
185 : : u8 id_len, ext_id_len, i, loop_len, id;
186 : : const u8 *list;
187 : :
188 : 0 : if (elem->id == WLAN_EID_MULTIPLE_BSSID)
189 : : return false;
190 : :
191 : 0 : if (!non_inherit_elem || non_inherit_elem->datalen < 2)
192 : : return true;
193 : :
194 : : /*
195 : : * non inheritance element format is:
196 : : * ext ID (56) | IDs list len | list | extension IDs list len | list
197 : : * Both lists are optional. Both lengths are mandatory.
198 : : * This means valid length is:
199 : : * elem_len = 1 (extension ID) + 2 (list len fields) + list lengths
200 : : */
201 : 0 : id_len = non_inherit_elem->data[1];
202 : 0 : if (non_inherit_elem->datalen < 3 + id_len)
203 : : return true;
204 : :
205 : 0 : ext_id_len = non_inherit_elem->data[2 + id_len];
206 : 0 : if (non_inherit_elem->datalen < 3 + id_len + ext_id_len)
207 : : return true;
208 : :
209 : 0 : if (elem->id == WLAN_EID_EXTENSION) {
210 : 0 : if (!ext_id_len)
211 : : return true;
212 : : loop_len = ext_id_len;
213 : 0 : list = &non_inherit_elem->data[3 + id_len];
214 : 0 : id = elem->data[0];
215 : : } else {
216 : 0 : if (!id_len)
217 : : return true;
218 : : loop_len = id_len;
219 : 0 : list = &non_inherit_elem->data[2];
220 : : id = elem->id;
221 : : }
222 : :
223 : 0 : for (i = 0; i < loop_len; i++) {
224 : 0 : if (list[i] == id)
225 : : return false;
226 : : }
227 : :
228 : : return true;
229 : : }
230 : : EXPORT_SYMBOL(cfg80211_is_element_inherited);
231 : :
232 : 0 : static size_t cfg80211_gen_new_ie(const u8 *ie, size_t ielen,
233 : : const u8 *subelement, size_t subie_len,
234 : : u8 *new_ie, gfp_t gfp)
235 : : {
236 : : u8 *pos, *tmp;
237 : : const u8 *tmp_old, *tmp_new;
238 : : const struct element *non_inherit_elem;
239 : : u8 *sub_copy;
240 : :
241 : : /* copy subelement as we need to change its content to
242 : : * mark an ie after it is processed.
243 : : */
244 : 0 : sub_copy = kmemdup(subelement, subie_len, gfp);
245 : 0 : if (!sub_copy)
246 : : return 0;
247 : :
248 : : pos = &new_ie[0];
249 : :
250 : : /* set new ssid */
251 : : tmp_new = cfg80211_find_ie(WLAN_EID_SSID, sub_copy, subie_len);
252 : 0 : if (tmp_new) {
253 : 0 : memcpy(pos, tmp_new, tmp_new[1] + 2);
254 : 0 : pos += (tmp_new[1] + 2);
255 : : }
256 : :
257 : : /* get non inheritance list if exists */
258 : : non_inherit_elem =
259 : : cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
260 : : sub_copy, subie_len);
261 : :
262 : : /* go through IEs in ie (skip SSID) and subelement,
263 : : * merge them into new_ie
264 : : */
265 : : tmp_old = cfg80211_find_ie(WLAN_EID_SSID, ie, ielen);
266 : 0 : tmp_old = (tmp_old) ? tmp_old + tmp_old[1] + 2 : ie;
267 : :
268 : 0 : while (tmp_old + tmp_old[1] + 2 - ie <= ielen) {
269 : 0 : if (tmp_old[0] == 0) {
270 : 0 : tmp_old++;
271 : 0 : continue;
272 : : }
273 : :
274 : 0 : if (tmp_old[0] == WLAN_EID_EXTENSION)
275 : 0 : tmp = (u8 *)cfg80211_find_ext_ie(tmp_old[2], sub_copy,
276 : : subie_len);
277 : : else
278 : : tmp = (u8 *)cfg80211_find_ie(tmp_old[0], sub_copy,
279 : : subie_len);
280 : :
281 : 0 : if (!tmp) {
282 : : const struct element *old_elem = (void *)tmp_old;
283 : :
284 : : /* ie in old ie but not in subelement */
285 : 0 : if (cfg80211_is_element_inherited(old_elem,
286 : : non_inherit_elem)) {
287 : 0 : memcpy(pos, tmp_old, tmp_old[1] + 2);
288 : 0 : pos += tmp_old[1] + 2;
289 : : }
290 : : } else {
291 : : /* ie in transmitting ie also in subelement,
292 : : * copy from subelement and flag the ie in subelement
293 : : * as copied (by setting eid field to WLAN_EID_SSID,
294 : : * which is skipped anyway).
295 : : * For vendor ie, compare OUI + type + subType to
296 : : * determine if they are the same ie.
297 : : */
298 : 0 : if (tmp_old[0] == WLAN_EID_VENDOR_SPECIFIC) {
299 : 0 : if (!memcmp(tmp_old + 2, tmp + 2, 5)) {
300 : : /* same vendor ie, copy from
301 : : * subelement
302 : : */
303 : 0 : memcpy(pos, tmp, tmp[1] + 2);
304 : 0 : pos += tmp[1] + 2;
305 : 0 : tmp[0] = WLAN_EID_SSID;
306 : : } else {
307 : 0 : memcpy(pos, tmp_old, tmp_old[1] + 2);
308 : 0 : pos += tmp_old[1] + 2;
309 : : }
310 : : } else {
311 : : /* copy ie from subelement into new ie */
312 : 0 : memcpy(pos, tmp, tmp[1] + 2);
313 : 0 : pos += tmp[1] + 2;
314 : 0 : tmp[0] = WLAN_EID_SSID;
315 : : }
316 : : }
317 : :
318 : 0 : if (tmp_old + tmp_old[1] + 2 - ie == ielen)
319 : : break;
320 : :
321 : : tmp_old += tmp_old[1] + 2;
322 : : }
323 : :
324 : : /* go through subelement again to check if there is any ie not
325 : : * copied to new ie, skip ssid, capability, bssid-index ie
326 : : */
327 : : tmp_new = sub_copy;
328 : 0 : while (tmp_new + tmp_new[1] + 2 - sub_copy <= subie_len) {
329 : 0 : if (!(tmp_new[0] == WLAN_EID_NON_TX_BSSID_CAP ||
330 : : tmp_new[0] == WLAN_EID_SSID)) {
331 : 0 : memcpy(pos, tmp_new, tmp_new[1] + 2);
332 : 0 : pos += tmp_new[1] + 2;
333 : : }
334 : 0 : if (tmp_new + tmp_new[1] + 2 - sub_copy == subie_len)
335 : : break;
336 : : tmp_new += tmp_new[1] + 2;
337 : : }
338 : :
339 : 0 : kfree(sub_copy);
340 : 0 : return pos - new_ie;
341 : : }
342 : :
343 : 0 : static bool is_bss(struct cfg80211_bss *a, const u8 *bssid,
344 : : const u8 *ssid, size_t ssid_len)
345 : : {
346 : : const struct cfg80211_bss_ies *ies;
347 : : const u8 *ssidie;
348 : :
349 : 0 : if (bssid && !ether_addr_equal(a->bssid, bssid))
350 : : return false;
351 : :
352 : 0 : if (!ssid)
353 : : return true;
354 : :
355 : 0 : ies = rcu_access_pointer(a->ies);
356 : 0 : if (!ies)
357 : : return false;
358 : 0 : ssidie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
359 : 0 : if (!ssidie)
360 : : return false;
361 : 0 : if (ssidie[1] != ssid_len)
362 : : return false;
363 : 0 : return memcmp(ssidie + 2, ssid, ssid_len) == 0;
364 : : }
365 : :
366 : : static int
367 : 0 : cfg80211_add_nontrans_list(struct cfg80211_bss *trans_bss,
368 : : struct cfg80211_bss *nontrans_bss)
369 : : {
370 : : const u8 *ssid;
371 : : size_t ssid_len;
372 : : struct cfg80211_bss *bss = NULL;
373 : :
374 : : rcu_read_lock();
375 : : ssid = ieee80211_bss_get_ie(nontrans_bss, WLAN_EID_SSID);
376 : 0 : if (!ssid) {
377 : : rcu_read_unlock();
378 : 0 : return -EINVAL;
379 : : }
380 : 0 : ssid_len = ssid[1];
381 : 0 : ssid = ssid + 2;
382 : : rcu_read_unlock();
383 : :
384 : : /* check if nontrans_bss is in the list */
385 : 0 : list_for_each_entry(bss, &trans_bss->nontrans_list, nontrans_list) {
386 : 0 : if (is_bss(bss, nontrans_bss->bssid, ssid, ssid_len))
387 : : return 0;
388 : : }
389 : :
390 : : /* add to the list */
391 : 0 : list_add_tail(&nontrans_bss->nontrans_list, &trans_bss->nontrans_list);
392 : 0 : return 0;
393 : : }
394 : :
395 : 0 : static void __cfg80211_bss_expire(struct cfg80211_registered_device *rdev,
396 : : unsigned long expire_time)
397 : : {
398 : : struct cfg80211_internal_bss *bss, *tmp;
399 : : bool expired = false;
400 : :
401 : : lockdep_assert_held(&rdev->bss_lock);
402 : :
403 : 0 : list_for_each_entry_safe(bss, tmp, &rdev->bss_list, list) {
404 : 0 : if (atomic_read(&bss->hold))
405 : 0 : continue;
406 : 0 : if (!time_after(expire_time, bss->ts))
407 : 0 : continue;
408 : :
409 : 0 : if (__cfg80211_unlink_bss(rdev, bss))
410 : : expired = true;
411 : : }
412 : :
413 : 0 : if (expired)
414 : 0 : rdev->bss_generation++;
415 : 0 : }
416 : :
417 : 0 : static bool cfg80211_bss_expire_oldest(struct cfg80211_registered_device *rdev)
418 : : {
419 : : struct cfg80211_internal_bss *bss, *oldest = NULL;
420 : : bool ret;
421 : :
422 : : lockdep_assert_held(&rdev->bss_lock);
423 : :
424 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
425 : 0 : if (atomic_read(&bss->hold))
426 : 0 : continue;
427 : :
428 : 0 : if (!list_empty(&bss->hidden_list) &&
429 : 0 : !bss->pub.hidden_beacon_bss)
430 : 0 : continue;
431 : :
432 : 0 : if (oldest && time_before(oldest->ts, bss->ts))
433 : 0 : continue;
434 : : oldest = bss;
435 : : }
436 : :
437 : 0 : if (WARN_ON(!oldest))
438 : : return false;
439 : :
440 : : /*
441 : : * The callers make sure to increase rdev->bss_generation if anything
442 : : * gets removed (and a new entry added), so there's no need to also do
443 : : * it here.
444 : : */
445 : :
446 : 0 : ret = __cfg80211_unlink_bss(rdev, oldest);
447 : 0 : WARN_ON(!ret);
448 : 0 : return ret;
449 : : }
450 : :
451 : 0 : void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
452 : : bool send_message)
453 : : {
454 : : struct cfg80211_scan_request *request;
455 : : struct wireless_dev *wdev;
456 : : struct sk_buff *msg;
457 : : #ifdef CONFIG_CFG80211_WEXT
458 : : union iwreq_data wrqu;
459 : : #endif
460 : :
461 : 0 : ASSERT_RTNL();
462 : :
463 : 0 : if (rdev->scan_msg) {
464 : 0 : nl80211_send_scan_msg(rdev, rdev->scan_msg);
465 : 0 : rdev->scan_msg = NULL;
466 : 0 : return;
467 : : }
468 : :
469 : 0 : request = rdev->scan_req;
470 : 0 : if (!request)
471 : : return;
472 : :
473 : 0 : wdev = request->wdev;
474 : :
475 : : /*
476 : : * This must be before sending the other events!
477 : : * Otherwise, wpa_supplicant gets completely confused with
478 : : * wext events.
479 : : */
480 : 0 : if (wdev->netdev)
481 : 0 : cfg80211_sme_scan_done(wdev->netdev);
482 : :
483 : 0 : if (!request->info.aborted &&
484 : 0 : request->flags & NL80211_SCAN_FLAG_FLUSH) {
485 : : /* flush entries from previous scans */
486 : : spin_lock_bh(&rdev->bss_lock);
487 : 0 : __cfg80211_bss_expire(rdev, request->scan_start);
488 : : spin_unlock_bh(&rdev->bss_lock);
489 : : }
490 : :
491 : 0 : msg = nl80211_build_scan_msg(rdev, wdev, request->info.aborted);
492 : :
493 : : #ifdef CONFIG_CFG80211_WEXT
494 : 0 : if (wdev->netdev && !request->info.aborted) {
495 : 0 : memset(&wrqu, 0, sizeof(wrqu));
496 : :
497 : 0 : wireless_send_event(wdev->netdev, SIOCGIWSCAN, &wrqu, NULL);
498 : : }
499 : : #endif
500 : :
501 : 0 : if (wdev->netdev)
502 : 0 : dev_put(wdev->netdev);
503 : :
504 : 0 : rdev->scan_req = NULL;
505 : 0 : kfree(request);
506 : :
507 : 0 : if (!send_message)
508 : 0 : rdev->scan_msg = msg;
509 : : else
510 : 0 : nl80211_send_scan_msg(rdev, msg);
511 : : }
512 : :
513 : 0 : void __cfg80211_scan_done(struct work_struct *wk)
514 : : {
515 : : struct cfg80211_registered_device *rdev;
516 : :
517 : 0 : rdev = container_of(wk, struct cfg80211_registered_device,
518 : : scan_done_wk);
519 : :
520 : 0 : rtnl_lock();
521 : 0 : ___cfg80211_scan_done(rdev, true);
522 : 0 : rtnl_unlock();
523 : 0 : }
524 : :
525 : 0 : void cfg80211_scan_done(struct cfg80211_scan_request *request,
526 : : struct cfg80211_scan_info *info)
527 : : {
528 : 0 : trace_cfg80211_scan_done(request, info);
529 : 0 : WARN_ON(request != wiphy_to_rdev(request->wiphy)->scan_req);
530 : :
531 : 0 : request->info = *info;
532 : 0 : request->notified = true;
533 : 0 : queue_work(cfg80211_wq, &wiphy_to_rdev(request->wiphy)->scan_done_wk);
534 : 0 : }
535 : : EXPORT_SYMBOL(cfg80211_scan_done);
536 : :
537 : 0 : void cfg80211_add_sched_scan_req(struct cfg80211_registered_device *rdev,
538 : : struct cfg80211_sched_scan_request *req)
539 : : {
540 : 0 : ASSERT_RTNL();
541 : :
542 : 0 : list_add_rcu(&req->list, &rdev->sched_scan_req_list);
543 : 0 : }
544 : :
545 : 0 : static void cfg80211_del_sched_scan_req(struct cfg80211_registered_device *rdev,
546 : : struct cfg80211_sched_scan_request *req)
547 : : {
548 : 0 : ASSERT_RTNL();
549 : :
550 : : list_del_rcu(&req->list);
551 : 0 : kfree_rcu(req, rcu_head);
552 : 0 : }
553 : :
554 : : static struct cfg80211_sched_scan_request *
555 : : cfg80211_find_sched_scan_req(struct cfg80211_registered_device *rdev, u64 reqid)
556 : : {
557 : : struct cfg80211_sched_scan_request *pos;
558 : :
559 : : WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held());
560 : :
561 : 0 : list_for_each_entry_rcu(pos, &rdev->sched_scan_req_list, list) {
562 : 0 : if (pos->reqid == reqid)
563 : 0 : return pos;
564 : : }
565 : : return NULL;
566 : : }
567 : :
568 : : /*
569 : : * Determines if a scheduled scan request can be handled. When a legacy
570 : : * scheduled scan is running no other scheduled scan is allowed regardless
571 : : * whether the request is for legacy or multi-support scan. When a multi-support
572 : : * scheduled scan is running a request for legacy scan is not allowed. In this
573 : : * case a request for multi-support scan can be handled if resources are
574 : : * available, ie. struct wiphy::max_sched_scan_reqs limit is not yet reached.
575 : : */
576 : 0 : int cfg80211_sched_scan_req_possible(struct cfg80211_registered_device *rdev,
577 : : bool want_multi)
578 : : {
579 : : struct cfg80211_sched_scan_request *pos;
580 : : int i = 0;
581 : :
582 : 0 : list_for_each_entry(pos, &rdev->sched_scan_req_list, list) {
583 : : /* request id zero means legacy in progress */
584 : 0 : if (!i && !pos->reqid)
585 : : return -EINPROGRESS;
586 : 0 : i++;
587 : : }
588 : :
589 : 0 : if (i) {
590 : : /* no legacy allowed when multi request(s) are active */
591 : 0 : if (!want_multi)
592 : : return -EINPROGRESS;
593 : :
594 : : /* resource limit reached */
595 : 0 : if (i == rdev->wiphy.max_sched_scan_reqs)
596 : : return -ENOSPC;
597 : : }
598 : 0 : return 0;
599 : : }
600 : :
601 : 0 : void cfg80211_sched_scan_results_wk(struct work_struct *work)
602 : : {
603 : : struct cfg80211_registered_device *rdev;
604 : : struct cfg80211_sched_scan_request *req, *tmp;
605 : :
606 : 0 : rdev = container_of(work, struct cfg80211_registered_device,
607 : : sched_scan_res_wk);
608 : :
609 : 0 : rtnl_lock();
610 : 0 : list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
611 : 0 : if (req->report_results) {
612 : 0 : req->report_results = false;
613 : 0 : if (req->flags & NL80211_SCAN_FLAG_FLUSH) {
614 : : /* flush entries from previous scans */
615 : : spin_lock_bh(&rdev->bss_lock);
616 : 0 : __cfg80211_bss_expire(rdev, req->scan_start);
617 : : spin_unlock_bh(&rdev->bss_lock);
618 : 0 : req->scan_start = jiffies;
619 : : }
620 : 0 : nl80211_send_sched_scan(req,
621 : : NL80211_CMD_SCHED_SCAN_RESULTS);
622 : : }
623 : : }
624 : 0 : rtnl_unlock();
625 : 0 : }
626 : :
627 : 0 : void cfg80211_sched_scan_results(struct wiphy *wiphy, u64 reqid)
628 : : {
629 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
630 : : struct cfg80211_sched_scan_request *request;
631 : :
632 : 0 : trace_cfg80211_sched_scan_results(wiphy, reqid);
633 : : /* ignore if we're not scanning */
634 : :
635 : : rcu_read_lock();
636 : : request = cfg80211_find_sched_scan_req(rdev, reqid);
637 : 0 : if (request) {
638 : 0 : request->report_results = true;
639 : 0 : queue_work(cfg80211_wq, &rdev->sched_scan_res_wk);
640 : : }
641 : : rcu_read_unlock();
642 : 0 : }
643 : : EXPORT_SYMBOL(cfg80211_sched_scan_results);
644 : :
645 : 0 : void cfg80211_sched_scan_stopped_rtnl(struct wiphy *wiphy, u64 reqid)
646 : : {
647 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
648 : :
649 : 0 : ASSERT_RTNL();
650 : :
651 : 0 : trace_cfg80211_sched_scan_stopped(wiphy, reqid);
652 : :
653 : 0 : __cfg80211_stop_sched_scan(rdev, reqid, true);
654 : 0 : }
655 : : EXPORT_SYMBOL(cfg80211_sched_scan_stopped_rtnl);
656 : :
657 : 0 : void cfg80211_sched_scan_stopped(struct wiphy *wiphy, u64 reqid)
658 : : {
659 : 0 : rtnl_lock();
660 : 0 : cfg80211_sched_scan_stopped_rtnl(wiphy, reqid);
661 : 0 : rtnl_unlock();
662 : 0 : }
663 : : EXPORT_SYMBOL(cfg80211_sched_scan_stopped);
664 : :
665 : 0 : int cfg80211_stop_sched_scan_req(struct cfg80211_registered_device *rdev,
666 : : struct cfg80211_sched_scan_request *req,
667 : : bool driver_initiated)
668 : : {
669 : 0 : ASSERT_RTNL();
670 : :
671 : 0 : if (!driver_initiated) {
672 : 0 : int err = rdev_sched_scan_stop(rdev, req->dev, req->reqid);
673 : 0 : if (err)
674 : : return err;
675 : : }
676 : :
677 : 0 : nl80211_send_sched_scan(req, NL80211_CMD_SCHED_SCAN_STOPPED);
678 : :
679 : 0 : cfg80211_del_sched_scan_req(rdev, req);
680 : :
681 : 0 : return 0;
682 : : }
683 : :
684 : 0 : int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
685 : : u64 reqid, bool driver_initiated)
686 : : {
687 : : struct cfg80211_sched_scan_request *sched_scan_req;
688 : :
689 : 0 : ASSERT_RTNL();
690 : :
691 : : sched_scan_req = cfg80211_find_sched_scan_req(rdev, reqid);
692 : 0 : if (!sched_scan_req)
693 : : return -ENOENT;
694 : :
695 : 0 : return cfg80211_stop_sched_scan_req(rdev, sched_scan_req,
696 : : driver_initiated);
697 : : }
698 : :
699 : 0 : void cfg80211_bss_age(struct cfg80211_registered_device *rdev,
700 : : unsigned long age_secs)
701 : : {
702 : : struct cfg80211_internal_bss *bss;
703 : 0 : unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
704 : :
705 : : spin_lock_bh(&rdev->bss_lock);
706 : 0 : list_for_each_entry(bss, &rdev->bss_list, list)
707 : 0 : bss->ts -= age_jiffies;
708 : : spin_unlock_bh(&rdev->bss_lock);
709 : 0 : }
710 : :
711 : 0 : void cfg80211_bss_expire(struct cfg80211_registered_device *rdev)
712 : : {
713 : 0 : __cfg80211_bss_expire(rdev, jiffies - IEEE80211_SCAN_RESULT_EXPIRE);
714 : 0 : }
715 : :
716 : : const struct element *
717 : 0 : cfg80211_find_elem_match(u8 eid, const u8 *ies, unsigned int len,
718 : : const u8 *match, unsigned int match_len,
719 : : unsigned int match_offset)
720 : : {
721 : : const struct element *elem;
722 : :
723 : 0 : for_each_element_id(elem, eid, ies, len) {
724 : 0 : if (elem->datalen >= match_offset + match_len &&
725 : 0 : !memcmp(elem->data + match_offset, match, match_len))
726 : 0 : return elem;
727 : : }
728 : :
729 : : return NULL;
730 : : }
731 : : EXPORT_SYMBOL(cfg80211_find_elem_match);
732 : :
733 : 0 : const struct element *cfg80211_find_vendor_elem(unsigned int oui, int oui_type,
734 : : const u8 *ies,
735 : : unsigned int len)
736 : : {
737 : : const struct element *elem;
738 : 0 : u8 match[] = { oui >> 16, oui >> 8, oui, oui_type };
739 : 0 : int match_len = (oui_type < 0) ? 3 : sizeof(match);
740 : :
741 : 0 : if (WARN_ON(oui_type > 0xff))
742 : : return NULL;
743 : :
744 : 0 : elem = cfg80211_find_elem_match(WLAN_EID_VENDOR_SPECIFIC, ies, len,
745 : : match, match_len, 0);
746 : :
747 : 0 : if (!elem || elem->datalen < 4)
748 : : return NULL;
749 : :
750 : 0 : return elem;
751 : : }
752 : : EXPORT_SYMBOL(cfg80211_find_vendor_elem);
753 : :
754 : : /**
755 : : * enum bss_compare_mode - BSS compare mode
756 : : * @BSS_CMP_REGULAR: regular compare mode (for insertion and normal find)
757 : : * @BSS_CMP_HIDE_ZLEN: find hidden SSID with zero-length mode
758 : : * @BSS_CMP_HIDE_NUL: find hidden SSID with NUL-ed out mode
759 : : */
760 : : enum bss_compare_mode {
761 : : BSS_CMP_REGULAR,
762 : : BSS_CMP_HIDE_ZLEN,
763 : : BSS_CMP_HIDE_NUL,
764 : : };
765 : :
766 : 0 : static int cmp_bss(struct cfg80211_bss *a,
767 : : struct cfg80211_bss *b,
768 : : enum bss_compare_mode mode)
769 : : {
770 : : const struct cfg80211_bss_ies *a_ies, *b_ies;
771 : : const u8 *ie1 = NULL;
772 : : const u8 *ie2 = NULL;
773 : : int i, r;
774 : :
775 : 0 : if (a->channel != b->channel)
776 : 0 : return b->channel->center_freq - a->channel->center_freq;
777 : :
778 : 0 : a_ies = rcu_access_pointer(a->ies);
779 : 0 : if (!a_ies)
780 : : return -1;
781 : 0 : b_ies = rcu_access_pointer(b->ies);
782 : 0 : if (!b_ies)
783 : : return 1;
784 : :
785 : 0 : if (WLAN_CAPABILITY_IS_STA_BSS(a->capability))
786 : 0 : ie1 = cfg80211_find_ie(WLAN_EID_MESH_ID,
787 : 0 : a_ies->data, a_ies->len);
788 : 0 : if (WLAN_CAPABILITY_IS_STA_BSS(b->capability))
789 : 0 : ie2 = cfg80211_find_ie(WLAN_EID_MESH_ID,
790 : 0 : b_ies->data, b_ies->len);
791 : 0 : if (ie1 && ie2) {
792 : : int mesh_id_cmp;
793 : :
794 : 0 : if (ie1[1] == ie2[1])
795 : 0 : mesh_id_cmp = memcmp(ie1 + 2, ie2 + 2, ie1[1]);
796 : : else
797 : 0 : mesh_id_cmp = ie2[1] - ie1[1];
798 : :
799 : 0 : ie1 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
800 : 0 : a_ies->data, a_ies->len);
801 : 0 : ie2 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
802 : 0 : b_ies->data, b_ies->len);
803 : 0 : if (ie1 && ie2) {
804 : 0 : if (mesh_id_cmp)
805 : : return mesh_id_cmp;
806 : 0 : if (ie1[1] != ie2[1])
807 : 0 : return ie2[1] - ie1[1];
808 : 0 : return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
809 : : }
810 : : }
811 : :
812 : 0 : r = memcmp(a->bssid, b->bssid, sizeof(a->bssid));
813 : 0 : if (r)
814 : : return r;
815 : :
816 : 0 : ie1 = cfg80211_find_ie(WLAN_EID_SSID, a_ies->data, a_ies->len);
817 : 0 : ie2 = cfg80211_find_ie(WLAN_EID_SSID, b_ies->data, b_ies->len);
818 : :
819 : 0 : if (!ie1 && !ie2)
820 : : return 0;
821 : :
822 : : /*
823 : : * Note that with "hide_ssid", the function returns a match if
824 : : * the already-present BSS ("b") is a hidden SSID beacon for
825 : : * the new BSS ("a").
826 : : */
827 : :
828 : : /* sort missing IE before (left of) present IE */
829 : 0 : if (!ie1)
830 : : return -1;
831 : 0 : if (!ie2)
832 : : return 1;
833 : :
834 : 0 : switch (mode) {
835 : : case BSS_CMP_HIDE_ZLEN:
836 : : /*
837 : : * In ZLEN mode we assume the BSS entry we're
838 : : * looking for has a zero-length SSID. So if
839 : : * the one we're looking at right now has that,
840 : : * return 0. Otherwise, return the difference
841 : : * in length, but since we're looking for the
842 : : * 0-length it's really equivalent to returning
843 : : * the length of the one we're looking at.
844 : : *
845 : : * No content comparison is needed as we assume
846 : : * the content length is zero.
847 : : */
848 : 0 : return ie2[1];
849 : : case BSS_CMP_REGULAR:
850 : : default:
851 : : /* sort by length first, then by contents */
852 : 0 : if (ie1[1] != ie2[1])
853 : 0 : return ie2[1] - ie1[1];
854 : 0 : return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
855 : : case BSS_CMP_HIDE_NUL:
856 : 0 : if (ie1[1] != ie2[1])
857 : 0 : return ie2[1] - ie1[1];
858 : : /* this is equivalent to memcmp(zeroes, ie2 + 2, len) */
859 : 0 : for (i = 0; i < ie2[1]; i++)
860 : 0 : if (ie2[i + 2])
861 : : return -1;
862 : : return 0;
863 : : }
864 : : }
865 : :
866 : 0 : static bool cfg80211_bss_type_match(u16 capability,
867 : : enum nl80211_band band,
868 : : enum ieee80211_bss_type bss_type)
869 : : {
870 : : bool ret = true;
871 : : u16 mask, val;
872 : :
873 : 0 : if (bss_type == IEEE80211_BSS_TYPE_ANY)
874 : : return ret;
875 : :
876 : 0 : if (band == NL80211_BAND_60GHZ) {
877 : : mask = WLAN_CAPABILITY_DMG_TYPE_MASK;
878 : 0 : switch (bss_type) {
879 : : case IEEE80211_BSS_TYPE_ESS:
880 : : val = WLAN_CAPABILITY_DMG_TYPE_AP;
881 : : break;
882 : : case IEEE80211_BSS_TYPE_PBSS:
883 : : val = WLAN_CAPABILITY_DMG_TYPE_PBSS;
884 : 0 : break;
885 : : case IEEE80211_BSS_TYPE_IBSS:
886 : : val = WLAN_CAPABILITY_DMG_TYPE_IBSS;
887 : 0 : break;
888 : : default:
889 : : return false;
890 : : }
891 : : } else {
892 : : mask = WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS;
893 : 0 : switch (bss_type) {
894 : : case IEEE80211_BSS_TYPE_ESS:
895 : : val = WLAN_CAPABILITY_ESS;
896 : : break;
897 : : case IEEE80211_BSS_TYPE_IBSS:
898 : : val = WLAN_CAPABILITY_IBSS;
899 : 0 : break;
900 : : case IEEE80211_BSS_TYPE_MBSS:
901 : : val = 0;
902 : 0 : break;
903 : : default:
904 : : return false;
905 : : }
906 : : }
907 : :
908 : 0 : ret = ((capability & mask) == val);
909 : 0 : return ret;
910 : : }
911 : :
912 : : /* Returned bss is reference counted and must be cleaned up appropriately. */
913 : 0 : struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
914 : : struct ieee80211_channel *channel,
915 : : const u8 *bssid,
916 : : const u8 *ssid, size_t ssid_len,
917 : : enum ieee80211_bss_type bss_type,
918 : : enum ieee80211_privacy privacy)
919 : : {
920 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
921 : : struct cfg80211_internal_bss *bss, *res = NULL;
922 : 0 : unsigned long now = jiffies;
923 : : int bss_privacy;
924 : :
925 : 0 : trace_cfg80211_get_bss(wiphy, channel, bssid, ssid, ssid_len, bss_type,
926 : : privacy);
927 : :
928 : : spin_lock_bh(&rdev->bss_lock);
929 : :
930 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
931 : 0 : if (!cfg80211_bss_type_match(bss->pub.capability,
932 : 0 : bss->pub.channel->band, bss_type))
933 : 0 : continue;
934 : :
935 : 0 : bss_privacy = (bss->pub.capability & WLAN_CAPABILITY_PRIVACY);
936 : 0 : if ((privacy == IEEE80211_PRIVACY_ON && !bss_privacy) ||
937 : 0 : (privacy == IEEE80211_PRIVACY_OFF && bss_privacy))
938 : 0 : continue;
939 : 0 : if (channel && bss->pub.channel != channel)
940 : 0 : continue;
941 : 0 : if (!is_valid_ether_addr(bss->pub.bssid))
942 : 0 : continue;
943 : : /* Don't get expired BSS structs */
944 : 0 : if (time_after(now, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE) &&
945 : 0 : !atomic_read(&bss->hold))
946 : 0 : continue;
947 : 0 : if (is_bss(&bss->pub, bssid, ssid, ssid_len)) {
948 : 0 : res = bss;
949 : 0 : bss_ref_get(rdev, res);
950 : 0 : break;
951 : : }
952 : : }
953 : :
954 : : spin_unlock_bh(&rdev->bss_lock);
955 : 0 : if (!res)
956 : : return NULL;
957 : 0 : trace_cfg80211_return_bss(&res->pub);
958 : 0 : return &res->pub;
959 : : }
960 : : EXPORT_SYMBOL(cfg80211_get_bss);
961 : :
962 : 0 : static void rb_insert_bss(struct cfg80211_registered_device *rdev,
963 : : struct cfg80211_internal_bss *bss)
964 : : {
965 : 0 : struct rb_node **p = &rdev->bss_tree.rb_node;
966 : : struct rb_node *parent = NULL;
967 : : struct cfg80211_internal_bss *tbss;
968 : : int cmp;
969 : :
970 : 0 : while (*p) {
971 : : parent = *p;
972 : : tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn);
973 : :
974 : 0 : cmp = cmp_bss(&bss->pub, &tbss->pub, BSS_CMP_REGULAR);
975 : :
976 : 0 : if (WARN_ON(!cmp)) {
977 : : /* will sort of leak this BSS */
978 : 0 : return;
979 : : }
980 : :
981 : 0 : if (cmp < 0)
982 : 0 : p = &(*p)->rb_left;
983 : : else
984 : 0 : p = &(*p)->rb_right;
985 : : }
986 : :
987 : 0 : rb_link_node(&bss->rbn, parent, p);
988 : 0 : rb_insert_color(&bss->rbn, &rdev->bss_tree);
989 : : }
990 : :
991 : : static struct cfg80211_internal_bss *
992 : 0 : rb_find_bss(struct cfg80211_registered_device *rdev,
993 : : struct cfg80211_internal_bss *res,
994 : : enum bss_compare_mode mode)
995 : : {
996 : 0 : struct rb_node *n = rdev->bss_tree.rb_node;
997 : : struct cfg80211_internal_bss *bss;
998 : : int r;
999 : :
1000 : 0 : while (n) {
1001 : 0 : bss = rb_entry(n, struct cfg80211_internal_bss, rbn);
1002 : 0 : r = cmp_bss(&res->pub, &bss->pub, mode);
1003 : :
1004 : 0 : if (r == 0)
1005 : 0 : return bss;
1006 : 0 : else if (r < 0)
1007 : 0 : n = n->rb_left;
1008 : : else
1009 : 0 : n = n->rb_right;
1010 : : }
1011 : :
1012 : : return NULL;
1013 : : }
1014 : :
1015 : 0 : static bool cfg80211_combine_bsses(struct cfg80211_registered_device *rdev,
1016 : : struct cfg80211_internal_bss *new)
1017 : : {
1018 : : const struct cfg80211_bss_ies *ies;
1019 : : struct cfg80211_internal_bss *bss;
1020 : : const u8 *ie;
1021 : : int i, ssidlen;
1022 : : u8 fold = 0;
1023 : : u32 n_entries = 0;
1024 : :
1025 : 0 : ies = rcu_access_pointer(new->pub.beacon_ies);
1026 : 0 : if (WARN_ON(!ies))
1027 : : return false;
1028 : :
1029 : 0 : ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
1030 : 0 : if (!ie) {
1031 : : /* nothing to do */
1032 : : return true;
1033 : : }
1034 : :
1035 : 0 : ssidlen = ie[1];
1036 : 0 : for (i = 0; i < ssidlen; i++)
1037 : 0 : fold |= ie[2 + i];
1038 : :
1039 : 0 : if (fold) {
1040 : : /* not a hidden SSID */
1041 : : return true;
1042 : : }
1043 : :
1044 : : /* This is the bad part ... */
1045 : :
1046 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
1047 : : /*
1048 : : * we're iterating all the entries anyway, so take the
1049 : : * opportunity to validate the list length accounting
1050 : : */
1051 : 0 : n_entries++;
1052 : :
1053 : 0 : if (!ether_addr_equal(bss->pub.bssid, new->pub.bssid))
1054 : 0 : continue;
1055 : 0 : if (bss->pub.channel != new->pub.channel)
1056 : 0 : continue;
1057 : 0 : if (bss->pub.scan_width != new->pub.scan_width)
1058 : 0 : continue;
1059 : 0 : if (rcu_access_pointer(bss->pub.beacon_ies))
1060 : 0 : continue;
1061 : 0 : ies = rcu_access_pointer(bss->pub.ies);
1062 : 0 : if (!ies)
1063 : 0 : continue;
1064 : 0 : ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
1065 : 0 : if (!ie)
1066 : 0 : continue;
1067 : 0 : if (ssidlen && ie[1] != ssidlen)
1068 : 0 : continue;
1069 : 0 : if (WARN_ON_ONCE(bss->pub.hidden_beacon_bss))
1070 : 0 : continue;
1071 : 0 : if (WARN_ON_ONCE(!list_empty(&bss->hidden_list)))
1072 : : list_del(&bss->hidden_list);
1073 : : /* combine them */
1074 : 0 : list_add(&bss->hidden_list, &new->hidden_list);
1075 : 0 : bss->pub.hidden_beacon_bss = &new->pub;
1076 : 0 : new->refcount += bss->refcount;
1077 : 0 : rcu_assign_pointer(bss->pub.beacon_ies,
1078 : : new->pub.beacon_ies);
1079 : : }
1080 : :
1081 : 0 : WARN_ONCE(n_entries != rdev->bss_entries,
1082 : : "rdev bss entries[%d]/list[len:%d] corruption\n",
1083 : : rdev->bss_entries, n_entries);
1084 : :
1085 : : return true;
1086 : : }
1087 : :
1088 : : struct cfg80211_non_tx_bss {
1089 : : struct cfg80211_bss *tx_bss;
1090 : : u8 max_bssid_indicator;
1091 : : u8 bssid_index;
1092 : : };
1093 : :
1094 : : static bool
1095 : 0 : cfg80211_update_known_bss(struct cfg80211_registered_device *rdev,
1096 : : struct cfg80211_internal_bss *known,
1097 : : struct cfg80211_internal_bss *new,
1098 : : bool signal_valid)
1099 : : {
1100 : : lockdep_assert_held(&rdev->bss_lock);
1101 : :
1102 : : /* Update IEs */
1103 : 0 : if (rcu_access_pointer(new->pub.proberesp_ies)) {
1104 : : const struct cfg80211_bss_ies *old;
1105 : :
1106 : 0 : old = rcu_access_pointer(known->pub.proberesp_ies);
1107 : :
1108 : 0 : rcu_assign_pointer(known->pub.proberesp_ies,
1109 : : new->pub.proberesp_ies);
1110 : : /* Override possible earlier Beacon frame IEs */
1111 : 0 : rcu_assign_pointer(known->pub.ies,
1112 : : new->pub.proberesp_ies);
1113 : 0 : if (old)
1114 : 0 : kfree_rcu((struct cfg80211_bss_ies *)old, rcu_head);
1115 : 0 : } else if (rcu_access_pointer(new->pub.beacon_ies)) {
1116 : : const struct cfg80211_bss_ies *old;
1117 : : struct cfg80211_internal_bss *bss;
1118 : :
1119 : 0 : if (known->pub.hidden_beacon_bss &&
1120 : 0 : !list_empty(&known->hidden_list)) {
1121 : : const struct cfg80211_bss_ies *f;
1122 : :
1123 : : /* The known BSS struct is one of the probe
1124 : : * response members of a group, but we're
1125 : : * receiving a beacon (beacon_ies in the new
1126 : : * bss is used). This can only mean that the
1127 : : * AP changed its beacon from not having an
1128 : : * SSID to showing it, which is confusing so
1129 : : * drop this information.
1130 : : */
1131 : :
1132 : 0 : f = rcu_access_pointer(new->pub.beacon_ies);
1133 : 0 : kfree_rcu((struct cfg80211_bss_ies *)f, rcu_head);
1134 : : return false;
1135 : : }
1136 : :
1137 : 0 : old = rcu_access_pointer(known->pub.beacon_ies);
1138 : :
1139 : 0 : rcu_assign_pointer(known->pub.beacon_ies, new->pub.beacon_ies);
1140 : :
1141 : : /* Override IEs if they were from a beacon before */
1142 : 0 : if (old == rcu_access_pointer(known->pub.ies))
1143 : 0 : rcu_assign_pointer(known->pub.ies, new->pub.beacon_ies);
1144 : :
1145 : : /* Assign beacon IEs to all sub entries */
1146 : 0 : list_for_each_entry(bss, &known->hidden_list, hidden_list) {
1147 : : const struct cfg80211_bss_ies *ies;
1148 : :
1149 : 0 : ies = rcu_access_pointer(bss->pub.beacon_ies);
1150 : 0 : WARN_ON(ies != old);
1151 : :
1152 : 0 : rcu_assign_pointer(bss->pub.beacon_ies,
1153 : : new->pub.beacon_ies);
1154 : : }
1155 : :
1156 : 0 : if (old)
1157 : 0 : kfree_rcu((struct cfg80211_bss_ies *)old, rcu_head);
1158 : : }
1159 : :
1160 : 0 : known->pub.beacon_interval = new->pub.beacon_interval;
1161 : :
1162 : : /* don't update the signal if beacon was heard on
1163 : : * adjacent channel.
1164 : : */
1165 : 0 : if (signal_valid)
1166 : 0 : known->pub.signal = new->pub.signal;
1167 : 0 : known->pub.capability = new->pub.capability;
1168 : 0 : known->ts = new->ts;
1169 : 0 : known->ts_boottime = new->ts_boottime;
1170 : 0 : known->parent_tsf = new->parent_tsf;
1171 : 0 : known->pub.chains = new->pub.chains;
1172 : 0 : memcpy(known->pub.chain_signal, new->pub.chain_signal,
1173 : : IEEE80211_MAX_CHAINS);
1174 : : ether_addr_copy(known->parent_bssid, new->parent_bssid);
1175 : 0 : known->pub.max_bssid_indicator = new->pub.max_bssid_indicator;
1176 : 0 : known->pub.bssid_index = new->pub.bssid_index;
1177 : :
1178 : 0 : return true;
1179 : : }
1180 : :
1181 : : /* Returned bss is reference counted and must be cleaned up appropriately. */
1182 : : struct cfg80211_internal_bss *
1183 : 0 : cfg80211_bss_update(struct cfg80211_registered_device *rdev,
1184 : : struct cfg80211_internal_bss *tmp,
1185 : : bool signal_valid, unsigned long ts)
1186 : : {
1187 : : struct cfg80211_internal_bss *found = NULL;
1188 : :
1189 : 0 : if (WARN_ON(!tmp->pub.channel))
1190 : : return NULL;
1191 : :
1192 : 0 : tmp->ts = ts;
1193 : :
1194 : : spin_lock_bh(&rdev->bss_lock);
1195 : :
1196 : 0 : if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) {
1197 : : spin_unlock_bh(&rdev->bss_lock);
1198 : 0 : return NULL;
1199 : : }
1200 : :
1201 : 0 : found = rb_find_bss(rdev, tmp, BSS_CMP_REGULAR);
1202 : :
1203 : 0 : if (found) {
1204 : 0 : if (!cfg80211_update_known_bss(rdev, found, tmp, signal_valid))
1205 : : goto drop;
1206 : : } else {
1207 : : struct cfg80211_internal_bss *new;
1208 : : struct cfg80211_internal_bss *hidden;
1209 : : struct cfg80211_bss_ies *ies;
1210 : :
1211 : : /*
1212 : : * create a copy -- the "res" variable that is passed in
1213 : : * is allocated on the stack since it's not needed in the
1214 : : * more common case of an update
1215 : : */
1216 : 0 : new = kzalloc(sizeof(*new) + rdev->wiphy.bss_priv_size,
1217 : : GFP_ATOMIC);
1218 : 0 : if (!new) {
1219 : 0 : ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
1220 : 0 : if (ies)
1221 : 0 : kfree_rcu(ies, rcu_head);
1222 : 0 : ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
1223 : 0 : if (ies)
1224 : 0 : kfree_rcu(ies, rcu_head);
1225 : : goto drop;
1226 : : }
1227 : 0 : memcpy(new, tmp, sizeof(*new));
1228 : 0 : new->refcount = 1;
1229 : 0 : INIT_LIST_HEAD(&new->hidden_list);
1230 : 0 : INIT_LIST_HEAD(&new->pub.nontrans_list);
1231 : :
1232 : 0 : if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
1233 : 0 : hidden = rb_find_bss(rdev, tmp, BSS_CMP_HIDE_ZLEN);
1234 : 0 : if (!hidden)
1235 : 0 : hidden = rb_find_bss(rdev, tmp,
1236 : : BSS_CMP_HIDE_NUL);
1237 : 0 : if (hidden) {
1238 : 0 : new->pub.hidden_beacon_bss = &hidden->pub;
1239 : 0 : list_add(&new->hidden_list,
1240 : : &hidden->hidden_list);
1241 : 0 : hidden->refcount++;
1242 : 0 : rcu_assign_pointer(new->pub.beacon_ies,
1243 : : hidden->pub.beacon_ies);
1244 : : }
1245 : : } else {
1246 : : /*
1247 : : * Ok so we found a beacon, and don't have an entry. If
1248 : : * it's a beacon with hidden SSID, we might be in for an
1249 : : * expensive search for any probe responses that should
1250 : : * be grouped with this beacon for updates ...
1251 : : */
1252 : 0 : if (!cfg80211_combine_bsses(rdev, new)) {
1253 : 0 : kfree(new);
1254 : 0 : goto drop;
1255 : : }
1256 : : }
1257 : :
1258 : 0 : if (rdev->bss_entries >= bss_entries_limit &&
1259 : 0 : !cfg80211_bss_expire_oldest(rdev)) {
1260 : 0 : kfree(new);
1261 : 0 : goto drop;
1262 : : }
1263 : :
1264 : : /* This must be before the call to bss_ref_get */
1265 : 0 : if (tmp->pub.transmitted_bss) {
1266 : : struct cfg80211_internal_bss *pbss =
1267 : 0 : container_of(tmp->pub.transmitted_bss,
1268 : : struct cfg80211_internal_bss,
1269 : : pub);
1270 : :
1271 : 0 : new->pub.transmitted_bss = tmp->pub.transmitted_bss;
1272 : 0 : bss_ref_get(rdev, pbss);
1273 : : }
1274 : :
1275 : 0 : list_add_tail(&new->list, &rdev->bss_list);
1276 : 0 : rdev->bss_entries++;
1277 : 0 : rb_insert_bss(rdev, new);
1278 : : found = new;
1279 : : }
1280 : :
1281 : 0 : rdev->bss_generation++;
1282 : 0 : bss_ref_get(rdev, found);
1283 : : spin_unlock_bh(&rdev->bss_lock);
1284 : :
1285 : 0 : return found;
1286 : : drop:
1287 : : spin_unlock_bh(&rdev->bss_lock);
1288 : 0 : return NULL;
1289 : : }
1290 : :
1291 : : /*
1292 : : * Update RX channel information based on the available frame payload
1293 : : * information. This is mainly for the 2.4 GHz band where frames can be received
1294 : : * from neighboring channels and the Beacon frames use the DSSS Parameter Set
1295 : : * element to indicate the current (transmitting) channel, but this might also
1296 : : * be needed on other bands if RX frequency does not match with the actual
1297 : : * operating channel of a BSS.
1298 : : */
1299 : : static struct ieee80211_channel *
1300 : 0 : cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
1301 : : struct ieee80211_channel *channel,
1302 : : enum nl80211_bss_scan_width scan_width)
1303 : : {
1304 : : const u8 *tmp;
1305 : : u32 freq;
1306 : : int channel_number = -1;
1307 : : struct ieee80211_channel *alt_channel;
1308 : :
1309 : : tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
1310 : 0 : if (tmp && tmp[1] == 1) {
1311 : 0 : channel_number = tmp[2];
1312 : : } else {
1313 : : tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
1314 : 0 : if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
1315 : : struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
1316 : :
1317 : 0 : channel_number = htop->primary_chan;
1318 : : }
1319 : : }
1320 : :
1321 : 0 : if (channel_number < 0) {
1322 : : /* No channel information in frame payload */
1323 : : return channel;
1324 : : }
1325 : :
1326 : 0 : freq = ieee80211_channel_to_frequency(channel_number, channel->band);
1327 : 0 : alt_channel = ieee80211_get_channel(wiphy, freq);
1328 : 0 : if (!alt_channel) {
1329 : 0 : if (channel->band == NL80211_BAND_2GHZ) {
1330 : : /*
1331 : : * Better not allow unexpected channels when that could
1332 : : * be going beyond the 1-11 range (e.g., discovering
1333 : : * BSS on channel 12 when radio is configured for
1334 : : * channel 11.
1335 : : */
1336 : : return NULL;
1337 : : }
1338 : :
1339 : : /* No match for the payload channel number - ignore it */
1340 : 0 : return channel;
1341 : : }
1342 : :
1343 : 0 : if (scan_width == NL80211_BSS_CHAN_WIDTH_10 ||
1344 : : scan_width == NL80211_BSS_CHAN_WIDTH_5) {
1345 : : /*
1346 : : * Ignore channel number in 5 and 10 MHz channels where there
1347 : : * may not be an n:1 or 1:n mapping between frequencies and
1348 : : * channel numbers.
1349 : : */
1350 : : return channel;
1351 : : }
1352 : :
1353 : : /*
1354 : : * Use the channel determined through the payload channel number
1355 : : * instead of the RX channel reported by the driver.
1356 : : */
1357 : 0 : if (alt_channel->flags & IEEE80211_CHAN_DISABLED)
1358 : : return NULL;
1359 : 0 : return alt_channel;
1360 : : }
1361 : :
1362 : : /* Returned bss is reference counted and must be cleaned up appropriately. */
1363 : : static struct cfg80211_bss *
1364 : 0 : cfg80211_inform_single_bss_data(struct wiphy *wiphy,
1365 : : struct cfg80211_inform_bss *data,
1366 : : enum cfg80211_bss_frame_type ftype,
1367 : : const u8 *bssid, u64 tsf, u16 capability,
1368 : : u16 beacon_interval, const u8 *ie, size_t ielen,
1369 : : struct cfg80211_non_tx_bss *non_tx_data,
1370 : : gfp_t gfp)
1371 : : {
1372 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1373 : : struct cfg80211_bss_ies *ies;
1374 : : struct ieee80211_channel *channel;
1375 : 0 : struct cfg80211_internal_bss tmp = {}, *res;
1376 : : int bss_type;
1377 : : bool signal_valid;
1378 : : unsigned long ts;
1379 : :
1380 : 0 : if (WARN_ON(!wiphy))
1381 : : return NULL;
1382 : :
1383 : 0 : if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
1384 : : (data->signal < 0 || data->signal > 100)))
1385 : : return NULL;
1386 : :
1387 : 0 : channel = cfg80211_get_bss_channel(wiphy, ie, ielen, data->chan,
1388 : : data->scan_width);
1389 : 0 : if (!channel)
1390 : : return NULL;
1391 : :
1392 : 0 : memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
1393 : 0 : tmp.pub.channel = channel;
1394 : 0 : tmp.pub.scan_width = data->scan_width;
1395 : 0 : tmp.pub.signal = data->signal;
1396 : 0 : tmp.pub.beacon_interval = beacon_interval;
1397 : 0 : tmp.pub.capability = capability;
1398 : 0 : tmp.ts_boottime = data->boottime_ns;
1399 : 0 : if (non_tx_data) {
1400 : 0 : tmp.pub.transmitted_bss = non_tx_data->tx_bss;
1401 : 0 : ts = bss_from_pub(non_tx_data->tx_bss)->ts;
1402 : 0 : tmp.pub.bssid_index = non_tx_data->bssid_index;
1403 : 0 : tmp.pub.max_bssid_indicator = non_tx_data->max_bssid_indicator;
1404 : : } else {
1405 : 0 : ts = jiffies;
1406 : : }
1407 : :
1408 : : /*
1409 : : * If we do not know here whether the IEs are from a Beacon or Probe
1410 : : * Response frame, we need to pick one of the options and only use it
1411 : : * with the driver that does not provide the full Beacon/Probe Response
1412 : : * frame. Use Beacon frame pointer to avoid indicating that this should
1413 : : * override the IEs pointer should we have received an earlier
1414 : : * indication of Probe Response data.
1415 : : */
1416 : 0 : ies = kzalloc(sizeof(*ies) + ielen, gfp);
1417 : 0 : if (!ies)
1418 : : return NULL;
1419 : 0 : ies->len = ielen;
1420 : 0 : ies->tsf = tsf;
1421 : 0 : ies->from_beacon = false;
1422 : 0 : memcpy(ies->data, ie, ielen);
1423 : :
1424 : 0 : switch (ftype) {
1425 : : case CFG80211_BSS_FTYPE_BEACON:
1426 : 0 : ies->from_beacon = true;
1427 : : /* fall through */
1428 : : case CFG80211_BSS_FTYPE_UNKNOWN:
1429 : 0 : rcu_assign_pointer(tmp.pub.beacon_ies, ies);
1430 : 0 : break;
1431 : : case CFG80211_BSS_FTYPE_PRESP:
1432 : 0 : rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
1433 : 0 : break;
1434 : : }
1435 : 0 : rcu_assign_pointer(tmp.pub.ies, ies);
1436 : :
1437 : 0 : signal_valid = abs(data->chan->center_freq - channel->center_freq) <=
1438 : 0 : wiphy->max_adj_channel_rssi_comp;
1439 : 0 : res = cfg80211_bss_update(wiphy_to_rdev(wiphy), &tmp, signal_valid, ts);
1440 : 0 : if (!res)
1441 : : return NULL;
1442 : :
1443 : 0 : if (channel->band == NL80211_BAND_60GHZ) {
1444 : 0 : bss_type = res->pub.capability & WLAN_CAPABILITY_DMG_TYPE_MASK;
1445 : 0 : if (bss_type == WLAN_CAPABILITY_DMG_TYPE_AP ||
1446 : : bss_type == WLAN_CAPABILITY_DMG_TYPE_PBSS)
1447 : 0 : regulatory_hint_found_beacon(wiphy, channel, gfp);
1448 : : } else {
1449 : 0 : if (res->pub.capability & WLAN_CAPABILITY_ESS)
1450 : 0 : regulatory_hint_found_beacon(wiphy, channel, gfp);
1451 : : }
1452 : :
1453 : 0 : if (non_tx_data) {
1454 : : /* this is a nontransmitting bss, we need to add it to
1455 : : * transmitting bss' list if it is not there
1456 : : */
1457 : 0 : if (cfg80211_add_nontrans_list(non_tx_data->tx_bss,
1458 : : &res->pub)) {
1459 : 0 : if (__cfg80211_unlink_bss(rdev, res))
1460 : 0 : rdev->bss_generation++;
1461 : : }
1462 : : }
1463 : :
1464 : 0 : trace_cfg80211_return_bss(&res->pub);
1465 : : /* cfg80211_bss_update gives us a referenced result */
1466 : 0 : return &res->pub;
1467 : : }
1468 : :
1469 : : static const struct element
1470 : 0 : *cfg80211_get_profile_continuation(const u8 *ie, size_t ielen,
1471 : : const struct element *mbssid_elem,
1472 : : const struct element *sub_elem)
1473 : : {
1474 : 0 : const u8 *mbssid_end = mbssid_elem->data + mbssid_elem->datalen;
1475 : : const struct element *next_mbssid;
1476 : : const struct element *next_sub;
1477 : :
1478 : : next_mbssid = cfg80211_find_elem(WLAN_EID_MULTIPLE_BSSID,
1479 : : mbssid_end,
1480 : 0 : ielen - (mbssid_end - ie));
1481 : :
1482 : : /*
1483 : : * If is is not the last subelement in current MBSSID IE or there isn't
1484 : : * a next MBSSID IE - profile is complete.
1485 : : */
1486 : 0 : if ((sub_elem->data + sub_elem->datalen < mbssid_end - 1) ||
1487 : : !next_mbssid)
1488 : : return NULL;
1489 : :
1490 : : /* For any length error, just return NULL */
1491 : :
1492 : 0 : if (next_mbssid->datalen < 4)
1493 : : return NULL;
1494 : :
1495 : : next_sub = (void *)&next_mbssid->data[1];
1496 : :
1497 : 0 : if (next_mbssid->data + next_mbssid->datalen <
1498 : 0 : next_sub->data + next_sub->datalen)
1499 : : return NULL;
1500 : :
1501 : 0 : if (next_sub->id != 0 || next_sub->datalen < 2)
1502 : : return NULL;
1503 : :
1504 : : /*
1505 : : * Check if the first element in the next sub element is a start
1506 : : * of a new profile
1507 : : */
1508 : 0 : return next_sub->data[0] == WLAN_EID_NON_TX_BSSID_CAP ?
1509 : 0 : NULL : next_mbssid;
1510 : : }
1511 : :
1512 : 0 : size_t cfg80211_merge_profile(const u8 *ie, size_t ielen,
1513 : : const struct element *mbssid_elem,
1514 : : const struct element *sub_elem,
1515 : : u8 *merged_ie, size_t max_copy_len)
1516 : : {
1517 : 0 : size_t copied_len = sub_elem->datalen;
1518 : : const struct element *next_mbssid;
1519 : :
1520 : 0 : if (sub_elem->datalen > max_copy_len)
1521 : : return 0;
1522 : :
1523 : 0 : memcpy(merged_ie, sub_elem->data, sub_elem->datalen);
1524 : :
1525 : 0 : while ((next_mbssid = cfg80211_get_profile_continuation(ie, ielen,
1526 : : mbssid_elem,
1527 : : sub_elem))) {
1528 : : const struct element *next_sub = (void *)&next_mbssid->data[1];
1529 : :
1530 : 0 : if (copied_len + next_sub->datalen > max_copy_len)
1531 : : break;
1532 : 0 : memcpy(merged_ie + copied_len, next_sub->data,
1533 : : next_sub->datalen);
1534 : 0 : copied_len += next_sub->datalen;
1535 : : }
1536 : :
1537 : 0 : return copied_len;
1538 : : }
1539 : : EXPORT_SYMBOL(cfg80211_merge_profile);
1540 : :
1541 : 0 : static void cfg80211_parse_mbssid_data(struct wiphy *wiphy,
1542 : : struct cfg80211_inform_bss *data,
1543 : : enum cfg80211_bss_frame_type ftype,
1544 : : const u8 *bssid, u64 tsf,
1545 : : u16 beacon_interval, const u8 *ie,
1546 : : size_t ielen,
1547 : : struct cfg80211_non_tx_bss *non_tx_data,
1548 : : gfp_t gfp)
1549 : : {
1550 : : const u8 *mbssid_index_ie;
1551 : : const struct element *elem, *sub;
1552 : : size_t new_ie_len;
1553 : : u8 new_bssid[ETH_ALEN];
1554 : : u8 *new_ie, *profile;
1555 : : u64 seen_indices = 0;
1556 : : u16 capability;
1557 : : struct cfg80211_bss *bss;
1558 : :
1559 : 0 : if (!non_tx_data)
1560 : 0 : return;
1561 : 0 : if (!cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ie, ielen))
1562 : : return;
1563 : 0 : if (!wiphy->support_mbssid)
1564 : : return;
1565 : 0 : if (wiphy->support_only_he_mbssid &&
1566 : : !cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ie, ielen))
1567 : : return;
1568 : :
1569 : : new_ie = kmalloc(IEEE80211_MAX_DATA_LEN, gfp);
1570 : 0 : if (!new_ie)
1571 : : return;
1572 : :
1573 : : profile = kmalloc(ielen, gfp);
1574 : 0 : if (!profile)
1575 : : goto out;
1576 : :
1577 : 0 : for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, ie, ielen) {
1578 : 0 : if (elem->datalen < 4)
1579 : 0 : continue;
1580 : 0 : for_each_element(sub, elem->data + 1, elem->datalen - 1) {
1581 : : u8 profile_len;
1582 : :
1583 : 0 : if (sub->id != 0 || sub->datalen < 4) {
1584 : : /* not a valid BSS profile */
1585 : 0 : continue;
1586 : : }
1587 : :
1588 : 0 : if (sub->data[0] != WLAN_EID_NON_TX_BSSID_CAP ||
1589 : 0 : sub->data[1] != 2) {
1590 : : /* The first element within the Nontransmitted
1591 : : * BSSID Profile is not the Nontransmitted
1592 : : * BSSID Capability element.
1593 : : */
1594 : 0 : continue;
1595 : : }
1596 : :
1597 : 0 : memset(profile, 0, ielen);
1598 : 0 : profile_len = cfg80211_merge_profile(ie, ielen,
1599 : : elem,
1600 : : sub,
1601 : : profile,
1602 : : ielen);
1603 : :
1604 : : /* found a Nontransmitted BSSID Profile */
1605 : : mbssid_index_ie = cfg80211_find_ie
1606 : : (WLAN_EID_MULTI_BSSID_IDX,
1607 : : profile, profile_len);
1608 : 0 : if (!mbssid_index_ie || mbssid_index_ie[1] < 1 ||
1609 : 0 : mbssid_index_ie[2] == 0 ||
1610 : : mbssid_index_ie[2] > 46) {
1611 : : /* No valid Multiple BSSID-Index element */
1612 : 0 : continue;
1613 : : }
1614 : :
1615 : : if (seen_indices & BIT_ULL(mbssid_index_ie[2]))
1616 : : /* We don't support legacy split of a profile */
1617 : : net_dbg_ratelimited("Partial info for BSSID index %d\n",
1618 : : mbssid_index_ie[2]);
1619 : :
1620 : : seen_indices |= BIT_ULL(mbssid_index_ie[2]);
1621 : :
1622 : 0 : non_tx_data->bssid_index = mbssid_index_ie[2];
1623 : 0 : non_tx_data->max_bssid_indicator = elem->data[0];
1624 : :
1625 : 0 : cfg80211_gen_new_bssid(bssid,
1626 : : non_tx_data->max_bssid_indicator,
1627 : : non_tx_data->bssid_index,
1628 : : new_bssid);
1629 : 0 : memset(new_ie, 0, IEEE80211_MAX_DATA_LEN);
1630 : 0 : new_ie_len = cfg80211_gen_new_ie(ie, ielen,
1631 : : profile,
1632 : : profile_len, new_ie,
1633 : : gfp);
1634 : 0 : if (!new_ie_len)
1635 : 0 : continue;
1636 : :
1637 : : capability = get_unaligned_le16(profile + 2);
1638 : 0 : bss = cfg80211_inform_single_bss_data(wiphy, data,
1639 : : ftype,
1640 : : new_bssid, tsf,
1641 : : capability,
1642 : : beacon_interval,
1643 : : new_ie,
1644 : : new_ie_len,
1645 : : non_tx_data,
1646 : : gfp);
1647 : 0 : if (!bss)
1648 : : break;
1649 : 0 : cfg80211_put_bss(wiphy, bss);
1650 : : }
1651 : : }
1652 : :
1653 : : out:
1654 : 0 : kfree(new_ie);
1655 : 0 : kfree(profile);
1656 : : }
1657 : :
1658 : : struct cfg80211_bss *
1659 : 0 : cfg80211_inform_bss_data(struct wiphy *wiphy,
1660 : : struct cfg80211_inform_bss *data,
1661 : : enum cfg80211_bss_frame_type ftype,
1662 : : const u8 *bssid, u64 tsf, u16 capability,
1663 : : u16 beacon_interval, const u8 *ie, size_t ielen,
1664 : : gfp_t gfp)
1665 : : {
1666 : : struct cfg80211_bss *res;
1667 : : struct cfg80211_non_tx_bss non_tx_data;
1668 : :
1669 : 0 : res = cfg80211_inform_single_bss_data(wiphy, data, ftype, bssid, tsf,
1670 : : capability, beacon_interval, ie,
1671 : : ielen, NULL, gfp);
1672 : 0 : if (!res)
1673 : : return NULL;
1674 : 0 : non_tx_data.tx_bss = res;
1675 : 0 : cfg80211_parse_mbssid_data(wiphy, data, ftype, bssid, tsf,
1676 : : beacon_interval, ie, ielen, &non_tx_data,
1677 : : gfp);
1678 : 0 : return res;
1679 : : }
1680 : : EXPORT_SYMBOL(cfg80211_inform_bss_data);
1681 : :
1682 : : static void
1683 : 0 : cfg80211_parse_mbssid_frame_data(struct wiphy *wiphy,
1684 : : struct cfg80211_inform_bss *data,
1685 : : struct ieee80211_mgmt *mgmt, size_t len,
1686 : : struct cfg80211_non_tx_bss *non_tx_data,
1687 : : gfp_t gfp)
1688 : : {
1689 : : enum cfg80211_bss_frame_type ftype;
1690 : 0 : const u8 *ie = mgmt->u.probe_resp.variable;
1691 : 0 : size_t ielen = len - offsetof(struct ieee80211_mgmt,
1692 : : u.probe_resp.variable);
1693 : :
1694 : 0 : ftype = ieee80211_is_beacon(mgmt->frame_control) ?
1695 : : CFG80211_BSS_FTYPE_BEACON : CFG80211_BSS_FTYPE_PRESP;
1696 : :
1697 : 0 : cfg80211_parse_mbssid_data(wiphy, data, ftype, mgmt->bssid,
1698 : : le64_to_cpu(mgmt->u.probe_resp.timestamp),
1699 : : le16_to_cpu(mgmt->u.probe_resp.beacon_int),
1700 : : ie, ielen, non_tx_data, gfp);
1701 : 0 : }
1702 : :
1703 : : static void
1704 : 0 : cfg80211_update_notlisted_nontrans(struct wiphy *wiphy,
1705 : : struct cfg80211_bss *nontrans_bss,
1706 : : struct ieee80211_mgmt *mgmt, size_t len)
1707 : : {
1708 : : u8 *ie, *new_ie, *pos;
1709 : : const u8 *nontrans_ssid, *trans_ssid, *mbssid;
1710 : 0 : size_t ielen = len - offsetof(struct ieee80211_mgmt,
1711 : : u.probe_resp.variable);
1712 : : size_t new_ie_len;
1713 : : struct cfg80211_bss_ies *new_ies;
1714 : : const struct cfg80211_bss_ies *old;
1715 : : u8 cpy_len;
1716 : :
1717 : : lockdep_assert_held(&wiphy_to_rdev(wiphy)->bss_lock);
1718 : :
1719 : 0 : ie = mgmt->u.probe_resp.variable;
1720 : :
1721 : : new_ie_len = ielen;
1722 : : trans_ssid = cfg80211_find_ie(WLAN_EID_SSID, ie, ielen);
1723 : 0 : if (!trans_ssid)
1724 : : return;
1725 : 0 : new_ie_len -= trans_ssid[1];
1726 : : mbssid = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ie, ielen);
1727 : : /*
1728 : : * It's not valid to have the MBSSID element before SSID
1729 : : * ignore if that happens - the code below assumes it is
1730 : : * after (while copying things inbetween).
1731 : : */
1732 : 0 : if (!mbssid || mbssid < trans_ssid)
1733 : : return;
1734 : 0 : new_ie_len -= mbssid[1];
1735 : :
1736 : : nontrans_ssid = ieee80211_bss_get_ie(nontrans_bss, WLAN_EID_SSID);
1737 : 0 : if (!nontrans_ssid)
1738 : : return;
1739 : :
1740 : 0 : new_ie_len += nontrans_ssid[1];
1741 : :
1742 : : /* generate new ie for nontrans BSS
1743 : : * 1. replace SSID with nontrans BSS' SSID
1744 : : * 2. skip MBSSID IE
1745 : : */
1746 : 0 : new_ie = kzalloc(new_ie_len, GFP_ATOMIC);
1747 : 0 : if (!new_ie)
1748 : : return;
1749 : :
1750 : 0 : new_ies = kzalloc(sizeof(*new_ies) + new_ie_len, GFP_ATOMIC);
1751 : 0 : if (!new_ies)
1752 : : goto out_free;
1753 : :
1754 : : pos = new_ie;
1755 : :
1756 : : /* copy the nontransmitted SSID */
1757 : 0 : cpy_len = nontrans_ssid[1] + 2;
1758 : 0 : memcpy(pos, nontrans_ssid, cpy_len);
1759 : 0 : pos += cpy_len;
1760 : : /* copy the IEs between SSID and MBSSID */
1761 : 0 : cpy_len = trans_ssid[1] + 2;
1762 : 0 : memcpy(pos, (trans_ssid + cpy_len), (mbssid - (trans_ssid + cpy_len)));
1763 : 0 : pos += (mbssid - (trans_ssid + cpy_len));
1764 : : /* copy the IEs after MBSSID */
1765 : 0 : cpy_len = mbssid[1] + 2;
1766 : 0 : memcpy(pos, mbssid + cpy_len, ((ie + ielen) - (mbssid + cpy_len)));
1767 : :
1768 : : /* update ie */
1769 : 0 : new_ies->len = new_ie_len;
1770 : 0 : new_ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
1771 : 0 : new_ies->from_beacon = ieee80211_is_beacon(mgmt->frame_control);
1772 : 0 : memcpy(new_ies->data, new_ie, new_ie_len);
1773 : 0 : if (ieee80211_is_probe_resp(mgmt->frame_control)) {
1774 : 0 : old = rcu_access_pointer(nontrans_bss->proberesp_ies);
1775 : 0 : rcu_assign_pointer(nontrans_bss->proberesp_ies, new_ies);
1776 : 0 : rcu_assign_pointer(nontrans_bss->ies, new_ies);
1777 : 0 : if (old)
1778 : 0 : kfree_rcu((struct cfg80211_bss_ies *)old, rcu_head);
1779 : : } else {
1780 : 0 : old = rcu_access_pointer(nontrans_bss->beacon_ies);
1781 : 0 : rcu_assign_pointer(nontrans_bss->beacon_ies, new_ies);
1782 : 0 : rcu_assign_pointer(nontrans_bss->ies, new_ies);
1783 : 0 : if (old)
1784 : 0 : kfree_rcu((struct cfg80211_bss_ies *)old, rcu_head);
1785 : : }
1786 : :
1787 : : out_free:
1788 : 0 : kfree(new_ie);
1789 : : }
1790 : :
1791 : : /* cfg80211_inform_bss_width_frame helper */
1792 : : static struct cfg80211_bss *
1793 : 0 : cfg80211_inform_single_bss_frame_data(struct wiphy *wiphy,
1794 : : struct cfg80211_inform_bss *data,
1795 : : struct ieee80211_mgmt *mgmt, size_t len,
1796 : : gfp_t gfp)
1797 : : {
1798 : 0 : struct cfg80211_internal_bss tmp = {}, *res;
1799 : : struct cfg80211_bss_ies *ies;
1800 : : struct ieee80211_channel *channel;
1801 : : bool signal_valid;
1802 : 0 : size_t ielen = len - offsetof(struct ieee80211_mgmt,
1803 : : u.probe_resp.variable);
1804 : : int bss_type;
1805 : :
1806 : : BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
1807 : : offsetof(struct ieee80211_mgmt, u.beacon.variable));
1808 : :
1809 : 0 : trace_cfg80211_inform_bss_frame(wiphy, data, mgmt, len);
1810 : :
1811 : 0 : if (WARN_ON(!mgmt))
1812 : : return NULL;
1813 : :
1814 : 0 : if (WARN_ON(!wiphy))
1815 : : return NULL;
1816 : :
1817 : 0 : if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
1818 : : (data->signal < 0 || data->signal > 100)))
1819 : : return NULL;
1820 : :
1821 : 0 : if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
1822 : : return NULL;
1823 : :
1824 : 0 : channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
1825 : : ielen, data->chan, data->scan_width);
1826 : 0 : if (!channel)
1827 : : return NULL;
1828 : :
1829 : 0 : ies = kzalloc(sizeof(*ies) + ielen, gfp);
1830 : 0 : if (!ies)
1831 : : return NULL;
1832 : 0 : ies->len = ielen;
1833 : 0 : ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
1834 : 0 : ies->from_beacon = ieee80211_is_beacon(mgmt->frame_control);
1835 : 0 : memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
1836 : :
1837 : 0 : if (ieee80211_is_probe_resp(mgmt->frame_control))
1838 : 0 : rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
1839 : : else
1840 : 0 : rcu_assign_pointer(tmp.pub.beacon_ies, ies);
1841 : 0 : rcu_assign_pointer(tmp.pub.ies, ies);
1842 : :
1843 : 0 : memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
1844 : 0 : tmp.pub.channel = channel;
1845 : 0 : tmp.pub.scan_width = data->scan_width;
1846 : 0 : tmp.pub.signal = data->signal;
1847 : 0 : tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
1848 : 0 : tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
1849 : 0 : tmp.ts_boottime = data->boottime_ns;
1850 : 0 : tmp.parent_tsf = data->parent_tsf;
1851 : 0 : tmp.pub.chains = data->chains;
1852 : 0 : memcpy(tmp.pub.chain_signal, data->chain_signal, IEEE80211_MAX_CHAINS);
1853 : : ether_addr_copy(tmp.parent_bssid, data->parent_bssid);
1854 : :
1855 : 0 : signal_valid = abs(data->chan->center_freq - channel->center_freq) <=
1856 : 0 : wiphy->max_adj_channel_rssi_comp;
1857 : 0 : res = cfg80211_bss_update(wiphy_to_rdev(wiphy), &tmp, signal_valid,
1858 : : jiffies);
1859 : 0 : if (!res)
1860 : : return NULL;
1861 : :
1862 : 0 : if (channel->band == NL80211_BAND_60GHZ) {
1863 : 0 : bss_type = res->pub.capability & WLAN_CAPABILITY_DMG_TYPE_MASK;
1864 : 0 : if (bss_type == WLAN_CAPABILITY_DMG_TYPE_AP ||
1865 : : bss_type == WLAN_CAPABILITY_DMG_TYPE_PBSS)
1866 : 0 : regulatory_hint_found_beacon(wiphy, channel, gfp);
1867 : : } else {
1868 : 0 : if (res->pub.capability & WLAN_CAPABILITY_ESS)
1869 : 0 : regulatory_hint_found_beacon(wiphy, channel, gfp);
1870 : : }
1871 : :
1872 : 0 : trace_cfg80211_return_bss(&res->pub);
1873 : : /* cfg80211_bss_update gives us a referenced result */
1874 : 0 : return &res->pub;
1875 : : }
1876 : :
1877 : : struct cfg80211_bss *
1878 : 0 : cfg80211_inform_bss_frame_data(struct wiphy *wiphy,
1879 : : struct cfg80211_inform_bss *data,
1880 : : struct ieee80211_mgmt *mgmt, size_t len,
1881 : : gfp_t gfp)
1882 : : {
1883 : : struct cfg80211_bss *res, *tmp_bss;
1884 : 0 : const u8 *ie = mgmt->u.probe_resp.variable;
1885 : : const struct cfg80211_bss_ies *ies1, *ies2;
1886 : 0 : size_t ielen = len - offsetof(struct ieee80211_mgmt,
1887 : : u.probe_resp.variable);
1888 : : struct cfg80211_non_tx_bss non_tx_data;
1889 : :
1890 : 0 : res = cfg80211_inform_single_bss_frame_data(wiphy, data, mgmt,
1891 : : len, gfp);
1892 : 0 : if (!res || !wiphy->support_mbssid ||
1893 : : !cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ie, ielen))
1894 : : return res;
1895 : 0 : if (wiphy->support_only_he_mbssid &&
1896 : : !cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ie, ielen))
1897 : : return res;
1898 : :
1899 : 0 : non_tx_data.tx_bss = res;
1900 : : /* process each non-transmitting bss */
1901 : 0 : cfg80211_parse_mbssid_frame_data(wiphy, data, mgmt, len,
1902 : : &non_tx_data, gfp);
1903 : :
1904 : : spin_lock_bh(&wiphy_to_rdev(wiphy)->bss_lock);
1905 : :
1906 : : /* check if the res has other nontransmitting bss which is not
1907 : : * in MBSSID IE
1908 : : */
1909 : 0 : ies1 = rcu_access_pointer(res->ies);
1910 : :
1911 : : /* go through nontrans_list, if the timestamp of the BSS is
1912 : : * earlier than the timestamp of the transmitting BSS then
1913 : : * update it
1914 : : */
1915 : 0 : list_for_each_entry(tmp_bss, &res->nontrans_list,
1916 : : nontrans_list) {
1917 : 0 : ies2 = rcu_access_pointer(tmp_bss->ies);
1918 : 0 : if (ies2->tsf < ies1->tsf)
1919 : 0 : cfg80211_update_notlisted_nontrans(wiphy, tmp_bss,
1920 : : mgmt, len);
1921 : : }
1922 : : spin_unlock_bh(&wiphy_to_rdev(wiphy)->bss_lock);
1923 : :
1924 : 0 : return res;
1925 : : }
1926 : : EXPORT_SYMBOL(cfg80211_inform_bss_frame_data);
1927 : :
1928 : 0 : void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1929 : : {
1930 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1931 : : struct cfg80211_internal_bss *bss;
1932 : :
1933 : 0 : if (!pub)
1934 : 0 : return;
1935 : :
1936 : 0 : bss = container_of(pub, struct cfg80211_internal_bss, pub);
1937 : :
1938 : : spin_lock_bh(&rdev->bss_lock);
1939 : 0 : bss_ref_get(rdev, bss);
1940 : : spin_unlock_bh(&rdev->bss_lock);
1941 : : }
1942 : : EXPORT_SYMBOL(cfg80211_ref_bss);
1943 : :
1944 : 0 : void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1945 : : {
1946 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1947 : : struct cfg80211_internal_bss *bss;
1948 : :
1949 : 0 : if (!pub)
1950 : 0 : return;
1951 : :
1952 : 0 : bss = container_of(pub, struct cfg80211_internal_bss, pub);
1953 : :
1954 : : spin_lock_bh(&rdev->bss_lock);
1955 : 0 : bss_ref_put(rdev, bss);
1956 : : spin_unlock_bh(&rdev->bss_lock);
1957 : : }
1958 : : EXPORT_SYMBOL(cfg80211_put_bss);
1959 : :
1960 : 0 : void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1961 : : {
1962 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1963 : : struct cfg80211_internal_bss *bss, *tmp1;
1964 : : struct cfg80211_bss *nontrans_bss, *tmp;
1965 : :
1966 : 0 : if (WARN_ON(!pub))
1967 : 0 : return;
1968 : :
1969 : 0 : bss = container_of(pub, struct cfg80211_internal_bss, pub);
1970 : :
1971 : : spin_lock_bh(&rdev->bss_lock);
1972 : 0 : if (list_empty(&bss->list))
1973 : : goto out;
1974 : :
1975 : 0 : list_for_each_entry_safe(nontrans_bss, tmp,
1976 : : &pub->nontrans_list,
1977 : : nontrans_list) {
1978 : 0 : tmp1 = container_of(nontrans_bss,
1979 : : struct cfg80211_internal_bss, pub);
1980 : 0 : if (__cfg80211_unlink_bss(rdev, tmp1))
1981 : 0 : rdev->bss_generation++;
1982 : : }
1983 : :
1984 : 0 : if (__cfg80211_unlink_bss(rdev, bss))
1985 : 0 : rdev->bss_generation++;
1986 : : out:
1987 : : spin_unlock_bh(&rdev->bss_lock);
1988 : : }
1989 : : EXPORT_SYMBOL(cfg80211_unlink_bss);
1990 : :
1991 : 0 : void cfg80211_bss_iter(struct wiphy *wiphy,
1992 : : struct cfg80211_chan_def *chandef,
1993 : : void (*iter)(struct wiphy *wiphy,
1994 : : struct cfg80211_bss *bss,
1995 : : void *data),
1996 : : void *iter_data)
1997 : : {
1998 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1999 : : struct cfg80211_internal_bss *bss;
2000 : :
2001 : : spin_lock_bh(&rdev->bss_lock);
2002 : :
2003 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
2004 : 0 : if (!chandef || cfg80211_is_sub_chan(chandef, bss->pub.channel))
2005 : 0 : iter(wiphy, &bss->pub, iter_data);
2006 : : }
2007 : :
2008 : : spin_unlock_bh(&rdev->bss_lock);
2009 : 0 : }
2010 : : EXPORT_SYMBOL(cfg80211_bss_iter);
2011 : :
2012 : 0 : void cfg80211_update_assoc_bss_entry(struct wireless_dev *wdev,
2013 : : struct ieee80211_channel *chan)
2014 : : {
2015 : 0 : struct wiphy *wiphy = wdev->wiphy;
2016 : : struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2017 : 0 : struct cfg80211_internal_bss *cbss = wdev->current_bss;
2018 : : struct cfg80211_internal_bss *new = NULL;
2019 : : struct cfg80211_internal_bss *bss;
2020 : : struct cfg80211_bss *nontrans_bss;
2021 : : struct cfg80211_bss *tmp;
2022 : :
2023 : : spin_lock_bh(&rdev->bss_lock);
2024 : :
2025 : : /*
2026 : : * Some APs use CSA also for bandwidth changes, i.e., without actually
2027 : : * changing the control channel, so no need to update in such a case.
2028 : : */
2029 : 0 : if (cbss->pub.channel == chan)
2030 : : goto done;
2031 : :
2032 : : /* use transmitting bss */
2033 : 0 : if (cbss->pub.transmitted_bss)
2034 : 0 : cbss = container_of(cbss->pub.transmitted_bss,
2035 : : struct cfg80211_internal_bss,
2036 : : pub);
2037 : :
2038 : 0 : cbss->pub.channel = chan;
2039 : :
2040 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
2041 : 0 : if (!cfg80211_bss_type_match(bss->pub.capability,
2042 : 0 : bss->pub.channel->band,
2043 : : wdev->conn_bss_type))
2044 : 0 : continue;
2045 : :
2046 : 0 : if (bss == cbss)
2047 : 0 : continue;
2048 : :
2049 : 0 : if (!cmp_bss(&bss->pub, &cbss->pub, BSS_CMP_REGULAR)) {
2050 : 0 : new = bss;
2051 : 0 : break;
2052 : : }
2053 : : }
2054 : :
2055 : 0 : if (new) {
2056 : : /* to save time, update IEs for transmitting bss only */
2057 : 0 : if (cfg80211_update_known_bss(rdev, cbss, new, false)) {
2058 : 0 : new->pub.proberesp_ies = NULL;
2059 : 0 : new->pub.beacon_ies = NULL;
2060 : : }
2061 : :
2062 : 0 : list_for_each_entry_safe(nontrans_bss, tmp,
2063 : : &new->pub.nontrans_list,
2064 : : nontrans_list) {
2065 : 0 : bss = container_of(nontrans_bss,
2066 : : struct cfg80211_internal_bss, pub);
2067 : 0 : if (__cfg80211_unlink_bss(rdev, bss))
2068 : 0 : rdev->bss_generation++;
2069 : : }
2070 : :
2071 : 0 : WARN_ON(atomic_read(&new->hold));
2072 : 0 : if (!WARN_ON(!__cfg80211_unlink_bss(rdev, new)))
2073 : 0 : rdev->bss_generation++;
2074 : : }
2075 : :
2076 : 0 : rb_erase(&cbss->rbn, &rdev->bss_tree);
2077 : 0 : rb_insert_bss(rdev, cbss);
2078 : 0 : rdev->bss_generation++;
2079 : :
2080 : 0 : list_for_each_entry_safe(nontrans_bss, tmp,
2081 : : &cbss->pub.nontrans_list,
2082 : : nontrans_list) {
2083 : 0 : bss = container_of(nontrans_bss,
2084 : : struct cfg80211_internal_bss, pub);
2085 : 0 : bss->pub.channel = chan;
2086 : 0 : rb_erase(&bss->rbn, &rdev->bss_tree);
2087 : 0 : rb_insert_bss(rdev, bss);
2088 : 0 : rdev->bss_generation++;
2089 : : }
2090 : :
2091 : : done:
2092 : : spin_unlock_bh(&rdev->bss_lock);
2093 : 0 : }
2094 : :
2095 : : #ifdef CONFIG_CFG80211_WEXT
2096 : : static struct cfg80211_registered_device *
2097 : 0 : cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
2098 : : {
2099 : : struct cfg80211_registered_device *rdev;
2100 : : struct net_device *dev;
2101 : :
2102 : 0 : ASSERT_RTNL();
2103 : :
2104 : 0 : dev = dev_get_by_index(net, ifindex);
2105 : 0 : if (!dev)
2106 : : return ERR_PTR(-ENODEV);
2107 : 0 : if (dev->ieee80211_ptr)
2108 : 0 : rdev = wiphy_to_rdev(dev->ieee80211_ptr->wiphy);
2109 : : else
2110 : : rdev = ERR_PTR(-ENODEV);
2111 : 0 : dev_put(dev);
2112 : 0 : return rdev;
2113 : : }
2114 : :
2115 : 0 : int cfg80211_wext_siwscan(struct net_device *dev,
2116 : : struct iw_request_info *info,
2117 : : union iwreq_data *wrqu, char *extra)
2118 : : {
2119 : : struct cfg80211_registered_device *rdev;
2120 : : struct wiphy *wiphy;
2121 : : struct iw_scan_req *wreq = NULL;
2122 : : struct cfg80211_scan_request *creq = NULL;
2123 : : int i, err, n_channels = 0;
2124 : : enum nl80211_band band;
2125 : :
2126 : 0 : if (!netif_running(dev))
2127 : : return -ENETDOWN;
2128 : :
2129 : 0 : if (wrqu->data.length == sizeof(struct iw_scan_req))
2130 : : wreq = (struct iw_scan_req *)extra;
2131 : :
2132 : 0 : rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
2133 : :
2134 : 0 : if (IS_ERR(rdev))
2135 : 0 : return PTR_ERR(rdev);
2136 : :
2137 : 0 : if (rdev->scan_req || rdev->scan_msg) {
2138 : : err = -EBUSY;
2139 : : goto out;
2140 : : }
2141 : :
2142 : 0 : wiphy = &rdev->wiphy;
2143 : :
2144 : : /* Determine number of channels, needed to allocate creq */
2145 : 0 : if (wreq && wreq->num_channels)
2146 : 0 : n_channels = wreq->num_channels;
2147 : : else
2148 : 0 : n_channels = ieee80211_get_num_supported_channels(wiphy);
2149 : :
2150 : 0 : creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
2151 : 0 : n_channels * sizeof(void *),
2152 : : GFP_ATOMIC);
2153 : 0 : if (!creq) {
2154 : : err = -ENOMEM;
2155 : : goto out;
2156 : : }
2157 : :
2158 : 0 : creq->wiphy = wiphy;
2159 : 0 : creq->wdev = dev->ieee80211_ptr;
2160 : : /* SSIDs come after channels */
2161 : 0 : creq->ssids = (void *)&creq->channels[n_channels];
2162 : 0 : creq->n_channels = n_channels;
2163 : 0 : creq->n_ssids = 1;
2164 : 0 : creq->scan_start = jiffies;
2165 : :
2166 : : /* translate "Scan on frequencies" request */
2167 : : i = 0;
2168 : 0 : for (band = 0; band < NUM_NL80211_BANDS; band++) {
2169 : : int j;
2170 : :
2171 : 0 : if (!wiphy->bands[band])
2172 : 0 : continue;
2173 : :
2174 : 0 : for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
2175 : : /* ignore disabled channels */
2176 : 0 : if (wiphy->bands[band]->channels[j].flags &
2177 : : IEEE80211_CHAN_DISABLED)
2178 : 0 : continue;
2179 : :
2180 : : /* If we have a wireless request structure and the
2181 : : * wireless request specifies frequencies, then search
2182 : : * for the matching hardware channel.
2183 : : */
2184 : 0 : if (wreq && wreq->num_channels) {
2185 : : int k;
2186 : 0 : int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
2187 : 0 : for (k = 0; k < wreq->num_channels; k++) {
2188 : 0 : struct iw_freq *freq =
2189 : : &wreq->channel_list[k];
2190 : 0 : int wext_freq =
2191 : : cfg80211_wext_freq(freq);
2192 : :
2193 : 0 : if (wext_freq == wiphy_freq)
2194 : : goto wext_freq_found;
2195 : : }
2196 : : goto wext_freq_not_found;
2197 : : }
2198 : :
2199 : : wext_freq_found:
2200 : 0 : creq->channels[i] = &wiphy->bands[band]->channels[j];
2201 : 0 : i++;
2202 : : wext_freq_not_found: ;
2203 : : }
2204 : : }
2205 : : /* No channels found? */
2206 : 0 : if (!i) {
2207 : : err = -EINVAL;
2208 : : goto out;
2209 : : }
2210 : :
2211 : : /* Set real number of channels specified in creq->channels[] */
2212 : 0 : creq->n_channels = i;
2213 : :
2214 : : /* translate "Scan for SSID" request */
2215 : 0 : if (wreq) {
2216 : 0 : if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
2217 : 0 : if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
2218 : : err = -EINVAL;
2219 : : goto out;
2220 : : }
2221 : 0 : memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
2222 : 0 : creq->ssids[0].ssid_len = wreq->essid_len;
2223 : : }
2224 : 0 : if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
2225 : 0 : creq->n_ssids = 0;
2226 : : }
2227 : :
2228 : 0 : for (i = 0; i < NUM_NL80211_BANDS; i++)
2229 : 0 : if (wiphy->bands[i])
2230 : 0 : creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
2231 : :
2232 : 0 : eth_broadcast_addr(creq->bssid);
2233 : :
2234 : 0 : rdev->scan_req = creq;
2235 : 0 : err = rdev_scan(rdev, creq);
2236 : 0 : if (err) {
2237 : 0 : rdev->scan_req = NULL;
2238 : : /* creq will be freed below */
2239 : : } else {
2240 : 0 : nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
2241 : : /* creq now owned by driver */
2242 : : creq = NULL;
2243 : 0 : dev_hold(dev);
2244 : : }
2245 : : out:
2246 : 0 : kfree(creq);
2247 : 0 : return err;
2248 : : }
2249 : : EXPORT_WEXT_HANDLER(cfg80211_wext_siwscan);
2250 : :
2251 : 0 : static char *ieee80211_scan_add_ies(struct iw_request_info *info,
2252 : : const struct cfg80211_bss_ies *ies,
2253 : : char *current_ev, char *end_buf)
2254 : : {
2255 : : const u8 *pos, *end, *next;
2256 : : struct iw_event iwe;
2257 : :
2258 : 0 : if (!ies)
2259 : : return current_ev;
2260 : :
2261 : : /*
2262 : : * If needed, fragment the IEs buffer (at IE boundaries) into short
2263 : : * enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
2264 : : */
2265 : 0 : pos = ies->data;
2266 : 0 : end = pos + ies->len;
2267 : :
2268 : 0 : while (end - pos > IW_GENERIC_IE_MAX) {
2269 : 0 : next = pos + 2 + pos[1];
2270 : 0 : while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
2271 : : next = next + 2 + next[1];
2272 : :
2273 : 0 : memset(&iwe, 0, sizeof(iwe));
2274 : 0 : iwe.cmd = IWEVGENIE;
2275 : 0 : iwe.u.data.length = next - pos;
2276 : : current_ev = iwe_stream_add_point_check(info, current_ev,
2277 : : end_buf, &iwe,
2278 : : (void *)pos);
2279 : 0 : if (IS_ERR(current_ev))
2280 : 0 : return current_ev;
2281 : 0 : pos = next;
2282 : : }
2283 : :
2284 : 0 : if (end > pos) {
2285 : 0 : memset(&iwe, 0, sizeof(iwe));
2286 : 0 : iwe.cmd = IWEVGENIE;
2287 : 0 : iwe.u.data.length = end - pos;
2288 : : current_ev = iwe_stream_add_point_check(info, current_ev,
2289 : : end_buf, &iwe,
2290 : : (void *)pos);
2291 : 0 : if (IS_ERR(current_ev))
2292 : : return current_ev;
2293 : : }
2294 : :
2295 : 0 : return current_ev;
2296 : : }
2297 : :
2298 : : static char *
2299 : 0 : ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
2300 : : struct cfg80211_internal_bss *bss, char *current_ev,
2301 : : char *end_buf)
2302 : : {
2303 : : const struct cfg80211_bss_ies *ies;
2304 : : struct iw_event iwe;
2305 : : const u8 *ie;
2306 : : u8 buf[50];
2307 : : u8 *cfg, *p, *tmp;
2308 : : int rem, i, sig;
2309 : : bool ismesh = false;
2310 : :
2311 : 0 : memset(&iwe, 0, sizeof(iwe));
2312 : 0 : iwe.cmd = SIOCGIWAP;
2313 : 0 : iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2314 : 0 : memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
2315 : : current_ev = iwe_stream_add_event_check(info, current_ev, end_buf, &iwe,
2316 : : IW_EV_ADDR_LEN);
2317 : 0 : if (IS_ERR(current_ev))
2318 : : return current_ev;
2319 : :
2320 : 0 : memset(&iwe, 0, sizeof(iwe));
2321 : 0 : iwe.cmd = SIOCGIWFREQ;
2322 : 0 : iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
2323 : 0 : iwe.u.freq.e = 0;
2324 : : current_ev = iwe_stream_add_event_check(info, current_ev, end_buf, &iwe,
2325 : : IW_EV_FREQ_LEN);
2326 : 0 : if (IS_ERR(current_ev))
2327 : : return current_ev;
2328 : :
2329 : 0 : memset(&iwe, 0, sizeof(iwe));
2330 : 0 : iwe.cmd = SIOCGIWFREQ;
2331 : 0 : iwe.u.freq.m = bss->pub.channel->center_freq;
2332 : 0 : iwe.u.freq.e = 6;
2333 : : current_ev = iwe_stream_add_event_check(info, current_ev, end_buf, &iwe,
2334 : : IW_EV_FREQ_LEN);
2335 : 0 : if (IS_ERR(current_ev))
2336 : : return current_ev;
2337 : :
2338 : 0 : if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
2339 : 0 : memset(&iwe, 0, sizeof(iwe));
2340 : 0 : iwe.cmd = IWEVQUAL;
2341 : 0 : iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
2342 : : IW_QUAL_NOISE_INVALID |
2343 : : IW_QUAL_QUAL_UPDATED;
2344 : 0 : switch (wiphy->signal_type) {
2345 : : case CFG80211_SIGNAL_TYPE_MBM:
2346 : 0 : sig = bss->pub.signal / 100;
2347 : 0 : iwe.u.qual.level = sig;
2348 : 0 : iwe.u.qual.updated |= IW_QUAL_DBM;
2349 : 0 : if (sig < -110) /* rather bad */
2350 : : sig = -110;
2351 : 0 : else if (sig > -40) /* perfect */
2352 : : sig = -40;
2353 : : /* will give a range of 0 .. 70 */
2354 : 0 : iwe.u.qual.qual = sig + 110;
2355 : 0 : break;
2356 : : case CFG80211_SIGNAL_TYPE_UNSPEC:
2357 : 0 : iwe.u.qual.level = bss->pub.signal;
2358 : : /* will give range 0 .. 100 */
2359 : 0 : iwe.u.qual.qual = bss->pub.signal;
2360 : 0 : break;
2361 : : default:
2362 : : /* not reached */
2363 : : break;
2364 : : }
2365 : : current_ev = iwe_stream_add_event_check(info, current_ev,
2366 : : end_buf, &iwe,
2367 : : IW_EV_QUAL_LEN);
2368 : 0 : if (IS_ERR(current_ev))
2369 : : return current_ev;
2370 : : }
2371 : :
2372 : 0 : memset(&iwe, 0, sizeof(iwe));
2373 : 0 : iwe.cmd = SIOCGIWENCODE;
2374 : 0 : if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
2375 : 0 : iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2376 : : else
2377 : 0 : iwe.u.data.flags = IW_ENCODE_DISABLED;
2378 : : iwe.u.data.length = 0;
2379 : : current_ev = iwe_stream_add_point_check(info, current_ev, end_buf,
2380 : : &iwe, "");
2381 : 0 : if (IS_ERR(current_ev))
2382 : : return current_ev;
2383 : :
2384 : : rcu_read_lock();
2385 : 0 : ies = rcu_dereference(bss->pub.ies);
2386 : 0 : rem = ies->len;
2387 : 0 : ie = ies->data;
2388 : :
2389 : 0 : while (rem >= 2) {
2390 : : /* invalid data */
2391 : 0 : if (ie[1] > rem - 2)
2392 : : break;
2393 : :
2394 : 0 : switch (ie[0]) {
2395 : : case WLAN_EID_SSID:
2396 : 0 : memset(&iwe, 0, sizeof(iwe));
2397 : 0 : iwe.cmd = SIOCGIWESSID;
2398 : 0 : iwe.u.data.length = ie[1];
2399 : 0 : iwe.u.data.flags = 1;
2400 : 0 : current_ev = iwe_stream_add_point_check(info,
2401 : : current_ev,
2402 : : end_buf, &iwe,
2403 : : (u8 *)ie + 2);
2404 : 0 : if (IS_ERR(current_ev))
2405 : : goto unlock;
2406 : : break;
2407 : : case WLAN_EID_MESH_ID:
2408 : 0 : memset(&iwe, 0, sizeof(iwe));
2409 : 0 : iwe.cmd = SIOCGIWESSID;
2410 : 0 : iwe.u.data.length = ie[1];
2411 : 0 : iwe.u.data.flags = 1;
2412 : 0 : current_ev = iwe_stream_add_point_check(info,
2413 : : current_ev,
2414 : : end_buf, &iwe,
2415 : : (u8 *)ie + 2);
2416 : 0 : if (IS_ERR(current_ev))
2417 : : goto unlock;
2418 : : break;
2419 : : case WLAN_EID_MESH_CONFIG:
2420 : : ismesh = true;
2421 : 0 : if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
2422 : : break;
2423 : : cfg = (u8 *)ie + 2;
2424 : 0 : memset(&iwe, 0, sizeof(iwe));
2425 : 0 : iwe.cmd = IWEVCUSTOM;
2426 : 0 : sprintf(buf, "Mesh Network Path Selection Protocol ID: "
2427 : 0 : "0x%02X", cfg[0]);
2428 : 0 : iwe.u.data.length = strlen(buf);
2429 : : current_ev = iwe_stream_add_point_check(info,
2430 : : current_ev,
2431 : : end_buf,
2432 : : &iwe, buf);
2433 : 0 : if (IS_ERR(current_ev))
2434 : : goto unlock;
2435 : 0 : sprintf(buf, "Path Selection Metric ID: 0x%02X",
2436 : 0 : cfg[1]);
2437 : 0 : iwe.u.data.length = strlen(buf);
2438 : : current_ev = iwe_stream_add_point_check(info,
2439 : : current_ev,
2440 : : end_buf,
2441 : : &iwe, buf);
2442 : 0 : if (IS_ERR(current_ev))
2443 : : goto unlock;
2444 : 0 : sprintf(buf, "Congestion Control Mode ID: 0x%02X",
2445 : 0 : cfg[2]);
2446 : 0 : iwe.u.data.length = strlen(buf);
2447 : : current_ev = iwe_stream_add_point_check(info,
2448 : : current_ev,
2449 : : end_buf,
2450 : : &iwe, buf);
2451 : 0 : if (IS_ERR(current_ev))
2452 : : goto unlock;
2453 : 0 : sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
2454 : 0 : iwe.u.data.length = strlen(buf);
2455 : : current_ev = iwe_stream_add_point_check(info,
2456 : : current_ev,
2457 : : end_buf,
2458 : : &iwe, buf);
2459 : 0 : if (IS_ERR(current_ev))
2460 : : goto unlock;
2461 : 0 : sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
2462 : 0 : iwe.u.data.length = strlen(buf);
2463 : : current_ev = iwe_stream_add_point_check(info,
2464 : : current_ev,
2465 : : end_buf,
2466 : : &iwe, buf);
2467 : 0 : if (IS_ERR(current_ev))
2468 : : goto unlock;
2469 : 0 : sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
2470 : 0 : iwe.u.data.length = strlen(buf);
2471 : : current_ev = iwe_stream_add_point_check(info,
2472 : : current_ev,
2473 : : end_buf,
2474 : : &iwe, buf);
2475 : 0 : if (IS_ERR(current_ev))
2476 : : goto unlock;
2477 : 0 : sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
2478 : 0 : iwe.u.data.length = strlen(buf);
2479 : : current_ev = iwe_stream_add_point_check(info,
2480 : : current_ev,
2481 : : end_buf,
2482 : : &iwe, buf);
2483 : 0 : if (IS_ERR(current_ev))
2484 : : goto unlock;
2485 : : break;
2486 : : case WLAN_EID_SUPP_RATES:
2487 : : case WLAN_EID_EXT_SUPP_RATES:
2488 : : /* display all supported rates in readable format */
2489 : 0 : p = current_ev + iwe_stream_lcp_len(info);
2490 : :
2491 : 0 : memset(&iwe, 0, sizeof(iwe));
2492 : 0 : iwe.cmd = SIOCGIWRATE;
2493 : : /* Those two flags are ignored... */
2494 : : iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
2495 : :
2496 : 0 : for (i = 0; i < ie[1]; i++) {
2497 : 0 : iwe.u.bitrate.value =
2498 : 0 : ((ie[i + 2] & 0x7f) * 500000);
2499 : : tmp = p;
2500 : 0 : p = iwe_stream_add_value(info, current_ev, p,
2501 : : end_buf, &iwe,
2502 : : IW_EV_PARAM_LEN);
2503 : 0 : if (p == tmp) {
2504 : : current_ev = ERR_PTR(-E2BIG);
2505 : : goto unlock;
2506 : : }
2507 : : }
2508 : 0 : current_ev = p;
2509 : 0 : break;
2510 : : }
2511 : 0 : rem -= ie[1] + 2;
2512 : 0 : ie += ie[1] + 2;
2513 : : }
2514 : :
2515 : 0 : if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
2516 : : ismesh) {
2517 : 0 : memset(&iwe, 0, sizeof(iwe));
2518 : 0 : iwe.cmd = SIOCGIWMODE;
2519 : 0 : if (ismesh)
2520 : 0 : iwe.u.mode = IW_MODE_MESH;
2521 : 0 : else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
2522 : 0 : iwe.u.mode = IW_MODE_MASTER;
2523 : : else
2524 : 0 : iwe.u.mode = IW_MODE_ADHOC;
2525 : : current_ev = iwe_stream_add_event_check(info, current_ev,
2526 : : end_buf, &iwe,
2527 : : IW_EV_UINT_LEN);
2528 : 0 : if (IS_ERR(current_ev))
2529 : : goto unlock;
2530 : : }
2531 : :
2532 : 0 : memset(&iwe, 0, sizeof(iwe));
2533 : 0 : iwe.cmd = IWEVCUSTOM;
2534 : 0 : sprintf(buf, "tsf=%016llx", (unsigned long long)(ies->tsf));
2535 : 0 : iwe.u.data.length = strlen(buf);
2536 : : current_ev = iwe_stream_add_point_check(info, current_ev, end_buf,
2537 : : &iwe, buf);
2538 : 0 : if (IS_ERR(current_ev))
2539 : : goto unlock;
2540 : 0 : memset(&iwe, 0, sizeof(iwe));
2541 : 0 : iwe.cmd = IWEVCUSTOM;
2542 : 0 : sprintf(buf, " Last beacon: %ums ago",
2543 : : elapsed_jiffies_msecs(bss->ts));
2544 : 0 : iwe.u.data.length = strlen(buf);
2545 : : current_ev = iwe_stream_add_point_check(info, current_ev,
2546 : : end_buf, &iwe, buf);
2547 : 0 : if (IS_ERR(current_ev))
2548 : : goto unlock;
2549 : :
2550 : 0 : current_ev = ieee80211_scan_add_ies(info, ies, current_ev, end_buf);
2551 : :
2552 : : unlock:
2553 : : rcu_read_unlock();
2554 : 0 : return current_ev;
2555 : : }
2556 : :
2557 : :
2558 : 0 : static int ieee80211_scan_results(struct cfg80211_registered_device *rdev,
2559 : : struct iw_request_info *info,
2560 : : char *buf, size_t len)
2561 : : {
2562 : : char *current_ev = buf;
2563 : 0 : char *end_buf = buf + len;
2564 : : struct cfg80211_internal_bss *bss;
2565 : : int err = 0;
2566 : :
2567 : : spin_lock_bh(&rdev->bss_lock);
2568 : : cfg80211_bss_expire(rdev);
2569 : :
2570 : 0 : list_for_each_entry(bss, &rdev->bss_list, list) {
2571 : 0 : if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
2572 : : err = -E2BIG;
2573 : : break;
2574 : : }
2575 : 0 : current_ev = ieee80211_bss(&rdev->wiphy, info, bss,
2576 : : current_ev, end_buf);
2577 : 0 : if (IS_ERR(current_ev)) {
2578 : : err = PTR_ERR(current_ev);
2579 : 0 : break;
2580 : : }
2581 : : }
2582 : : spin_unlock_bh(&rdev->bss_lock);
2583 : :
2584 : 0 : if (err)
2585 : : return err;
2586 : 0 : return current_ev - buf;
2587 : : }
2588 : :
2589 : :
2590 : 0 : int cfg80211_wext_giwscan(struct net_device *dev,
2591 : : struct iw_request_info *info,
2592 : : struct iw_point *data, char *extra)
2593 : : {
2594 : : struct cfg80211_registered_device *rdev;
2595 : : int res;
2596 : :
2597 : 0 : if (!netif_running(dev))
2598 : : return -ENETDOWN;
2599 : :
2600 : 0 : rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
2601 : :
2602 : 0 : if (IS_ERR(rdev))
2603 : 0 : return PTR_ERR(rdev);
2604 : :
2605 : 0 : if (rdev->scan_req || rdev->scan_msg)
2606 : : return -EAGAIN;
2607 : :
2608 : 0 : res = ieee80211_scan_results(rdev, info, extra, data->length);
2609 : 0 : data->length = 0;
2610 : 0 : if (res >= 0) {
2611 : 0 : data->length = res;
2612 : : res = 0;
2613 : : }
2614 : :
2615 : 0 : return res;
2616 : : }
2617 : : EXPORT_WEXT_HANDLER(cfg80211_wext_giwscan);
2618 : : #endif
|
