blob: d4fe065eeb1129cd227e25929e58520fd0e83b86 [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
Rajkumar Manoharanf9616e02012-04-13 16:38:40 +053022#define IEEE80211_SCAN_RESULT_EXPIRE (30 * HZ)
Johannes Berg2a519312009-02-10 21:25:55 +010023
Amitkumar Karware8e27c62012-10-11 21:03:33 -070024static void bss_release(struct kref *ref)
25{
Johannes Berg9caf0362012-11-29 01:25:20 +010026 struct cfg80211_bss_ies *ies;
Amitkumar Karware8e27c62012-10-11 21:03:33 -070027 struct cfg80211_internal_bss *bss;
28
29 bss = container_of(ref, struct cfg80211_internal_bss, ref);
Johannes Bergb629ea32012-11-28 22:14:56 +010030
31 if (WARN_ON(atomic_read(&bss->hold)))
32 return;
33
Johannes Berg9caf0362012-11-29 01:25:20 +010034 ies = (void *)rcu_access_pointer(bss->pub.beacon_ies);
35 if (ies)
36 kfree_rcu(ies, rcu_head);
37 ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies);
38 if (ies)
39 kfree_rcu(ies, rcu_head);
Amitkumar Karware8e27c62012-10-11 21:03:33 -070040
Amitkumar Karware8e27c62012-10-11 21:03:33 -070041 kfree(bss);
42}
43
44/* must hold dev->bss_lock! */
45static void __cfg80211_unlink_bss(struct cfg80211_registered_device *dev,
46 struct cfg80211_internal_bss *bss)
47{
48 list_del_init(&bss->list);
49 rb_erase(&bss->rbn, &dev->bss_tree);
50 kref_put(&bss->ref, bss_release);
51}
52
Sam Leffler15d60302012-10-11 21:03:34 -070053/* must hold dev->bss_lock! */
54static void __cfg80211_bss_expire(struct cfg80211_registered_device *dev,
55 unsigned long expire_time)
56{
57 struct cfg80211_internal_bss *bss, *tmp;
58 bool expired = false;
59
60 list_for_each_entry_safe(bss, tmp, &dev->bss_list, list) {
61 if (atomic_read(&bss->hold))
62 continue;
63 if (!time_after(expire_time, bss->ts))
64 continue;
65
66 __cfg80211_unlink_bss(dev, bss);
67 expired = true;
68 }
69
70 if (expired)
71 dev->bss_generation++;
72}
73
Johannes Berg01a0ac42009-08-20 21:36:16 +020074void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev, bool leak)
Johannes Berg2a519312009-02-10 21:25:55 +010075{
Johannes Berg667503d2009-07-07 03:56:11 +020076 struct cfg80211_scan_request *request;
Johannes Bergfd014282012-06-18 19:17:03 +020077 struct wireless_dev *wdev;
Johannes Berg3d23e342009-09-29 23:27:28 +020078#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a519312009-02-10 21:25:55 +010079 union iwreq_data wrqu;
80#endif
81
Johannes Berg01a0ac42009-08-20 21:36:16 +020082 ASSERT_RDEV_LOCK(rdev);
83
Johannes Berg667503d2009-07-07 03:56:11 +020084 request = rdev->scan_req;
85
Johannes Berg01a0ac42009-08-20 21:36:16 +020086 if (!request)
87 return;
88
Johannes Bergfd014282012-06-18 19:17:03 +020089 wdev = request->wdev;
Johannes Berg2a519312009-02-10 21:25:55 +010090
Johannes Berg6829c872009-07-02 09:13:27 +020091 /*
92 * This must be before sending the other events!
93 * Otherwise, wpa_supplicant gets completely confused with
94 * wext events.
95 */
Johannes Bergfd014282012-06-18 19:17:03 +020096 if (wdev->netdev)
97 cfg80211_sme_scan_done(wdev->netdev);
Johannes Berg6829c872009-07-02 09:13:27 +020098
Sam Leffler15d60302012-10-11 21:03:34 -070099 if (request->aborted) {
Johannes Bergfd014282012-06-18 19:17:03 +0200100 nl80211_send_scan_aborted(rdev, wdev);
Sam Leffler15d60302012-10-11 21:03:34 -0700101 } else {
102 if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
103 /* flush entries from previous scans */
104 spin_lock_bh(&rdev->bss_lock);
105 __cfg80211_bss_expire(rdev, request->scan_start);
106 spin_unlock_bh(&rdev->bss_lock);
107 }
Johannes Bergfd014282012-06-18 19:17:03 +0200108 nl80211_send_scan_done(rdev, wdev);
Sam Leffler15d60302012-10-11 21:03:34 -0700109 }
Johannes Berg2a519312009-02-10 21:25:55 +0100110
Johannes Berg3d23e342009-09-29 23:27:28 +0200111#ifdef CONFIG_CFG80211_WEXT
Johannes Bergfd014282012-06-18 19:17:03 +0200112 if (wdev->netdev && !request->aborted) {
Johannes Berg2a519312009-02-10 21:25:55 +0100113 memset(&wrqu, 0, sizeof(wrqu));
114
Johannes Bergfd014282012-06-18 19:17:03 +0200115 wireless_send_event(wdev->netdev, SIOCGIWSCAN, &wrqu, NULL);
Johannes Berg2a519312009-02-10 21:25:55 +0100116 }
117#endif
118
Johannes Bergfd014282012-06-18 19:17:03 +0200119 if (wdev->netdev)
120 dev_put(wdev->netdev);
Johannes Berg2a519312009-02-10 21:25:55 +0100121
Johannes Berg36e6fea2009-08-12 22:21:21 +0200122 rdev->scan_req = NULL;
Johannes Berg01a0ac42009-08-20 21:36:16 +0200123
124 /*
125 * OK. If this is invoked with "leak" then we can't
126 * free this ... but we've cleaned it up anyway. The
127 * driver failed to call the scan_done callback, so
128 * all bets are off, it might still be trying to use
129 * the scan request or not ... if it accesses the dev
130 * in there (it shouldn't anyway) then it may crash.
131 */
132 if (!leak)
133 kfree(request);
Johannes Berg2a519312009-02-10 21:25:55 +0100134}
Johannes Berg667503d2009-07-07 03:56:11 +0200135
Johannes Berg36e6fea2009-08-12 22:21:21 +0200136void __cfg80211_scan_done(struct work_struct *wk)
137{
138 struct cfg80211_registered_device *rdev;
139
140 rdev = container_of(wk, struct cfg80211_registered_device,
141 scan_done_wk);
142
143 cfg80211_lock_rdev(rdev);
Johannes Berg01a0ac42009-08-20 21:36:16 +0200144 ___cfg80211_scan_done(rdev, false);
Johannes Berg36e6fea2009-08-12 22:21:21 +0200145 cfg80211_unlock_rdev(rdev);
146}
147
Johannes Berg667503d2009-07-07 03:56:11 +0200148void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted)
149{
Beni Lev4ee3e062012-08-27 12:49:39 +0300150 trace_cfg80211_scan_done(request, aborted);
Johannes Berg667503d2009-07-07 03:56:11 +0200151 WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req);
152
153 request->aborted = aborted;
Alban Browaeyse60d7442009-11-25 15:13:00 +0100154 queue_work(cfg80211_wq, &wiphy_to_dev(request->wiphy)->scan_done_wk);
Johannes Berg667503d2009-07-07 03:56:11 +0200155}
Johannes Berg2a519312009-02-10 21:25:55 +0100156EXPORT_SYMBOL(cfg80211_scan_done);
157
Luciano Coelho807f8a82011-05-11 17:09:35 +0300158void __cfg80211_sched_scan_results(struct work_struct *wk)
159{
160 struct cfg80211_registered_device *rdev;
Sam Leffler15d60302012-10-11 21:03:34 -0700161 struct cfg80211_sched_scan_request *request;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300162
163 rdev = container_of(wk, struct cfg80211_registered_device,
164 sched_scan_results_wk);
165
Sam Leffler15d60302012-10-11 21:03:34 -0700166 request = rdev->sched_scan_req;
167
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300168 mutex_lock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300169
170 /* we don't have sched_scan_req anymore if the scan is stopping */
Sam Leffler15d60302012-10-11 21:03:34 -0700171 if (request) {
172 if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
173 /* flush entries from previous scans */
174 spin_lock_bh(&rdev->bss_lock);
175 __cfg80211_bss_expire(rdev, request->scan_start);
176 spin_unlock_bh(&rdev->bss_lock);
177 request->scan_start =
178 jiffies + msecs_to_jiffies(request->interval);
179 }
180 nl80211_send_sched_scan_results(rdev, request->dev);
181 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300182
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300183 mutex_unlock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300184}
185
186void cfg80211_sched_scan_results(struct wiphy *wiphy)
187{
Beni Lev4ee3e062012-08-27 12:49:39 +0300188 trace_cfg80211_sched_scan_results(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300189 /* ignore if we're not scanning */
190 if (wiphy_to_dev(wiphy)->sched_scan_req)
191 queue_work(cfg80211_wq,
192 &wiphy_to_dev(wiphy)->sched_scan_results_wk);
193}
194EXPORT_SYMBOL(cfg80211_sched_scan_results);
195
Luciano Coelho85a99942011-05-12 16:28:29 +0300196void cfg80211_sched_scan_stopped(struct wiphy *wiphy)
Luciano Coelho807f8a82011-05-11 17:09:35 +0300197{
Luciano Coelho85a99942011-05-12 16:28:29 +0300198 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300199
Beni Lev4ee3e062012-08-27 12:49:39 +0300200 trace_cfg80211_sched_scan_stopped(wiphy);
201
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300202 mutex_lock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300203 __cfg80211_stop_sched_scan(rdev, true);
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300204 mutex_unlock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300205}
Luciano Coelho807f8a82011-05-11 17:09:35 +0300206EXPORT_SYMBOL(cfg80211_sched_scan_stopped);
207
208int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
209 bool driver_initiated)
210{
Luciano Coelho807f8a82011-05-11 17:09:35 +0300211 struct net_device *dev;
212
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300213 lockdep_assert_held(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300214
215 if (!rdev->sched_scan_req)
Luciano Coelho1a84ff72011-07-08 11:16:16 +0300216 return -ENOENT;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300217
218 dev = rdev->sched_scan_req->dev;
219
Luciano Coelho85a99942011-05-12 16:28:29 +0300220 if (!driver_initiated) {
Hila Gonene35e4d22012-06-27 17:19:42 +0300221 int err = rdev_sched_scan_stop(rdev, dev);
Luciano Coelho85a99942011-05-12 16:28:29 +0300222 if (err)
223 return err;
224 }
Luciano Coelho807f8a82011-05-11 17:09:35 +0300225
226 nl80211_send_sched_scan(rdev, dev, NL80211_CMD_SCHED_SCAN_STOPPED);
227
228 kfree(rdev->sched_scan_req);
229 rdev->sched_scan_req = NULL;
230
Jesper Juhl3b4670f2011-06-29 22:49:33 +0200231 return 0;
Luciano Coelho807f8a82011-05-11 17:09:35 +0300232}
233
Johannes Berg2a519312009-02-10 21:25:55 +0100234/* must hold dev->bss_lock! */
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500235void cfg80211_bss_age(struct cfg80211_registered_device *dev,
236 unsigned long age_secs)
237{
238 struct cfg80211_internal_bss *bss;
239 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
240
Johannes Berg915de2f2012-11-28 22:39:37 +0100241 list_for_each_entry(bss, &dev->bss_list, list)
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500242 bss->ts -= age_jiffies;
Dan Williamscb3a8ee2009-02-11 17:14:43 -0500243}
244
Johannes Berg2a519312009-02-10 21:25:55 +0100245void cfg80211_bss_expire(struct cfg80211_registered_device *dev)
246{
Sam Leffler15d60302012-10-11 21:03:34 -0700247 __cfg80211_bss_expire(dev, jiffies - IEEE80211_SCAN_RESULT_EXPIRE);
Johannes Berg2a519312009-02-10 21:25:55 +0100248}
249
Johannes Bergc21dbf92010-01-26 14:15:46 +0100250const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len)
Johannes Berg2a519312009-02-10 21:25:55 +0100251{
Johannes Bergc21dbf92010-01-26 14:15:46 +0100252 while (len > 2 && ies[0] != eid) {
Johannes Berg2a519312009-02-10 21:25:55 +0100253 len -= ies[1] + 2;
254 ies += ies[1] + 2;
255 }
256 if (len < 2)
257 return NULL;
258 if (len < 2 + ies[1])
259 return NULL;
260 return ies;
261}
Johannes Bergc21dbf92010-01-26 14:15:46 +0100262EXPORT_SYMBOL(cfg80211_find_ie);
Johannes Berg2a519312009-02-10 21:25:55 +0100263
Eliad Peller0c28ec52011-09-15 11:53:01 +0300264const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type,
265 const u8 *ies, int len)
266{
267 struct ieee80211_vendor_ie *ie;
268 const u8 *pos = ies, *end = ies + len;
269 int ie_oui;
270
271 while (pos < end) {
272 pos = cfg80211_find_ie(WLAN_EID_VENDOR_SPECIFIC, pos,
273 end - pos);
274 if (!pos)
275 return NULL;
276
277 if (end - pos < sizeof(*ie))
278 return NULL;
279
280 ie = (struct ieee80211_vendor_ie *)pos;
281 ie_oui = ie->oui[0] << 16 | ie->oui[1] << 8 | ie->oui[2];
282 if (ie_oui == oui && ie->oui_type == oui_type)
283 return pos;
284
285 pos += 2 + ie->len;
286 }
287 return NULL;
288}
289EXPORT_SYMBOL(cfg80211_find_vendor_ie);
290
Johannes Berg9caf0362012-11-29 01:25:20 +0100291static int cmp_ies(u8 num, const u8 *ies1, int len1, const u8 *ies2, int len2)
Johannes Berg2a519312009-02-10 21:25:55 +0100292{
Johannes Bergc21dbf92010-01-26 14:15:46 +0100293 const u8 *ie1 = cfg80211_find_ie(num, ies1, len1);
294 const u8 *ie2 = cfg80211_find_ie(num, ies2, len2);
Johannes Berg2a519312009-02-10 21:25:55 +0100295
Johannes Berg3b6ef632011-11-04 11:01:46 +0100296 /* equal if both missing */
Johannes Berg2a519312009-02-10 21:25:55 +0100297 if (!ie1 && !ie2)
298 return 0;
Johannes Berg3b6ef632011-11-04 11:01:46 +0100299 /* sort missing IE before (left of) present IE */
300 if (!ie1)
Johannes Berg2a519312009-02-10 21:25:55 +0100301 return -1;
Johannes Berg3b6ef632011-11-04 11:01:46 +0100302 if (!ie2)
303 return 1;
Johannes Berg2a519312009-02-10 21:25:55 +0100304
Johannes Berg3b6ef632011-11-04 11:01:46 +0100305 /* sort by length first, then by contents */
306 if (ie1[1] != ie2[1])
Johannes Berg2a519312009-02-10 21:25:55 +0100307 return ie2[1] - ie1[1];
Johannes Berg3b6ef632011-11-04 11:01:46 +0100308 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
Johannes Berg2a519312009-02-10 21:25:55 +0100309}
310
Johannes Berg915de2f2012-11-28 22:39:37 +0100311static bool is_bss(struct cfg80211_bss *a, const u8 *bssid,
Johannes Berg2a519312009-02-10 21:25:55 +0100312 const u8 *ssid, size_t ssid_len)
313{
Johannes Berg9caf0362012-11-29 01:25:20 +0100314 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100315 const u8 *ssidie;
316
Joe Perchesac422d32012-05-08 18:56:55 +0000317 if (bssid && !ether_addr_equal(a->bssid, bssid))
Johannes Berg2a519312009-02-10 21:25:55 +0100318 return false;
319
Johannes Berg79420f02009-02-10 21:25:59 +0100320 if (!ssid)
321 return true;
322
Johannes Berg9caf0362012-11-29 01:25:20 +0100323 ies = rcu_access_pointer(a->ies);
324 if (!ies)
325 return false;
326 ssidie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100327 if (!ssidie)
328 return false;
329 if (ssidie[1] != ssid_len)
330 return false;
331 return memcmp(ssidie + 2, ssid, ssid_len) == 0;
332}
333
Eliad Peller333ba732011-05-29 15:53:20 +0300334static bool is_mesh_bss(struct cfg80211_bss *a)
335{
Johannes Berg9caf0362012-11-29 01:25:20 +0100336 const struct cfg80211_bss_ies *ies;
Eliad Peller333ba732011-05-29 15:53:20 +0300337 const u8 *ie;
338
339 if (!WLAN_CAPABILITY_IS_STA_BSS(a->capability))
340 return false;
341
Johannes Berg9caf0362012-11-29 01:25:20 +0100342 ies = rcu_access_pointer(a->ies);
343 if (!ies)
344 return false;
345
346 ie = cfg80211_find_ie(WLAN_EID_MESH_ID, ies->data, ies->len);
Eliad Peller333ba732011-05-29 15:53:20 +0300347 if (!ie)
348 return false;
349
Johannes Berg9caf0362012-11-29 01:25:20 +0100350 ie = cfg80211_find_ie(WLAN_EID_MESH_CONFIG, ies->data, ies->len);
Eliad Peller333ba732011-05-29 15:53:20 +0300351 if (!ie)
352 return false;
353
354 return true;
355}
356
Johannes Berg2a519312009-02-10 21:25:55 +0100357static bool is_mesh(struct cfg80211_bss *a,
358 const u8 *meshid, size_t meshidlen,
359 const u8 *meshcfg)
360{
Johannes Berg9caf0362012-11-29 01:25:20 +0100361 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100362 const u8 *ie;
363
Eliad Peller333ba732011-05-29 15:53:20 +0300364 if (!WLAN_CAPABILITY_IS_STA_BSS(a->capability))
Johannes Berg2a519312009-02-10 21:25:55 +0100365 return false;
366
Johannes Berg9caf0362012-11-29 01:25:20 +0100367 ies = rcu_access_pointer(a->ies);
368 if (!ies)
369 return false;
370
371 ie = cfg80211_find_ie(WLAN_EID_MESH_ID, ies->data, ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100372 if (!ie)
373 return false;
374 if (ie[1] != meshidlen)
375 return false;
376 if (memcmp(ie + 2, meshid, meshidlen))
377 return false;
378
Johannes Berg9caf0362012-11-29 01:25:20 +0100379 ie = cfg80211_find_ie(WLAN_EID_MESH_CONFIG, ies->data, ies->len);
Johannes Bergcd3468b2009-07-29 22:07:44 +0200380 if (!ie)
381 return false;
Rui Paulo136cfa22009-11-18 18:40:00 +0000382 if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
Johannes Berg2a519312009-02-10 21:25:55 +0100383 return false;
384
385 /*
386 * Ignore mesh capability (last two bytes of the IE) when
387 * comparing since that may differ between stations taking
388 * part in the same mesh.
389 */
Rui Paulo136cfa22009-11-18 18:40:00 +0000390 return memcmp(ie + 2, meshcfg,
Johannes Berg915de2f2012-11-28 22:39:37 +0100391 sizeof(struct ieee80211_meshconf_ie) - 2) == 0;
Johannes Berg2a519312009-02-10 21:25:55 +0100392}
393
Johannes Berg915de2f2012-11-28 22:39:37 +0100394static int cmp_bss_core(struct cfg80211_bss *a, struct cfg80211_bss *b)
Johannes Berg2a519312009-02-10 21:25:55 +0100395{
Johannes Berg9caf0362012-11-29 01:25:20 +0100396 const struct cfg80211_bss_ies *a_ies, *b_ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100397 int r;
398
399 if (a->channel != b->channel)
400 return b->channel->center_freq - a->channel->center_freq;
401
Eliad Peller333ba732011-05-29 15:53:20 +0300402 if (is_mesh_bss(a) && is_mesh_bss(b)) {
Johannes Berg9caf0362012-11-29 01:25:20 +0100403 a_ies = rcu_access_pointer(a->ies);
404 if (!a_ies)
405 return -1;
406 b_ies = rcu_access_pointer(b->ies);
407 if (!b_ies)
408 return 1;
409
Johannes Berg2a519312009-02-10 21:25:55 +0100410 r = cmp_ies(WLAN_EID_MESH_ID,
Johannes Berg9caf0362012-11-29 01:25:20 +0100411 a_ies->data, a_ies->len,
412 b_ies->data, b_ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100413 if (r)
414 return r;
415 return cmp_ies(WLAN_EID_MESH_CONFIG,
Johannes Berg9caf0362012-11-29 01:25:20 +0100416 a_ies->data, a_ies->len,
417 b_ies->data, b_ies->len);
Johannes Berg2a519312009-02-10 21:25:55 +0100418 }
419
Emmanuel Grumbachef9456a2012-04-30 10:23:36 +0300420 /*
421 * we can't use compare_ether_addr here since we need a < > operator.
422 * The binary return value of compare_ether_addr isn't enough
423 */
424 return memcmp(a->bssid, b->bssid, sizeof(a->bssid));
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100425}
426
Johannes Berg4593c4c2013-02-01 19:20:03 +0100427/**
428 * enum bss_compare_mode - BSS compare mode
429 * @BSS_CMP_REGULAR: regular compare mode (for insertion and normal find)
430 * @BSS_CMP_HIDE_ZLEN: find hidden SSID with zero-length mode
431 * @BSS_CMP_HIDE_NUL: find hidden SSID with NUL-ed out mode
432 */
433enum bss_compare_mode {
434 BSS_CMP_REGULAR,
435 BSS_CMP_HIDE_ZLEN,
436 BSS_CMP_HIDE_NUL,
437};
438
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100439static int cmp_bss(struct cfg80211_bss *a,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100440 struct cfg80211_bss *b,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100441 enum bss_compare_mode mode)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100442{
Johannes Berg9caf0362012-11-29 01:25:20 +0100443 const struct cfg80211_bss_ies *a_ies, *b_ies;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100444 const u8 *ie1;
445 const u8 *ie2;
Johannes Berg5622f5b2013-01-30 00:26:45 +0100446 int i, r;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100447
448 r = cmp_bss_core(a, b);
449 if (r)
450 return r;
451
Johannes Berg9caf0362012-11-29 01:25:20 +0100452 a_ies = rcu_access_pointer(a->ies);
453 if (!a_ies)
454 return -1;
455 b_ies = rcu_access_pointer(b->ies);
456 if (!b_ies)
457 return 1;
458
459 ie1 = cfg80211_find_ie(WLAN_EID_SSID, a_ies->data, a_ies->len);
460 ie2 = cfg80211_find_ie(WLAN_EID_SSID, b_ies->data, b_ies->len);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100461
Johannes Berg5622f5b2013-01-30 00:26:45 +0100462 if (!ie1 && !ie2)
463 return 0;
464
Johannes Bergf94f8b12012-11-28 22:42:34 +0100465 /*
Johannes Berg5622f5b2013-01-30 00:26:45 +0100466 * Note that with "hide_ssid", the function returns a match if
467 * the already-present BSS ("b") is a hidden SSID beacon for
468 * the new BSS ("a").
Johannes Bergf94f8b12012-11-28 22:42:34 +0100469 */
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100470
471 /* sort missing IE before (left of) present IE */
472 if (!ie1)
473 return -1;
474 if (!ie2)
475 return 1;
476
Johannes Berg4593c4c2013-02-01 19:20:03 +0100477 switch (mode) {
478 case BSS_CMP_HIDE_ZLEN:
479 /*
480 * In ZLEN mode we assume the BSS entry we're
481 * looking for has a zero-length SSID. So if
482 * the one we're looking at right now has that,
483 * return 0. Otherwise, return the difference
484 * in length, but since we're looking for the
485 * 0-length it's really equivalent to returning
486 * the length of the one we're looking at.
487 *
488 * No content comparison is needed as we assume
489 * the content length is zero.
490 */
491 return ie2[1];
492 case BSS_CMP_REGULAR:
493 default:
494 /* sort by length first, then by contents */
495 if (ie1[1] != ie2[1])
496 return ie2[1] - ie1[1];
Johannes Berg5622f5b2013-01-30 00:26:45 +0100497 return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100498 case BSS_CMP_HIDE_NUL:
499 if (ie1[1] != ie2[1])
500 return ie2[1] - ie1[1];
501 /* this is equivalent to memcmp(zeroes, ie2 + 2, len) */
502 for (i = 0; i < ie2[1]; i++)
503 if (ie2[i + 2])
504 return -1;
505 return 0;
506 }
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100507}
508
Johannes Berg2a519312009-02-10 21:25:55 +0100509struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
510 struct ieee80211_channel *channel,
511 const u8 *bssid,
Johannes Berg79420f02009-02-10 21:25:59 +0100512 const u8 *ssid, size_t ssid_len,
513 u16 capa_mask, u16 capa_val)
Johannes Berg2a519312009-02-10 21:25:55 +0100514{
515 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
516 struct cfg80211_internal_bss *bss, *res = NULL;
Johannes Bergccb6c132010-07-13 10:55:38 +0200517 unsigned long now = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100518
Beni Lev4ee3e062012-08-27 12:49:39 +0300519 trace_cfg80211_get_bss(wiphy, channel, bssid, ssid, ssid_len, capa_mask,
520 capa_val);
521
Johannes Berg2a519312009-02-10 21:25:55 +0100522 spin_lock_bh(&dev->bss_lock);
523
524 list_for_each_entry(bss, &dev->bss_list, list) {
Johannes Berg79420f02009-02-10 21:25:59 +0100525 if ((bss->pub.capability & capa_mask) != capa_val)
526 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100527 if (channel && bss->pub.channel != channel)
528 continue;
Johannes Bergccb6c132010-07-13 10:55:38 +0200529 /* Don't get expired BSS structs */
530 if (time_after(now, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE) &&
531 !atomic_read(&bss->hold))
532 continue;
Johannes Berg2a519312009-02-10 21:25:55 +0100533 if (is_bss(&bss->pub, bssid, ssid, ssid_len)) {
534 res = bss;
535 kref_get(&res->ref);
536 break;
537 }
538 }
539
540 spin_unlock_bh(&dev->bss_lock);
541 if (!res)
542 return NULL;
Beni Lev4ee3e062012-08-27 12:49:39 +0300543 trace_cfg80211_return_bss(&res->pub);
Johannes Berg2a519312009-02-10 21:25:55 +0100544 return &res->pub;
545}
546EXPORT_SYMBOL(cfg80211_get_bss);
547
548struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy,
549 struct ieee80211_channel *channel,
550 const u8 *meshid, size_t meshidlen,
551 const u8 *meshcfg)
552{
553 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
554 struct cfg80211_internal_bss *bss, *res = NULL;
555
556 spin_lock_bh(&dev->bss_lock);
557
558 list_for_each_entry(bss, &dev->bss_list, list) {
559 if (channel && bss->pub.channel != channel)
560 continue;
561 if (is_mesh(&bss->pub, meshid, meshidlen, meshcfg)) {
562 res = bss;
563 kref_get(&res->ref);
564 break;
565 }
566 }
567
568 spin_unlock_bh(&dev->bss_lock);
569 if (!res)
570 return NULL;
571 return &res->pub;
572}
573EXPORT_SYMBOL(cfg80211_get_mesh);
574
575
576static void rb_insert_bss(struct cfg80211_registered_device *dev,
577 struct cfg80211_internal_bss *bss)
578{
579 struct rb_node **p = &dev->bss_tree.rb_node;
580 struct rb_node *parent = NULL;
581 struct cfg80211_internal_bss *tbss;
582 int cmp;
583
584 while (*p) {
585 parent = *p;
586 tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn);
587
Johannes Berg4593c4c2013-02-01 19:20:03 +0100588 cmp = cmp_bss(&bss->pub, &tbss->pub, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100589
590 if (WARN_ON(!cmp)) {
591 /* will sort of leak this BSS */
592 return;
593 }
594
595 if (cmp < 0)
596 p = &(*p)->rb_left;
597 else
598 p = &(*p)->rb_right;
599 }
600
601 rb_link_node(&bss->rbn, parent, p);
602 rb_insert_color(&bss->rbn, &dev->bss_tree);
603}
604
605static struct cfg80211_internal_bss *
606rb_find_bss(struct cfg80211_registered_device *dev,
Johannes Berg5622f5b2013-01-30 00:26:45 +0100607 struct cfg80211_internal_bss *res,
Johannes Berg4593c4c2013-02-01 19:20:03 +0100608 enum bss_compare_mode mode)
Johannes Berg2a519312009-02-10 21:25:55 +0100609{
610 struct rb_node *n = dev->bss_tree.rb_node;
611 struct cfg80211_internal_bss *bss;
612 int r;
613
614 while (n) {
615 bss = rb_entry(n, struct cfg80211_internal_bss, rbn);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100616 r = cmp_bss(&res->pub, &bss->pub, mode);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100617
618 if (r == 0)
619 return bss;
620 else if (r < 0)
621 n = n->rb_left;
622 else
623 n = n->rb_right;
624 }
625
626 return NULL;
627}
628
629static void
630copy_hidden_ies(struct cfg80211_internal_bss *res,
Johannes Berg915de2f2012-11-28 22:39:37 +0100631 struct cfg80211_internal_bss *hidden)
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100632{
Johannes Berg9caf0362012-11-29 01:25:20 +0100633 const struct cfg80211_bss_ies *ies;
634
635 if (rcu_access_pointer(res->pub.beacon_ies))
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100636 return;
637
Johannes Berg9caf0362012-11-29 01:25:20 +0100638 ies = rcu_access_pointer(hidden->pub.beacon_ies);
639 if (WARN_ON(!ies))
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100640 return;
641
Johannes Berg9caf0362012-11-29 01:25:20 +0100642 ies = kmemdup(ies, sizeof(*ies) + ies->len, GFP_ATOMIC);
643 if (unlikely(!ies))
644 return;
645 rcu_assign_pointer(res->pub.beacon_ies, ies);
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100646}
647
648static struct cfg80211_internal_bss *
Johannes Berg2a519312009-02-10 21:25:55 +0100649cfg80211_bss_update(struct cfg80211_registered_device *dev,
Johannes Berg9caf0362012-11-29 01:25:20 +0100650 struct cfg80211_internal_bss *tmp)
Johannes Berg2a519312009-02-10 21:25:55 +0100651{
652 struct cfg80211_internal_bss *found = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100653
Johannes Berg9caf0362012-11-29 01:25:20 +0100654 if (WARN_ON(!tmp->pub.channel))
Johannes Berg2a519312009-02-10 21:25:55 +0100655 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100656
Johannes Berg9caf0362012-11-29 01:25:20 +0100657 tmp->ts = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +0100658
Johannes Berg2a519312009-02-10 21:25:55 +0100659 spin_lock_bh(&dev->bss_lock);
660
Johannes Berg9caf0362012-11-29 01:25:20 +0100661 if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) {
662 spin_unlock_bh(&dev->bss_lock);
663 return NULL;
664 }
665
Johannes Berg4593c4c2013-02-01 19:20:03 +0100666 found = rb_find_bss(dev, tmp, BSS_CMP_REGULAR);
Johannes Berg2a519312009-02-10 21:25:55 +0100667
Johannes Bergcd1658f2009-04-16 15:00:58 +0200668 if (found) {
Johannes Berg9caf0362012-11-29 01:25:20 +0100669 found->pub.beacon_interval = tmp->pub.beacon_interval;
670 found->pub.tsf = tmp->pub.tsf;
671 found->pub.signal = tmp->pub.signal;
672 found->pub.capability = tmp->pub.capability;
673 found->ts = tmp->ts;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200674
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200675 /* Update IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100676 if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
677 const struct cfg80211_bss_ies *old;
Johannes Bergcd1658f2009-04-16 15:00:58 +0200678
Johannes Berg9caf0362012-11-29 01:25:20 +0100679 old = rcu_access_pointer(found->pub.proberesp_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200680
Johannes Berg9caf0362012-11-29 01:25:20 +0100681 rcu_assign_pointer(found->pub.proberesp_ies,
682 tmp->pub.proberesp_ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200683 /* Override possible earlier Beacon frame IEs */
Johannes Berg9caf0362012-11-29 01:25:20 +0100684 rcu_assign_pointer(found->pub.ies,
685 tmp->pub.proberesp_ies);
686 if (old)
687 kfree_rcu((struct cfg80211_bss_ies *)old,
688 rcu_head);
689 } else if (rcu_access_pointer(tmp->pub.beacon_ies)) {
690 const struct cfg80211_bss_ies *old, *ies;
Johannes Berg915de2f2012-11-28 22:39:37 +0100691
Johannes Berg9caf0362012-11-29 01:25:20 +0100692 old = rcu_access_pointer(found->pub.beacon_ies);
693 ies = rcu_access_pointer(found->pub.ies);
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200694
Johannes Berg9caf0362012-11-29 01:25:20 +0100695 rcu_assign_pointer(found->pub.beacon_ies,
696 tmp->pub.beacon_ies);
Sven Neumann01123e22010-12-09 15:05:24 +0100697
698 /* Override IEs if they were from a beacon before */
Johannes Berg9caf0362012-11-29 01:25:20 +0100699 if (old == ies)
700 rcu_assign_pointer(found->pub.ies,
701 tmp->pub.beacon_ies);
Johannes Bergcd1658f2009-04-16 15:00:58 +0200702
Johannes Berg9caf0362012-11-29 01:25:20 +0100703 if (old)
704 kfree_rcu((struct cfg80211_bss_ies *)old,
705 rcu_head);
706 }
Johannes Berg2a519312009-02-10 21:25:55 +0100707 } else {
Johannes Berg9caf0362012-11-29 01:25:20 +0100708 struct cfg80211_internal_bss *new;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100709 struct cfg80211_internal_bss *hidden;
Johannes Berg9caf0362012-11-29 01:25:20 +0100710 struct cfg80211_bss_ies *ies;
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100711
712 /* First check if the beacon is a probe response from
713 * a hidden bss. If so, copy beacon ies (with nullified
714 * ssid) into the probe response bss entry (with real ssid).
715 * It is required basically for PSM implementation
716 * (probe responses do not contain tim ie) */
717
718 /* TODO: The code is not trying to update existing probe
719 * response bss entries when beacon ies are
720 * getting changed. */
Johannes Berg4593c4c2013-02-01 19:20:03 +0100721 hidden = rb_find_bss(dev, tmp, BSS_CMP_HIDE_ZLEN);
722 if (hidden) {
Johannes Berg9caf0362012-11-29 01:25:20 +0100723 copy_hidden_ies(tmp, hidden);
Johannes Berg4593c4c2013-02-01 19:20:03 +0100724 } else {
725 hidden = rb_find_bss(dev, tmp, BSS_CMP_HIDE_NUL);
726 if (hidden)
727 copy_hidden_ies(tmp, hidden);
728 }
Dmitry Tarnyagindd9dfb92011-11-04 17:12:07 +0100729
Johannes Berg9caf0362012-11-29 01:25:20 +0100730 /*
731 * create a copy -- the "res" variable that is passed in
732 * is allocated on the stack since it's not needed in the
733 * more common case of an update
734 */
735 new = kzalloc(sizeof(*new) + dev->wiphy.bss_priv_size,
736 GFP_ATOMIC);
737 if (!new) {
738 ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
739 if (ies)
740 kfree_rcu(ies, rcu_head);
741 ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
742 if (ies)
743 kfree_rcu(ies, rcu_head);
744 spin_unlock_bh(&dev->bss_lock);
745 return NULL;
746 }
747 memcpy(new, tmp, sizeof(*new));
748 kref_init(&new->ref);
749 list_add_tail(&new->list, &dev->bss_list);
750 rb_insert_bss(dev, new);
751 found = new;
Johannes Berg2a519312009-02-10 21:25:55 +0100752 }
753
754 dev->bss_generation++;
755 spin_unlock_bh(&dev->bss_lock);
756
757 kref_get(&found->ref);
758 return found;
759}
760
Johannes Berg0172bb72012-11-23 14:23:30 +0100761static struct ieee80211_channel *
762cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
763 struct ieee80211_channel *channel)
764{
765 const u8 *tmp;
766 u32 freq;
767 int channel_number = -1;
768
769 tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
770 if (tmp && tmp[1] == 1) {
771 channel_number = tmp[2];
772 } else {
773 tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
774 if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
775 struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
776
777 channel_number = htop->primary_chan;
778 }
779 }
780
781 if (channel_number < 0)
782 return channel;
783
784 freq = ieee80211_channel_to_frequency(channel_number, channel->band);
785 channel = ieee80211_get_channel(wiphy, freq);
786 if (!channel)
787 return NULL;
788 if (channel->flags & IEEE80211_CHAN_DISABLED)
789 return NULL;
790 return channel;
791}
792
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200793struct cfg80211_bss*
794cfg80211_inform_bss(struct wiphy *wiphy,
795 struct ieee80211_channel *channel,
Johannes Berg7b8bcff2012-03-13 13:57:04 +0100796 const u8 *bssid, u64 tsf, u16 capability,
797 u16 beacon_interval, const u8 *ie, size_t ielen,
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200798 s32 signal, gfp_t gfp)
799{
Johannes Berg9caf0362012-11-29 01:25:20 +0100800 struct cfg80211_bss_ies *ies;
801 struct cfg80211_internal_bss tmp = {}, *res;
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200802
803 if (WARN_ON(!wiphy))
804 return NULL;
805
Sujith22fe88d2010-05-13 10:34:08 +0530806 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200807 (signal < 0 || signal > 100)))
808 return NULL;
809
Johannes Berg0172bb72012-11-23 14:23:30 +0100810 channel = cfg80211_get_bss_channel(wiphy, ie, ielen, channel);
811 if (!channel)
812 return NULL;
813
Johannes Berg9caf0362012-11-29 01:25:20 +0100814 memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
815 tmp.pub.channel = channel;
816 tmp.pub.signal = signal;
817 tmp.pub.tsf = tsf;
818 tmp.pub.beacon_interval = beacon_interval;
819 tmp.pub.capability = capability;
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200820 /*
821 * Since we do not know here whether the IEs are from a Beacon or Probe
822 * Response frame, we need to pick one of the options and only use it
823 * with the driver that does not provide the full Beacon/Probe Response
824 * frame. Use Beacon frame pointer to avoid indicating that this should
Johannes Berg9caf0362012-11-29 01:25:20 +0100825 * override the iies pointer should we have received an earlier
826 * indication of Probe Response data.
Jouni Malinen34a6edd2010-01-06 16:19:24 +0200827 *
828 * The initial buffer for the IEs is allocated with the BSS entry and
829 * is located after the private area.
830 */
Johannes Berg9caf0362012-11-29 01:25:20 +0100831 ies = kmalloc(sizeof(*ies) + ielen, gfp);
832 if (!ies)
833 return NULL;
834 ies->len = ielen;
835 memcpy(ies->data, ie, ielen);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200836
Johannes Berg9caf0362012-11-29 01:25:20 +0100837 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
838 rcu_assign_pointer(tmp.pub.ies, ies);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200839
Johannes Berg9caf0362012-11-29 01:25:20 +0100840 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200841 if (!res)
842 return NULL;
843
844 if (res->pub.capability & WLAN_CAPABILITY_ESS)
845 regulatory_hint_found_beacon(wiphy, channel, gfp);
846
Beni Lev4ee3e062012-08-27 12:49:39 +0300847 trace_cfg80211_return_bss(&res->pub);
Jussi Kivilinna06aa7af2009-03-26 23:40:09 +0200848 /* cfg80211_bss_update gives us a referenced result */
849 return &res->pub;
850}
851EXPORT_SYMBOL(cfg80211_inform_bss);
852
Johannes Berg2a519312009-02-10 21:25:55 +0100853struct cfg80211_bss *
854cfg80211_inform_bss_frame(struct wiphy *wiphy,
855 struct ieee80211_channel *channel,
856 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg77965c92009-02-18 18:45:06 +0100857 s32 signal, gfp_t gfp)
Johannes Berg2a519312009-02-10 21:25:55 +0100858{
Johannes Berg9caf0362012-11-29 01:25:20 +0100859 struct cfg80211_internal_bss tmp = {}, *res;
860 struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +0100861 size_t ielen = len - offsetof(struct ieee80211_mgmt,
862 u.probe_resp.variable);
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100863
Johannes Berg0172bb72012-11-23 14:23:30 +0100864 BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
865 offsetof(struct ieee80211_mgmt, u.beacon.variable));
866
Beni Lev4ee3e062012-08-27 12:49:39 +0300867 trace_cfg80211_inform_bss_frame(wiphy, channel, mgmt, len, signal);
868
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100869 if (WARN_ON(!mgmt))
870 return NULL;
871
872 if (WARN_ON(!wiphy))
873 return NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100874
Sujith22fe88d2010-05-13 10:34:08 +0530875 if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
Hila Gonen768be592012-08-26 11:00:28 +0300876 (signal < 0 || signal > 100)))
Johannes Berg2a519312009-02-10 21:25:55 +0100877 return NULL;
878
Mariusz Kozlowskibef9bac2011-03-26 19:26:55 +0100879 if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
Johannes Berg2a519312009-02-10 21:25:55 +0100880 return NULL;
881
Johannes Berg0172bb72012-11-23 14:23:30 +0100882 channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
883 ielen, channel);
884 if (!channel)
885 return NULL;
886
Johannes Berg9caf0362012-11-29 01:25:20 +0100887 ies = kmalloc(sizeof(*ies) + ielen, gfp);
888 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +0100889 return NULL;
Johannes Berg9caf0362012-11-29 01:25:20 +0100890 ies->len = ielen;
891 memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
Johannes Berg2a519312009-02-10 21:25:55 +0100892
Johannes Berg9caf0362012-11-29 01:25:20 +0100893 if (ieee80211_is_probe_resp(mgmt->frame_control))
894 rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
895 else
896 rcu_assign_pointer(tmp.pub.beacon_ies, ies);
897 rcu_assign_pointer(tmp.pub.ies, ies);
898
899 memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
900 tmp.pub.channel = channel;
901 tmp.pub.signal = signal;
902 tmp.pub.tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
903 tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
904 tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
Johannes Berg2a519312009-02-10 21:25:55 +0100905
Johannes Berg9caf0362012-11-29 01:25:20 +0100906 res = cfg80211_bss_update(wiphy_to_dev(wiphy), &tmp);
Johannes Berg2a519312009-02-10 21:25:55 +0100907 if (!res)
908 return NULL;
909
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500910 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);
Johannes Berg2a519312009-02-10 21:25:55 +0100914 /* cfg80211_bss_update gives us a referenced result */
915 return &res->pub;
916}
917EXPORT_SYMBOL(cfg80211_inform_bss_frame);
918
Johannes Berg4c0c0b72012-01-20 13:55:26 +0100919void cfg80211_ref_bss(struct cfg80211_bss *pub)
920{
921 struct cfg80211_internal_bss *bss;
922
923 if (!pub)
924 return;
925
926 bss = container_of(pub, struct cfg80211_internal_bss, pub);
927 kref_get(&bss->ref);
928}
929EXPORT_SYMBOL(cfg80211_ref_bss);
930
Johannes Berg2a519312009-02-10 21:25:55 +0100931void cfg80211_put_bss(struct cfg80211_bss *pub)
932{
933 struct cfg80211_internal_bss *bss;
934
935 if (!pub)
936 return;
937
938 bss = container_of(pub, struct cfg80211_internal_bss, pub);
939 kref_put(&bss->ref, bss_release);
940}
941EXPORT_SYMBOL(cfg80211_put_bss);
942
Johannes Bergd491af12009-02-10 21:25:58 +0100943void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
944{
945 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy);
946 struct cfg80211_internal_bss *bss;
947
948 if (WARN_ON(!pub))
949 return;
950
951 bss = container_of(pub, struct cfg80211_internal_bss, pub);
952
953 spin_lock_bh(&dev->bss_lock);
Johannes Berg32073902010-10-06 21:18:04 +0200954 if (!list_empty(&bss->list)) {
Juuso Oikarinen2b78ac92011-03-28 14:32:32 +0300955 __cfg80211_unlink_bss(dev, bss);
Johannes Berg32073902010-10-06 21:18:04 +0200956 dev->bss_generation++;
Johannes Berg32073902010-10-06 21:18:04 +0200957 }
Johannes Bergd491af12009-02-10 21:25:58 +0100958 spin_unlock_bh(&dev->bss_lock);
Johannes Bergd491af12009-02-10 21:25:58 +0100959}
960EXPORT_SYMBOL(cfg80211_unlink_bss);
961
Johannes Berg3d23e342009-09-29 23:27:28 +0200962#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a519312009-02-10 21:25:55 +0100963int cfg80211_wext_siwscan(struct net_device *dev,
964 struct iw_request_info *info,
965 union iwreq_data *wrqu, char *extra)
966{
967 struct cfg80211_registered_device *rdev;
968 struct wiphy *wiphy;
969 struct iw_scan_req *wreq = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +0100970 struct cfg80211_scan_request *creq = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +0100971 int i, err, n_channels = 0;
972 enum ieee80211_band band;
973
974 if (!netif_running(dev))
975 return -ENETDOWN;
976
Holger Schurigb2e3abd2009-09-09 13:09:54 +0200977 if (wrqu->data.length == sizeof(struct iw_scan_req))
978 wreq = (struct iw_scan_req *)extra;
979
Johannes Berg463d0182009-07-14 00:33:35 +0200980 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +0100981
982 if (IS_ERR(rdev))
983 return PTR_ERR(rdev);
984
985 if (rdev->scan_req) {
986 err = -EBUSY;
987 goto out;
988 }
989
990 wiphy = &rdev->wiphy;
991
Holger Schurigb2e3abd2009-09-09 13:09:54 +0200992 /* Determine number of channels, needed to allocate creq */
993 if (wreq && wreq->num_channels)
994 n_channels = wreq->num_channels;
995 else {
996 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
997 if (wiphy->bands[band])
998 n_channels += wiphy->bands[band]->n_channels;
999 }
Johannes Berg2a519312009-02-10 21:25:55 +01001000
1001 creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
1002 n_channels * sizeof(void *),
1003 GFP_ATOMIC);
1004 if (!creq) {
1005 err = -ENOMEM;
1006 goto out;
1007 }
1008
1009 creq->wiphy = wiphy;
Johannes Bergfd014282012-06-18 19:17:03 +02001010 creq->wdev = dev->ieee80211_ptr;
Johannes Berg5ba63532009-08-07 17:54:07 +02001011 /* SSIDs come after channels */
1012 creq->ssids = (void *)&creq->channels[n_channels];
Johannes Berg2a519312009-02-10 21:25:55 +01001013 creq->n_channels = n_channels;
1014 creq->n_ssids = 1;
Sam Leffler15d60302012-10-11 21:03:34 -07001015 creq->scan_start = jiffies;
Johannes Berg2a519312009-02-10 21:25:55 +01001016
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001017 /* translate "Scan on frequencies" request */
Johannes Berg2a519312009-02-10 21:25:55 +01001018 i = 0;
1019 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1020 int j;
Johannes Berg584991d2009-11-02 13:32:03 +01001021
Johannes Berg2a519312009-02-10 21:25:55 +01001022 if (!wiphy->bands[band])
1023 continue;
Johannes Berg584991d2009-11-02 13:32:03 +01001024
Johannes Berg2a519312009-02-10 21:25:55 +01001025 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
Johannes Berg584991d2009-11-02 13:32:03 +01001026 /* ignore disabled channels */
1027 if (wiphy->bands[band]->channels[j].flags &
1028 IEEE80211_CHAN_DISABLED)
1029 continue;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001030
1031 /* If we have a wireless request structure and the
1032 * wireless request specifies frequencies, then search
1033 * for the matching hardware channel.
1034 */
1035 if (wreq && wreq->num_channels) {
1036 int k;
1037 int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
1038 for (k = 0; k < wreq->num_channels; k++) {
Holger Schuriga4e7b732009-09-11 10:13:53 +02001039 int wext_freq = cfg80211_wext_freq(wiphy, &wreq->channel_list[k]);
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001040 if (wext_freq == wiphy_freq)
1041 goto wext_freq_found;
1042 }
1043 goto wext_freq_not_found;
1044 }
1045
1046 wext_freq_found:
Johannes Berg2a519312009-02-10 21:25:55 +01001047 creq->channels[i] = &wiphy->bands[band]->channels[j];
1048 i++;
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001049 wext_freq_not_found: ;
Johannes Berg2a519312009-02-10 21:25:55 +01001050 }
1051 }
Holger Schurig8862dc52009-09-11 10:13:55 +02001052 /* No channels found? */
1053 if (!i) {
1054 err = -EINVAL;
1055 goto out;
1056 }
Johannes Berg2a519312009-02-10 21:25:55 +01001057
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001058 /* Set real number of channels specified in creq->channels[] */
1059 creq->n_channels = i;
Johannes Berg2a519312009-02-10 21:25:55 +01001060
Holger Schurigb2e3abd2009-09-09 13:09:54 +02001061 /* translate "Scan for SSID" request */
1062 if (wreq) {
Johannes Berg2a519312009-02-10 21:25:55 +01001063 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
Johannes Berg65486c82009-12-23 15:33:35 +01001064 if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
1065 err = -EINVAL;
1066 goto out;
1067 }
Johannes Berg2a519312009-02-10 21:25:55 +01001068 memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
1069 creq->ssids[0].ssid_len = wreq->essid_len;
1070 }
1071 if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
1072 creq->n_ssids = 0;
1073 }
1074
Johannes Berg34850ab2011-07-18 18:08:35 +02001075 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
Johannes Berga401d2b2011-07-20 00:52:16 +02001076 if (wiphy->bands[i])
1077 creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
Johannes Berg34850ab2011-07-18 18:08:35 +02001078
Johannes Berg2a519312009-02-10 21:25:55 +01001079 rdev->scan_req = creq;
Hila Gonene35e4d22012-06-27 17:19:42 +03001080 err = rdev_scan(rdev, creq);
Johannes Berg2a519312009-02-10 21:25:55 +01001081 if (err) {
1082 rdev->scan_req = NULL;
Johannes Berg65486c82009-12-23 15:33:35 +01001083 /* creq will be freed below */
Johannes Berg463d0182009-07-14 00:33:35 +02001084 } else {
Johannes Bergfd014282012-06-18 19:17:03 +02001085 nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
Johannes Berg65486c82009-12-23 15:33:35 +01001086 /* creq now owned by driver */
1087 creq = NULL;
Johannes Berg463d0182009-07-14 00:33:35 +02001088 dev_hold(dev);
1089 }
Johannes Berg2a519312009-02-10 21:25:55 +01001090 out:
Johannes Berg65486c82009-12-23 15:33:35 +01001091 kfree(creq);
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001092 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001093 return err;
1094}
Johannes Bergba44cb72009-04-20 18:49:39 +02001095EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001096
1097static void ieee80211_scan_add_ies(struct iw_request_info *info,
Johannes Berg9caf0362012-11-29 01:25:20 +01001098 const struct cfg80211_bss_ies *ies,
Johannes Berg2a519312009-02-10 21:25:55 +01001099 char **current_ev, char *end_buf)
1100{
Johannes Berg9caf0362012-11-29 01:25:20 +01001101 const u8 *pos, *end, *next;
Johannes Berg2a519312009-02-10 21:25:55 +01001102 struct iw_event iwe;
1103
Johannes Berg9caf0362012-11-29 01:25:20 +01001104 if (!ies)
Johannes Berg2a519312009-02-10 21:25:55 +01001105 return;
1106
1107 /*
1108 * If needed, fragment the IEs buffer (at IE boundaries) into short
1109 * enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
1110 */
Johannes Berg9caf0362012-11-29 01:25:20 +01001111 pos = ies->data;
1112 end = pos + ies->len;
Johannes Berg2a519312009-02-10 21:25:55 +01001113
1114 while (end - pos > IW_GENERIC_IE_MAX) {
1115 next = pos + 2 + pos[1];
1116 while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
1117 next = next + 2 + next[1];
1118
1119 memset(&iwe, 0, sizeof(iwe));
1120 iwe.cmd = IWEVGENIE;
1121 iwe.u.data.length = next - pos;
1122 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001123 end_buf, &iwe,
1124 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001125
1126 pos = next;
1127 }
1128
1129 if (end > pos) {
1130 memset(&iwe, 0, sizeof(iwe));
1131 iwe.cmd = IWEVGENIE;
1132 iwe.u.data.length = end - pos;
1133 *current_ev = iwe_stream_add_point(info, *current_ev,
Johannes Berg9caf0362012-11-29 01:25:20 +01001134 end_buf, &iwe,
1135 (void *)pos);
Johannes Berg2a519312009-02-10 21:25:55 +01001136 }
1137}
1138
Dan Williamscb3a8ee2009-02-11 17:14:43 -05001139static inline unsigned int elapsed_jiffies_msecs(unsigned long start)
1140{
1141 unsigned long end = jiffies;
1142
1143 if (end >= start)
1144 return jiffies_to_msecs(end - start);
1145
1146 return jiffies_to_msecs(end + (MAX_JIFFY_OFFSET - start) + 1);
1147}
Johannes Berg2a519312009-02-10 21:25:55 +01001148
1149static char *
Johannes Berg77965c92009-02-18 18:45:06 +01001150ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
1151 struct cfg80211_internal_bss *bss, char *current_ev,
1152 char *end_buf)
Johannes Berg2a519312009-02-10 21:25:55 +01001153{
Johannes Berg9caf0362012-11-29 01:25:20 +01001154 const struct cfg80211_bss_ies *ies;
Johannes Berg2a519312009-02-10 21:25:55 +01001155 struct iw_event iwe;
Johannes Berg9caf0362012-11-29 01:25:20 +01001156 const u8 *ie;
Johannes Berg2a519312009-02-10 21:25:55 +01001157 u8 *buf, *cfg, *p;
Johannes Berg9caf0362012-11-29 01:25:20 +01001158 int rem, i, sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001159 bool ismesh = false;
1160
1161 memset(&iwe, 0, sizeof(iwe));
1162 iwe.cmd = SIOCGIWAP;
1163 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1164 memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
1165 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1166 IW_EV_ADDR_LEN);
1167
1168 memset(&iwe, 0, sizeof(iwe));
1169 iwe.cmd = SIOCGIWFREQ;
1170 iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
1171 iwe.u.freq.e = 0;
1172 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1173 IW_EV_FREQ_LEN);
1174
1175 memset(&iwe, 0, sizeof(iwe));
1176 iwe.cmd = SIOCGIWFREQ;
1177 iwe.u.freq.m = bss->pub.channel->center_freq;
1178 iwe.u.freq.e = 6;
1179 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1180 IW_EV_FREQ_LEN);
1181
Johannes Berg77965c92009-02-18 18:45:06 +01001182 if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
Johannes Berg2a519312009-02-10 21:25:55 +01001183 memset(&iwe, 0, sizeof(iwe));
1184 iwe.cmd = IWEVQUAL;
1185 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
1186 IW_QUAL_NOISE_INVALID |
Johannes Berga77b8552009-02-18 18:27:22 +01001187 IW_QUAL_QUAL_UPDATED;
Johannes Berg77965c92009-02-18 18:45:06 +01001188 switch (wiphy->signal_type) {
Johannes Berg2a519312009-02-10 21:25:55 +01001189 case CFG80211_SIGNAL_TYPE_MBM:
Johannes Berga77b8552009-02-18 18:27:22 +01001190 sig = bss->pub.signal / 100;
1191 iwe.u.qual.level = sig;
Johannes Berg2a519312009-02-10 21:25:55 +01001192 iwe.u.qual.updated |= IW_QUAL_DBM;
Johannes Berga77b8552009-02-18 18:27:22 +01001193 if (sig < -110) /* rather bad */
1194 sig = -110;
1195 else if (sig > -40) /* perfect */
1196 sig = -40;
1197 /* will give a range of 0 .. 70 */
1198 iwe.u.qual.qual = sig + 110;
Johannes Berg2a519312009-02-10 21:25:55 +01001199 break;
1200 case CFG80211_SIGNAL_TYPE_UNSPEC:
1201 iwe.u.qual.level = bss->pub.signal;
Johannes Berga77b8552009-02-18 18:27:22 +01001202 /* will give range 0 .. 100 */
1203 iwe.u.qual.qual = bss->pub.signal;
Johannes Berg2a519312009-02-10 21:25:55 +01001204 break;
1205 default:
1206 /* not reached */
1207 break;
1208 }
1209 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1210 &iwe, IW_EV_QUAL_LEN);
1211 }
1212
1213 memset(&iwe, 0, sizeof(iwe));
1214 iwe.cmd = SIOCGIWENCODE;
1215 if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
1216 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1217 else
1218 iwe.u.data.flags = IW_ENCODE_DISABLED;
1219 iwe.u.data.length = 0;
1220 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1221 &iwe, "");
1222
Johannes Berg9caf0362012-11-29 01:25:20 +01001223 rcu_read_lock();
1224 ies = rcu_dereference(bss->pub.ies);
1225 if (ies) {
1226 rem = ies->len;
1227 ie = ies->data;
1228 } else {
1229 rem = 0;
1230 ie = NULL;
1231 }
1232
1233 while (ies && rem >= 2) {
Johannes Berg2a519312009-02-10 21:25:55 +01001234 /* invalid data */
1235 if (ie[1] > rem - 2)
1236 break;
1237
1238 switch (ie[0]) {
1239 case WLAN_EID_SSID:
1240 memset(&iwe, 0, sizeof(iwe));
1241 iwe.cmd = SIOCGIWESSID;
1242 iwe.u.data.length = ie[1];
1243 iwe.u.data.flags = 1;
1244 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001245 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001246 break;
1247 case WLAN_EID_MESH_ID:
1248 memset(&iwe, 0, sizeof(iwe));
1249 iwe.cmd = SIOCGIWESSID;
1250 iwe.u.data.length = ie[1];
1251 iwe.u.data.flags = 1;
1252 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
Johannes Berg9caf0362012-11-29 01:25:20 +01001253 &iwe, (u8 *)ie + 2);
Johannes Berg2a519312009-02-10 21:25:55 +01001254 break;
1255 case WLAN_EID_MESH_CONFIG:
1256 ismesh = true;
Rui Paulo136cfa22009-11-18 18:40:00 +00001257 if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
Johannes Berg2a519312009-02-10 21:25:55 +01001258 break;
1259 buf = kmalloc(50, GFP_ATOMIC);
1260 if (!buf)
1261 break;
Johannes Berg9caf0362012-11-29 01:25:20 +01001262 cfg = (u8 *)ie + 2;
Johannes Berg2a519312009-02-10 21:25:55 +01001263 memset(&iwe, 0, sizeof(iwe));
1264 iwe.cmd = IWEVCUSTOM;
Rui Paulo76aa5e72009-11-18 18:22:59 +00001265 sprintf(buf, "Mesh Network Path Selection Protocol ID: "
1266 "0x%02X", cfg[0]);
Johannes Berg2a519312009-02-10 21:25:55 +01001267 iwe.u.data.length = strlen(buf);
1268 current_ev = iwe_stream_add_point(info, current_ev,
1269 end_buf,
1270 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001271 sprintf(buf, "Path Selection Metric ID: 0x%02X",
1272 cfg[1]);
Johannes Berg2a519312009-02-10 21:25:55 +01001273 iwe.u.data.length = strlen(buf);
1274 current_ev = iwe_stream_add_point(info, current_ev,
1275 end_buf,
1276 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001277 sprintf(buf, "Congestion Control Mode ID: 0x%02X",
1278 cfg[2]);
Johannes Berg2a519312009-02-10 21:25:55 +01001279 iwe.u.data.length = strlen(buf);
1280 current_ev = iwe_stream_add_point(info, current_ev,
1281 end_buf,
1282 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001283 sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
Johannes Berg2a519312009-02-10 21:25:55 +01001284 iwe.u.data.length = strlen(buf);
1285 current_ev = iwe_stream_add_point(info, current_ev,
1286 end_buf,
1287 &iwe, buf);
Rui Paulo76aa5e72009-11-18 18:22:59 +00001288 sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
1289 iwe.u.data.length = strlen(buf);
1290 current_ev = iwe_stream_add_point(info, current_ev,
1291 end_buf,
1292 &iwe, buf);
1293 sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
1294 iwe.u.data.length = strlen(buf);
1295 current_ev = iwe_stream_add_point(info, current_ev,
1296 end_buf,
1297 &iwe, buf);
1298 sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
Johannes Berg2a519312009-02-10 21:25:55 +01001299 iwe.u.data.length = strlen(buf);
1300 current_ev = iwe_stream_add_point(info, current_ev,
1301 end_buf,
1302 &iwe, buf);
1303 kfree(buf);
1304 break;
1305 case WLAN_EID_SUPP_RATES:
1306 case WLAN_EID_EXT_SUPP_RATES:
1307 /* display all supported rates in readable format */
1308 p = current_ev + iwe_stream_lcp_len(info);
1309
1310 memset(&iwe, 0, sizeof(iwe));
1311 iwe.cmd = SIOCGIWRATE;
1312 /* Those two flags are ignored... */
1313 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
1314
1315 for (i = 0; i < ie[1]; i++) {
1316 iwe.u.bitrate.value =
1317 ((ie[i + 2] & 0x7f) * 500000);
1318 p = iwe_stream_add_value(info, current_ev, p,
1319 end_buf, &iwe, IW_EV_PARAM_LEN);
1320 }
1321 current_ev = p;
1322 break;
1323 }
1324 rem -= ie[1] + 2;
1325 ie += ie[1] + 2;
1326 }
1327
Joe Perchesf64f9e72009-11-29 16:55:45 -08001328 if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
1329 ismesh) {
Johannes Berg2a519312009-02-10 21:25:55 +01001330 memset(&iwe, 0, sizeof(iwe));
1331 iwe.cmd = SIOCGIWMODE;
1332 if (ismesh)
1333 iwe.u.mode = IW_MODE_MESH;
1334 else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
1335 iwe.u.mode = IW_MODE_MASTER;
1336 else
1337 iwe.u.mode = IW_MODE_ADHOC;
1338 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1339 &iwe, IW_EV_UINT_LEN);
1340 }
1341
1342 buf = kmalloc(30, GFP_ATOMIC);
1343 if (buf) {
1344 memset(&iwe, 0, sizeof(iwe));
1345 iwe.cmd = IWEVCUSTOM;
1346 sprintf(buf, "tsf=%016llx", (unsigned long long)(bss->pub.tsf));
1347 iwe.u.data.length = strlen(buf);
1348 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1349 &iwe, buf);
1350 memset(&iwe, 0, sizeof(iwe));
1351 iwe.cmd = IWEVCUSTOM;
Dan Williamscb3a8ee2009-02-11 17:14:43 -05001352 sprintf(buf, " Last beacon: %ums ago",
1353 elapsed_jiffies_msecs(bss->ts));
Johannes Berg2a519312009-02-10 21:25:55 +01001354 iwe.u.data.length = strlen(buf);
1355 current_ev = iwe_stream_add_point(info, current_ev,
1356 end_buf, &iwe, buf);
1357 kfree(buf);
1358 }
1359
Johannes Berg9caf0362012-11-29 01:25:20 +01001360 ieee80211_scan_add_ies(info, ies, &current_ev, end_buf);
1361 rcu_read_unlock();
Johannes Berg2a519312009-02-10 21:25:55 +01001362
1363 return current_ev;
1364}
1365
1366
1367static int ieee80211_scan_results(struct cfg80211_registered_device *dev,
1368 struct iw_request_info *info,
1369 char *buf, size_t len)
1370{
1371 char *current_ev = buf;
1372 char *end_buf = buf + len;
1373 struct cfg80211_internal_bss *bss;
1374
1375 spin_lock_bh(&dev->bss_lock);
1376 cfg80211_bss_expire(dev);
1377
1378 list_for_each_entry(bss, &dev->bss_list, list) {
1379 if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
1380 spin_unlock_bh(&dev->bss_lock);
1381 return -E2BIG;
1382 }
Johannes Berg77965c92009-02-18 18:45:06 +01001383 current_ev = ieee80211_bss(&dev->wiphy, info, bss,
1384 current_ev, end_buf);
Johannes Berg2a519312009-02-10 21:25:55 +01001385 }
1386 spin_unlock_bh(&dev->bss_lock);
1387 return current_ev - buf;
1388}
1389
1390
1391int cfg80211_wext_giwscan(struct net_device *dev,
1392 struct iw_request_info *info,
1393 struct iw_point *data, char *extra)
1394{
1395 struct cfg80211_registered_device *rdev;
1396 int res;
1397
1398 if (!netif_running(dev))
1399 return -ENETDOWN;
1400
Johannes Berg463d0182009-07-14 00:33:35 +02001401 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01001402
1403 if (IS_ERR(rdev))
1404 return PTR_ERR(rdev);
1405
1406 if (rdev->scan_req) {
1407 res = -EAGAIN;
1408 goto out;
1409 }
1410
1411 res = ieee80211_scan_results(rdev, info, extra, data->length);
1412 data->length = 0;
1413 if (res >= 0) {
1414 data->length = res;
1415 res = 0;
1416 }
1417
1418 out:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001419 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01001420 return res;
1421}
Johannes Bergba44cb72009-04-20 18:49:39 +02001422EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
Johannes Berg2a519312009-02-10 21:25:55 +01001423#endif