blob: 674aadca007982257b14b3c68abbafc39ee01461 [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 Berg667503d2009-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 Berg01a0ac42009-08-20 21:36:16 +0200172 ASSERT_RDEV_LOCK(rdev);
173
Johannes Berg667503d2009-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 Berg667503d2009-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
233 cfg80211_lock_rdev(rdev);
Johannes Berg01a0ac42009-08-20 21:36:16 +0200234 ___cfg80211_scan_done(rdev, false);
Johannes Berg36e6fea2009-08-12 22:21:21 +0200235 cfg80211_unlock_rdev(rdev);
236}
237
Johannes Berg667503d2009-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 Berg667503d2009-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 Berg667503d2009-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) {
Johannes Berg9caf0362012-11-29 01:25:20 +0100701 found->pub.beacon_interval = tmp->pub.beacon_interval;
Johannes Berg9caf0362012-11-29 01:25:20 +0100702 found->pub.signal = tmp->pub.signal;
703 found->pub.capability = tmp->pub.capability;
704 found->ts = tmp->ts;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200705
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200706 /* Update IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100707 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
708 const struct cfg80211_bss_ies *old;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200709
Johannes Berg9caf0362012-11-29 01:25:20 +0100710 old = rcu_access_pointer(found->pub.proberesp_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200711
Johannes Berg9caf0362012-11-29 01:25:20 +0100712 rcu_assign_pointer(found->pub.proberesp_ies,
713 tmp->pub.proberesp_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200714 /* Override possible earlier Beacon frame IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100715 rcu_assign_pointer(found->pub.ies,
716 tmp->pub.proberesp_ies);
717 if (old)
718 kfree_rcu((struct cfg80211_bss_ies *)old,
719 rcu_head);
720 } else if (rcu_access_pointer(tmp->pub.beacon_ies)) {
Johannes Berg9537f222013-02-01 01:19:48 +0100721 const struct cfg80211_bss_ies *old;
Johannes Berg776b3582013-02-01 02:06:18 +0100722 struct cfg80211_internal_bss *bss;
723
724 if (found->pub.hidden_beacon_bss &&
725 !list_empty(&found->hidden_list)) {
726 /*
727 * The found BSS struct is one of the probe
728 * response members of a group, but we're
729 * receiving a beacon (beacon_ies in the tmp
730 * bss is used). This can only mean that the
731 * AP changed its beacon from not having an
732 * SSID to showing it, which is confusing so
733 * drop this information.
734 */
735 goto drop;
736 }
Johannes Berg915de2f2012-11-28 22:39:37 +0100737
Johannes Berg9caf0362012-11-29 01:25:20 +0100738 old = rcu_access_pointer(found->pub.beacon_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200739
Johannes Berg9caf0362012-11-29 01:25:20 +0100740 rcu_assign_pointer(found->pub.beacon_ies,
741 tmp->pub.beacon_ies);
Sven Neumann01123e22010-12-09 15:05:24 +0100742
743 /* Override IEs if they were from a beacon before */
Johannes Berg9537f222013-02-01 01:19:48 +0100744 if (old == rcu_access_pointer(found->pub.ies))
Johannes Berg9caf0362012-11-29 01:25:20 +0100745 rcu_assign_pointer(found->pub.ies,
746 tmp->pub.beacon_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200747
Johannes Berg776b3582013-02-01 02:06:18 +0100748 /* Assign beacon IEs to all sub entries */
749 list_for_each_entry(bss, &found->hidden_list,
750 hidden_list) {
751 const struct cfg80211_bss_ies *ies;
752
753 ies = rcu_access_pointer(bss->pub.beacon_ies);
754 WARN_ON(ies != old);
755
756 rcu_assign_pointer(bss->pub.beacon_ies,
757 tmp->pub.beacon_ies);
758 }
759
Johannes Berg9caf0362012-11-29 01:25:20 +0100760 if (old)
761 kfree_rcu((struct cfg80211_bss_ies *)old,
762 rcu_head);
763 }
Johannes Berg2a519312009-02-10 21:25:55 +0100764 } else {
Johannes Berg9caf0362012-11-29 01:25:20 +0100765 struct cfg80211_internal_bss *new;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100766 struct cfg80211_internal_bss *hidden;
Johannes Berg9caf0362012-11-29 01:25:20 +0100767 struct cfg80211_bss_ies *ies;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100768
Johannes Berg9caf0362012-11-29 01:25:20 +0100769 /*
770 * create a copy -- the "res" variable that is passed in
771 * is allocated on the stack since it's not needed in the
772 * more common case of an update
773 */
774 new = kzalloc(sizeof(*new) + dev->wiphy.bss_priv_size,
775 GFP_ATOMIC);
776 if (!new) {
777 ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
778 if (ies)
779 kfree_rcu(ies, rcu_head);
780 ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
781 if (ies)
782 kfree_rcu(ies, rcu_head);
Johannes Berg776b3582013-02-01 02:06:18 +0100783 goto drop;
Johannes Berg9caf0362012-11-29 01:25:20 +0100784 }
785 memcpy(new, tmp, sizeof(*new));
Johannes Berg776b3582013-02-01 02:06:18 +0100786 new->refcount = 1;
787 INIT_LIST_HEAD(&new->hidden_list);
788
789 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
790 hidden = rb_find_bss(dev, tmp, BSS_CMP_HIDE_ZLEN);
791 if (!hidden)
792 hidden = rb_find_bss(dev, tmp,
793 BSS_CMP_HIDE_NUL);
794 if (hidden) {
795 new->pub.hidden_beacon_bss = &hidden->pub;
796 list_add(&new->hidden_list,
797 &hidden->hidden_list);
798 hidden->refcount++;
799 rcu_assign_pointer(new->pub.beacon_ies,
800 hidden->pub.beacon_ies);
801 }
802 } else {
803 /*
804 * Ok so we found a beacon, and don't have an entry. If
805 * it's a beacon with hidden SSID, we might be in for an
806 * expensive search for any probe responses that should
807 * be grouped with this beacon for updates ...
808 */
809 if (!cfg80211_combine_bsses(dev, new)) {
810 kfree(new);
811 goto drop;
812 }
813 }
814
Johannes Berg9caf0362012-11-29 01:25:20 +0100815 list_add_tail(&new->list, &dev->bss_list);
816 rb_insert_bss(dev, new);
817 found = new;
Johannes Berg2a519312009-02-10 21:25:55 +0100818 }
819
820 dev->bss_generation++;
Johannes Berg776b3582013-02-01 02:06:18 +0100821 bss_ref_get(dev, found);
Johannes Berg2a519312009-02-10 21:25:55 +0100822 spin_unlock_bh(&dev->bss_lock);
823
Johannes Berg2a519312009-02-10 21:25:55 +0100824 return found;
Johannes Berg776b3582013-02-01 02:06:18 +0100825 drop:
826 spin_unlock_bh(&dev->bss_lock);
827 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100828}
829
Johannes Berg0172bb72012-11-23 14:23:30 +0100830static struct ieee80211_channel *
831cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
832 struct ieee80211_channel *channel)
833{
834 const u8 *tmp;
835 u32 freq;
836 int channel_number = -1;
837
838 tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
839 if (tmp && tmp[1] == 1) {
840 channel_number = tmp[2];
841 } else {
842 tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
843 if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
844 struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
845
846 channel_number = htop->primary_chan;
847 }
848 }
849
850 if (channel_number < 0)
851 return channel;
852
853 freq = ieee80211_channel_to_frequency(channel_number, channel->band);
854 channel = ieee80211_get_channel(wiphy, freq);
855 if (!channel)
856 return NULL;
857 if (channel->flags & IEEE80211_CHAN_DISABLED)
858 return NULL;
859 return channel;
860}
861
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200862struct cfg80211_bss*
863cfg80211_inform_bss(struct wiphy *wiphy,
864 struct ieee80211_channel *channel,
Johannes Berg7b8bcff2012-03-13 13:57:04 +0100865 const u8 *bssid, u64 tsf, u16 capability,
866 u16 beacon_interval, const u8 *ie, size_t ielen,
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200867 s32 signal, gfp_t gfp)
868{
Johannes Berg9caf0362012-11-29 01:25:20 +0100869 struct cfg80211_bss_ies *ies;
870 struct cfg80211_internal_bss tmp = {}, *res;
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200871
872 if (WARN_ON(!wiphy))
873 return NULL;
874
Sujith22fe88d2010-05-13 10:34:08 +0530875 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200876 (signal < 0 || signal > 100)))
877 return NULL;
878
Johannes Berg0172bb72012-11-23 14:23:30 +0100879 channel = cfg80211_get_bss_channel(wiphy, ie, ielen, channel);
880 if (!channel)
881 return NULL;
882
Johannes Berg9caf0362012-11-29 01:25:20 +0100883 memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
884 tmp.pub.channel = channel;
885 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100886 tmp.pub.beacon_interval = beacon_interval;
887 tmp.pub.capability = capability;
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200888 /*
889 * Since we do not know here whether the IEs are from a Beacon or Probe
890 * Response frame, we need to pick one of the options and only use it
891 * with the driver that does not provide the full Beacon/Probe Response
892 * frame. Use Beacon frame pointer to avoid indicating that this should
Johannes Berg50521aa2013-01-30 21:33:19 +0100893 * override the IEs pointer should we have received an earlier
Johannes Berg9caf0362012-11-29 01:25:20 +0100894 * indication of Probe Response data.
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200895 */
Johannes Berg9caf0362012-11-29 01:25:20 +0100896 ies = kmalloc(sizeof(*ies) + ielen, gfp);
897 if (!ies)
898 return NULL;
899 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100900 ies->tsf = tsf;
Johannes Berg9caf0362012-11-29 01:25:20 +0100901 memcpy(ies->data, ie, ielen);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200902
Johannes Berg9caf0362012-11-29 01:25:20 +0100903 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
904 rcu_assign_pointer(tmp.pub.ies, ies);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200905
Johannes Berg9caf0362012-11-29 01:25:20 +0100906 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200907 if (!res)
908 return NULL;
909
910 if (res->pub.capability & WLAN_CAPABILITY_ESS)
911 regulatory_hint_found_beacon(wiphy, channel, gfp);
912
Beni Lev4ee3e062012-08-27 12:49:39 +0300913 trace_cfg80211_return_bss(&res->pub);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200914 /* cfg80211_bss_update gives us a referenced result */
915 return &res->pub;
916}
917EXPORT_SYMBOL(cfg80211_inform_bss);
918
Johannes Berg2a519312009-02-10 21:25:55 +0100919struct cfg80211_bss *
920cfg80211_inform_bss_frame(struct wiphy *wiphy,
921 struct ieee80211_channel *channel,
922 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg77965c92009-02-18 18:45:06 +0100923 s32 signal, gfp_t gfp)
Johannes Berg2a519312009-02-10 21:25:55 +0100924{
Johannes Berg9caf0362012-11-29 01:25:20 +0100925 struct cfg80211_internal_bss tmp = {}, *res;
926 struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100927 size_t ielen = len - offsetof(struct ieee80211_mgmt,
928 u.probe_resp.variable);
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100929
Johannes Berg0172bb72012-11-23 14:23:30 +0100930 BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
931 offsetof(struct ieee80211_mgmt, u.beacon.variable));
932
Beni Lev4ee3e062012-08-27 12:49:39 +0300933 trace_cfg80211_inform_bss_frame(wiphy, channel, mgmt, len, signal);
934
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100935 if (WARN_ON(!mgmt))
936 return NULL;
937
938 if (WARN_ON(!wiphy))
939 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100940
Sujith22fe88d2010-05-13 10:34:08 +0530941 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Hila Gonen768be592012-08-26 11:00:28 +0300942 (signal < 0 || signal > 100)))
Johannes Berg2a519312009-02-10 21:25:55 +0100943 return NULL;
944
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100945 if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
Johannes Berg2a519312009-02-10 21:25:55 +0100946 return NULL;
947
Johannes Berg0172bb72012-11-23 14:23:30 +0100948 channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
949 ielen, channel);
950 if (!channel)
951 return NULL;
952
Johannes Berg9caf0362012-11-29 01:25:20 +0100953 ies = kmalloc(sizeof(*ies) + ielen, gfp);
954 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +0100955 return NULL;
Johannes Berg9caf0362012-11-29 01:25:20 +0100956 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100957 ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
Johannes Berg9caf0362012-11-29 01:25:20 +0100958 memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
Johannes Berg2a519312009-02-10 21:25:55 +0100959
Johannes Berg9caf0362012-11-29 01:25:20 +0100960 if (ieee80211_is_probe_resp(mgmt->frame_control))
961 rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
962 else
963 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
964 rcu_assign_pointer(tmp.pub.ies, ies);
965
966 memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
967 tmp.pub.channel = channel;
968 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100969 tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
970 tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
Johannes Berg2a519312009-02-10 21:25:55 +0100971
Johannes Berg9caf0362012-11-29 01:25:20 +0100972 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Johannes Berg2a519312009-02-10 21:25:55 +0100973 if (!res)
974 return NULL;
975
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500976 if (res->pub.capability & WLAN_CAPABILITY_ESS)
977 regulatory_hint_found_beacon(wiphy, channel, gfp);
978
Beni Lev4ee3e062012-08-27 12:49:39 +0300979 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100980 /* cfg80211_bss_update gives us a referenced result */
981 return &res->pub;
982}
983EXPORT_SYMBOL(cfg80211_inform_bss_frame);
984
Johannes Berg5b112d32013-02-01 01:49:58 +0100985void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100986{
Johannes Berg776b3582013-02-01 02:06:18 +0100987 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100988 struct cfg80211_internal_bss *bss;
989
990 if (!pub)
991 return;
992
993 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +0100994
995 spin_lock_bh(&dev->bss_lock);
996 bss_ref_get(dev, bss);
997 spin_unlock_bh(&dev->bss_lock);
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100998}
999EXPORT_SYMBOL(cfg80211_ref_bss);
1000
Johannes Berg5b112d32013-02-01 01:49:58 +01001001void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg2a519312009-02-10 21:25:55 +01001002{
Johannes Berg776b3582013-02-01 02:06:18 +01001003 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg2a519312009-02-10 21:25:55 +01001004 struct cfg80211_internal_bss *bss;
1005
1006 if (!pub)
1007 return;
1008
1009 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +01001010
1011 spin_lock_bh(&dev->bss_lock);
1012 bss_ref_put(dev, bss);
1013 spin_unlock_bh(&dev->bss_lock);
Johannes Berg2a519312009-02-10 21:25:55 +01001014}
1015EXPORT_SYMBOL(cfg80211_put_bss);
1016
Johannes Bergd491af12009-02-10 21:25:58 +01001017void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1018{
1019 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
1020 struct cfg80211_internal_bss *bss;
1021
1022 if (WARN_ON(!pub))
1023 return;
1024
1025 bss = container_of(pub, struct cfg80211_internal_bss, pub);
1026
1027 spin_lock_bh(&dev->bss_lock);
Johannes Berg32073902010-10-06 21:18:04 +02001028 if (!list_empty(&bss->list)) {
Johannes Berg776b3582013-02-01 02:06:18 +01001029 if (__cfg80211_unlink_bss(dev, bss))
1030 dev->bss_generation++;
Johannes Berg32073902010-10-06 21:18:04 +02001031 }
Johannes Bergd491af12009-02-10 21:25:58 +01001032 spin_unlock_bh(&dev->bss_lock);
Johannes Bergd491af12009-02-10 21:25:58 +01001033}
1034EXPORT_SYMBOL(cfg80211_unlink_bss);
1035
Johannes Berg3d23e342009-09-29 23:27:28 +02001036#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a519312009-02-10 21:25:55 +01001037int cfg80211_wext_siwscan(struct net_device *dev,
1038 struct iw_request_info *info,
1039 union iwreq_data *wrqu, char *extra)
1040{
1041 struct cfg80211_registered_device *rdev;
1042 struct wiphy *wiphy;
1043 struct iw_scan_req *wreq = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +01001044 struct cfg80211_scan_request *creq = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +01001045 int i, err, n_channels = 0;
1046 enum ieee80211_band band;
1047
1048 if (!netif_running(dev))
1049 return -ENETDOWN;
1050
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001051 if (wrqu->data.length == sizeof(struct iw_scan_req))
1052 wreq = (struct iw_scan_req *)extra;
1053
Johannes Berg463d0182009-07-14 00:33:35 +02001054 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001055
1056 if (IS_ERR(rdev))
1057 return PTR_ERR(rdev);
1058
1059 if (rdev->scan_req) {
1060 err = -EBUSY;
1061 goto out;
1062 }
1063
1064 wiphy = &rdev->wiphy;
1065
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001066 /* Determine number of channels, needed to allocate creq */
1067 if (wreq && wreq->num_channels)
1068 n_channels = wreq->num_channels;
1069 else {
1070 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1071 if (wiphy->bands[band])
1072 n_channels += wiphy->bands[band]->n_channels;
1073 }
Johannes Berg2a519312009-02-10 21:25:55 +01001074
1075 creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
1076 n_channels * sizeof(void *),
1077 GFP_ATOMIC);
1078 if (!creq) {
1079 err = -ENOMEM;
1080 goto out;
1081 }
1082
1083 creq->wiphy = wiphy;
Johannes Bergfd014282012-06-18 19:17:03 +02001084 creq->wdev = dev->ieee80211_ptr;
Johannes Berg5ba63532009-08-07 17:54:07 +02001085 /* SSIDs come after channels */
1086 creq->ssids = (void *)&creq->channels[n_channels];
Johannes Berg2a519312009-02-10 21:25:55 +01001087 creq->n_channels = n_channels;
1088 creq->n_ssids = 1;
Sam Leffler15d60302012-10-11 21:03:34 -07001089 creq->scan_start = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +01001090
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001091 /* translate "Scan on frequencies" request */
Johannes Berg2a519312009-02-10 21:25:55 +01001092 i = 0;
1093 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1094 int j;
Johannes Berg584991d2009-11-02 13:32:03 +01001095
Johannes Berg2a519312009-02-10 21:25:55 +01001096 if (!wiphy->bands[band])
1097 continue;
Johannes Berg584991d2009-11-02 13:32:03 +01001098
Johannes Berg2a519312009-02-10 21:25:55 +01001099 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
Johannes Berg584991d2009-11-02 13:32:03 +01001100 /* ignore disabled channels */
1101 if (wiphy->bands[band]->channels[j].flags &
1102 IEEE80211_CHAN_DISABLED)
1103 continue;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001104
1105 /* If we have a wireless request structure and the
1106 * wireless request specifies frequencies, then search
1107 * for the matching hardware channel.
1108 */
1109 if (wreq && wreq->num_channels) {
1110 int k;
1111 int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
1112 for (k = 0; k < wreq->num_channels; k++) {
Holger Schuriga4e7b732009-09-11 10:13:53 +02001113 int wext_freq = cfg80211_wext_freq(wiphy, &wreq->channel_list[k]);
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001114 if (wext_freq == wiphy_freq)
1115 goto wext_freq_found;
1116 }
1117 goto wext_freq_not_found;
1118 }
1119
1120 wext_freq_found:
Johannes Berg2a519312009-02-10 21:25:55 +01001121 creq->channels[i] = &wiphy->bands[band]->channels[j];
1122 i++;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001123 wext_freq_not_found: ;
Johannes Berg2a519312009-02-10 21:25:55 +01001124 }
1125 }
Holger Schurig8862dc52009-09-11 10:13:55 +02001126 /* No channels found? */
1127 if (!i) {
1128 err = -EINVAL;
1129 goto out;
1130 }
Johannes Berg2a519312009-02-10 21:25:55 +01001131
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001132 /* Set real number of channels specified in creq->channels[] */
1133 creq->n_channels = i;
Johannes Berg2a519312009-02-10 21:25:55 +01001134
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001135 /* translate "Scan for SSID" request */
1136 if (wreq) {
Johannes Berg2a519312009-02-10 21:25:55 +01001137 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
Johannes Berg65486c82009-12-23 15:33:35 +01001138 if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
1139 err = -EINVAL;
1140 goto out;
1141 }
Johannes Berg2a519312009-02-10 21:25:55 +01001142 memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
1143 creq->ssids[0].ssid_len = wreq->essid_len;
1144 }
1145 if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
1146 creq->n_ssids = 0;
1147 }
1148
Johannes Berg34850ab2011-07-18 18:08:35 +02001149 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
Johannes Berga401d2b2011-07-20 00:52:16 +02001150 if (wiphy->bands[i])
1151 creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
Johannes Berg34850ab2011-07-18 18:08:35 +02001152
Johannes Berg2a519312009-02-10 21:25:55 +01001153 rdev->scan_req = creq;
Hila Gonene35e4d22012-06-27 17:19:42 +03001154 err = rdev_scan(rdev, creq);
Johannes Berg2a519312009-02-10 21:25:55 +01001155 if (err) {
1156 rdev->scan_req = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +01001157 /* creq will be freed below */
Johannes Berg463d0182009-07-14 00:33:35 +02001158 } else {
Johannes Bergfd014282012-06-18 19:17:03 +02001159 nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
Johannes Berg65486c82009-12-23 15:33:35 +01001160 /* creq now owned by driver */
1161 creq = NULL;
Johannes Berg463d0182009-07-14 00:33:35 +02001162 dev_hold(dev);
1163 }
Johannes Berg2a519312009-02-10 21:25:55 +01001164 out:
Johannes Berg65486c82009-12-23 15:33:35 +01001165 kfree(creq);
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001166 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001167 return err;
1168}
Johannes Bergba44cb72009-04-20 18:49:39 +02001169EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001170
1171static void ieee80211_scan_add_ies(struct iw_request_info *info,
Johannes Berg9caf0362012-11-29 01:25:20 +01001172 const struct cfg80211_bss_ies *ies,
Johannes Berg2a519312009-02-10 21:25:55 +01001173 char **current_ev, char *end_buf)
1174{
Johannes Berg9caf0362012-11-29 01:25:20 +01001175 const u8 *pos, *end, *next;
Johannes Berg2a519312009-02-10 21:25:55 +01001176 struct iw_event iwe;
1177
Johannes Berg9caf0362012-11-29 01:25:20 +01001178 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +01001179 return;
1180
1181 /*
1182 * If needed, fragment the IEs buffer (at IE boundaries) into short
1183 * enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
1184 */
Johannes Berg9caf0362012-11-29 01:25:20 +01001185 pos = ies->data;
1186 end = pos + ies->len;
Johannes Berg2a519312009-02-10 21:25:55 +01001187
1188 while (end - pos > IW_GENERIC_IE_MAX) {
1189 next = pos + 2 + pos[1];
1190 while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
1191 next = next + 2 + next[1];
1192
1193 memset(&iwe, 0, sizeof(iwe));
1194 iwe.cmd = IWEVGENIE;
1195 iwe.u.data.length = next - pos;
1196 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001197 end_buf, &iwe,
1198 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001199
1200 pos = next;
1201 }
1202
1203 if (end > pos) {
1204 memset(&iwe, 0, sizeof(iwe));
1205 iwe.cmd = IWEVGENIE;
1206 iwe.u.data.length = end - pos;
1207 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001208 end_buf, &iwe,
1209 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001210 }
1211}
1212
Johannes Berg2a519312009-02-10 21:25:55 +01001213static char *
Johannes Berg77965c92009-02-18 18:45:06 +01001214ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
1215 struct cfg80211_internal_bss *bss, char *current_ev,
1216 char *end_buf)
Johannes Berg2a519312009-02-10 21:25:55 +01001217{
Johannes Berg9caf0362012-11-29 01:25:20 +01001218 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +01001219 struct iw_event iwe;
Johannes Berg9caf0362012-11-29 01:25:20 +01001220 const u8 *ie;
Johannes Berg2a519312009-02-10 21:25:55 +01001221 u8 *buf, *cfg, *p;
Johannes Berg9caf0362012-11-29 01:25:20 +01001222 int rem, i, sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001223 bool ismesh = false;
1224
1225 memset(&iwe, 0, sizeof(iwe));
1226 iwe.cmd = SIOCGIWAP;
1227 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1228 memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
1229 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1230 IW_EV_ADDR_LEN);
1231
1232 memset(&iwe, 0, sizeof(iwe));
1233 iwe.cmd = SIOCGIWFREQ;
1234 iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
1235 iwe.u.freq.e = 0;
1236 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1237 IW_EV_FREQ_LEN);
1238
1239 memset(&iwe, 0, sizeof(iwe));
1240 iwe.cmd = SIOCGIWFREQ;
1241 iwe.u.freq.m = bss->pub.channel->center_freq;
1242 iwe.u.freq.e = 6;
1243 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1244 IW_EV_FREQ_LEN);
1245
Johannes Berg77965c92009-02-18 18:45:06 +01001246 if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
Johannes Berg2a519312009-02-10 21:25:55 +01001247 memset(&iwe, 0, sizeof(iwe));
1248 iwe.cmd = IWEVQUAL;
1249 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
1250 IW_QUAL_NOISE_INVALID |
Johannes Berga77b8552009-02-18 18:27:22 +01001251 IW_QUAL_QUAL_UPDATED;
Johannes Berg77965c92009-02-18 18:45:06 +01001252 switch (wiphy->signal_type) {
Johannes Berg2a519312009-02-10 21:25:55 +01001253 case CFG80211_SIGNAL_TYPE_MBM:
Johannes Berga77b8552009-02-18 18:27:22 +01001254 sig = bss->pub.signal / 100;
1255 iwe.u.qual.level = sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001256 iwe.u.qual.updated |= IW_QUAL_DBM;
Johannes Berga77b8552009-02-18 18:27:22 +01001257 if (sig < -110) /* rather bad */
1258 sig = -110;
1259 else if (sig > -40) /* perfect */
1260 sig = -40;
1261 /* will give a range of 0 .. 70 */
1262 iwe.u.qual.qual = sig + 110;
Johannes Berg2a519312009-02-10 21:25:55 +01001263 break;
1264 case CFG80211_SIGNAL_TYPE_UNSPEC:
1265 iwe.u.qual.level = bss->pub.signal;
Johannes Berga77b8552009-02-18 18:27:22 +01001266 /* will give range 0 .. 100 */
1267 iwe.u.qual.qual = bss->pub.signal;
Johannes Berg2a519312009-02-10 21:25:55 +01001268 break;
1269 default:
1270 /* not reached */
1271 break;
1272 }
1273 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1274 &iwe, IW_EV_QUAL_LEN);
1275 }
1276
1277 memset(&iwe, 0, sizeof(iwe));
1278 iwe.cmd = SIOCGIWENCODE;
1279 if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
1280 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1281 else
1282 iwe.u.data.flags = IW_ENCODE_DISABLED;
1283 iwe.u.data.length = 0;
1284 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1285 &iwe, "");
1286
Johannes Berg9caf0362012-11-29 01:25:20 +01001287 rcu_read_lock();
1288 ies = rcu_dereference(bss->pub.ies);
Johannes Berg83c7aa12013-02-05 16:51:29 +01001289 rem = ies->len;
1290 ie = ies->data;
Johannes Berg9caf0362012-11-29 01:25:20 +01001291
Johannes Berg83c7aa12013-02-05 16:51:29 +01001292 while (rem >= 2) {
Johannes Berg2a519312009-02-10 21:25:55 +01001293 /* invalid data */
1294 if (ie[1] > rem - 2)
1295 break;
1296
1297 switch (ie[0]) {
1298 case WLAN_EID_SSID:
1299 memset(&iwe, 0, sizeof(iwe));
1300 iwe.cmd = SIOCGIWESSID;
1301 iwe.u.data.length = ie[1];
1302 iwe.u.data.flags = 1;
1303 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001304 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001305 break;
1306 case WLAN_EID_MESH_ID:
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_CONFIG:
1315 ismesh = true;
Rui Paulo136cfa22009-11-18 18:40:00 +00001316 if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
Johannes Berg2a519312009-02-10 21:25:55 +01001317 break;
1318 buf = kmalloc(50, GFP_ATOMIC);
1319 if (!buf)
1320 break;
Johannes Berg9caf0362012-11-29 01:25:20 +01001321 cfg = (u8 *)ie + 2;
Johannes Berg2a519312009-02-10 21:25:55 +01001322 memset(&iwe, 0, sizeof(iwe));
1323 iwe.cmd = IWEVCUSTOM;
Rui Paulo76aa5e72009-11-18 18:22:59 +00001324 sprintf(buf, "Mesh Network Path Selection Protocol ID: "
1325 "0x%02X", cfg[0]);
Johannes Berg2a519312009-02-10 21:25:55 +01001326 iwe.u.data.length = strlen(buf);
1327 current_ev = iwe_stream_add_point(info, current_ev,
1328 end_buf,
1329 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001330 sprintf(buf, "Path Selection Metric ID: 0x%02X",
1331 cfg[1]);
Johannes Berg2a519312009-02-10 21:25:55 +01001332 iwe.u.data.length = strlen(buf);
1333 current_ev = iwe_stream_add_point(info, current_ev,
1334 end_buf,
1335 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001336 sprintf(buf, "Congestion Control Mode ID: 0x%02X",
1337 cfg[2]);
Johannes Berg2a519312009-02-10 21:25:55 +01001338 iwe.u.data.length = strlen(buf);
1339 current_ev = iwe_stream_add_point(info, current_ev,
1340 end_buf,
1341 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001342 sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
Johannes Berg2a519312009-02-10 21:25:55 +01001343 iwe.u.data.length = strlen(buf);
1344 current_ev = iwe_stream_add_point(info, current_ev,
1345 end_buf,
1346 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001347 sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
1348 iwe.u.data.length = strlen(buf);
1349 current_ev = iwe_stream_add_point(info, current_ev,
1350 end_buf,
1351 &iwe, buf);
1352 sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
1353 iwe.u.data.length = strlen(buf);
1354 current_ev = iwe_stream_add_point(info, current_ev,
1355 end_buf,
1356 &iwe, buf);
1357 sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
Johannes Berg2a519312009-02-10 21:25:55 +01001358 iwe.u.data.length = strlen(buf);
1359 current_ev = iwe_stream_add_point(info, current_ev,
1360 end_buf,
1361 &iwe, buf);
1362 kfree(buf);
1363 break;
1364 case WLAN_EID_SUPP_RATES:
1365 case WLAN_EID_EXT_SUPP_RATES:
1366 /* display all supported rates in readable format */
1367 p = current_ev + iwe_stream_lcp_len(info);
1368
1369 memset(&iwe, 0, sizeof(iwe));
1370 iwe.cmd = SIOCGIWRATE;
1371 /* Those two flags are ignored... */
1372 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
1373
1374 for (i = 0; i < ie[1]; i++) {
1375 iwe.u.bitrate.value =
1376 ((ie[i + 2] & 0x7f) * 500000);
1377 p = iwe_stream_add_value(info, current_ev, p,
1378 end_buf, &iwe, IW_EV_PARAM_LEN);
1379 }
1380 current_ev = p;
1381 break;
1382 }
1383 rem -= ie[1] + 2;
1384 ie += ie[1] + 2;
1385 }
1386
Joe Perchesf64f9e72009-11-29 16:55:45 -08001387 if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
1388 ismesh) {
Johannes Berg2a519312009-02-10 21:25:55 +01001389 memset(&iwe, 0, sizeof(iwe));
1390 iwe.cmd = SIOCGIWMODE;
1391 if (ismesh)
1392 iwe.u.mode = IW_MODE_MESH;
1393 else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
1394 iwe.u.mode = IW_MODE_MASTER;
1395 else
1396 iwe.u.mode = IW_MODE_ADHOC;
1397 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1398 &iwe, IW_EV_UINT_LEN);
1399 }
1400
Dan Carpenterc49dc902013-01-24 09:40:00 +03001401 buf = kmalloc(31, GFP_ATOMIC);
Johannes Berg2a519312009-02-10 21:25:55 +01001402 if (buf) {
1403 memset(&iwe, 0, sizeof(iwe));
1404 iwe.cmd = IWEVCUSTOM;
Johannes Berg8cef2c92013-02-05 16:54:31 +01001405 sprintf(buf, "tsf=%016llx", (unsigned long long)(ies->tsf));
Johannes Berg2a519312009-02-10 21:25:55 +01001406 iwe.u.data.length = strlen(buf);
1407 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1408 &iwe, buf);
1409 memset(&iwe, 0, sizeof(iwe));
1410 iwe.cmd = IWEVCUSTOM;
Dan Williamscb3a8ee2009-02-11 17:14:43 -05001411 sprintf(buf, " Last beacon: %ums ago",
1412 elapsed_jiffies_msecs(bss->ts));
Johannes Berg2a519312009-02-10 21:25:55 +01001413 iwe.u.data.length = strlen(buf);
1414 current_ev = iwe_stream_add_point(info, current_ev,
1415 end_buf, &iwe, buf);
1416 kfree(buf);
1417 }
1418
Johannes Berg9caf0362012-11-29 01:25:20 +01001419 ieee80211_scan_add_ies(info, ies, &current_ev, end_buf);
1420 rcu_read_unlock();
Johannes Berg2a519312009-02-10 21:25:55 +01001421
1422 return current_ev;
1423}
1424
1425
1426static int ieee80211_scan_results(struct cfg80211_registered_device *dev,
1427 struct iw_request_info *info,
1428 char *buf, size_t len)
1429{
1430 char *current_ev = buf;
1431 char *end_buf = buf + len;
1432 struct cfg80211_internal_bss *bss;
1433
1434 spin_lock_bh(&dev->bss_lock);
1435 cfg80211_bss_expire(dev);
1436
1437 list_for_each_entry(bss, &dev->bss_list, list) {
1438 if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
1439 spin_unlock_bh(&dev->bss_lock);
1440 return -E2BIG;
1441 }
Johannes Berg77965c92009-02-18 18:45:06 +01001442 current_ev = ieee80211_bss(&dev->wiphy, info, bss,
1443 current_ev, end_buf);
Johannes Berg2a519312009-02-10 21:25:55 +01001444 }
1445 spin_unlock_bh(&dev->bss_lock);
1446 return current_ev - buf;
1447}
1448
1449
1450int cfg80211_wext_giwscan(struct net_device *dev,
1451 struct iw_request_info *info,
1452 struct iw_point *data, char *extra)
1453{
1454 struct cfg80211_registered_device *rdev;
1455 int res;
1456
1457 if (!netif_running(dev))
1458 return -ENETDOWN;
1459
Johannes Berg463d0182009-07-14 00:33:35 +02001460 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001461
1462 if (IS_ERR(rdev))
1463 return PTR_ERR(rdev);
1464
1465 if (rdev->scan_req) {
1466 res = -EAGAIN;
1467 goto out;
1468 }
1469
1470 res = ieee80211_scan_results(rdev, info, extra, data->length);
1471 data->length = 0;
1472 if (res >= 0) {
1473 data->length = res;
1474 res = 0;
1475 }
1476
1477 out:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001478 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001479 return res;
1480}
Johannes Bergba44cb72009-04-20 18:49:39 +02001481EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001482#endif