blob: ae8c186b50d68510f88e758b959ad663e911a5de [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 Berg5fe231e2013-05-08 21:45:15 +0200172 ASSERT_RTNL();
Johannes Berg01a0ac42009-08-20 21:36:16 +0200173
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 Berg6829c8782009-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 Berg6829c8782009-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
Johannes Berg5fe231e2013-05-08 21:45:15 +0200233 rtnl_lock();
Johannes Berg01a0ac42009-08-20 21:36:16 +0200234 ___cfg80211_scan_done(rdev, false);
Johannes Berg5fe231e2013-05-08 21:45:15 +0200235 rtnl_unlock();
Johannes Berg36e6fea2009-08-12 22:21:21 +0200236}
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;
Johannes Berg5fe231e2013-05-08 21:45:15 +0200244 request->notified = true;
Alban Browaeyse60d7442009-11-25 15:13:00 +0100245 queue_work(cfg80211_wq, &wiphy_to_dev(request->wiphy)->scan_done_wk);
Johannes Berg667503d2009-07-07 03:56:11 +0200246}
Johannes Berg2a519312009-02-10 21:25:55 +0100247EXPORT_SYMBOL(cfg80211_scan_done);
248
Luciano Coelho807f8a82011-05-11 17:09:35 +0300249void __cfg80211_sched_scan_results(struct work_struct *wk)
250{
251 struct cfg80211_registered_device *rdev;
Sam Leffler15d60302012-10-11 21:03:34 -0700252 struct cfg80211_sched_scan_request *request;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300253
254 rdev = container_of(wk, struct cfg80211_registered_device,
255 sched_scan_results_wk);
256
Sam Leffler15d60302012-10-11 21:03:34 -0700257 request = rdev->sched_scan_req;
258
Johannes Berg5fe231e2013-05-08 21:45:15 +0200259 rtnl_lock();
Luciano Coelho807f8a82011-05-11 17:09:35 +0300260
261 /* we don't have sched_scan_req anymore if the scan is stopping */
Sam Leffler15d60302012-10-11 21:03:34 -0700262 if (request) {
263 if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
264 /* flush entries from previous scans */
265 spin_lock_bh(&rdev->bss_lock);
266 __cfg80211_bss_expire(rdev, request->scan_start);
267 spin_unlock_bh(&rdev->bss_lock);
268 request->scan_start =
269 jiffies + msecs_to_jiffies(request->interval);
270 }
271 nl80211_send_sched_scan_results(rdev, request->dev);
272 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300273
Johannes Berg5fe231e2013-05-08 21:45:15 +0200274 rtnl_unlock();
Luciano Coelho807f8a82011-05-11 17:09:35 +0300275}
276
277void cfg80211_sched_scan_results(struct wiphy *wiphy)
278{
Beni Lev4ee3e062012-08-27 12:49:39 +0300279 trace_cfg80211_sched_scan_results(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300280 /* ignore if we're not scanning */
281 if (wiphy_to_dev(wiphy)->sched_scan_req)
282 queue_work(cfg80211_wq,
283 &wiphy_to_dev(wiphy)->sched_scan_results_wk);
284}
285EXPORT_SYMBOL(cfg80211_sched_scan_results);
286
Luciano Coelho85a99942011-05-12 16:28:29 +0300287void cfg80211_sched_scan_stopped(struct wiphy *wiphy)
Luciano Coelho807f8a82011-05-11 17:09:35 +0300288{
Luciano Coelho85a99942011-05-12 16:28:29 +0300289 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300290
Beni Lev4ee3e062012-08-27 12:49:39 +0300291 trace_cfg80211_sched_scan_stopped(wiphy);
292
Johannes Berg5fe231e2013-05-08 21:45:15 +0200293 rtnl_lock();
Luciano Coelho807f8a82011-05-11 17:09:35 +0300294 __cfg80211_stop_sched_scan(rdev, true);
Johannes Berg5fe231e2013-05-08 21:45:15 +0200295 rtnl_unlock();
Luciano Coelho807f8a82011-05-11 17:09:35 +0300296}
Luciano Coelho807f8a82011-05-11 17:09:35 +0300297EXPORT_SYMBOL(cfg80211_sched_scan_stopped);
298
299int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
300 bool driver_initiated)
301{
Luciano Coelho807f8a82011-05-11 17:09:35 +0300302 struct net_device *dev;
303
Johannes Berg5fe231e2013-05-08 21:45:15 +0200304 ASSERT_RTNL();
Luciano Coelho807f8a82011-05-11 17:09:35 +0300305
306 if (!rdev->sched_scan_req)
Luciano Coelho1a84ff72011-07-08 11:16:16 +0300307 return -ENOENT;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300308
309 dev = rdev->sched_scan_req->dev;
310
Luciano Coelho85a99942011-05-12 16:28:29 +0300311 if (!driver_initiated) {
Hila Gonene35e4d22012-06-27 17:19:42 +0300312 int err = rdev_sched_scan_stop(rdev, dev);
Luciano Coelho85a99942011-05-12 16:28:29 +0300313 if (err)
314 return err;
315 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300316
317 nl80211_send_sched_scan(rdev, dev, NL80211_CMD_SCHED_SCAN_STOPPED);
318
319 kfree(rdev->sched_scan_req);
320 rdev->sched_scan_req = NULL;
321
Jesper Juhl3b4670f2011-06-29 22:49:33 +0200322 return 0;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300323}
324
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500325void cfg80211_bss_age(struct cfg80211_registered_device *dev,
326 unsigned long age_secs)
327{
328 struct cfg80211_internal_bss *bss;
329 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
330
Johannes Berg2ca813a2013-02-01 01:04:14 +0100331 spin_lock_bh(&dev->bss_lock);
Johannes Berg915de2f2012-11-28 22:39:37 +0100332 list_for_each_entry(bss, &dev->bss_list, list)
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500333 bss->ts -= age_jiffies;
Johannes Berg2ca813a2013-02-01 01:04:14 +0100334 spin_unlock_bh(&dev->bss_lock);
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500335}
336
Johannes Berg2a519312009-02-10 21:25:55 +0100337void cfg80211_bss_expire(struct cfg80211_registered_device *dev)
338{
Sam Leffler15d60302012-10-11 21:03:34 -0700339 __cfg80211_bss_expire(dev, jiffies - IEEE80211_SCAN_RESULT_EXPIRE);
Johannes Berg2a519312009-02-10 21:25:55 +0100340}
341
Johannes Bergc21dbf92010-01-26 14:15:46 +0100342const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len)
Johannes Berg2a519312009-02-10 21:25:55 +0100343{
Johannes Bergc21dbf92010-01-26 14:15:46 +0100344 while (len > 2 && ies[0] != eid) {
Johannes Berg2a519312009-02-10 21:25:55 +0100345 len -= ies[1] + 2;
346 ies += ies[1] + 2;
347 }
348 if (len < 2)
349 return NULL;
350 if (len < 2 + ies[1])
351 return NULL;
352 return ies;
353}
Johannes Bergc21dbf92010-01-26 14:15:46 +0100354EXPORT_SYMBOL(cfg80211_find_ie);
Johannes Berg2a519312009-02-10 21:25:55 +0100355
Eliad Peller0c28ec52011-09-15 11:53:01 +0300356const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type,
357 const u8 *ies, int len)
358{
359 struct ieee80211_vendor_ie *ie;
360 const u8 *pos = ies, *end = ies + len;
361 int ie_oui;
362
363 while (pos < end) {
364 pos = cfg80211_find_ie(WLAN_EID_VENDOR_SPECIFIC, pos,
365 end - pos);
366 if (!pos)
367 return NULL;
368
Eliad Peller0c28ec52011-09-15 11:53:01 +0300369 ie = (struct ieee80211_vendor_ie *)pos;
Luciano Coelho67194292013-02-12 20:11:38 +0200370
371 /* make sure we can access ie->len */
372 BUILD_BUG_ON(offsetof(struct ieee80211_vendor_ie, len) != 1);
373
374 if (ie->len < sizeof(*ie))
375 goto cont;
376
Eliad Peller0c28ec52011-09-15 11:53:01 +0300377 ie_oui = ie->oui[0] << 16 | ie->oui[1] << 8 | ie->oui[2];
378 if (ie_oui == oui && ie->oui_type == oui_type)
379 return pos;
Luciano Coelho67194292013-02-12 20:11:38 +0200380cont:
Eliad Peller0c28ec52011-09-15 11:53:01 +0300381 pos += 2 + ie->len;
382 }
383 return NULL;
384}
385EXPORT_SYMBOL(cfg80211_find_vendor_ie);
386
Johannes Berg915de2f2012-11-28 22:39:37 +0100387static bool is_bss(struct cfg80211_bss *a, const u8 *bssid,
Johannes Berg2a519312009-02-10 21:25:55 +0100388 const u8 *ssid, size_t ssid_len)
389{
Johannes Berg9caf0362012-11-29 01:25:20 +0100390 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100391 const u8 *ssidie;
392
Joe Perchesac422d32012-05-08 18:56:55 +0000393 if (bssid && !ether_addr_equal(a->bssid, bssid))
Johannes Berg2a519312009-02-10 21:25:55 +0100394 return false;
395
Johannes Berg79420f02009-02-10 21:25:59 +0100396 if (!ssid)
397 return true;
398
Johannes Berg9caf0362012-11-29 01:25:20 +0100399 ies = rcu_access_pointer(a->ies);
400 if (!ies)
401 return false;
402 ssidie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100403 if (!ssidie)
404 return false;
405 if (ssidie[1] != ssid_len)
406 return false;
407 return memcmp(ssidie + 2, ssid, ssid_len) == 0;
408}
409
Johannes Berg4593c4c2013-02-01 19:20:03 +0100410/**
411 * enum bss_compare_mode - BSS compare mode
412 * @BSS_CMP_REGULAR: regular compare mode (for insertion and normal find)
413 * @BSS_CMP_HIDE_ZLEN: find hidden SSID with zero-length mode
414 * @BSS_CMP_HIDE_NUL: find hidden SSID with NUL-ed out mode
415 */
416enum bss_compare_mode {
417 BSS_CMP_REGULAR,
418 BSS_CMP_HIDE_ZLEN,
419 BSS_CMP_HIDE_NUL,
420};
421
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100422static int cmp_bss(struct cfg80211_bss *a,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100423 struct cfg80211_bss *b,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100424 enum bss_compare_mode mode)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100425{
Johannes Berg9caf0362012-11-29 01:25:20 +0100426 const struct cfg80211_bss_ies *a_ies, *b_ies;
Johannes Berg3af63412013-01-30 00:40:20 +0100427 const u8 *ie1 = NULL;
428 const u8 *ie2 = NULL;
Johannes Berg5622f5b2013-01-30 00:26:45 +0100429 int i, r;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100430
Johannes Berg3af63412013-01-30 00:40:20 +0100431 if (a->channel != b->channel)
432 return b->channel->center_freq - a->channel->center_freq;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100433
Johannes Berg9caf0362012-11-29 01:25:20 +0100434 a_ies = rcu_access_pointer(a->ies);
435 if (!a_ies)
436 return -1;
437 b_ies = rcu_access_pointer(b->ies);
438 if (!b_ies)
439 return 1;
440
Johannes Berg3af63412013-01-30 00:40:20 +0100441 if (WLAN_CAPABILITY_IS_STA_BSS(a->capability))
442 ie1 = cfg80211_find_ie(WLAN_EID_MESH_ID,
443 a_ies->data, a_ies->len);
444 if (WLAN_CAPABILITY_IS_STA_BSS(b->capability))
445 ie2 = cfg80211_find_ie(WLAN_EID_MESH_ID,
446 b_ies->data, b_ies->len);
447 if (ie1 && ie2) {
448 int mesh_id_cmp;
449
450 if (ie1[1] == ie2[1])
451 mesh_id_cmp = memcmp(ie1 + 2, ie2 + 2, ie1[1]);
452 else
453 mesh_id_cmp = ie2[1] - ie1[1];
454
455 ie1 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
456 a_ies->data, a_ies->len);
457 ie2 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
458 b_ies->data, b_ies->len);
459 if (ie1 && ie2) {
460 if (mesh_id_cmp)
461 return mesh_id_cmp;
462 if (ie1[1] != ie2[1])
463 return ie2[1] - ie1[1];
464 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
465 }
466 }
467
468 /*
469 * we can't use compare_ether_addr here since we need a < > operator.
470 * The binary return value of compare_ether_addr isn't enough
471 */
472 r = memcmp(a->bssid, b->bssid, sizeof(a->bssid));
473 if (r)
474 return r;
475
Johannes Berg9caf0362012-11-29 01:25:20 +0100476 ie1 = cfg80211_find_ie(WLAN_EID_SSID, a_ies->data, a_ies->len);
477 ie2 = cfg80211_find_ie(WLAN_EID_SSID, b_ies->data, b_ies->len);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100478
Johannes Berg5622f5b2013-01-30 00:26:45 +0100479 if (!ie1 && !ie2)
480 return 0;
481
Johannes Bergf94f8b12012-11-28 22:42:34 +0100482 /*
Johannes Berg5622f5b2013-01-30 00:26:45 +0100483 * Note that with "hide_ssid", the function returns a match if
484 * the already-present BSS ("b") is a hidden SSID beacon for
485 * the new BSS ("a").
Johannes Bergf94f8b12012-11-28 22:42:34 +0100486 */
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100487
488 /* sort missing IE before (left of) present IE */
489 if (!ie1)
490 return -1;
491 if (!ie2)
492 return 1;
493
Johannes Berg4593c4c2013-02-01 19:20:03 +0100494 switch (mode) {
495 case BSS_CMP_HIDE_ZLEN:
496 /*
497 * In ZLEN mode we assume the BSS entry we're
498 * looking for has a zero-length SSID. So if
499 * the one we're looking at right now has that,
500 * return 0. Otherwise, return the difference
501 * in length, but since we're looking for the
502 * 0-length it's really equivalent to returning
503 * the length of the one we're looking at.
504 *
505 * No content comparison is needed as we assume
506 * the content length is zero.
507 */
508 return ie2[1];
509 case BSS_CMP_REGULAR:
510 default:
511 /* sort by length first, then by contents */
512 if (ie1[1] != ie2[1])
513 return ie2[1] - ie1[1];
Johannes Berg5622f5b2013-01-30 00:26:45 +0100514 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100515 case BSS_CMP_HIDE_NUL:
516 if (ie1[1] != ie2[1])
517 return ie2[1] - ie1[1];
518 /* this is equivalent to memcmp(zeroes, ie2 + 2, len) */
519 for (i = 0; i < ie2[1]; i++)
520 if (ie2[i + 2])
521 return -1;
522 return 0;
523 }
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100524}
525
Ben Greear0e3a39b2013-06-19 14:06:27 -0700526/* Returned bss is reference counted and must be cleaned up appropriately. */
Johannes Berg2a519312009-02-10 21:25:55 +0100527struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
528 struct ieee80211_channel *channel,
529 const u8 *bssid,
Johannes Berg79420f02009-02-10 21:25:59 +0100530 const u8 *ssid, size_t ssid_len,
531 u16 capa_mask, u16 capa_val)
Johannes Berg2a519312009-02-10 21:25:55 +0100532{
533 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
534 struct cfg80211_internal_bss *bss, *res = NULL;
Johannes Bergccb6c132010-07-13 10:55:38 +0200535 unsigned long now = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100536
Beni Lev4ee3e062012-08-27 12:49:39 +0300537 trace_cfg80211_get_bss(wiphy, channel, bssid, ssid, ssid_len, capa_mask,
538 capa_val);
539
Johannes Berg2a519312009-02-10 21:25:55 +0100540 spin_lock_bh(&dev->bss_lock);
541
542 list_for_each_entry(bss, &dev->bss_list, list) {
Johannes Berg79420f02009-02-10 21:25:59 +0100543 if ((bss->pub.capability & capa_mask) != capa_val)
544 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100545 if (channel && bss->pub.channel != channel)
546 continue;
Johannes Bergccb6c132010-07-13 10:55:38 +0200547 /* Don't get expired BSS structs */
548 if (time_after(now, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE) &&
549 !atomic_read(&bss->hold))
550 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100551 if (is_bss(&bss->pub, bssid, ssid, ssid_len)) {
552 res = bss;
Johannes Berg776b3582013-02-01 02:06:18 +0100553 bss_ref_get(dev, res);
Johannes Berg2a519312009-02-10 21:25:55 +0100554 break;
555 }
556 }
557
558 spin_unlock_bh(&dev->bss_lock);
559 if (!res)
560 return NULL;
Beni Lev4ee3e062012-08-27 12:49:39 +0300561 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100562 return &res->pub;
563}
564EXPORT_SYMBOL(cfg80211_get_bss);
565
Johannes Berg2a519312009-02-10 21:25:55 +0100566static void rb_insert_bss(struct cfg80211_registered_device *dev,
567 struct cfg80211_internal_bss *bss)
568{
569 struct rb_node **p = &dev->bss_tree.rb_node;
570 struct rb_node *parent = NULL;
571 struct cfg80211_internal_bss *tbss;
572 int cmp;
573
574 while (*p) {
575 parent = *p;
576 tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn);
577
Johannes Berg4593c4c2013-02-01 19:20:03 +0100578 cmp = cmp_bss(&bss->pub, &tbss->pub, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100579
580 if (WARN_ON(!cmp)) {
581 /* will sort of leak this BSS */
582 return;
583 }
584
585 if (cmp < 0)
586 p = &(*p)->rb_left;
587 else
588 p = &(*p)->rb_right;
589 }
590
591 rb_link_node(&bss->rbn, parent, p);
592 rb_insert_color(&bss->rbn, &dev->bss_tree);
593}
594
595static struct cfg80211_internal_bss *
596rb_find_bss(struct cfg80211_registered_device *dev,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100597 struct cfg80211_internal_bss *res,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100598 enum bss_compare_mode mode)
Johannes Berg2a519312009-02-10 21:25:55 +0100599{
600 struct rb_node *n = dev->bss_tree.rb_node;
601 struct cfg80211_internal_bss *bss;
602 int r;
603
604 while (n) {
605 bss = rb_entry(n, struct cfg80211_internal_bss, rbn);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100606 r = cmp_bss(&res->pub, &bss->pub, mode);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100607
608 if (r == 0)
609 return bss;
610 else if (r < 0)
611 n = n->rb_left;
612 else
613 n = n->rb_right;
614 }
615
616 return NULL;
617}
618
Johannes Berg776b3582013-02-01 02:06:18 +0100619static bool cfg80211_combine_bsses(struct cfg80211_registered_device *dev,
620 struct cfg80211_internal_bss *new)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100621{
Johannes Berg9caf0362012-11-29 01:25:20 +0100622 const struct cfg80211_bss_ies *ies;
Johannes Berg776b3582013-02-01 02:06:18 +0100623 struct cfg80211_internal_bss *bss;
624 const u8 *ie;
625 int i, ssidlen;
626 u8 fold = 0;
Johannes Berg9caf0362012-11-29 01:25:20 +0100627
Johannes Berg776b3582013-02-01 02:06:18 +0100628 ies = rcu_access_pointer(new->pub.beacon_ies);
Johannes Berg9caf0362012-11-29 01:25:20 +0100629 if (WARN_ON(!ies))
Johannes Berg776b3582013-02-01 02:06:18 +0100630 return false;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100631
Johannes Berg776b3582013-02-01 02:06:18 +0100632 ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
633 if (!ie) {
634 /* nothing to do */
635 return true;
636 }
637
638 ssidlen = ie[1];
639 for (i = 0; i < ssidlen; i++)
640 fold |= ie[2 + i];
641
642 if (fold) {
643 /* not a hidden SSID */
644 return true;
645 }
646
647 /* This is the bad part ... */
648
649 list_for_each_entry(bss, &dev->bss_list, list) {
650 if (!ether_addr_equal(bss->pub.bssid, new->pub.bssid))
651 continue;
652 if (bss->pub.channel != new->pub.channel)
653 continue;
654 if (rcu_access_pointer(bss->pub.beacon_ies))
655 continue;
656 ies = rcu_access_pointer(bss->pub.ies);
657 if (!ies)
658 continue;
659 ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
660 if (!ie)
661 continue;
662 if (ssidlen && ie[1] != ssidlen)
663 continue;
664 /* that would be odd ... */
665 if (bss->pub.beacon_ies)
666 continue;
667 if (WARN_ON_ONCE(bss->pub.hidden_beacon_bss))
668 continue;
669 if (WARN_ON_ONCE(!list_empty(&bss->hidden_list)))
670 list_del(&bss->hidden_list);
671 /* combine them */
672 list_add(&bss->hidden_list, &new->hidden_list);
673 bss->pub.hidden_beacon_bss = &new->pub;
674 new->refcount += bss->refcount;
675 rcu_assign_pointer(bss->pub.beacon_ies,
676 new->pub.beacon_ies);
677 }
678
679 return true;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100680}
681
Ben Greear0e3a39b2013-06-19 14:06:27 -0700682/* Returned bss is reference counted and must be cleaned up appropriately. */
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100683static struct cfg80211_internal_bss *
Johannes Berg2a519312009-02-10 21:25:55 +0100684cfg80211_bss_update(struct cfg80211_registered_device *dev,
Johannes Berg9caf0362012-11-29 01:25:20 +0100685 struct cfg80211_internal_bss *tmp)
Johannes Berg2a519312009-02-10 21:25:55 +0100686{
687 struct cfg80211_internal_bss *found = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100688
Johannes Berg9caf0362012-11-29 01:25:20 +0100689 if (WARN_ON(!tmp->pub.channel))
Johannes Berg2a519312009-02-10 21:25:55 +0100690 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100691
Johannes Berg9caf0362012-11-29 01:25:20 +0100692 tmp->ts = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100693
Johannes Berg2a519312009-02-10 21:25:55 +0100694 spin_lock_bh(&dev->bss_lock);
695
Johannes Berg9caf0362012-11-29 01:25:20 +0100696 if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) {
697 spin_unlock_bh(&dev->bss_lock);
698 return NULL;
699 }
700
Johannes Berg4593c4c2013-02-01 19:20:03 +0100701 found = rb_find_bss(dev, tmp, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100702
Johannes Bergcd1658f2009-04-16 15:00:58 +0200703 if (found) {
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200704 /* Update IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100705 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
706 const struct cfg80211_bss_ies *old;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200707
Johannes Berg9caf0362012-11-29 01:25:20 +0100708 old = rcu_access_pointer(found->pub.proberesp_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200709
Johannes Berg9caf0362012-11-29 01:25:20 +0100710 rcu_assign_pointer(found->pub.proberesp_ies,
711 tmp->pub.proberesp_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200712 /* Override possible earlier Beacon frame IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100713 rcu_assign_pointer(found->pub.ies,
714 tmp->pub.proberesp_ies);
715 if (old)
716 kfree_rcu((struct cfg80211_bss_ies *)old,
717 rcu_head);
718 } else if (rcu_access_pointer(tmp->pub.beacon_ies)) {
Johannes Berg9537f222013-02-01 01:19:48 +0100719 const struct cfg80211_bss_ies *old;
Johannes Berg776b3582013-02-01 02:06:18 +0100720 struct cfg80211_internal_bss *bss;
721
722 if (found->pub.hidden_beacon_bss &&
723 !list_empty(&found->hidden_list)) {
Johannes Berg1345ee62013-03-06 10:31:05 +0100724 const struct cfg80211_bss_ies *f;
725
Johannes Berg776b3582013-02-01 02:06:18 +0100726 /*
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 */
Johannes Berg1345ee62013-03-06 10:31:05 +0100735
736 f = rcu_access_pointer(tmp->pub.beacon_ies);
737 kfree_rcu((struct cfg80211_bss_ies *)f,
738 rcu_head);
Johannes Berg776b3582013-02-01 02:06:18 +0100739 goto drop;
740 }
Johannes Berg915de2f2012-11-28 22:39:37 +0100741
Johannes Berg9caf0362012-11-29 01:25:20 +0100742 old = rcu_access_pointer(found->pub.beacon_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200743
Johannes Berg9caf0362012-11-29 01:25:20 +0100744 rcu_assign_pointer(found->pub.beacon_ies,
745 tmp->pub.beacon_ies);
Sven Neumann01123e22010-12-09 15:05:24 +0100746
747 /* Override IEs if they were from a beacon before */
Johannes Berg9537f222013-02-01 01:19:48 +0100748 if (old == rcu_access_pointer(found->pub.ies))
Johannes Berg9caf0362012-11-29 01:25:20 +0100749 rcu_assign_pointer(found->pub.ies,
750 tmp->pub.beacon_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200751
Johannes Berg776b3582013-02-01 02:06:18 +0100752 /* Assign beacon IEs to all sub entries */
753 list_for_each_entry(bss, &found->hidden_list,
754 hidden_list) {
755 const struct cfg80211_bss_ies *ies;
756
757 ies = rcu_access_pointer(bss->pub.beacon_ies);
758 WARN_ON(ies != old);
759
760 rcu_assign_pointer(bss->pub.beacon_ies,
761 tmp->pub.beacon_ies);
762 }
763
Johannes Berg9caf0362012-11-29 01:25:20 +0100764 if (old)
765 kfree_rcu((struct cfg80211_bss_ies *)old,
766 rcu_head);
767 }
Johannes Berg1345ee62013-03-06 10:31:05 +0100768
769 found->pub.beacon_interval = tmp->pub.beacon_interval;
770 found->pub.signal = tmp->pub.signal;
771 found->pub.capability = tmp->pub.capability;
772 found->ts = tmp->ts;
Johannes Berg2a519312009-02-10 21:25:55 +0100773 } else {
Johannes Berg9caf0362012-11-29 01:25:20 +0100774 struct cfg80211_internal_bss *new;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100775 struct cfg80211_internal_bss *hidden;
Johannes Berg9caf0362012-11-29 01:25:20 +0100776 struct cfg80211_bss_ies *ies;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100777
Johannes Berg9caf0362012-11-29 01:25:20 +0100778 /*
779 * create a copy -- the "res" variable that is passed in
780 * is allocated on the stack since it's not needed in the
781 * more common case of an update
782 */
783 new = kzalloc(sizeof(*new) + dev->wiphy.bss_priv_size,
784 GFP_ATOMIC);
785 if (!new) {
786 ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
787 if (ies)
788 kfree_rcu(ies, rcu_head);
789 ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
790 if (ies)
791 kfree_rcu(ies, rcu_head);
Johannes Berg776b3582013-02-01 02:06:18 +0100792 goto drop;
Johannes Berg9caf0362012-11-29 01:25:20 +0100793 }
794 memcpy(new, tmp, sizeof(*new));
Johannes Berg776b3582013-02-01 02:06:18 +0100795 new->refcount = 1;
796 INIT_LIST_HEAD(&new->hidden_list);
797
798 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
799 hidden = rb_find_bss(dev, tmp, BSS_CMP_HIDE_ZLEN);
800 if (!hidden)
801 hidden = rb_find_bss(dev, tmp,
802 BSS_CMP_HIDE_NUL);
803 if (hidden) {
804 new->pub.hidden_beacon_bss = &hidden->pub;
805 list_add(&new->hidden_list,
806 &hidden->hidden_list);
807 hidden->refcount++;
808 rcu_assign_pointer(new->pub.beacon_ies,
809 hidden->pub.beacon_ies);
810 }
811 } else {
812 /*
813 * Ok so we found a beacon, and don't have an entry. If
814 * it's a beacon with hidden SSID, we might be in for an
815 * expensive search for any probe responses that should
816 * be grouped with this beacon for updates ...
817 */
818 if (!cfg80211_combine_bsses(dev, new)) {
819 kfree(new);
820 goto drop;
821 }
822 }
823
Johannes Berg9caf0362012-11-29 01:25:20 +0100824 list_add_tail(&new->list, &dev->bss_list);
825 rb_insert_bss(dev, new);
826 found = new;
Johannes Berg2a519312009-02-10 21:25:55 +0100827 }
828
829 dev->bss_generation++;
Johannes Berg776b3582013-02-01 02:06:18 +0100830 bss_ref_get(dev, found);
Johannes Berg2a519312009-02-10 21:25:55 +0100831 spin_unlock_bh(&dev->bss_lock);
832
Johannes Berg2a519312009-02-10 21:25:55 +0100833 return found;
Johannes Berg776b3582013-02-01 02:06:18 +0100834 drop:
835 spin_unlock_bh(&dev->bss_lock);
836 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100837}
838
Johannes Berg0172bb72012-11-23 14:23:30 +0100839static struct ieee80211_channel *
840cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
841 struct ieee80211_channel *channel)
842{
843 const u8 *tmp;
844 u32 freq;
845 int channel_number = -1;
846
847 tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
848 if (tmp && tmp[1] == 1) {
849 channel_number = tmp[2];
850 } else {
851 tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
852 if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
853 struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
854
855 channel_number = htop->primary_chan;
856 }
857 }
858
859 if (channel_number < 0)
860 return channel;
861
862 freq = ieee80211_channel_to_frequency(channel_number, channel->band);
863 channel = ieee80211_get_channel(wiphy, freq);
864 if (!channel)
865 return NULL;
866 if (channel->flags & IEEE80211_CHAN_DISABLED)
867 return NULL;
868 return channel;
869}
870
Ben Greear0e3a39b2013-06-19 14:06:27 -0700871/* Returned bss is reference counted and must be cleaned up appropriately. */
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200872struct cfg80211_bss*
873cfg80211_inform_bss(struct wiphy *wiphy,
874 struct ieee80211_channel *channel,
Johannes Berg7b8bcff2012-03-13 13:57:04 +0100875 const u8 *bssid, u64 tsf, u16 capability,
876 u16 beacon_interval, const u8 *ie, size_t ielen,
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200877 s32 signal, gfp_t gfp)
878{
Johannes Berg9caf0362012-11-29 01:25:20 +0100879 struct cfg80211_bss_ies *ies;
880 struct cfg80211_internal_bss tmp = {}, *res;
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200881
882 if (WARN_ON(!wiphy))
883 return NULL;
884
Sujith22fe88d2010-05-13 10:34:08 +0530885 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200886 (signal < 0 || signal > 100)))
887 return NULL;
888
Johannes Berg0172bb72012-11-23 14:23:30 +0100889 channel = cfg80211_get_bss_channel(wiphy, ie, ielen, channel);
890 if (!channel)
891 return NULL;
892
Johannes Berg9caf0362012-11-29 01:25:20 +0100893 memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
894 tmp.pub.channel = channel;
895 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100896 tmp.pub.beacon_interval = beacon_interval;
897 tmp.pub.capability = capability;
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200898 /*
899 * Since we do not know here whether the IEs are from a Beacon or Probe
900 * Response frame, we need to pick one of the options and only use it
901 * with the driver that does not provide the full Beacon/Probe Response
902 * frame. Use Beacon frame pointer to avoid indicating that this should
Johannes Berg50521aa2013-01-30 21:33:19 +0100903 * override the IEs pointer should we have received an earlier
Johannes Berg9caf0362012-11-29 01:25:20 +0100904 * indication of Probe Response data.
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200905 */
Johannes Berg9caf0362012-11-29 01:25:20 +0100906 ies = kmalloc(sizeof(*ies) + ielen, gfp);
907 if (!ies)
908 return NULL;
909 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100910 ies->tsf = tsf;
Johannes Berg9caf0362012-11-29 01:25:20 +0100911 memcpy(ies->data, ie, ielen);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200912
Johannes Berg9caf0362012-11-29 01:25:20 +0100913 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
914 rcu_assign_pointer(tmp.pub.ies, ies);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200915
Johannes Berg9caf0362012-11-29 01:25:20 +0100916 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200917 if (!res)
918 return NULL;
919
920 if (res->pub.capability & WLAN_CAPABILITY_ESS)
921 regulatory_hint_found_beacon(wiphy, channel, gfp);
922
Beni Lev4ee3e062012-08-27 12:49:39 +0300923 trace_cfg80211_return_bss(&res->pub);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200924 /* cfg80211_bss_update gives us a referenced result */
925 return &res->pub;
926}
927EXPORT_SYMBOL(cfg80211_inform_bss);
928
Ben Greear0e3a39b2013-06-19 14:06:27 -0700929/* Returned bss is reference counted and must be cleaned up appropriately. */
Johannes Berg2a519312009-02-10 21:25:55 +0100930struct cfg80211_bss *
931cfg80211_inform_bss_frame(struct wiphy *wiphy,
932 struct ieee80211_channel *channel,
933 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg77965c92009-02-18 18:45:06 +0100934 s32 signal, gfp_t gfp)
Johannes Berg2a519312009-02-10 21:25:55 +0100935{
Johannes Berg9caf0362012-11-29 01:25:20 +0100936 struct cfg80211_internal_bss tmp = {}, *res;
937 struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100938 size_t ielen = len - offsetof(struct ieee80211_mgmt,
939 u.probe_resp.variable);
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100940
Johannes Berg0172bb72012-11-23 14:23:30 +0100941 BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
942 offsetof(struct ieee80211_mgmt, u.beacon.variable));
943
Beni Lev4ee3e062012-08-27 12:49:39 +0300944 trace_cfg80211_inform_bss_frame(wiphy, channel, mgmt, len, signal);
945
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100946 if (WARN_ON(!mgmt))
947 return NULL;
948
949 if (WARN_ON(!wiphy))
950 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100951
Sujith22fe88d2010-05-13 10:34:08 +0530952 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Hila Gonen768be592012-08-26 11:00:28 +0300953 (signal < 0 || signal > 100)))
Johannes Berg2a519312009-02-10 21:25:55 +0100954 return NULL;
955
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100956 if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
Johannes Berg2a519312009-02-10 21:25:55 +0100957 return NULL;
958
Johannes Berg0172bb72012-11-23 14:23:30 +0100959 channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
960 ielen, channel);
961 if (!channel)
962 return NULL;
963
Johannes Berg9caf0362012-11-29 01:25:20 +0100964 ies = kmalloc(sizeof(*ies) + ielen, gfp);
965 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +0100966 return NULL;
Johannes Berg9caf0362012-11-29 01:25:20 +0100967 ies->len = ielen;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100968 ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
Johannes Berg9caf0362012-11-29 01:25:20 +0100969 memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
Johannes Berg2a519312009-02-10 21:25:55 +0100970
Johannes Berg9caf0362012-11-29 01:25:20 +0100971 if (ieee80211_is_probe_resp(mgmt->frame_control))
972 rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
973 else
974 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
975 rcu_assign_pointer(tmp.pub.ies, ies);
976
977 memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
978 tmp.pub.channel = channel;
979 tmp.pub.signal = signal;
Johannes Berg9caf0362012-11-29 01:25:20 +0100980 tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
981 tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
Johannes Berg2a519312009-02-10 21:25:55 +0100982
Johannes Berg9caf0362012-11-29 01:25:20 +0100983 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Johannes Berg2a519312009-02-10 21:25:55 +0100984 if (!res)
985 return NULL;
986
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500987 if (res->pub.capability & WLAN_CAPABILITY_ESS)
988 regulatory_hint_found_beacon(wiphy, channel, gfp);
989
Beni Lev4ee3e062012-08-27 12:49:39 +0300990 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100991 /* cfg80211_bss_update gives us a referenced result */
992 return &res->pub;
993}
994EXPORT_SYMBOL(cfg80211_inform_bss_frame);
995
Johannes Berg5b112d32013-02-01 01:49:58 +0100996void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100997{
Johannes Berg776b3582013-02-01 02:06:18 +0100998 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100999 struct cfg80211_internal_bss *bss;
1000
1001 if (!pub)
1002 return;
1003
1004 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +01001005
1006 spin_lock_bh(&dev->bss_lock);
1007 bss_ref_get(dev, bss);
1008 spin_unlock_bh(&dev->bss_lock);
Johannes Berg4c0c0b72012-01-20 13:55:26 +01001009}
1010EXPORT_SYMBOL(cfg80211_ref_bss);
1011
Johannes Berg5b112d32013-02-01 01:49:58 +01001012void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
Johannes Berg2a519312009-02-10 21:25:55 +01001013{
Johannes Berg776b3582013-02-01 02:06:18 +01001014 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
Johannes Berg2a519312009-02-10 21:25:55 +01001015 struct cfg80211_internal_bss *bss;
1016
1017 if (!pub)
1018 return;
1019
1020 bss = container_of(pub, struct cfg80211_internal_bss, pub);
Johannes Berg776b3582013-02-01 02:06:18 +01001021
1022 spin_lock_bh(&dev->bss_lock);
1023 bss_ref_put(dev, bss);
1024 spin_unlock_bh(&dev->bss_lock);
Johannes Berg2a519312009-02-10 21:25:55 +01001025}
1026EXPORT_SYMBOL(cfg80211_put_bss);
1027
Johannes Bergd491af12009-02-10 21:25:58 +01001028void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
1029{
1030 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
1031 struct cfg80211_internal_bss *bss;
1032
1033 if (WARN_ON(!pub))
1034 return;
1035
1036 bss = container_of(pub, struct cfg80211_internal_bss, pub);
1037
1038 spin_lock_bh(&dev->bss_lock);
Johannes Berg32073902010-10-06 21:18:04 +02001039 if (!list_empty(&bss->list)) {
Johannes Berg776b3582013-02-01 02:06:18 +01001040 if (__cfg80211_unlink_bss(dev, bss))
1041 dev->bss_generation++;
Johannes Berg32073902010-10-06 21:18:04 +02001042 }
Johannes Bergd491af12009-02-10 21:25:58 +01001043 spin_unlock_bh(&dev->bss_lock);
Johannes Bergd491af12009-02-10 21:25:58 +01001044}
1045EXPORT_SYMBOL(cfg80211_unlink_bss);
1046
Johannes Berg3d23e342009-09-29 23:27:28 +02001047#ifdef CONFIG_CFG80211_WEXT
Johannes Berg9f419f32013-05-08 21:34:22 +02001048static struct cfg80211_registered_device *
1049cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
1050{
Johannes Berg5fe231e2013-05-08 21:45:15 +02001051 struct cfg80211_registered_device *rdev;
Johannes Berg9f419f32013-05-08 21:34:22 +02001052 struct net_device *dev;
1053
Johannes Berg5fe231e2013-05-08 21:45:15 +02001054 ASSERT_RTNL();
1055
Johannes Berg9f419f32013-05-08 21:34:22 +02001056 dev = dev_get_by_index(net, ifindex);
1057 if (!dev)
Johannes Berg5fe231e2013-05-08 21:45:15 +02001058 return ERR_PTR(-ENODEV);
1059 if (dev->ieee80211_ptr)
Johannes Berg9f419f32013-05-08 21:34:22 +02001060 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
Johannes Berg5fe231e2013-05-08 21:45:15 +02001061 else
Johannes Berg9f419f32013-05-08 21:34:22 +02001062 rdev = ERR_PTR(-ENODEV);
1063 dev_put(dev);
Johannes Berg9f419f32013-05-08 21:34:22 +02001064 return rdev;
1065}
1066
Johannes Berg2a519312009-02-10 21:25:55 +01001067int cfg80211_wext_siwscan(struct net_device *dev,
1068 struct iw_request_info *info,
1069 union iwreq_data *wrqu, char *extra)
1070{
1071 struct cfg80211_registered_device *rdev;
1072 struct wiphy *wiphy;
1073 struct iw_scan_req *wreq = NULL;
Johannes Berg65486c8b2009-12-23 15:33:35 +01001074 struct cfg80211_scan_request *creq = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +01001075 int i, err, n_channels = 0;
1076 enum ieee80211_band band;
1077
1078 if (!netif_running(dev))
1079 return -ENETDOWN;
1080
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001081 if (wrqu->data.length == sizeof(struct iw_scan_req))
1082 wreq = (struct iw_scan_req *)extra;
1083
Johannes Berg463d0182009-07-14 00:33:35 +02001084 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001085
1086 if (IS_ERR(rdev))
1087 return PTR_ERR(rdev);
1088
1089 if (rdev->scan_req) {
1090 err = -EBUSY;
1091 goto out;
1092 }
1093
1094 wiphy = &rdev->wiphy;
1095
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001096 /* Determine number of channels, needed to allocate creq */
1097 if (wreq && wreq->num_channels)
1098 n_channels = wreq->num_channels;
1099 else {
1100 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1101 if (wiphy->bands[band])
1102 n_channels += wiphy->bands[band]->n_channels;
1103 }
Johannes Berg2a519312009-02-10 21:25:55 +01001104
1105 creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
1106 n_channels * sizeof(void *),
1107 GFP_ATOMIC);
1108 if (!creq) {
1109 err = -ENOMEM;
1110 goto out;
1111 }
1112
1113 creq->wiphy = wiphy;
Johannes Bergfd014282012-06-18 19:17:03 +02001114 creq->wdev = dev->ieee80211_ptr;
Johannes Berg5ba63532009-08-07 17:54:07 +02001115 /* SSIDs come after channels */
1116 creq->ssids = (void *)&creq->channels[n_channels];
Johannes Berg2a519312009-02-10 21:25:55 +01001117 creq->n_channels = n_channels;
1118 creq->n_ssids = 1;
Sam Leffler15d60302012-10-11 21:03:34 -07001119 creq->scan_start = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +01001120
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001121 /* translate "Scan on frequencies" request */
Johannes Berg2a519312009-02-10 21:25:55 +01001122 i = 0;
1123 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1124 int j;
Johannes Berg584991d2009-11-02 13:32:03 +01001125
Johannes Berg2a519312009-02-10 21:25:55 +01001126 if (!wiphy->bands[band])
1127 continue;
Johannes Berg584991d2009-11-02 13:32:03 +01001128
Johannes Berg2a519312009-02-10 21:25:55 +01001129 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
Johannes Berg584991d2009-11-02 13:32:03 +01001130 /* ignore disabled channels */
1131 if (wiphy->bands[band]->channels[j].flags &
1132 IEEE80211_CHAN_DISABLED)
1133 continue;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001134
1135 /* If we have a wireless request structure and the
1136 * wireless request specifies frequencies, then search
1137 * for the matching hardware channel.
1138 */
1139 if (wreq && wreq->num_channels) {
1140 int k;
1141 int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
1142 for (k = 0; k < wreq->num_channels; k++) {
Holger Schuriga4e7b732009-09-11 10:13:53 +02001143 int wext_freq = cfg80211_wext_freq(wiphy, &wreq->channel_list[k]);
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001144 if (wext_freq == wiphy_freq)
1145 goto wext_freq_found;
1146 }
1147 goto wext_freq_not_found;
1148 }
1149
1150 wext_freq_found:
Johannes Berg2a519312009-02-10 21:25:55 +01001151 creq->channels[i] = &wiphy->bands[band]->channels[j];
1152 i++;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001153 wext_freq_not_found: ;
Johannes Berg2a519312009-02-10 21:25:55 +01001154 }
1155 }
Holger Schurig8862dc52009-09-11 10:13:55 +02001156 /* No channels found? */
1157 if (!i) {
1158 err = -EINVAL;
1159 goto out;
1160 }
Johannes Berg2a519312009-02-10 21:25:55 +01001161
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001162 /* Set real number of channels specified in creq->channels[] */
1163 creq->n_channels = i;
Johannes Berg2a519312009-02-10 21:25:55 +01001164
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001165 /* translate "Scan for SSID" request */
1166 if (wreq) {
Johannes Berg2a519312009-02-10 21:25:55 +01001167 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
Johannes Berg65486c8b2009-12-23 15:33:35 +01001168 if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
1169 err = -EINVAL;
1170 goto out;
1171 }
Johannes Berg2a519312009-02-10 21:25:55 +01001172 memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
1173 creq->ssids[0].ssid_len = wreq->essid_len;
1174 }
1175 if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
1176 creq->n_ssids = 0;
1177 }
1178
Johannes Berg34850ab2011-07-18 18:08:35 +02001179 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
Johannes Berga401d2b2011-07-20 00:52:16 +02001180 if (wiphy->bands[i])
1181 creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
Johannes Berg34850ab2011-07-18 18:08:35 +02001182
Johannes Berg2a519312009-02-10 21:25:55 +01001183 rdev->scan_req = creq;
Hila Gonene35e4d22012-06-27 17:19:42 +03001184 err = rdev_scan(rdev, creq);
Johannes Berg2a519312009-02-10 21:25:55 +01001185 if (err) {
1186 rdev->scan_req = NULL;
Johannes Berg65486c8b2009-12-23 15:33:35 +01001187 /* creq will be freed below */
Johannes Berg463d0182009-07-14 00:33:35 +02001188 } else {
Johannes Bergfd014282012-06-18 19:17:03 +02001189 nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
Johannes Berg65486c8b2009-12-23 15:33:35 +01001190 /* creq now owned by driver */
1191 creq = NULL;
Johannes Berg463d0182009-07-14 00:33:35 +02001192 dev_hold(dev);
1193 }
Johannes Berg2a519312009-02-10 21:25:55 +01001194 out:
Johannes Berg65486c8b2009-12-23 15:33:35 +01001195 kfree(creq);
Johannes Berg2a519312009-02-10 21:25:55 +01001196 return err;
1197}
Johannes Bergba44cb72009-04-20 18:49:39 +02001198EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001199
1200static void ieee80211_scan_add_ies(struct iw_request_info *info,
Johannes Berg9caf0362012-11-29 01:25:20 +01001201 const struct cfg80211_bss_ies *ies,
Johannes Berg2a519312009-02-10 21:25:55 +01001202 char **current_ev, char *end_buf)
1203{
Johannes Berg9caf0362012-11-29 01:25:20 +01001204 const u8 *pos, *end, *next;
Johannes Berg2a519312009-02-10 21:25:55 +01001205 struct iw_event iwe;
1206
Johannes Berg9caf0362012-11-29 01:25:20 +01001207 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +01001208 return;
1209
1210 /*
1211 * If needed, fragment the IEs buffer (at IE boundaries) into short
1212 * enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
1213 */
Johannes Berg9caf0362012-11-29 01:25:20 +01001214 pos = ies->data;
1215 end = pos + ies->len;
Johannes Berg2a519312009-02-10 21:25:55 +01001216
1217 while (end - pos > IW_GENERIC_IE_MAX) {
1218 next = pos + 2 + pos[1];
1219 while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
1220 next = next + 2 + next[1];
1221
1222 memset(&iwe, 0, sizeof(iwe));
1223 iwe.cmd = IWEVGENIE;
1224 iwe.u.data.length = next - pos;
1225 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001226 end_buf, &iwe,
1227 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001228
1229 pos = next;
1230 }
1231
1232 if (end > pos) {
1233 memset(&iwe, 0, sizeof(iwe));
1234 iwe.cmd = IWEVGENIE;
1235 iwe.u.data.length = end - pos;
1236 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001237 end_buf, &iwe,
1238 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001239 }
1240}
1241
Johannes Berg2a519312009-02-10 21:25:55 +01001242static char *
Johannes Berg77965c92009-02-18 18:45:06 +01001243ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
1244 struct cfg80211_internal_bss *bss, char *current_ev,
1245 char *end_buf)
Johannes Berg2a519312009-02-10 21:25:55 +01001246{
Johannes Berg9caf0362012-11-29 01:25:20 +01001247 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +01001248 struct iw_event iwe;
Johannes Berg9caf0362012-11-29 01:25:20 +01001249 const u8 *ie;
Johannes Berg2a519312009-02-10 21:25:55 +01001250 u8 *buf, *cfg, *p;
Johannes Berg9caf0362012-11-29 01:25:20 +01001251 int rem, i, sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001252 bool ismesh = false;
1253
1254 memset(&iwe, 0, sizeof(iwe));
1255 iwe.cmd = SIOCGIWAP;
1256 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1257 memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
1258 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1259 IW_EV_ADDR_LEN);
1260
1261 memset(&iwe, 0, sizeof(iwe));
1262 iwe.cmd = SIOCGIWFREQ;
1263 iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
1264 iwe.u.freq.e = 0;
1265 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1266 IW_EV_FREQ_LEN);
1267
1268 memset(&iwe, 0, sizeof(iwe));
1269 iwe.cmd = SIOCGIWFREQ;
1270 iwe.u.freq.m = bss->pub.channel->center_freq;
1271 iwe.u.freq.e = 6;
1272 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1273 IW_EV_FREQ_LEN);
1274
Johannes Berg77965c92009-02-18 18:45:06 +01001275 if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
Johannes Berg2a519312009-02-10 21:25:55 +01001276 memset(&iwe, 0, sizeof(iwe));
1277 iwe.cmd = IWEVQUAL;
1278 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
1279 IW_QUAL_NOISE_INVALID |
Johannes Berga77b8552009-02-18 18:27:22 +01001280 IW_QUAL_QUAL_UPDATED;
Johannes Berg77965c92009-02-18 18:45:06 +01001281 switch (wiphy->signal_type) {
Johannes Berg2a519312009-02-10 21:25:55 +01001282 case CFG80211_SIGNAL_TYPE_MBM:
Johannes Berga77b8552009-02-18 18:27:22 +01001283 sig = bss->pub.signal / 100;
1284 iwe.u.qual.level = sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001285 iwe.u.qual.updated |= IW_QUAL_DBM;
Johannes Berga77b8552009-02-18 18:27:22 +01001286 if (sig < -110) /* rather bad */
1287 sig = -110;
1288 else if (sig > -40) /* perfect */
1289 sig = -40;
1290 /* will give a range of 0 .. 70 */
1291 iwe.u.qual.qual = sig + 110;
Johannes Berg2a519312009-02-10 21:25:55 +01001292 break;
1293 case CFG80211_SIGNAL_TYPE_UNSPEC:
1294 iwe.u.qual.level = bss->pub.signal;
Johannes Berga77b8552009-02-18 18:27:22 +01001295 /* will give range 0 .. 100 */
1296 iwe.u.qual.qual = bss->pub.signal;
Johannes Berg2a519312009-02-10 21:25:55 +01001297 break;
1298 default:
1299 /* not reached */
1300 break;
1301 }
1302 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1303 &iwe, IW_EV_QUAL_LEN);
1304 }
1305
1306 memset(&iwe, 0, sizeof(iwe));
1307 iwe.cmd = SIOCGIWENCODE;
1308 if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
1309 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1310 else
1311 iwe.u.data.flags = IW_ENCODE_DISABLED;
1312 iwe.u.data.length = 0;
1313 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1314 &iwe, "");
1315
Johannes Berg9caf0362012-11-29 01:25:20 +01001316 rcu_read_lock();
1317 ies = rcu_dereference(bss->pub.ies);
Johannes Berg83c7aa12013-02-05 16:51:29 +01001318 rem = ies->len;
1319 ie = ies->data;
Johannes Berg9caf0362012-11-29 01:25:20 +01001320
Johannes Berg83c7aa12013-02-05 16:51:29 +01001321 while (rem >= 2) {
Johannes Berg2a519312009-02-10 21:25:55 +01001322 /* invalid data */
1323 if (ie[1] > rem - 2)
1324 break;
1325
1326 switch (ie[0]) {
1327 case WLAN_EID_SSID:
1328 memset(&iwe, 0, sizeof(iwe));
1329 iwe.cmd = SIOCGIWESSID;
1330 iwe.u.data.length = ie[1];
1331 iwe.u.data.flags = 1;
1332 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001333 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001334 break;
1335 case WLAN_EID_MESH_ID:
1336 memset(&iwe, 0, sizeof(iwe));
1337 iwe.cmd = SIOCGIWESSID;
1338 iwe.u.data.length = ie[1];
1339 iwe.u.data.flags = 1;
1340 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001341 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001342 break;
1343 case WLAN_EID_MESH_CONFIG:
1344 ismesh = true;
Rui Paulo136cfa22009-11-18 18:40:00 +00001345 if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
Johannes Berg2a519312009-02-10 21:25:55 +01001346 break;
1347 buf = kmalloc(50, GFP_ATOMIC);
1348 if (!buf)
1349 break;
Johannes Berg9caf0362012-11-29 01:25:20 +01001350 cfg = (u8 *)ie + 2;
Johannes Berg2a519312009-02-10 21:25:55 +01001351 memset(&iwe, 0, sizeof(iwe));
1352 iwe.cmd = IWEVCUSTOM;
Rui Paulo76aa5e72009-11-18 18:22:59 +00001353 sprintf(buf, "Mesh Network Path Selection Protocol ID: "
1354 "0x%02X", cfg[0]);
Johannes Berg2a519312009-02-10 21:25:55 +01001355 iwe.u.data.length = strlen(buf);
1356 current_ev = iwe_stream_add_point(info, current_ev,
1357 end_buf,
1358 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001359 sprintf(buf, "Path Selection Metric ID: 0x%02X",
1360 cfg[1]);
Johannes Berg2a519312009-02-10 21:25:55 +01001361 iwe.u.data.length = strlen(buf);
1362 current_ev = iwe_stream_add_point(info, current_ev,
1363 end_buf,
1364 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001365 sprintf(buf, "Congestion Control Mode ID: 0x%02X",
1366 cfg[2]);
Johannes Berg2a519312009-02-10 21:25:55 +01001367 iwe.u.data.length = strlen(buf);
1368 current_ev = iwe_stream_add_point(info, current_ev,
1369 end_buf,
1370 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001371 sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
Johannes Berg2a519312009-02-10 21:25:55 +01001372 iwe.u.data.length = strlen(buf);
1373 current_ev = iwe_stream_add_point(info, current_ev,
1374 end_buf,
1375 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001376 sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
1377 iwe.u.data.length = strlen(buf);
1378 current_ev = iwe_stream_add_point(info, current_ev,
1379 end_buf,
1380 &iwe, buf);
1381 sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
1382 iwe.u.data.length = strlen(buf);
1383 current_ev = iwe_stream_add_point(info, current_ev,
1384 end_buf,
1385 &iwe, buf);
1386 sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
Johannes Berg2a519312009-02-10 21:25:55 +01001387 iwe.u.data.length = strlen(buf);
1388 current_ev = iwe_stream_add_point(info, current_ev,
1389 end_buf,
1390 &iwe, buf);
1391 kfree(buf);
1392 break;
1393 case WLAN_EID_SUPP_RATES:
1394 case WLAN_EID_EXT_SUPP_RATES:
1395 /* display all supported rates in readable format */
1396 p = current_ev + iwe_stream_lcp_len(info);
1397
1398 memset(&iwe, 0, sizeof(iwe));
1399 iwe.cmd = SIOCGIWRATE;
1400 /* Those two flags are ignored... */
1401 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
1402
1403 for (i = 0; i < ie[1]; i++) {
1404 iwe.u.bitrate.value =
1405 ((ie[i + 2] & 0x7f) * 500000);
1406 p = iwe_stream_add_value(info, current_ev, p,
1407 end_buf, &iwe, IW_EV_PARAM_LEN);
1408 }
1409 current_ev = p;
1410 break;
1411 }
1412 rem -= ie[1] + 2;
1413 ie += ie[1] + 2;
1414 }
1415
Joe Perchesf64f9e72009-11-29 16:55:45 -08001416 if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
1417 ismesh) {
Johannes Berg2a519312009-02-10 21:25:55 +01001418 memset(&iwe, 0, sizeof(iwe));
1419 iwe.cmd = SIOCGIWMODE;
1420 if (ismesh)
1421 iwe.u.mode = IW_MODE_MESH;
1422 else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
1423 iwe.u.mode = IW_MODE_MASTER;
1424 else
1425 iwe.u.mode = IW_MODE_ADHOC;
1426 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1427 &iwe, IW_EV_UINT_LEN);
1428 }
1429
Dan Carpenterc49dc902013-01-24 09:40:00 +03001430 buf = kmalloc(31, GFP_ATOMIC);
Johannes Berg2a519312009-02-10 21:25:55 +01001431 if (buf) {
1432 memset(&iwe, 0, sizeof(iwe));
1433 iwe.cmd = IWEVCUSTOM;
Johannes Berg8cef2c92013-02-05 16:54:31 +01001434 sprintf(buf, "tsf=%016llx", (unsigned long long)(ies->tsf));
Johannes Berg2a519312009-02-10 21:25:55 +01001435 iwe.u.data.length = strlen(buf);
1436 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1437 &iwe, buf);
1438 memset(&iwe, 0, sizeof(iwe));
1439 iwe.cmd = IWEVCUSTOM;
Dan Williamscb3a8ee2009-02-11 17:14:43 -05001440 sprintf(buf, " Last beacon: %ums ago",
1441 elapsed_jiffies_msecs(bss->ts));
Johannes Berg2a519312009-02-10 21:25:55 +01001442 iwe.u.data.length = strlen(buf);
1443 current_ev = iwe_stream_add_point(info, current_ev,
1444 end_buf, &iwe, buf);
1445 kfree(buf);
1446 }
1447
Johannes Berg9caf0362012-11-29 01:25:20 +01001448 ieee80211_scan_add_ies(info, ies, &current_ev, end_buf);
1449 rcu_read_unlock();
Johannes Berg2a519312009-02-10 21:25:55 +01001450
1451 return current_ev;
1452}
1453
1454
1455static int ieee80211_scan_results(struct cfg80211_registered_device *dev,
1456 struct iw_request_info *info,
1457 char *buf, size_t len)
1458{
1459 char *current_ev = buf;
1460 char *end_buf = buf + len;
1461 struct cfg80211_internal_bss *bss;
1462
1463 spin_lock_bh(&dev->bss_lock);
1464 cfg80211_bss_expire(dev);
1465
1466 list_for_each_entry(bss, &dev->bss_list, list) {
1467 if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
1468 spin_unlock_bh(&dev->bss_lock);
1469 return -E2BIG;
1470 }
Johannes Berg77965c92009-02-18 18:45:06 +01001471 current_ev = ieee80211_bss(&dev->wiphy, info, bss,
1472 current_ev, end_buf);
Johannes Berg2a519312009-02-10 21:25:55 +01001473 }
1474 spin_unlock_bh(&dev->bss_lock);
1475 return current_ev - buf;
1476}
1477
1478
1479int cfg80211_wext_giwscan(struct net_device *dev,
1480 struct iw_request_info *info,
1481 struct iw_point *data, char *extra)
1482{
1483 struct cfg80211_registered_device *rdev;
1484 int res;
1485
1486 if (!netif_running(dev))
1487 return -ENETDOWN;
1488
Johannes Berg463d0182009-07-14 00:33:35 +02001489 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001490
1491 if (IS_ERR(rdev))
1492 return PTR_ERR(rdev);
1493
Johannes Berg5fe231e2013-05-08 21:45:15 +02001494 if (rdev->scan_req)
1495 return -EAGAIN;
Johannes Berg2a519312009-02-10 21:25:55 +01001496
1497 res = ieee80211_scan_results(rdev, info, extra, data->length);
1498 data->length = 0;
1499 if (res >= 0) {
1500 data->length = res;
1501 res = 0;
1502 }
1503
Johannes Berg2a519312009-02-10 21:25:55 +01001504 return res;
1505}
Johannes Bergba44cb72009-04-20 18:49:39 +02001506EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001507#endif