blob: fd99ea495b7e68cd9e5265542a6aa059d0ac7760 [file] [log] [blame]
Johannes Berg2a519312009-02-10 21:25:55 +01001/*
2 * cfg80211 scan result handling
3 *
4 * Copyright 2008 Johannes Berg <johannes@sipsolutions.net>
5 */
6#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09007#include <linux/slab.h>
Johannes Berg2a519312009-02-10 21:25:55 +01008#include <linux/module.h>
9#include <linux/netdevice.h>
10#include <linux/wireless.h>
11#include <linux/nl80211.h>
12#include <linux/etherdevice.h>
13#include <net/arp.h>
14#include <net/cfg80211.h>
Johannes Berg262eb9b22011-07-13 10:39:09 +020015#include <net/cfg80211-wext.h>
Johannes Berg2a519312009-02-10 21:25:55 +010016#include <net/iw_handler.h>
17#include "core.h"
18#include "nl80211.h"
Johannes Berga9a11622009-07-27 12:01:53 +020019#include "wext-compat.h"
Hila Gonene35e4d22012-06-27 17:19:42 +030020#include "rdev-ops.h"
Johannes Berg2a519312009-02-10 21:25:55 +010021
Johannes Berg776b3582013-02-01 02:06:18 +010022/**
23 * DOC: BSS tree/list structure
24 *
25 * At the top level, the BSS list is kept in both a list in each
26 * registered device (@bss_list) as well as an RB-tree for faster
27 * lookup. In the RB-tree, entries can be looked up using their
28 * channel, MESHID, MESHCONF (for MBSSes) or channel, BSSID, SSID
29 * for other BSSes.
30 *
31 * Due to the possibility of hidden SSIDs, there's a second level
32 * structure, the "hidden_list" and "hidden_beacon_bss" pointer.
33 * The hidden_list connects all BSSes belonging to a single AP
34 * that has a hidden SSID, and connects beacon and probe response
35 * entries. For a probe response entry for a hidden SSID, the
36 * hidden_beacon_bss pointer points to the BSS struct holding the
37 * beacon's information.
38 *
39 * Reference counting is done for all these references except for
40 * the hidden_list, so that a beacon BSS struct that is otherwise
41 * not referenced has one reference for being on the bss_list and
42 * one for each probe response entry that points to it using the
43 * hidden_beacon_bss pointer. When a BSS struct that has such a
44 * pointer is get/put, the refcount update is also propagated to
45 * the referenced struct, this ensure that it cannot get removed
46 * while somebody is using the probe response version.
47 *
48 * Note that the hidden_beacon_bss pointer never changes, due to
49 * the reference counting. Therefore, no locking is needed for
50 * it.
51 *
52 * Also note that the hidden_beacon_bss pointer is only relevant
53 * if the driver uses something other than the IEs, e.g. private
54 * data stored stored in the BSS struct, since the beacon IEs are
55 * also linked into the probe response struct.
56 */
57
Rajkumar Manoharanf9616e02012-04-13 16:38:40 +053058#define IEEE80211_SCAN_RESULT_EXPIRE (30 * HZ)
Johannes Berg2a519312009-02-10 21:25:55 +010059
Johannes Berg776b3582013-02-01 02:06:18 +010060static void bss_free(struct cfg80211_internal_bss *bss)
Amitkumar Karware8e27c62012-10-11 21:03:33 -070061{
Johannes Berg9caf0362012-11-29 01:25:20 +010062 struct cfg80211_bss_ies *ies;
Johannes Bergb629ea32012-11-28 22:14:56 +010063
64 if (WARN_ON(atomic_read(&bss->hold)))
65 return;
66
Johannes Berg9caf0362012-11-29 01:25:20 +010067 ies = (void *)rcu_access_pointer(bss->pub.beacon_ies);
Johannes Berg776b3582013-02-01 02:06:18 +010068 if (ies && !bss->pub.hidden_beacon_bss)
Johannes Berg9caf0362012-11-29 01:25:20 +010069 kfree_rcu(ies, rcu_head);
70 ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies);
71 if (ies)
72 kfree_rcu(ies, rcu_head);
Amitkumar Karware8e27c62012-10-11 21:03:33 -070073
Johannes Berg776b3582013-02-01 02:06:18 +010074 /*
75 * This happens when the module is removed, it doesn't
76 * really matter any more save for completeness
77 */
78 if (!list_empty(&bss->hidden_list))
79 list_del(&bss->hidden_list);
80
Amitkumar Karware8e27c62012-10-11 21:03:33 -070081 kfree(bss);
82}
83
Johannes Berg776b3582013-02-01 02:06:18 +010084static inline void bss_ref_get(struct cfg80211_registered_device *dev,
85 struct cfg80211_internal_bss *bss)
Johannes Berg0532d4f2013-02-01 01:34:36 +010086{
Johannes Berg776b3582013-02-01 02:06:18 +010087 lockdep_assert_held(&dev->bss_lock);
88
89 bss->refcount++;
90 if (bss->pub.hidden_beacon_bss) {
91 bss = container_of(bss->pub.hidden_beacon_bss,
92 struct cfg80211_internal_bss,
93 pub);
94 bss->refcount++;
95 }
Johannes Berg0532d4f2013-02-01 01:34:36 +010096}
97
Johannes Berg776b3582013-02-01 02:06:18 +010098static inline void bss_ref_put(struct cfg80211_registered_device *dev,
99 struct cfg80211_internal_bss *bss)
Johannes Berg0532d4f2013-02-01 01:34:36 +0100100{
Johannes Berg776b3582013-02-01 02:06:18 +0100101 lockdep_assert_held(&dev->bss_lock);
102
103 if (bss->pub.hidden_beacon_bss) {
104 struct cfg80211_internal_bss *hbss;
105 hbss = container_of(bss->pub.hidden_beacon_bss,
106 struct cfg80211_internal_bss,
107 pub);
108 hbss->refcount--;
109 if (hbss->refcount == 0)
110 bss_free(hbss);
111 }
112 bss->refcount--;
113 if (bss->refcount == 0)
114 bss_free(bss);
Johannes Berg0532d4f2013-02-01 01:34:36 +0100115}
116
Johannes Berg776b3582013-02-01 02:06:18 +0100117static bool __cfg80211_unlink_bss(struct cfg80211_registered_device *dev,
Amitkumar Karware8e27c62012-10-11 21:03:33 -0700118 struct cfg80211_internal_bss *bss)
119{
Johannes Berg4b1af472013-02-01 01:05:43 +0100120 lockdep_assert_held(&dev->bss_lock);
121
Johannes Berg776b3582013-02-01 02:06:18 +0100122 if (!list_empty(&bss->hidden_list)) {
123 /*
124 * don't remove the beacon entry if it has
125 * probe responses associated with it
126 */
127 if (!bss->pub.hidden_beacon_bss)
128 return false;
129 /*
130 * if it's a probe response entry break its
131 * link to the other entries in the group
132 */
133 list_del_init(&bss->hidden_list);
134 }
135
Amitkumar Karware8e27c62012-10-11 21:03:33 -0700136 list_del_init(&bss->list);
137 rb_erase(&bss->rbn, &dev->bss_tree);
Johannes Berg776b3582013-02-01 02:06:18 +0100138 bss_ref_put(dev, bss);
139 return true;
Amitkumar Karware8e27c62012-10-11 21:03:33 -0700140}
141
Sam Leffler15d60302012-10-11 21:03:34 -0700142static void __cfg80211_bss_expire(struct cfg80211_registered_device *dev,
143 unsigned long expire_time)
144{
145 struct cfg80211_internal_bss *bss, *tmp;
146 bool expired = false;
147
Johannes Berg4b1af472013-02-01 01:05:43 +0100148 lockdep_assert_held(&dev->bss_lock);
149
Sam Leffler15d60302012-10-11 21:03:34 -0700150 list_for_each_entry_safe(bss, tmp, &dev->bss_list, list) {
151 if (atomic_read(&bss->hold))
152 continue;
153 if (!time_after(expire_time, bss->ts))
154 continue;
155
Johannes Berg776b3582013-02-01 02:06:18 +0100156 if (__cfg80211_unlink_bss(dev, bss))
157 expired = true;
Sam Leffler15d60302012-10-11 21:03:34 -0700158 }
159
160 if (expired)
161 dev->bss_generation++;
162}
163
Johannes Berg01a0ac42009-08-20 21:36:16 +0200164void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev, bool leak)
Johannes Berg2a519312009-02-10 21:25:55 +0100165{
Johannes Berg667503dd2009-07-07 03:56:11 +0200166 struct cfg80211_scan_request *request;
Johannes Bergfd014282012-06-18 19:17:03 +0200167 struct wireless_dev *wdev;
Johannes Berg3d23e342009-09-29 23:27:28 +0200168#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a519312009-02-10 21:25:55 +0100169 union iwreq_data wrqu;
170#endif
171
Johannes Bergf9f47522013-03-19 15:04:07 +0100172 lockdep_assert_held(&rdev->sched_scan_mtx);
Johannes Berg01a0ac42009-08-20 21:36:16 +0200173
Johannes Berg667503dd2009-07-07 03:56:11 +0200174 request = rdev->scan_req;
175
Johannes Berg01a0ac42009-08-20 21:36:16 +0200176 if (!request)
177 return;
178
Johannes Bergfd014282012-06-18 19:17:03 +0200179 wdev = request->wdev;
Johannes Berg2a519312009-02-10 21:25:55 +0100180
Johannes Berg6829c872009-07-02 09:13:27 +0200181 /*
182 * This must be before sending the other events!
183 * Otherwise, wpa_supplicant gets completely confused with
184 * wext events.
185 */
Johannes Bergfd014282012-06-18 19:17:03 +0200186 if (wdev->netdev)
187 cfg80211_sme_scan_done(wdev->netdev);
Johannes Berg6829c872009-07-02 09:13:27 +0200188
Sam Leffler15d60302012-10-11 21:03:34 -0700189 if (request->aborted) {
Johannes Bergfd014282012-06-18 19:17:03 +0200190 nl80211_send_scan_aborted(rdev, wdev);
Sam Leffler15d60302012-10-11 21:03:34 -0700191 } else {
192 if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
193 /* flush entries from previous scans */
194 spin_lock_bh(&rdev->bss_lock);
195 __cfg80211_bss_expire(rdev, request->scan_start);
196 spin_unlock_bh(&rdev->bss_lock);
197 }
Johannes Bergfd014282012-06-18 19:17:03 +0200198 nl80211_send_scan_done(rdev, wdev);
Sam Leffler15d60302012-10-11 21:03:34 -0700199 }
Johannes Berg2a519312009-02-10 21:25:55 +0100200
Johannes Berg3d23e342009-09-29 23:27:28 +0200201#ifdef CONFIG_CFG80211_WEXT
Johannes Bergfd014282012-06-18 19:17:03 +0200202 if (wdev->netdev && !request->aborted) {
Johannes Berg2a519312009-02-10 21:25:55 +0100203 memset(&wrqu, 0, sizeof(wrqu));
204
Johannes Bergfd014282012-06-18 19:17:03 +0200205 wireless_send_event(wdev->netdev, SIOCGIWSCAN, &wrqu, NULL);
Johannes Berg2a519312009-02-10 21:25:55 +0100206 }
207#endif
208
Johannes Bergfd014282012-06-18 19:17:03 +0200209 if (wdev->netdev)
210 dev_put(wdev->netdev);
Johannes Berg2a519312009-02-10 21:25:55 +0100211
Johannes Berg36e6fea2009-08-12 22:21:21 +0200212 rdev->scan_req = NULL;
Johannes Berg01a0ac42009-08-20 21:36:16 +0200213
214 /*
215 * OK. If this is invoked with "leak" then we can't
216 * free this ... but we've cleaned it up anyway. The
217 * driver failed to call the scan_done callback, so
218 * all bets are off, it might still be trying to use
219 * the scan request or not ... if it accesses the dev
220 * in there (it shouldn't anyway) then it may crash.
221 */
222 if (!leak)
223 kfree(request);
Johannes Berg2a519312009-02-10 21:25:55 +0100224}
Johannes Berg667503dd2009-07-07 03:56:11 +0200225
Johannes Berg36e6fea2009-08-12 22:21:21 +0200226void __cfg80211_scan_done(struct work_struct *wk)
227{
228 struct cfg80211_registered_device *rdev;
229
230 rdev = container_of(wk, struct cfg80211_registered_device,
231 scan_done_wk);
232
Johannes Bergf9f47522013-03-19 15:04:07 +0100233 mutex_lock(&rdev->sched_scan_mtx);
Johannes Berg01a0ac42009-08-20 21:36:16 +0200234 ___cfg80211_scan_done(rdev, false);
Johannes Bergf9f47522013-03-19 15:04:07 +0100235 mutex_unlock(&rdev->sched_scan_mtx);
Johannes Berg36e6fea2009-08-12 22:21:21 +0200236}
237
Johannes Berg667503dd2009-07-07 03:56:11 +0200238void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted)
239{
Beni Lev4ee3e062012-08-27 12:49:39 +0300240 trace_cfg80211_scan_done(request, aborted);
Johannes Berg667503dd2009-07-07 03:56:11 +0200241 WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req);
242
243 request->aborted = aborted;
Alban Browaeyse60d7442009-11-25 15:13:00 +0100244 queue_work(cfg80211_wq, &wiphy_to_dev(request->wiphy)->scan_done_wk);
Johannes Berg667503dd2009-07-07 03:56:11 +0200245}
Johannes Berg2a519312009-02-10 21:25:55 +0100246EXPORT_SYMBOL(cfg80211_scan_done);
247
Luciano Coelho807f8a82011-05-11 17:09:35 +0300248void __cfg80211_sched_scan_results(struct work_struct *wk)
249{
250 struct cfg80211_registered_device *rdev;
Sam Leffler15d60302012-10-11 21:03:34 -0700251 struct cfg80211_sched_scan_request *request;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300252
253 rdev = container_of(wk, struct cfg80211_registered_device,
254 sched_scan_results_wk);
255
Sam Leffler15d60302012-10-11 21:03:34 -0700256 request = rdev->sched_scan_req;
257
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300258 mutex_lock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300259
260 /* we don't have sched_scan_req anymore if the scan is stopping */
Sam Leffler15d60302012-10-11 21:03:34 -0700261 if (request) {
262 if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
263 /* flush entries from previous scans */
264 spin_lock_bh(&rdev->bss_lock);
265 __cfg80211_bss_expire(rdev, request->scan_start);
266 spin_unlock_bh(&rdev->bss_lock);
267 request->scan_start =
268 jiffies + msecs_to_jiffies(request->interval);
269 }
270 nl80211_send_sched_scan_results(rdev, request->dev);
271 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300272
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300273 mutex_unlock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300274}
275
276void cfg80211_sched_scan_results(struct wiphy *wiphy)
277{
Beni Lev4ee3e062012-08-27 12:49:39 +0300278 trace_cfg80211_sched_scan_results(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300279 /* ignore if we're not scanning */
280 if (wiphy_to_dev(wiphy)->sched_scan_req)
281 queue_work(cfg80211_wq,
282 &wiphy_to_dev(wiphy)->sched_scan_results_wk);
283}
284EXPORT_SYMBOL(cfg80211_sched_scan_results);
285
Luciano Coelho85a99942011-05-12 16:28:29 +0300286void cfg80211_sched_scan_stopped(struct wiphy *wiphy)
Luciano Coelho807f8a82011-05-11 17:09:35 +0300287{
Luciano Coelho85a99942011-05-12 16:28:29 +0300288 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300289
Beni Lev4ee3e062012-08-27 12:49:39 +0300290 trace_cfg80211_sched_scan_stopped(wiphy);
291
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300292 mutex_lock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300293 __cfg80211_stop_sched_scan(rdev, true);
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300294 mutex_unlock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300295}
Luciano Coelho807f8a82011-05-11 17:09:35 +0300296EXPORT_SYMBOL(cfg80211_sched_scan_stopped);
297
298int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
299 bool driver_initiated)
300{
Luciano Coelho807f8a82011-05-11 17:09:35 +0300301 struct net_device *dev;
302
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300303 lockdep_assert_held(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300304
305 if (!rdev->sched_scan_req)
Luciano Coelho1a84ff72011-07-08 11:16:16 +0300306 return -ENOENT;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300307
308 dev = rdev->sched_scan_req->dev;
309
Luciano Coelho85a99942011-05-12 16:28:29 +0300310 if (!driver_initiated) {
Hila Gonene35e4d22012-06-27 17:19:42 +0300311 int err = rdev_sched_scan_stop(rdev, dev);
Luciano Coelho85a99942011-05-12 16:28:29 +0300312 if (err)
313 return err;
314 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300315
316 nl80211_send_sched_scan(rdev, dev, NL80211_CMD_SCHED_SCAN_STOPPED);
317
318 kfree(rdev->sched_scan_req);
319 rdev->sched_scan_req = NULL;
320
Jesper Juhl3b4670f2011-06-29 22:49:33 +0200321 return 0;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300322}
323
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500324void cfg80211_bss_age(struct cfg80211_registered_device *dev,
325 unsigned long age_secs)
326{
327 struct cfg80211_internal_bss *bss;
328 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
329
Johannes Berg2ca813a2013-02-01 01:04:14 +0100330 spin_lock_bh(&dev->bss_lock);
Johannes Berg915de2f2012-11-28 22:39:37 +0100331 list_for_each_entry(bss, &dev->bss_list, list)
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500332 bss->ts -= age_jiffies;
Johannes Berg2ca813a2013-02-01 01:04:14 +0100333 spin_unlock_bh(&dev->bss_lock);
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500334}
335
Johannes Berg2a519312009-02-10 21:25:55 +0100336void cfg80211_bss_expire(struct cfg80211_registered_device *dev)
337{
Sam Leffler15d60302012-10-11 21:03:34 -0700338 __cfg80211_bss_expire(dev, jiffies - IEEE80211_SCAN_RESULT_EXPIRE);
Johannes Berg2a519312009-02-10 21:25:55 +0100339}
340
Johannes Bergc21dbf92010-01-26 14:15:46 +0100341const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len)
Johannes Berg2a519312009-02-10 21:25:55 +0100342{
Johannes Bergc21dbf92010-01-26 14:15:46 +0100343 while (len > 2 && ies[0] != eid) {
Johannes Berg2a519312009-02-10 21:25:55 +0100344 len -= ies[1] + 2;
345 ies += ies[1] + 2;
346 }
347 if (len < 2)
348 return NULL;
349 if (len < 2 + ies[1])
350 return NULL;
351 return ies;
352}
Johannes Bergc21dbf92010-01-26 14:15:46 +0100353EXPORT_SYMBOL(cfg80211_find_ie);
Johannes Berg2a519312009-02-10 21:25:55 +0100354
Eliad Peller0c28ec52011-09-15 11:53:01 +0300355const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type,
356 const u8 *ies, int len)
357{
358 struct ieee80211_vendor_ie *ie;
359 const u8 *pos = ies, *end = ies + len;
360 int ie_oui;
361
362 while (pos < end) {
363 pos = cfg80211_find_ie(WLAN_EID_VENDOR_SPECIFIC, pos,
364 end - pos);
365 if (!pos)
366 return NULL;
367
Eliad Peller0c28ec52011-09-15 11:53:01 +0300368 ie = (struct ieee80211_vendor_ie *)pos;
Luciano Coelho67194292013-02-12 20:11:38 +0200369
370 /* make sure we can access ie->len */
371 BUILD_BUG_ON(offsetof(struct ieee80211_vendor_ie, len) != 1);
372
373 if (ie->len < sizeof(*ie))
374 goto cont;
375
Eliad Peller0c28ec52011-09-15 11:53:01 +0300376 ie_oui = ie->oui[0] << 16 | ie->oui[1] << 8 | ie->oui[2];
377 if (ie_oui == oui && ie->oui_type == oui_type)
378 return pos;
Luciano Coelho67194292013-02-12 20:11:38 +0200379cont:
Eliad Peller0c28ec52011-09-15 11:53:01 +0300380 pos += 2 + ie->len;
381 }
382 return NULL;
383}
384EXPORT_SYMBOL(cfg80211_find_vendor_ie);
385
Johannes Berg915de2f2012-11-28 22:39:37 +0100386static bool is_bss(struct cfg80211_bss *a, const u8 *bssid,
Johannes Berg2a519312009-02-10 21:25:55 +0100387 const u8 *ssid, size_t ssid_len)
388{
Johannes Berg9caf0362012-11-29 01:25:20 +0100389 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100390 const u8 *ssidie;
391
Joe Perchesac422d32012-05-08 18:56:55 +0000392 if (bssid && !ether_addr_equal(a->bssid, bssid))
Johannes Berg2a519312009-02-10 21:25:55 +0100393 return false;
394
Johannes Berg79420f02009-02-10 21:25:59 +0100395 if (!ssid)
396 return true;
397
Johannes Berg9caf0362012-11-29 01:25:20 +0100398 ies = rcu_access_pointer(a->ies);
399 if (!ies)
400 return false;
401 ssidie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100402 if (!ssidie)
403 return false;
404 if (ssidie[1] != ssid_len)
405 return false;
406 return memcmp(ssidie + 2, ssid, ssid_len) == 0;
407}
408
Johannes Berg4593c4c2013-02-01 19:20:03 +0100409/**
410 * enum bss_compare_mode - BSS compare mode
411 * @BSS_CMP_REGULAR: regular compare mode (for insertion and normal find)
412 * @BSS_CMP_HIDE_ZLEN: find hidden SSID with zero-length mode
413 * @BSS_CMP_HIDE_NUL: find hidden SSID with NUL-ed out mode
414 */
415enum bss_compare_mode {
416 BSS_CMP_REGULAR,
417 BSS_CMP_HIDE_ZLEN,
418 BSS_CMP_HIDE_NUL,
419};
420
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100421static int cmp_bss(struct cfg80211_bss *a,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100422 struct cfg80211_bss *b,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100423 enum bss_compare_mode mode)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100424{
Johannes Berg9caf0362012-11-29 01:25:20 +0100425 const struct cfg80211_bss_ies *a_ies, *b_ies;
Johannes Berg3af63412013-01-30 00:40:20 +0100426 const u8 *ie1 = NULL;
427 const u8 *ie2 = NULL;
Johannes Berg5622f5b2013-01-30 00:26:45 +0100428 int i, r;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100429
Johannes Berg3af63412013-01-30 00:40:20 +0100430 if (a->channel != b->channel)
431 return b->channel->center_freq - a->channel->center_freq;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100432
Johannes Berg9caf0362012-11-29 01:25:20 +0100433 a_ies = rcu_access_pointer(a->ies);
434 if (!a_ies)
435 return -1;
436 b_ies = rcu_access_pointer(b->ies);
437 if (!b_ies)
438 return 1;
439
Johannes Berg3af63412013-01-30 00:40:20 +0100440 if (WLAN_CAPABILITY_IS_STA_BSS(a->capability))
441 ie1 = cfg80211_find_ie(WLAN_EID_MESH_ID,
442 a_ies->data, a_ies->len);
443 if (WLAN_CAPABILITY_IS_STA_BSS(b->capability))
444 ie2 = cfg80211_find_ie(WLAN_EID_MESH_ID,
445 b_ies->data, b_ies->len);
446 if (ie1 && ie2) {
447 int mesh_id_cmp;
448
449 if (ie1[1] == ie2[1])
450 mesh_id_cmp = memcmp(ie1 + 2, ie2 + 2, ie1[1]);
451 else
452 mesh_id_cmp = ie2[1] - ie1[1];
453
454 ie1 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
455 a_ies->data, a_ies->len);
456 ie2 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
457 b_ies->data, b_ies->len);
458 if (ie1 && ie2) {
459 if (mesh_id_cmp)
460 return mesh_id_cmp;
461 if (ie1[1] != ie2[1])
462 return ie2[1] - ie1[1];
463 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
464 }
465 }
466
467 /*
468 * we can't use compare_ether_addr here since we need a < > operator.
469 * The binary return value of compare_ether_addr isn't enough
470 */
471 r = memcmp(a->bssid, b->bssid, sizeof(a->bssid));
472 if (r)
473 return r;
474
Johannes Berg9caf0362012-11-29 01:25:20 +0100475 ie1 = cfg80211_find_ie(WLAN_EID_SSID, a_ies->data, a_ies->len);
476 ie2 = cfg80211_find_ie(WLAN_EID_SSID, b_ies->data, b_ies->len);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100477
Johannes Berg5622f5b2013-01-30 00:26:45 +0100478 if (!ie1 && !ie2)
479 return 0;
480
Johannes Bergf94f8b12012-11-28 22:42:34 +0100481 /*
Johannes Berg5622f5b2013-01-30 00:26:45 +0100482 * Note that with "hide_ssid", the function returns a match if
483 * the already-present BSS ("b") is a hidden SSID beacon for
484 * the new BSS ("a").
Johannes Bergf94f8b12012-11-28 22:42:34 +0100485 */
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100486
487 /* sort missing IE before (left of) present IE */
488 if (!ie1)
489 return -1;
490 if (!ie2)
491 return 1;
492
Johannes Berg4593c4c2013-02-01 19:20:03 +0100493 switch (mode) {
494 case BSS_CMP_HIDE_ZLEN:
495 /*
496 * In ZLEN mode we assume the BSS entry we're
497 * looking for has a zero-length SSID. So if
498 * the one we're looking at right now has that,
499 * return 0. Otherwise, return the difference
500 * in length, but since we're looking for the
501 * 0-length it's really equivalent to returning
502 * the length of the one we're looking at.
503 *
504 * No content comparison is needed as we assume
505 * the content length is zero.
506 */
507 return ie2[1];
508 case BSS_CMP_REGULAR:
509 default:
510 /* sort by length first, then by contents */
511 if (ie1[1] != ie2[1])
512 return ie2[1] - ie1[1];
Johannes Berg5622f5b2013-01-30 00:26:45 +0100513 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100514 case BSS_CMP_HIDE_NUL:
515 if (ie1[1] != ie2[1])
516 return ie2[1] - ie1[1];
517 /* this is equivalent to memcmp(zeroes, ie2 + 2, len) */
518 for (i = 0; i < ie2[1]; i++)
519 if (ie2[i + 2])
520 return -1;
521 return 0;
522 }
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100523}
524
Johannes Berg2a519312009-02-10 21:25:55 +0100525struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
526 struct ieee80211_channel *channel,
527 const u8 *bssid,
Johannes Berg79420f02009-02-10 21:25:59 +0100528 const u8 *ssid, size_t ssid_len,
529 u16 capa_mask, u16 capa_val)
Johannes Berg2a519312009-02-10 21:25:55 +0100530{
531 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
532 struct cfg80211_internal_bss *bss, *res = NULL;
Johannes Bergccb6c132010-07-13 10:55:38 +0200533 unsigned long now = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100534
Beni Lev4ee3e062012-08-27 12:49:39 +0300535 trace_cfg80211_get_bss(wiphy, channel, bssid, ssid, ssid_len, capa_mask,
536 capa_val);
537
Johannes Berg2a519312009-02-10 21:25:55 +0100538 spin_lock_bh(&dev->bss_lock);
539
540 list_for_each_entry(bss, &dev->bss_list, list) {
Johannes Berg79420f02009-02-10 21:25:59 +0100541 if ((bss->pub.capability & capa_mask) != capa_val)
542 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100543 if (channel && bss->pub.channel != channel)
544 continue;
Johannes Bergccb6c132010-07-13 10:55:38 +0200545 /* Don't get expired BSS structs */
546 if (time_after(now, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE) &&
547 !atomic_read(&bss->hold))
548 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100549 if (is_bss(&bss->pub, bssid, ssid, ssid_len)) {
550 res = bss;
Johannes Berg776b3582013-02-01 02:06:18 +0100551 bss_ref_get(dev, res);
Johannes Berg2a519312009-02-10 21:25:55 +0100552 break;
553 }
554 }
555
556 spin_unlock_bh(&dev->bss_lock);
557 if (!res)
558 return NULL;
Beni Lev4ee3e062012-08-27 12:49:39 +0300559 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100560 return &res->pub;
561}
562EXPORT_SYMBOL(cfg80211_get_bss);
563
Johannes Berg2a519312009-02-10 21:25:55 +0100564static void rb_insert_bss(struct cfg80211_registered_device *dev,
565 struct cfg80211_internal_bss *bss)
566{
567 struct rb_node **p = &dev->bss_tree.rb_node;
568 struct rb_node *parent = NULL;
569 struct cfg80211_internal_bss *tbss;
570 int cmp;
571
572 while (*p) {
573 parent = *p;
574 tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn);
575
Johannes Berg4593c4c2013-02-01 19:20:03 +0100576 cmp = cmp_bss(&bss->pub, &tbss->pub, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100577
578 if (WARN_ON(!cmp)) {
579 /* will sort of leak this BSS */
580 return;
581 }
582
583 if (cmp < 0)
584 p = &(*p)->rb_left;
585 else
586 p = &(*p)->rb_right;
587 }
588
589 rb_link_node(&bss->rbn, parent, p);
590 rb_insert_color(&bss->rbn, &dev->bss_tree);
591}
592
593static struct cfg80211_internal_bss *
594rb_find_bss(struct cfg80211_registered_device *dev,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100595 struct cfg80211_internal_bss *res,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100596 enum bss_compare_mode mode)
Johannes Berg2a519312009-02-10 21:25:55 +0100597{
598 struct rb_node *n = dev->bss_tree.rb_node;
599 struct cfg80211_internal_bss *bss;
600 int r;
601
602 while (n) {
603 bss = rb_entry(n, struct cfg80211_internal_bss, rbn);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100604 r = cmp_bss(&res->pub, &bss->pub, mode);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100605
606 if (r == 0)
607 return bss;
608 else if (r < 0)
609 n = n->rb_left;
610 else
611 n = n->rb_right;
612 }
613
614 return NULL;
615}
616
Johannes Berg776b3582013-02-01 02:06:18 +0100617static bool cfg80211_combine_bsses(struct cfg80211_registered_device *dev,
618 struct cfg80211_internal_bss *new)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100619{
Johannes Berg9caf0362012-11-29 01:25:20 +0100620 const struct cfg80211_bss_ies *ies;
Johannes Berg776b3582013-02-01 02:06:18 +0100621 struct cfg80211_internal_bss *bss;
622 const u8 *ie;
623 int i, ssidlen;
624 u8 fold = 0;
Johannes Berg9caf0362012-11-29 01:25:20 +0100625
Johannes Berg776b3582013-02-01 02:06:18 +0100626 ies = rcu_access_pointer(new->pub.beacon_ies);
Johannes Berg9caf0362012-11-29 01:25:20 +0100627 if (WARN_ON(!ies))
Johannes Berg776b3582013-02-01 02:06:18 +0100628 return false;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100629
Johannes Berg776b3582013-02-01 02:06:18 +0100630 ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
631 if (!ie) {
632 /* nothing to do */
633 return true;
634 }
635
636 ssidlen = ie[1];
637 for (i = 0; i < ssidlen; i++)
638 fold |= ie[2 + i];
639
640 if (fold) {
641 /* not a hidden SSID */
642 return true;
643 }
644
645 /* This is the bad part ... */
646
647 list_for_each_entry(bss, &dev->bss_list, list) {
648 if (!ether_addr_equal(bss->pub.bssid, new->pub.bssid))
649 continue;
650 if (bss->pub.channel != new->pub.channel)
651 continue;
652 if (rcu_access_pointer(bss->pub.beacon_ies))
653 continue;
654 ies = rcu_access_pointer(bss->pub.ies);
655 if (!ies)
656 continue;
657 ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
658 if (!ie)
659 continue;
660 if (ssidlen && ie[1] != ssidlen)
661 continue;
662 /* that would be odd ... */
663 if (bss->pub.beacon_ies)
664 continue;
665 if (WARN_ON_ONCE(bss->pub.hidden_beacon_bss))
666 continue;
667 if (WARN_ON_ONCE(!list_empty(&bss->hidden_list)))
668 list_del(&bss->hidden_list);
669 /* combine them */
670 list_add(&bss->hidden_list, &new->hidden_list);
671 bss->pub.hidden_beacon_bss = &new->pub;
672 new->refcount += bss->refcount;
673 rcu_assign_pointer(bss->pub.beacon_ies,
674 new->pub.beacon_ies);
675 }
676
677 return true;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100678}
679
680static struct cfg80211_internal_bss *
Johannes Berg2a519312009-02-10 21:25:55 +0100681cfg80211_bss_update(struct cfg80211_registered_device *dev,
Johannes Berg9caf0362012-11-29 01:25:20 +0100682 struct cfg80211_internal_bss *tmp)
Johannes Berg2a519312009-02-10 21:25:55 +0100683{
684 struct cfg80211_internal_bss *found = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100685
Johannes Berg9caf0362012-11-29 01:25:20 +0100686 if (WARN_ON(!tmp->pub.channel))
Johannes Berg2a519312009-02-10 21:25:55 +0100687 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100688
Johannes Berg9caf0362012-11-29 01:25:20 +0100689 tmp->ts = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100690
Johannes Berg2a519312009-02-10 21:25:55 +0100691 spin_lock_bh(&dev->bss_lock);
692
Johannes Berg9caf0362012-11-29 01:25:20 +0100693 if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) {
694 spin_unlock_bh(&dev->bss_lock);
695 return NULL;
696 }
697
Johannes Berg4593c4c2013-02-01 19:20:03 +0100698 found = rb_find_bss(dev, tmp, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100699
Johannes Bergcd1658f2009-04-16 15:00:58 +0200700 if (found) {
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200701 /* Update IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100702 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
703 const struct cfg80211_bss_ies *old;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200704
Johannes Berg9caf0362012-11-29 01:25:20 +0100705 old = rcu_access_pointer(found->pub.proberesp_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200706
Johannes Berg9caf0362012-11-29 01:25:20 +0100707 rcu_assign_pointer(found->pub.proberesp_ies,
708 tmp->pub.proberesp_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200709 /* Override possible earlier Beacon frame IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100710 rcu_assign_pointer(found->pub.ies,
711 tmp->pub.proberesp_ies);
712 if (old)
713 kfree_rcu((struct cfg80211_bss_ies *)old,
714 rcu_head);
715 } else if (rcu_access_pointer(tmp->pub.beacon_ies)) {
Johannes Berg9537f222013-02-01 01:19:48 +0100716 const struct cfg80211_bss_ies *old;
Johannes Berg776b3582013-02-01 02:06:18 +0100717 struct cfg80211_internal_bss *bss;
718
719 if (found->pub.hidden_beacon_bss &&
720 !list_empty(&found->hidden_list)) {
Johannes Berg1345ee62013-03-06 10:31:05 +0100721 const struct cfg80211_bss_ies *f;
722
Johannes Berg776b3582013-02-01 02:06:18 +0100723 /*
724 * The found BSS struct is one of the probe
725 * response members of a group, but we're
726 * receiving a beacon (beacon_ies in the tmp
727 * bss is used). This can only mean that the
728 * AP changed its beacon from not having an
729 * SSID to showing it, which is confusing so
730 * drop this information.
731 */
Johannes Berg1345ee62013-03-06 10:31:05 +0100732
733 f = rcu_access_pointer(tmp->pub.beacon_ies);
734 kfree_rcu((struct cfg80211_bss_ies *)f,
735 rcu_head);
Johannes Berg776b3582013-02-01 02:06:18 +0100736 goto drop;
737 }
Johannes Berg915de2f2012-11-28 22:39:37 +0100738
Johannes Berg9caf0362012-11-29 01:25:20 +0100739 old = rcu_access_pointer(found->pub.beacon_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200740
Johannes Berg9caf0362012-11-29 01:25:20 +0100741 rcu_assign_pointer(found->pub.beacon_ies,
742 tmp->pub.beacon_ies);
Sven Neumann01123e22010-12-09 15:05:24 +0100743
744 /* Override IEs if they were from a beacon before */
Johannes Berg9537f222013-02-01 01:19:48 +0100745 if (old == rcu_access_pointer(found->pub.ies))
Johannes Berg9caf0362012-11-29 01:25:20 +0100746 rcu_assign_pointer(found->pub.ies,
747 tmp->pub.beacon_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200748
Johannes Berg776b3582013-02-01 02:06:18 +0100749 /* Assign beacon IEs to all sub entries */
750 list_for_each_entry(bss, &found->hidden_list,
751 hidden_list) {
752 const struct cfg80211_bss_ies *ies;
753
754 ies = rcu_access_pointer(bss->pub.beacon_ies);
755 WARN_ON(ies != old);
756
757 rcu_assign_pointer(bss->pub.beacon_ies,
758 tmp->pub.beacon_ies);
759 }
760
Johannes Berg9caf0362012-11-29 01:25:20 +0100761 if (old)
762 kfree_rcu((struct cfg80211_bss_ies *)old,
763 rcu_head);
764 }
Johannes Berg1345ee62013-03-06 10:31:05 +0100765
766 found->pub.beacon_interval = tmp->pub.beacon_interval;
767 found->pub.signal = tmp->pub.signal;
768 found->pub.capability = tmp->pub.capability;
769 found->ts = tmp->ts;
Johannes Berg2a519312009-02-10 21:25:55 +0100770 } else {
Johannes Berg9caf0362012-11-29 01:25:20 +0100771 struct cfg80211_internal_bss *new;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100772 struct cfg80211_internal_bss *hidden;
Johannes Berg9caf0362012-11-29 01:25:20 +0100773 struct cfg80211_bss_ies *ies;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100774
Johannes Berg9caf0362012-11-29 01:25:20 +0100775 /*
776 * create a copy -- the "res" variable that is passed in
777 * is allocated on the stack since it's not needed in the
778 * more common case of an update
779 */
780 new = kzalloc(sizeof(*new) + dev->wiphy.bss_priv_size,
781 GFP_ATOMIC);
782 if (!new) {
783 ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
784 if (ies)
785 kfree_rcu(ies, rcu_head);
786 ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
787 if (ies)
788 kfree_rcu(ies, rcu_head);
Johannes Berg776b3582013-02-01 02:06:18 +0100789 goto drop;
Johannes Berg9caf0362012-11-29 01:25:20 +0100790 }
791 memcpy(new, tmp, sizeof(*new));
Johannes Berg776b3582013-02-01 02:06:18 +0100792 new->refcount = 1;
793 INIT_LIST_HEAD(&new->hidden_list);
794
795 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
796 hidden = rb_find_bss(dev, tmp, BSS_CMP_HIDE_ZLEN);
797 if (!hidden)
798 hidden = rb_find_bss(dev, tmp,
799 BSS_CMP_HIDE_NUL);
800 if (hidden) {
801 new->pub.hidden_beacon_bss = &hidden->pub;
802 list_add(&new->hidden_list,
803 &hidden->hidden_list);
804 hidden->refcount++;
805 rcu_assign_pointer(new->pub.beacon_ies,
806 hidden->pub.beacon_ies);
807 }
808 } else {
809 /*
810 * Ok so we found a beacon, and don't have an entry. If
811 * it's a beacon with hidden SSID, we might be in for an
812 * expensive search for any probe responses that should
813 * be grouped with this beacon for updates ...
814 */
815 if (!cfg80211_combine_bsses(dev, new)) {
816 kfree(new);
817 goto drop;
818 }
819 }
820
Johannes Berg9caf0362012-11-29 01:25:20 +0100821 list_add_tail(&new->list, &dev->bss_list);
822 rb_insert_bss(dev, new);
823 found = new;
Johannes Berg2a519312009-02-10 21:25:55 +0100824 }
825
826 dev->bss_generation++;
Johannes Berg776b3582013-02-01 02:06:18 +0100827 bss_ref_get(dev, found);
Johannes Berg2a519312009-02-10 21:25:55 +0100828 spin_unlock_bh(&dev->bss_lock);
829
Johannes Berg2a519312009-02-10 21:25:55 +0100830 return found;
Johannes Berg776b3582013-02-01 02:06:18 +0100831 drop:
832 spin_unlock_bh(&dev->bss_lock);
833 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100834}
835
Johannes Berg0172bb72012-11-23 14:23:30 +0100836static struct ieee80211_channel *
837cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
838 struct ieee80211_channel *channel)
839{
840 const u8 *tmp;
841 u32 freq;
842 int channel_number = -1;
843
844 tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
845 if (tmp && tmp[1] == 1) {
846 channel_number = tmp[2];
847 } else {
848 tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
849 if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
850 struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
851
852 channel_number = htop->primary_chan;
853 }
854 }
855
856 if (channel_number < 0)
857 return channel;
858
859 freq = ieee80211_channel_to_frequency(channel_number, channel->band);
860 channel = ieee80211_get_channel(wiphy, freq);
861 if (!channel)
862 return NULL;
863 if (channel->flags & IEEE80211_CHAN_DISABLED)
864 return NULL;
865 return channel;
866}
867
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200868struct cfg80211_bss*
869cfg80211_inform_bss(struct wiphy *wiphy,
870 struct ieee80211_channel *channel,
Johannes Berg7b8bcff2012-03-13 13:57:04 +0100871 const u8 *bssid, u64 tsf, u16 capability,
872 u16 beacon_interval, const u8 *ie, size_t ielen,
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200873 s32 signal, gfp_t gfp)
874{
Johannes Berg9caf0362012-11-29 01:25:20 +0100875 struct cfg80211_bss_ies *ies;
876 struct cfg80211_internal_bss tmp = {}, *res;
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200877
878 if (WARN_ON(!wiphy))
879 return NULL;
880
Sujith22fe88d2010-05-13 10:34:08 +0530881 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200882 (signal < 0 || signal > 100)))
883 return NULL;
884
Johannes Berg0172bb72012-11-23 14:23:30 +0100885 channel = cfg80211_get_bss_channel(wiphy, ie, ielen, channel);
886 if (!channel)
887 return NULL;
888
Johannes Berg9caf0362012-11-29 01:25:20 +0100889 memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
890 tmp.pub.channel = channel;
891 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100892 tmp.pub.beacon_interval = beacon_interval;
893 tmp.pub.capability = capability;
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200894 /*
895 * Since we do not know here whether the IEs are from a Beacon or Probe
896 * Response frame, we need to pick one of the options and only use it
897 * with the driver that does not provide the full Beacon/Probe Response
898 * frame. Use Beacon frame pointer to avoid indicating that this should
Johannes Berg50521aa2013-01-30 21:33:19 +0100899 * override the IEs pointer should we have received an earlier
Johannes Berg9caf0362012-11-29 01:25:20 +0100900 * indication of Probe Response data.
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200901 */
Johannes Berg9caf0362012-11-29 01:25:20 +0100902 ies = kmalloc(sizeof(*ies) + ielen, gfp);
903 if (!ies)
904 return NULL;
905 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100906 ies->tsf = tsf;
Johannes Berg9caf0362012-11-29 01:25:20 +0100907 memcpy(ies->data, ie, ielen);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200908
Johannes Berg9caf0362012-11-29 01:25:20 +0100909 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
910 rcu_assign_pointer(tmp.pub.ies, ies);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200911
Johannes Berg9caf0362012-11-29 01:25:20 +0100912 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200913 if (!res)
914 return NULL;
915
916 if (res->pub.capability & WLAN_CAPABILITY_ESS)
917 regulatory_hint_found_beacon(wiphy, channel, gfp);
918
Beni Lev4ee3e062012-08-27 12:49:39 +0300919 trace_cfg80211_return_bss(&res->pub);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200920 /* cfg80211_bss_update gives us a referenced result */
921 return &res->pub;
922}
923EXPORT_SYMBOL(cfg80211_inform_bss);
924
Johannes Berg2a519312009-02-10 21:25:55 +0100925struct cfg80211_bss *
926cfg80211_inform_bss_frame(struct wiphy *wiphy,
927 struct ieee80211_channel *channel,
928 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg77965c92009-02-18 18:45:06 +0100929 s32 signal, gfp_t gfp)
Johannes Berg2a519312009-02-10 21:25:55 +0100930{
Johannes Berg9caf0362012-11-29 01:25:20 +0100931 struct cfg80211_internal_bss tmp = {}, *res;
932 struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100933 size_t ielen = len - offsetof(struct ieee80211_mgmt,
934 u.probe_resp.variable);
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100935
Johannes Berg0172bb72012-11-23 14:23:30 +0100936 BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
937 offsetof(struct ieee80211_mgmt, u.beacon.variable));
938
Beni Lev4ee3e062012-08-27 12:49:39 +0300939 trace_cfg80211_inform_bss_frame(wiphy, channel, mgmt, len, signal);
940
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100941 if (WARN_ON(!mgmt))
942 return NULL;
943
944 if (WARN_ON(!wiphy))
945 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100946
Sujith22fe88d2010-05-13 10:34:08 +0530947 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Hila Gonen768be592012-08-26 11:00:28 +0300948 (signal < 0 || signal > 100)))
Johannes Berg2a519312009-02-10 21:25:55 +0100949 return NULL;
950
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100951 if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
Johannes Berg2a519312009-02-10 21:25:55 +0100952 return NULL;
953
Johannes Berg0172bb72012-11-23 14:23:30 +0100954 channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
955 ielen, channel);
956 if (!channel)
957 return NULL;
958
Johannes Berg9caf0362012-11-29 01:25:20 +0100959 ies = kmalloc(sizeof(*ies) + ielen, gfp);
960 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +0100961 return NULL;
Johannes Berg9caf0362012-11-29 01:25:20 +0100962 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100963 ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
Johannes Berg9caf0362012-11-29 01:25:20 +0100964 memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
Johannes Berg2a519312009-02-10 21:25:55 +0100965
Johannes Berg9caf0362012-11-29 01:25:20 +0100966 if (ieee80211_is_probe_resp(mgmt->frame_control))
967 rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
968 else
969 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
970 rcu_assign_pointer(tmp.pub.ies, ies);
971
972 memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
973 tmp.pub.channel = channel;
974 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100975 tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
976 tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
Johannes Berg2a519312009-02-10 21:25:55 +0100977
Johannes Berg9caf0362012-11-29 01:25:20 +0100978 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Johannes Berg2a519312009-02-10 21:25:55 +0100979 if (!res)
980 return NULL;
981
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500982 if (res->pub.capability & WLAN_CAPABILITY_ESS)
983 regulatory_hint_found_beacon(wiphy, channel, gfp);
984
Beni Lev4ee3e062012-08-27 12:49:39 +0300985 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100986 /* cfg80211_bss_update gives us a referenced result */
987 return &res->pub;
988}
989EXPORT_SYMBOL(cfg80211_inform_bss_frame);
990
Johannes Berg5b112d32013-02-01 01:49:58 +0100991void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100992{
Johannes Berg776b3582013-02-01 02:06:18 +0100993 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100994 struct cfg80211_internal_bss *bss;
995
996 if (!pub)
997 return;
998
999 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +01001000
1001 spin_lock_bh(&dev->bss_lock);
1002 bss_ref_get(dev, bss);
1003 spin_unlock_bh(&dev->bss_lock);
Johannes Berg4c0c0b72012-01-20 13:55:26 +01001004}
1005EXPORT_SYMBOL(cfg80211_ref_bss);
1006
Johannes Berg5b112d32013-02-01 01:49:58 +01001007void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg2a519312009-02-10 21:25:55 +01001008{
Johannes Berg776b3582013-02-01 02:06:18 +01001009 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg2a519312009-02-10 21:25:55 +01001010 struct cfg80211_internal_bss *bss;
1011
1012 if (!pub)
1013 return;
1014
1015 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +01001016
1017 spin_lock_bh(&dev->bss_lock);
1018 bss_ref_put(dev, bss);
1019 spin_unlock_bh(&dev->bss_lock);
Johannes Berg2a519312009-02-10 21:25:55 +01001020}
1021EXPORT_SYMBOL(cfg80211_put_bss);
1022
Johannes Bergd491af12009-02-10 21:25:58 +01001023void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1024{
1025 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
1026 struct cfg80211_internal_bss *bss;
1027
1028 if (WARN_ON(!pub))
1029 return;
1030
1031 bss = container_of(pub, struct cfg80211_internal_bss, pub);
1032
1033 spin_lock_bh(&dev->bss_lock);
Johannes Berg32073902010-10-06 21:18:04 +02001034 if (!list_empty(&bss->list)) {
Johannes Berg776b3582013-02-01 02:06:18 +01001035 if (__cfg80211_unlink_bss(dev, bss))
1036 dev->bss_generation++;
Johannes Berg32073902010-10-06 21:18:04 +02001037 }
Johannes Bergd491af12009-02-10 21:25:58 +01001038 spin_unlock_bh(&dev->bss_lock);
Johannes Bergd491af12009-02-10 21:25:58 +01001039}
1040EXPORT_SYMBOL(cfg80211_unlink_bss);
1041
Johannes Berg3d23e342009-09-29 23:27:28 +02001042#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a519312009-02-10 21:25:55 +01001043int cfg80211_wext_siwscan(struct net_device *dev,
1044 struct iw_request_info *info,
1045 union iwreq_data *wrqu, char *extra)
1046{
1047 struct cfg80211_registered_device *rdev;
1048 struct wiphy *wiphy;
1049 struct iw_scan_req *wreq = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +01001050 struct cfg80211_scan_request *creq = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +01001051 int i, err, n_channels = 0;
1052 enum ieee80211_band band;
1053
1054 if (!netif_running(dev))
1055 return -ENETDOWN;
1056
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001057 if (wrqu->data.length == sizeof(struct iw_scan_req))
1058 wreq = (struct iw_scan_req *)extra;
1059
Johannes Berg463d0182009-07-14 00:33:35 +02001060 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001061
1062 if (IS_ERR(rdev))
1063 return PTR_ERR(rdev);
1064
Johannes Bergf9f47522013-03-19 15:04:07 +01001065 mutex_lock(&rdev->sched_scan_mtx);
Johannes Berg2a519312009-02-10 21:25:55 +01001066 if (rdev->scan_req) {
1067 err = -EBUSY;
1068 goto out;
1069 }
1070
1071 wiphy = &rdev->wiphy;
1072
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001073 /* Determine number of channels, needed to allocate creq */
1074 if (wreq && wreq->num_channels)
1075 n_channels = wreq->num_channels;
1076 else {
1077 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1078 if (wiphy->bands[band])
1079 n_channels += wiphy->bands[band]->n_channels;
1080 }
Johannes Berg2a519312009-02-10 21:25:55 +01001081
1082 creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
1083 n_channels * sizeof(void *),
1084 GFP_ATOMIC);
1085 if (!creq) {
1086 err = -ENOMEM;
1087 goto out;
1088 }
1089
1090 creq->wiphy = wiphy;
Johannes Bergfd014282012-06-18 19:17:03 +02001091 creq->wdev = dev->ieee80211_ptr;
Johannes Berg5ba63532009-08-07 17:54:07 +02001092 /* SSIDs come after channels */
1093 creq->ssids = (void *)&creq->channels[n_channels];
Johannes Berg2a519312009-02-10 21:25:55 +01001094 creq->n_channels = n_channels;
1095 creq->n_ssids = 1;
Sam Leffler15d60302012-10-11 21:03:34 -07001096 creq->scan_start = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +01001097
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001098 /* translate "Scan on frequencies" request */
Johannes Berg2a519312009-02-10 21:25:55 +01001099 i = 0;
1100 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1101 int j;
Johannes Berg584991d2009-11-02 13:32:03 +01001102
Johannes Berg2a519312009-02-10 21:25:55 +01001103 if (!wiphy->bands[band])
1104 continue;
Johannes Berg584991d2009-11-02 13:32:03 +01001105
Johannes Berg2a519312009-02-10 21:25:55 +01001106 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
Johannes Berg584991d2009-11-02 13:32:03 +01001107 /* ignore disabled channels */
1108 if (wiphy->bands[band]->channels[j].flags &
1109 IEEE80211_CHAN_DISABLED)
1110 continue;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001111
1112 /* If we have a wireless request structure and the
1113 * wireless request specifies frequencies, then search
1114 * for the matching hardware channel.
1115 */
1116 if (wreq && wreq->num_channels) {
1117 int k;
1118 int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
1119 for (k = 0; k < wreq->num_channels; k++) {
Holger Schuriga4e7b732009-09-11 10:13:53 +02001120 int wext_freq = cfg80211_wext_freq(wiphy, &wreq->channel_list[k]);
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001121 if (wext_freq == wiphy_freq)
1122 goto wext_freq_found;
1123 }
1124 goto wext_freq_not_found;
1125 }
1126
1127 wext_freq_found:
Johannes Berg2a519312009-02-10 21:25:55 +01001128 creq->channels[i] = &wiphy->bands[band]->channels[j];
1129 i++;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001130 wext_freq_not_found: ;
Johannes Berg2a519312009-02-10 21:25:55 +01001131 }
1132 }
Holger Schurig8862dc52009-09-11 10:13:55 +02001133 /* No channels found? */
1134 if (!i) {
1135 err = -EINVAL;
1136 goto out;
1137 }
Johannes Berg2a519312009-02-10 21:25:55 +01001138
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001139 /* Set real number of channels specified in creq->channels[] */
1140 creq->n_channels = i;
Johannes Berg2a519312009-02-10 21:25:55 +01001141
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001142 /* translate "Scan for SSID" request */
1143 if (wreq) {
Johannes Berg2a519312009-02-10 21:25:55 +01001144 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
Johannes Berg65486c82009-12-23 15:33:35 +01001145 if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
1146 err = -EINVAL;
1147 goto out;
1148 }
Johannes Berg2a519312009-02-10 21:25:55 +01001149 memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
1150 creq->ssids[0].ssid_len = wreq->essid_len;
1151 }
1152 if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
1153 creq->n_ssids = 0;
1154 }
1155
Johannes Berg34850ab2011-07-18 18:08:35 +02001156 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
Johannes Berga401d2b2011-07-20 00:52:16 +02001157 if (wiphy->bands[i])
1158 creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
Johannes Berg34850ab2011-07-18 18:08:35 +02001159
Johannes Berg2a519312009-02-10 21:25:55 +01001160 rdev->scan_req = creq;
Hila Gonene35e4d22012-06-27 17:19:42 +03001161 err = rdev_scan(rdev, creq);
Johannes Berg2a519312009-02-10 21:25:55 +01001162 if (err) {
1163 rdev->scan_req = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +01001164 /* creq will be freed below */
Johannes Berg463d0182009-07-14 00:33:35 +02001165 } else {
Johannes Bergfd014282012-06-18 19:17:03 +02001166 nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
Johannes Berg65486c82009-12-23 15:33:35 +01001167 /* creq now owned by driver */
1168 creq = NULL;
Johannes Berg463d0182009-07-14 00:33:35 +02001169 dev_hold(dev);
1170 }
Johannes Berg2a519312009-02-10 21:25:55 +01001171 out:
Johannes Bergf9f47522013-03-19 15:04:07 +01001172 mutex_unlock(&rdev->sched_scan_mtx);
Johannes Berg65486c82009-12-23 15:33:35 +01001173 kfree(creq);
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001174 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001175 return err;
1176}
Johannes Bergba44cb72009-04-20 18:49:39 +02001177EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001178
1179static void ieee80211_scan_add_ies(struct iw_request_info *info,
Johannes Berg9caf0362012-11-29 01:25:20 +01001180 const struct cfg80211_bss_ies *ies,
Johannes Berg2a519312009-02-10 21:25:55 +01001181 char **current_ev, char *end_buf)
1182{
Johannes Berg9caf0362012-11-29 01:25:20 +01001183 const u8 *pos, *end, *next;
Johannes Berg2a519312009-02-10 21:25:55 +01001184 struct iw_event iwe;
1185
Johannes Berg9caf0362012-11-29 01:25:20 +01001186 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +01001187 return;
1188
1189 /*
1190 * If needed, fragment the IEs buffer (at IE boundaries) into short
1191 * enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
1192 */
Johannes Berg9caf0362012-11-29 01:25:20 +01001193 pos = ies->data;
1194 end = pos + ies->len;
Johannes Berg2a519312009-02-10 21:25:55 +01001195
1196 while (end - pos > IW_GENERIC_IE_MAX) {
1197 next = pos + 2 + pos[1];
1198 while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
1199 next = next + 2 + next[1];
1200
1201 memset(&iwe, 0, sizeof(iwe));
1202 iwe.cmd = IWEVGENIE;
1203 iwe.u.data.length = next - pos;
1204 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001205 end_buf, &iwe,
1206 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001207
1208 pos = next;
1209 }
1210
1211 if (end > pos) {
1212 memset(&iwe, 0, sizeof(iwe));
1213 iwe.cmd = IWEVGENIE;
1214 iwe.u.data.length = end - pos;
1215 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001216 end_buf, &iwe,
1217 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001218 }
1219}
1220
Johannes Berg2a519312009-02-10 21:25:55 +01001221static char *
Johannes Berg77965c92009-02-18 18:45:06 +01001222ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
1223 struct cfg80211_internal_bss *bss, char *current_ev,
1224 char *end_buf)
Johannes Berg2a519312009-02-10 21:25:55 +01001225{
Johannes Berg9caf0362012-11-29 01:25:20 +01001226 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +01001227 struct iw_event iwe;
Johannes Berg9caf0362012-11-29 01:25:20 +01001228 const u8 *ie;
Johannes Berg2a519312009-02-10 21:25:55 +01001229 u8 *buf, *cfg, *p;
Johannes Berg9caf0362012-11-29 01:25:20 +01001230 int rem, i, sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001231 bool ismesh = false;
1232
1233 memset(&iwe, 0, sizeof(iwe));
1234 iwe.cmd = SIOCGIWAP;
1235 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1236 memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
1237 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1238 IW_EV_ADDR_LEN);
1239
1240 memset(&iwe, 0, sizeof(iwe));
1241 iwe.cmd = SIOCGIWFREQ;
1242 iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
1243 iwe.u.freq.e = 0;
1244 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1245 IW_EV_FREQ_LEN);
1246
1247 memset(&iwe, 0, sizeof(iwe));
1248 iwe.cmd = SIOCGIWFREQ;
1249 iwe.u.freq.m = bss->pub.channel->center_freq;
1250 iwe.u.freq.e = 6;
1251 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1252 IW_EV_FREQ_LEN);
1253
Johannes Berg77965c92009-02-18 18:45:06 +01001254 if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
Johannes Berg2a519312009-02-10 21:25:55 +01001255 memset(&iwe, 0, sizeof(iwe));
1256 iwe.cmd = IWEVQUAL;
1257 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
1258 IW_QUAL_NOISE_INVALID |
Johannes Berga77b8552009-02-18 18:27:22 +01001259 IW_QUAL_QUAL_UPDATED;
Johannes Berg77965c92009-02-18 18:45:06 +01001260 switch (wiphy->signal_type) {
Johannes Berg2a519312009-02-10 21:25:55 +01001261 case CFG80211_SIGNAL_TYPE_MBM:
Johannes Berga77b8552009-02-18 18:27:22 +01001262 sig = bss->pub.signal / 100;
1263 iwe.u.qual.level = sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001264 iwe.u.qual.updated |= IW_QUAL_DBM;
Johannes Berga77b8552009-02-18 18:27:22 +01001265 if (sig < -110) /* rather bad */
1266 sig = -110;
1267 else if (sig > -40) /* perfect */
1268 sig = -40;
1269 /* will give a range of 0 .. 70 */
1270 iwe.u.qual.qual = sig + 110;
Johannes Berg2a519312009-02-10 21:25:55 +01001271 break;
1272 case CFG80211_SIGNAL_TYPE_UNSPEC:
1273 iwe.u.qual.level = bss->pub.signal;
Johannes Berga77b8552009-02-18 18:27:22 +01001274 /* will give range 0 .. 100 */
1275 iwe.u.qual.qual = bss->pub.signal;
Johannes Berg2a519312009-02-10 21:25:55 +01001276 break;
1277 default:
1278 /* not reached */
1279 break;
1280 }
1281 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1282 &iwe, IW_EV_QUAL_LEN);
1283 }
1284
1285 memset(&iwe, 0, sizeof(iwe));
1286 iwe.cmd = SIOCGIWENCODE;
1287 if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
1288 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1289 else
1290 iwe.u.data.flags = IW_ENCODE_DISABLED;
1291 iwe.u.data.length = 0;
1292 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1293 &iwe, "");
1294
Johannes Berg9caf0362012-11-29 01:25:20 +01001295 rcu_read_lock();
1296 ies = rcu_dereference(bss->pub.ies);
Johannes Berg83c7aa12013-02-05 16:51:29 +01001297 rem = ies->len;
1298 ie = ies->data;
Johannes Berg9caf0362012-11-29 01:25:20 +01001299
Johannes Berg83c7aa12013-02-05 16:51:29 +01001300 while (rem >= 2) {
Johannes Berg2a519312009-02-10 21:25:55 +01001301 /* invalid data */
1302 if (ie[1] > rem - 2)
1303 break;
1304
1305 switch (ie[0]) {
1306 case WLAN_EID_SSID:
1307 memset(&iwe, 0, sizeof(iwe));
1308 iwe.cmd = SIOCGIWESSID;
1309 iwe.u.data.length = ie[1];
1310 iwe.u.data.flags = 1;
1311 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001312 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001313 break;
1314 case WLAN_EID_MESH_ID:
1315 memset(&iwe, 0, sizeof(iwe));
1316 iwe.cmd = SIOCGIWESSID;
1317 iwe.u.data.length = ie[1];
1318 iwe.u.data.flags = 1;
1319 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001320 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001321 break;
1322 case WLAN_EID_MESH_CONFIG:
1323 ismesh = true;
Rui Paulo136cfa22009-11-18 18:40:00 +00001324 if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
Johannes Berg2a519312009-02-10 21:25:55 +01001325 break;
1326 buf = kmalloc(50, GFP_ATOMIC);
1327 if (!buf)
1328 break;
Johannes Berg9caf0362012-11-29 01:25:20 +01001329 cfg = (u8 *)ie + 2;
Johannes Berg2a519312009-02-10 21:25:55 +01001330 memset(&iwe, 0, sizeof(iwe));
1331 iwe.cmd = IWEVCUSTOM;
Rui Paulo76aa5e72009-11-18 18:22:59 +00001332 sprintf(buf, "Mesh Network Path Selection Protocol ID: "
1333 "0x%02X", cfg[0]);
Johannes Berg2a519312009-02-10 21:25:55 +01001334 iwe.u.data.length = strlen(buf);
1335 current_ev = iwe_stream_add_point(info, current_ev,
1336 end_buf,
1337 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001338 sprintf(buf, "Path Selection Metric ID: 0x%02X",
1339 cfg[1]);
Johannes Berg2a519312009-02-10 21:25:55 +01001340 iwe.u.data.length = strlen(buf);
1341 current_ev = iwe_stream_add_point(info, current_ev,
1342 end_buf,
1343 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001344 sprintf(buf, "Congestion Control Mode ID: 0x%02X",
1345 cfg[2]);
Johannes Berg2a519312009-02-10 21:25:55 +01001346 iwe.u.data.length = strlen(buf);
1347 current_ev = iwe_stream_add_point(info, current_ev,
1348 end_buf,
1349 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001350 sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
Johannes Berg2a519312009-02-10 21:25:55 +01001351 iwe.u.data.length = strlen(buf);
1352 current_ev = iwe_stream_add_point(info, current_ev,
1353 end_buf,
1354 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001355 sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
1356 iwe.u.data.length = strlen(buf);
1357 current_ev = iwe_stream_add_point(info, current_ev,
1358 end_buf,
1359 &iwe, buf);
1360 sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
1361 iwe.u.data.length = strlen(buf);
1362 current_ev = iwe_stream_add_point(info, current_ev,
1363 end_buf,
1364 &iwe, buf);
1365 sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
Johannes Berg2a519312009-02-10 21:25:55 +01001366 iwe.u.data.length = strlen(buf);
1367 current_ev = iwe_stream_add_point(info, current_ev,
1368 end_buf,
1369 &iwe, buf);
1370 kfree(buf);
1371 break;
1372 case WLAN_EID_SUPP_RATES:
1373 case WLAN_EID_EXT_SUPP_RATES:
1374 /* display all supported rates in readable format */
1375 p = current_ev + iwe_stream_lcp_len(info);
1376
1377 memset(&iwe, 0, sizeof(iwe));
1378 iwe.cmd = SIOCGIWRATE;
1379 /* Those two flags are ignored... */
1380 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
1381
1382 for (i = 0; i < ie[1]; i++) {
1383 iwe.u.bitrate.value =
1384 ((ie[i + 2] & 0x7f) * 500000);
1385 p = iwe_stream_add_value(info, current_ev, p,
1386 end_buf, &iwe, IW_EV_PARAM_LEN);
1387 }
1388 current_ev = p;
1389 break;
1390 }
1391 rem -= ie[1] + 2;
1392 ie += ie[1] + 2;
1393 }
1394
Joe Perchesf64f9e72009-11-29 16:55:45 -08001395 if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
1396 ismesh) {
Johannes Berg2a519312009-02-10 21:25:55 +01001397 memset(&iwe, 0, sizeof(iwe));
1398 iwe.cmd = SIOCGIWMODE;
1399 if (ismesh)
1400 iwe.u.mode = IW_MODE_MESH;
1401 else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
1402 iwe.u.mode = IW_MODE_MASTER;
1403 else
1404 iwe.u.mode = IW_MODE_ADHOC;
1405 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1406 &iwe, IW_EV_UINT_LEN);
1407 }
1408
Dan Carpenterc49dc902013-01-24 09:40:00 +03001409 buf = kmalloc(31, GFP_ATOMIC);
Johannes Berg2a519312009-02-10 21:25:55 +01001410 if (buf) {
1411 memset(&iwe, 0, sizeof(iwe));
1412 iwe.cmd = IWEVCUSTOM;
Johannes Berg8cef2c92013-02-05 16:54:31 +01001413 sprintf(buf, "tsf=%016llx", (unsigned long long)(ies->tsf));
Johannes Berg2a519312009-02-10 21:25:55 +01001414 iwe.u.data.length = strlen(buf);
1415 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1416 &iwe, buf);
1417 memset(&iwe, 0, sizeof(iwe));
1418 iwe.cmd = IWEVCUSTOM;
Dan Williamscb3a8ee2009-02-11 17:14:43 -05001419 sprintf(buf, " Last beacon: %ums ago",
1420 elapsed_jiffies_msecs(bss->ts));
Johannes Berg2a519312009-02-10 21:25:55 +01001421 iwe.u.data.length = strlen(buf);
1422 current_ev = iwe_stream_add_point(info, current_ev,
1423 end_buf, &iwe, buf);
1424 kfree(buf);
1425 }
1426
Johannes Berg9caf0362012-11-29 01:25:20 +01001427 ieee80211_scan_add_ies(info, ies, &current_ev, end_buf);
1428 rcu_read_unlock();
Johannes Berg2a519312009-02-10 21:25:55 +01001429
1430 return current_ev;
1431}
1432
1433
1434static int ieee80211_scan_results(struct cfg80211_registered_device *dev,
1435 struct iw_request_info *info,
1436 char *buf, size_t len)
1437{
1438 char *current_ev = buf;
1439 char *end_buf = buf + len;
1440 struct cfg80211_internal_bss *bss;
1441
1442 spin_lock_bh(&dev->bss_lock);
1443 cfg80211_bss_expire(dev);
1444
1445 list_for_each_entry(bss, &dev->bss_list, list) {
1446 if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
1447 spin_unlock_bh(&dev->bss_lock);
1448 return -E2BIG;
1449 }
Johannes Berg77965c92009-02-18 18:45:06 +01001450 current_ev = ieee80211_bss(&dev->wiphy, info, bss,
1451 current_ev, end_buf);
Johannes Berg2a519312009-02-10 21:25:55 +01001452 }
1453 spin_unlock_bh(&dev->bss_lock);
1454 return current_ev - buf;
1455}
1456
1457
1458int cfg80211_wext_giwscan(struct net_device *dev,
1459 struct iw_request_info *info,
1460 struct iw_point *data, char *extra)
1461{
1462 struct cfg80211_registered_device *rdev;
1463 int res;
1464
1465 if (!netif_running(dev))
1466 return -ENETDOWN;
1467
Johannes Berg463d0182009-07-14 00:33:35 +02001468 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001469
1470 if (IS_ERR(rdev))
1471 return PTR_ERR(rdev);
1472
1473 if (rdev->scan_req) {
1474 res = -EAGAIN;
1475 goto out;
1476 }
1477
1478 res = ieee80211_scan_results(rdev, info, extra, data->length);
1479 data->length = 0;
1480 if (res >= 0) {
1481 data->length = res;
1482 res = 0;
1483 }
1484
1485 out:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001486 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001487 return res;
1488}
Johannes Bergba44cb72009-04-20 18:49:39 +02001489EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001490#endif