2009-02-10 13:25:55 -07:00
|
|
|
/*
|
|
|
|
* cfg80211 scan result handling
|
|
|
|
*
|
|
|
|
* Copyright 2008 Johannes Berg <johannes@sipsolutions.net>
|
2014-09-03 06:24:58 -06:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2009-02-10 13:25:55 -07:00
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-02-10 13:25:55 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/nl80211.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <net/arp.h>
|
|
|
|
#include <net/cfg80211.h>
|
2011-07-13 02:39:09 -06:00
|
|
|
#include <net/cfg80211-wext.h>
|
2009-02-10 13:25:55 -07:00
|
|
|
#include <net/iw_handler.h>
|
|
|
|
#include "core.h"
|
|
|
|
#include "nl80211.h"
|
2009-07-27 04:01:53 -06:00
|
|
|
#include "wext-compat.h"
|
2012-06-27 08:19:42 -06:00
|
|
|
#include "rdev-ops.h"
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
/**
|
|
|
|
* DOC: BSS tree/list structure
|
|
|
|
*
|
|
|
|
* At the top level, the BSS list is kept in both a list in each
|
|
|
|
* registered device (@bss_list) as well as an RB-tree for faster
|
|
|
|
* lookup. In the RB-tree, entries can be looked up using their
|
|
|
|
* channel, MESHID, MESHCONF (for MBSSes) or channel, BSSID, SSID
|
|
|
|
* for other BSSes.
|
|
|
|
*
|
|
|
|
* Due to the possibility of hidden SSIDs, there's a second level
|
|
|
|
* structure, the "hidden_list" and "hidden_beacon_bss" pointer.
|
|
|
|
* The hidden_list connects all BSSes belonging to a single AP
|
|
|
|
* that has a hidden SSID, and connects beacon and probe response
|
|
|
|
* entries. For a probe response entry for a hidden SSID, the
|
|
|
|
* hidden_beacon_bss pointer points to the BSS struct holding the
|
|
|
|
* beacon's information.
|
|
|
|
*
|
|
|
|
* Reference counting is done for all these references except for
|
|
|
|
* the hidden_list, so that a beacon BSS struct that is otherwise
|
|
|
|
* not referenced has one reference for being on the bss_list and
|
|
|
|
* one for each probe response entry that points to it using the
|
|
|
|
* hidden_beacon_bss pointer. When a BSS struct that has such a
|
|
|
|
* pointer is get/put, the refcount update is also propagated to
|
|
|
|
* the referenced struct, this ensure that it cannot get removed
|
|
|
|
* while somebody is using the probe response version.
|
|
|
|
*
|
|
|
|
* Note that the hidden_beacon_bss pointer never changes, due to
|
|
|
|
* the reference counting. Therefore, no locking is needed for
|
|
|
|
* it.
|
|
|
|
*
|
|
|
|
* Also note that the hidden_beacon_bss pointer is only relevant
|
|
|
|
* if the driver uses something other than the IEs, e.g. private
|
|
|
|
* data stored stored in the BSS struct, since the beacon IEs are
|
|
|
|
* also linked into the probe response struct.
|
|
|
|
*/
|
|
|
|
|
2012-04-13 05:08:40 -06:00
|
|
|
#define IEEE80211_SCAN_RESULT_EXPIRE (30 * HZ)
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
static void bss_free(struct cfg80211_internal_bss *bss)
|
2012-10-11 22:03:33 -06:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_bss_ies *ies;
|
2012-11-28 14:14:56 -07:00
|
|
|
|
|
|
|
if (WARN_ON(atomic_read(&bss->hold)))
|
|
|
|
return;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
ies = (void *)rcu_access_pointer(bss->pub.beacon_ies);
|
2013-01-31 18:06:18 -07:00
|
|
|
if (ies && !bss->pub.hidden_beacon_bss)
|
2012-11-28 17:25:20 -07:00
|
|
|
kfree_rcu(ies, rcu_head);
|
|
|
|
ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies);
|
|
|
|
if (ies)
|
|
|
|
kfree_rcu(ies, rcu_head);
|
2012-10-11 22:03:33 -06:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
/*
|
|
|
|
* This happens when the module is removed, it doesn't
|
|
|
|
* really matter any more save for completeness
|
|
|
|
*/
|
|
|
|
if (!list_empty(&bss->hidden_list))
|
|
|
|
list_del(&bss->hidden_list);
|
|
|
|
|
2012-10-11 22:03:33 -06:00
|
|
|
kfree(bss);
|
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static inline void bss_ref_get(struct cfg80211_registered_device *rdev,
|
2013-01-31 18:06:18 -07:00
|
|
|
struct cfg80211_internal_bss *bss)
|
2013-01-31 17:34:36 -07:00
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
lockdep_assert_held(&rdev->bss_lock);
|
2013-01-31 18:06:18 -07:00
|
|
|
|
|
|
|
bss->refcount++;
|
|
|
|
if (bss->pub.hidden_beacon_bss) {
|
|
|
|
bss = container_of(bss->pub.hidden_beacon_bss,
|
|
|
|
struct cfg80211_internal_bss,
|
|
|
|
pub);
|
|
|
|
bss->refcount++;
|
|
|
|
}
|
2013-01-31 17:34:36 -07:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static inline void bss_ref_put(struct cfg80211_registered_device *rdev,
|
2013-01-31 18:06:18 -07:00
|
|
|
struct cfg80211_internal_bss *bss)
|
2013-01-31 17:34:36 -07:00
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
lockdep_assert_held(&rdev->bss_lock);
|
2013-01-31 18:06:18 -07:00
|
|
|
|
|
|
|
if (bss->pub.hidden_beacon_bss) {
|
|
|
|
struct cfg80211_internal_bss *hbss;
|
|
|
|
hbss = container_of(bss->pub.hidden_beacon_bss,
|
|
|
|
struct cfg80211_internal_bss,
|
|
|
|
pub);
|
|
|
|
hbss->refcount--;
|
|
|
|
if (hbss->refcount == 0)
|
|
|
|
bss_free(hbss);
|
|
|
|
}
|
|
|
|
bss->refcount--;
|
|
|
|
if (bss->refcount == 0)
|
|
|
|
bss_free(bss);
|
2013-01-31 17:34:36 -07:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static bool __cfg80211_unlink_bss(struct cfg80211_registered_device *rdev,
|
2012-10-11 22:03:33 -06:00
|
|
|
struct cfg80211_internal_bss *bss)
|
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
lockdep_assert_held(&rdev->bss_lock);
|
2013-01-31 17:05:43 -07:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
if (!list_empty(&bss->hidden_list)) {
|
|
|
|
/*
|
|
|
|
* don't remove the beacon entry if it has
|
|
|
|
* probe responses associated with it
|
|
|
|
*/
|
|
|
|
if (!bss->pub.hidden_beacon_bss)
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* if it's a probe response entry break its
|
|
|
|
* link to the other entries in the group
|
|
|
|
*/
|
|
|
|
list_del_init(&bss->hidden_list);
|
|
|
|
}
|
|
|
|
|
2012-10-11 22:03:33 -06:00
|
|
|
list_del_init(&bss->list);
|
2014-04-20 22:53:02 -06:00
|
|
|
rb_erase(&bss->rbn, &rdev->bss_tree);
|
|
|
|
bss_ref_put(rdev, bss);
|
2013-01-31 18:06:18 -07:00
|
|
|
return true;
|
2012-10-11 22:03:33 -06:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static void __cfg80211_bss_expire(struct cfg80211_registered_device *rdev,
|
2012-10-11 22:03:34 -06:00
|
|
|
unsigned long expire_time)
|
|
|
|
{
|
|
|
|
struct cfg80211_internal_bss *bss, *tmp;
|
|
|
|
bool expired = false;
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
lockdep_assert_held(&rdev->bss_lock);
|
2013-01-31 17:05:43 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
list_for_each_entry_safe(bss, tmp, &rdev->bss_list, list) {
|
2012-10-11 22:03:34 -06:00
|
|
|
if (atomic_read(&bss->hold))
|
|
|
|
continue;
|
|
|
|
if (!time_after(expire_time, bss->ts))
|
|
|
|
continue;
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
if (__cfg80211_unlink_bss(rdev, bss))
|
2013-01-31 18:06:18 -07:00
|
|
|
expired = true;
|
2012-10-11 22:03:34 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (expired)
|
2014-04-20 22:53:02 -06:00
|
|
|
rdev->bss_generation++;
|
2012-10-11 22:03:34 -06:00
|
|
|
}
|
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
|
|
|
|
bool send_message)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2009-07-06 19:56:11 -06:00
|
|
|
struct cfg80211_scan_request *request;
|
2012-06-18 11:17:03 -06:00
|
|
|
struct wireless_dev *wdev;
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
struct sk_buff *msg;
|
2009-09-29 15:27:28 -06:00
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
2009-02-10 13:25:55 -07:00
|
|
|
union iwreq_data wrqu;
|
|
|
|
#endif
|
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
ASSERT_RTNL();
|
2009-08-20 13:36:16 -06:00
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
if (rdev->scan_msg) {
|
|
|
|
nl80211_send_scan_result(rdev, rdev->scan_msg);
|
|
|
|
rdev->scan_msg = NULL;
|
|
|
|
return;
|
|
|
|
}
|
2009-07-06 19:56:11 -06:00
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
request = rdev->scan_req;
|
2009-08-20 13:36:16 -06:00
|
|
|
if (!request)
|
|
|
|
return;
|
|
|
|
|
2012-06-18 11:17:03 -06:00
|
|
|
wdev = request->wdev;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-07-02 01:13:27 -06:00
|
|
|
/*
|
|
|
|
* This must be before sending the other events!
|
|
|
|
* Otherwise, wpa_supplicant gets completely confused with
|
|
|
|
* wext events.
|
|
|
|
*/
|
2012-06-18 11:17:03 -06:00
|
|
|
if (wdev->netdev)
|
|
|
|
cfg80211_sme_scan_done(wdev->netdev);
|
2009-07-02 01:13:27 -06:00
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
if (!request->aborted &&
|
|
|
|
request->flags & NL80211_SCAN_FLAG_FLUSH) {
|
|
|
|
/* flush entries from previous scans */
|
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
__cfg80211_bss_expire(rdev, request->scan_start);
|
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2012-10-11 22:03:34 -06:00
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
msg = nl80211_build_scan_msg(rdev, wdev, request->aborted);
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
2012-06-18 11:17:03 -06:00
|
|
|
if (wdev->netdev && !request->aborted) {
|
2009-02-10 13:25:55 -07:00
|
|
|
memset(&wrqu, 0, sizeof(wrqu));
|
|
|
|
|
2012-06-18 11:17:03 -06:00
|
|
|
wireless_send_event(wdev->netdev, SIOCGIWSCAN, &wrqu, NULL);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-06-18 11:17:03 -06:00
|
|
|
if (wdev->netdev)
|
|
|
|
dev_put(wdev->netdev);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-08-12 14:21:21 -06:00
|
|
|
rdev->scan_req = NULL;
|
2013-12-05 09:30:17 -07:00
|
|
|
kfree(request);
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
|
|
|
|
if (!send_message)
|
|
|
|
rdev->scan_msg = msg;
|
|
|
|
else
|
|
|
|
nl80211_send_scan_result(rdev, msg);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
2009-07-06 19:56:11 -06:00
|
|
|
|
2009-08-12 14:21:21 -06:00
|
|
|
void __cfg80211_scan_done(struct work_struct *wk)
|
|
|
|
{
|
|
|
|
struct cfg80211_registered_device *rdev;
|
|
|
|
|
|
|
|
rdev = container_of(wk, struct cfg80211_registered_device,
|
|
|
|
scan_done_wk);
|
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
rtnl_lock();
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
___cfg80211_scan_done(rdev, true);
|
2013-05-08 13:45:15 -06:00
|
|
|
rtnl_unlock();
|
2009-08-12 14:21:21 -06:00
|
|
|
}
|
|
|
|
|
2009-07-06 19:56:11 -06:00
|
|
|
void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted)
|
|
|
|
{
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_scan_done(request, aborted);
|
2014-04-20 22:53:03 -06:00
|
|
|
WARN_ON(request != wiphy_to_rdev(request->wiphy)->scan_req);
|
2009-07-06 19:56:11 -06:00
|
|
|
|
|
|
|
request->aborted = aborted;
|
2013-05-08 13:45:15 -06:00
|
|
|
request->notified = true;
|
2014-04-20 22:53:03 -06:00
|
|
|
queue_work(cfg80211_wq, &wiphy_to_rdev(request->wiphy)->scan_done_wk);
|
2009-07-06 19:56:11 -06:00
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
EXPORT_SYMBOL(cfg80211_scan_done);
|
|
|
|
|
2011-05-11 08:09:35 -06:00
|
|
|
void __cfg80211_sched_scan_results(struct work_struct *wk)
|
|
|
|
{
|
|
|
|
struct cfg80211_registered_device *rdev;
|
2012-10-11 22:03:34 -06:00
|
|
|
struct cfg80211_sched_scan_request *request;
|
2011-05-11 08:09:35 -06:00
|
|
|
|
|
|
|
rdev = container_of(wk, struct cfg80211_registered_device,
|
|
|
|
sched_scan_results_wk);
|
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
rtnl_lock();
|
2011-05-11 08:09:35 -06:00
|
|
|
|
2013-10-21 03:33:35 -06:00
|
|
|
request = rdev->sched_scan_req;
|
|
|
|
|
2011-05-11 08:09:35 -06:00
|
|
|
/* we don't have sched_scan_req anymore if the scan is stopping */
|
2012-10-11 22:03:34 -06:00
|
|
|
if (request) {
|
|
|
|
if (request->flags & NL80211_SCAN_FLAG_FLUSH) {
|
|
|
|
/* flush entries from previous scans */
|
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
__cfg80211_bss_expire(rdev, request->scan_start);
|
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
|
|
|
request->scan_start =
|
|
|
|
jiffies + msecs_to_jiffies(request->interval);
|
|
|
|
}
|
|
|
|
nl80211_send_sched_scan_results(rdev, request->dev);
|
|
|
|
}
|
2011-05-11 08:09:35 -06:00
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
rtnl_unlock();
|
2011-05-11 08:09:35 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void cfg80211_sched_scan_results(struct wiphy *wiphy)
|
|
|
|
{
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_sched_scan_results(wiphy);
|
2011-05-11 08:09:35 -06:00
|
|
|
/* ignore if we're not scanning */
|
2014-04-20 22:53:03 -06:00
|
|
|
if (wiphy_to_rdev(wiphy)->sched_scan_req)
|
2011-05-11 08:09:35 -06:00
|
|
|
queue_work(cfg80211_wq,
|
2014-04-20 22:53:03 -06:00
|
|
|
&wiphy_to_rdev(wiphy)->sched_scan_results_wk);
|
2011-05-11 08:09:35 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_sched_scan_results);
|
|
|
|
|
2014-04-30 07:14:23 -06:00
|
|
|
void cfg80211_sched_scan_stopped_rtnl(struct wiphy *wiphy)
|
2011-05-11 08:09:35 -06:00
|
|
|
{
|
2014-04-20 22:53:03 -06:00
|
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
|
2011-05-11 08:09:35 -06:00
|
|
|
|
2014-04-30 07:14:23 -06:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_sched_scan_stopped(wiphy);
|
|
|
|
|
2011-05-11 08:09:35 -06:00
|
|
|
__cfg80211_stop_sched_scan(rdev, true);
|
2014-04-30 07:14:23 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_sched_scan_stopped_rtnl);
|
|
|
|
|
|
|
|
void cfg80211_sched_scan_stopped(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
rtnl_lock();
|
|
|
|
cfg80211_sched_scan_stopped_rtnl(wiphy);
|
2013-05-08 13:45:15 -06:00
|
|
|
rtnl_unlock();
|
2011-05-11 08:09:35 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_sched_scan_stopped);
|
|
|
|
|
|
|
|
int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
|
|
|
|
bool driver_initiated)
|
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
ASSERT_RTNL();
|
2011-05-11 08:09:35 -06:00
|
|
|
|
|
|
|
if (!rdev->sched_scan_req)
|
2011-07-08 02:16:16 -06:00
|
|
|
return -ENOENT;
|
2011-05-11 08:09:35 -06:00
|
|
|
|
|
|
|
dev = rdev->sched_scan_req->dev;
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
if (!driver_initiated) {
|
2012-06-27 08:19:42 -06:00
|
|
|
int err = rdev_sched_scan_stop(rdev, dev);
|
2011-05-12 07:28:29 -06:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2011-05-11 08:09:35 -06:00
|
|
|
|
|
|
|
nl80211_send_sched_scan(rdev, dev, NL80211_CMD_SCHED_SCAN_STOPPED);
|
|
|
|
|
|
|
|
kfree(rdev->sched_scan_req);
|
|
|
|
rdev->sched_scan_req = NULL;
|
|
|
|
|
2011-06-29 14:49:33 -06:00
|
|
|
return 0;
|
2011-05-11 08:09:35 -06:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
void cfg80211_bss_age(struct cfg80211_registered_device *rdev,
|
2009-02-11 15:14:43 -07:00
|
|
|
unsigned long age_secs)
|
|
|
|
{
|
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
list_for_each_entry(bss, &rdev->bss_list, list)
|
2009-02-11 15:14:43 -07:00
|
|
|
bss->ts -= age_jiffies;
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-11 15:14:43 -07:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
void cfg80211_bss_expire(struct cfg80211_registered_device *rdev)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
__cfg80211_bss_expire(rdev, jiffies - IEEE80211_SCAN_RESULT_EXPIRE);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
|
2010-01-26 06:15:46 -07:00
|
|
|
const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2010-01-26 06:15:46 -07:00
|
|
|
while (len > 2 && ies[0] != eid) {
|
2009-02-10 13:25:55 -07:00
|
|
|
len -= ies[1] + 2;
|
|
|
|
ies += ies[1] + 2;
|
|
|
|
}
|
|
|
|
if (len < 2)
|
|
|
|
return NULL;
|
|
|
|
if (len < 2 + ies[1])
|
|
|
|
return NULL;
|
|
|
|
return ies;
|
|
|
|
}
|
2010-01-26 06:15:46 -07:00
|
|
|
EXPORT_SYMBOL(cfg80211_find_ie);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2011-09-15 02:53:01 -06:00
|
|
|
const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type,
|
|
|
|
const u8 *ies, int len)
|
|
|
|
{
|
|
|
|
struct ieee80211_vendor_ie *ie;
|
|
|
|
const u8 *pos = ies, *end = ies + len;
|
|
|
|
int ie_oui;
|
|
|
|
|
|
|
|
while (pos < end) {
|
|
|
|
pos = cfg80211_find_ie(WLAN_EID_VENDOR_SPECIFIC, pos,
|
|
|
|
end - pos);
|
|
|
|
if (!pos)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ie = (struct ieee80211_vendor_ie *)pos;
|
2013-02-12 11:11:38 -07:00
|
|
|
|
|
|
|
/* make sure we can access ie->len */
|
|
|
|
BUILD_BUG_ON(offsetof(struct ieee80211_vendor_ie, len) != 1);
|
|
|
|
|
|
|
|
if (ie->len < sizeof(*ie))
|
|
|
|
goto cont;
|
|
|
|
|
2011-09-15 02:53:01 -06:00
|
|
|
ie_oui = ie->oui[0] << 16 | ie->oui[1] << 8 | ie->oui[2];
|
|
|
|
if (ie_oui == oui && ie->oui_type == oui_type)
|
|
|
|
return pos;
|
2013-02-12 11:11:38 -07:00
|
|
|
cont:
|
2011-09-15 02:53:01 -06:00
|
|
|
pos += 2 + ie->len;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_find_vendor_ie);
|
|
|
|
|
2012-11-28 14:39:37 -07:00
|
|
|
static bool is_bss(struct cfg80211_bss *a, const u8 *bssid,
|
2009-02-10 13:25:55 -07:00
|
|
|
const u8 *ssid, size_t ssid_len)
|
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
const struct cfg80211_bss_ies *ies;
|
2009-02-10 13:25:55 -07:00
|
|
|
const u8 *ssidie;
|
|
|
|
|
wireless: Convert compare_ether_addr to ether_addr_equal
Use the new bool function ether_addr_equal to add
some clarity and reduce the likelihood for misuse
of compare_ether_addr for sorting.
I removed a conversion from scan.c/cmp_bss_core
that appears to be a sorting function.
Done via cocci script:
$ cat compare_ether_addr.cocci
@@
expression a,b;
@@
- !compare_ether_addr(a, b)
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- compare_ether_addr(a, b)
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) == 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) != 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) == 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) != 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !!ether_addr_equal(a, b)
+ ether_addr_equal(a, b)
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-05-08 12:56:55 -06:00
|
|
|
if (bssid && !ether_addr_equal(a->bssid, bssid))
|
2009-02-10 13:25:55 -07:00
|
|
|
return false;
|
|
|
|
|
2009-02-10 13:25:59 -07:00
|
|
|
if (!ssid)
|
|
|
|
return true;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
ies = rcu_access_pointer(a->ies);
|
|
|
|
if (!ies)
|
|
|
|
return false;
|
|
|
|
ssidie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
|
2009-02-10 13:25:55 -07:00
|
|
|
if (!ssidie)
|
|
|
|
return false;
|
|
|
|
if (ssidie[1] != ssid_len)
|
|
|
|
return false;
|
|
|
|
return memcmp(ssidie + 2, ssid, ssid_len) == 0;
|
|
|
|
}
|
|
|
|
|
2013-02-01 11:20:03 -07:00
|
|
|
/**
|
|
|
|
* enum bss_compare_mode - BSS compare mode
|
|
|
|
* @BSS_CMP_REGULAR: regular compare mode (for insertion and normal find)
|
|
|
|
* @BSS_CMP_HIDE_ZLEN: find hidden SSID with zero-length mode
|
|
|
|
* @BSS_CMP_HIDE_NUL: find hidden SSID with NUL-ed out mode
|
|
|
|
*/
|
|
|
|
enum bss_compare_mode {
|
|
|
|
BSS_CMP_REGULAR,
|
|
|
|
BSS_CMP_HIDE_ZLEN,
|
|
|
|
BSS_CMP_HIDE_NUL,
|
|
|
|
};
|
|
|
|
|
2011-11-04 10:12:07 -06:00
|
|
|
static int cmp_bss(struct cfg80211_bss *a,
|
2013-01-29 16:26:45 -07:00
|
|
|
struct cfg80211_bss *b,
|
2013-02-01 11:20:03 -07:00
|
|
|
enum bss_compare_mode mode)
|
2011-11-04 10:12:07 -06:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
const struct cfg80211_bss_ies *a_ies, *b_ies;
|
2013-01-29 16:40:20 -07:00
|
|
|
const u8 *ie1 = NULL;
|
|
|
|
const u8 *ie2 = NULL;
|
2013-01-29 16:26:45 -07:00
|
|
|
int i, r;
|
2011-11-04 10:12:07 -06:00
|
|
|
|
2013-01-29 16:40:20 -07:00
|
|
|
if (a->channel != b->channel)
|
|
|
|
return b->channel->center_freq - a->channel->center_freq;
|
2011-11-04 10:12:07 -06:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
a_ies = rcu_access_pointer(a->ies);
|
|
|
|
if (!a_ies)
|
|
|
|
return -1;
|
|
|
|
b_ies = rcu_access_pointer(b->ies);
|
|
|
|
if (!b_ies)
|
|
|
|
return 1;
|
|
|
|
|
2013-01-29 16:40:20 -07:00
|
|
|
if (WLAN_CAPABILITY_IS_STA_BSS(a->capability))
|
|
|
|
ie1 = cfg80211_find_ie(WLAN_EID_MESH_ID,
|
|
|
|
a_ies->data, a_ies->len);
|
|
|
|
if (WLAN_CAPABILITY_IS_STA_BSS(b->capability))
|
|
|
|
ie2 = cfg80211_find_ie(WLAN_EID_MESH_ID,
|
|
|
|
b_ies->data, b_ies->len);
|
|
|
|
if (ie1 && ie2) {
|
|
|
|
int mesh_id_cmp;
|
|
|
|
|
|
|
|
if (ie1[1] == ie2[1])
|
|
|
|
mesh_id_cmp = memcmp(ie1 + 2, ie2 + 2, ie1[1]);
|
|
|
|
else
|
|
|
|
mesh_id_cmp = ie2[1] - ie1[1];
|
|
|
|
|
|
|
|
ie1 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
|
|
|
|
a_ies->data, a_ies->len);
|
|
|
|
ie2 = cfg80211_find_ie(WLAN_EID_MESH_CONFIG,
|
|
|
|
b_ies->data, b_ies->len);
|
|
|
|
if (ie1 && ie2) {
|
|
|
|
if (mesh_id_cmp)
|
|
|
|
return mesh_id_cmp;
|
|
|
|
if (ie1[1] != ie2[1])
|
|
|
|
return ie2[1] - ie1[1];
|
|
|
|
return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = memcmp(a->bssid, b->bssid, sizeof(a->bssid));
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
ie1 = cfg80211_find_ie(WLAN_EID_SSID, a_ies->data, a_ies->len);
|
|
|
|
ie2 = cfg80211_find_ie(WLAN_EID_SSID, b_ies->data, b_ies->len);
|
2011-11-04 10:12:07 -06:00
|
|
|
|
2013-01-29 16:26:45 -07:00
|
|
|
if (!ie1 && !ie2)
|
|
|
|
return 0;
|
|
|
|
|
2012-11-28 14:42:34 -07:00
|
|
|
/*
|
2013-01-29 16:26:45 -07:00
|
|
|
* Note that with "hide_ssid", the function returns a match if
|
|
|
|
* the already-present BSS ("b") is a hidden SSID beacon for
|
|
|
|
* the new BSS ("a").
|
2012-11-28 14:42:34 -07:00
|
|
|
*/
|
2011-11-04 10:12:07 -06:00
|
|
|
|
|
|
|
/* sort missing IE before (left of) present IE */
|
|
|
|
if (!ie1)
|
|
|
|
return -1;
|
|
|
|
if (!ie2)
|
|
|
|
return 1;
|
|
|
|
|
2013-02-01 11:20:03 -07:00
|
|
|
switch (mode) {
|
|
|
|
case BSS_CMP_HIDE_ZLEN:
|
|
|
|
/*
|
|
|
|
* In ZLEN mode we assume the BSS entry we're
|
|
|
|
* looking for has a zero-length SSID. So if
|
|
|
|
* the one we're looking at right now has that,
|
|
|
|
* return 0. Otherwise, return the difference
|
|
|
|
* in length, but since we're looking for the
|
|
|
|
* 0-length it's really equivalent to returning
|
|
|
|
* the length of the one we're looking at.
|
|
|
|
*
|
|
|
|
* No content comparison is needed as we assume
|
|
|
|
* the content length is zero.
|
|
|
|
*/
|
|
|
|
return ie2[1];
|
|
|
|
case BSS_CMP_REGULAR:
|
|
|
|
default:
|
|
|
|
/* sort by length first, then by contents */
|
|
|
|
if (ie1[1] != ie2[1])
|
|
|
|
return ie2[1] - ie1[1];
|
2013-01-29 16:26:45 -07:00
|
|
|
return memcmp(ie1 + 2, ie2 + 2, ie1[1]);
|
2013-02-01 11:20:03 -07:00
|
|
|
case BSS_CMP_HIDE_NUL:
|
|
|
|
if (ie1[1] != ie2[1])
|
|
|
|
return ie2[1] - ie1[1];
|
|
|
|
/* this is equivalent to memcmp(zeroes, ie2 + 2, len) */
|
|
|
|
for (i = 0; i < ie2[1]; i++)
|
|
|
|
if (ie2[i + 2])
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
2011-11-04 10:12:07 -06:00
|
|
|
}
|
|
|
|
|
2013-06-19 15:06:27 -06:00
|
|
|
/* Returned bss is reference counted and must be cleaned up appropriately. */
|
2009-02-10 13:25:55 -07:00
|
|
|
struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
|
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
const u8 *bssid,
|
2009-02-10 13:25:59 -07:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
|
|
|
u16 capa_mask, u16 capa_val)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2014-04-20 22:53:03 -06:00
|
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
|
2009-02-10 13:25:55 -07:00
|
|
|
struct cfg80211_internal_bss *bss, *res = NULL;
|
2010-07-13 02:55:38 -06:00
|
|
|
unsigned long now = jiffies;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_get_bss(wiphy, channel, bssid, ssid, ssid_len, capa_mask,
|
|
|
|
capa_val);
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
list_for_each_entry(bss, &rdev->bss_list, list) {
|
2009-02-10 13:25:59 -07:00
|
|
|
if ((bss->pub.capability & capa_mask) != capa_val)
|
|
|
|
continue;
|
2009-02-10 13:25:55 -07:00
|
|
|
if (channel && bss->pub.channel != channel)
|
|
|
|
continue;
|
2014-04-09 14:36:50 -06:00
|
|
|
if (!is_valid_ether_addr(bss->pub.bssid))
|
|
|
|
continue;
|
2010-07-13 02:55:38 -06:00
|
|
|
/* Don't get expired BSS structs */
|
|
|
|
if (time_after(now, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE) &&
|
|
|
|
!atomic_read(&bss->hold))
|
|
|
|
continue;
|
2009-02-10 13:25:55 -07:00
|
|
|
if (is_bss(&bss->pub, bssid, ssid, ssid_len)) {
|
|
|
|
res = bss;
|
2014-04-20 22:53:02 -06:00
|
|
|
bss_ref_get(rdev, res);
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
if (!res)
|
|
|
|
return NULL;
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_return_bss(&res->pub);
|
2009-02-10 13:25:55 -07:00
|
|
|
return &res->pub;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_get_bss);
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static void rb_insert_bss(struct cfg80211_registered_device *rdev,
|
2009-02-10 13:25:55 -07:00
|
|
|
struct cfg80211_internal_bss *bss)
|
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
struct rb_node **p = &rdev->bss_tree.rb_node;
|
2009-02-10 13:25:55 -07:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct cfg80211_internal_bss *tbss;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn);
|
|
|
|
|
2013-02-01 11:20:03 -07:00
|
|
|
cmp = cmp_bss(&bss->pub, &tbss->pub, BSS_CMP_REGULAR);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
if (WARN_ON(!cmp)) {
|
|
|
|
/* will sort of leak this BSS */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&bss->rbn, parent, p);
|
2014-04-20 22:53:02 -06:00
|
|
|
rb_insert_color(&bss->rbn, &rdev->bss_tree);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct cfg80211_internal_bss *
|
2014-04-20 22:53:02 -06:00
|
|
|
rb_find_bss(struct cfg80211_registered_device *rdev,
|
2013-01-29 16:26:45 -07:00
|
|
|
struct cfg80211_internal_bss *res,
|
2013-02-01 11:20:03 -07:00
|
|
|
enum bss_compare_mode mode)
|
2011-11-04 10:12:07 -06:00
|
|
|
{
|
2014-04-20 22:53:02 -06:00
|
|
|
struct rb_node *n = rdev->bss_tree.rb_node;
|
2011-11-04 10:12:07 -06:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
while (n) {
|
|
|
|
bss = rb_entry(n, struct cfg80211_internal_bss, rbn);
|
2013-02-01 11:20:03 -07:00
|
|
|
r = cmp_bss(&res->pub, &bss->pub, mode);
|
2011-11-04 10:12:07 -06:00
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
return bss;
|
|
|
|
else if (r < 0)
|
|
|
|
n = n->rb_left;
|
|
|
|
else
|
|
|
|
n = n->rb_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static bool cfg80211_combine_bsses(struct cfg80211_registered_device *rdev,
|
2013-01-31 18:06:18 -07:00
|
|
|
struct cfg80211_internal_bss *new)
|
2011-11-04 10:12:07 -06:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
const struct cfg80211_bss_ies *ies;
|
2013-01-31 18:06:18 -07:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
const u8 *ie;
|
|
|
|
int i, ssidlen;
|
|
|
|
u8 fold = 0;
|
2012-11-28 17:25:20 -07:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
ies = rcu_access_pointer(new->pub.beacon_ies);
|
2012-11-28 17:25:20 -07:00
|
|
|
if (WARN_ON(!ies))
|
2013-01-31 18:06:18 -07:00
|
|
|
return false;
|
2011-11-04 10:12:07 -06:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
|
|
|
|
if (!ie) {
|
|
|
|
/* nothing to do */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssidlen = ie[1];
|
|
|
|
for (i = 0; i < ssidlen; i++)
|
|
|
|
fold |= ie[2 + i];
|
|
|
|
|
|
|
|
if (fold) {
|
|
|
|
/* not a hidden SSID */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is the bad part ... */
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
list_for_each_entry(bss, &rdev->bss_list, list) {
|
2013-01-31 18:06:18 -07:00
|
|
|
if (!ether_addr_equal(bss->pub.bssid, new->pub.bssid))
|
|
|
|
continue;
|
|
|
|
if (bss->pub.channel != new->pub.channel)
|
|
|
|
continue;
|
2013-07-08 08:55:49 -06:00
|
|
|
if (bss->pub.scan_width != new->pub.scan_width)
|
|
|
|
continue;
|
2013-01-31 18:06:18 -07:00
|
|
|
if (rcu_access_pointer(bss->pub.beacon_ies))
|
|
|
|
continue;
|
|
|
|
ies = rcu_access_pointer(bss->pub.ies);
|
|
|
|
if (!ies)
|
|
|
|
continue;
|
|
|
|
ie = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
|
|
|
|
if (!ie)
|
|
|
|
continue;
|
|
|
|
if (ssidlen && ie[1] != ssidlen)
|
|
|
|
continue;
|
|
|
|
if (WARN_ON_ONCE(bss->pub.hidden_beacon_bss))
|
|
|
|
continue;
|
|
|
|
if (WARN_ON_ONCE(!list_empty(&bss->hidden_list)))
|
|
|
|
list_del(&bss->hidden_list);
|
|
|
|
/* combine them */
|
|
|
|
list_add(&bss->hidden_list, &new->hidden_list);
|
|
|
|
bss->pub.hidden_beacon_bss = &new->pub;
|
|
|
|
new->refcount += bss->refcount;
|
|
|
|
rcu_assign_pointer(bss->pub.beacon_ies,
|
|
|
|
new->pub.beacon_ies);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2011-11-04 10:12:07 -06:00
|
|
|
}
|
|
|
|
|
2013-06-19 15:06:27 -06:00
|
|
|
/* Returned bss is reference counted and must be cleaned up appropriately. */
|
2009-02-10 13:25:55 -07:00
|
|
|
static struct cfg80211_internal_bss *
|
2014-04-20 22:53:02 -06:00
|
|
|
cfg80211_bss_update(struct cfg80211_registered_device *rdev,
|
2014-03-04 07:50:13 -07:00
|
|
|
struct cfg80211_internal_bss *tmp,
|
|
|
|
bool signal_valid)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
|
|
|
struct cfg80211_internal_bss *found = NULL;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
if (WARN_ON(!tmp->pub.channel))
|
2009-02-10 13:25:55 -07:00
|
|
|
return NULL;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
tmp->ts = jiffies;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) {
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2012-11-28 17:25:20 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
found = rb_find_bss(rdev, tmp, BSS_CMP_REGULAR);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-04-16 07:00:58 -06:00
|
|
|
if (found) {
|
2010-01-06 07:19:24 -07:00
|
|
|
/* Update IEs */
|
2012-11-28 17:25:20 -07:00
|
|
|
if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
|
|
|
|
const struct cfg80211_bss_ies *old;
|
|
|
|
|
|
|
|
old = rcu_access_pointer(found->pub.proberesp_ies);
|
2009-04-16 07:00:58 -06:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
rcu_assign_pointer(found->pub.proberesp_ies,
|
|
|
|
tmp->pub.proberesp_ies);
|
2010-01-06 07:19:24 -07:00
|
|
|
/* Override possible earlier Beacon frame IEs */
|
2012-11-28 17:25:20 -07:00
|
|
|
rcu_assign_pointer(found->pub.ies,
|
|
|
|
tmp->pub.proberesp_ies);
|
|
|
|
if (old)
|
|
|
|
kfree_rcu((struct cfg80211_bss_ies *)old,
|
|
|
|
rcu_head);
|
|
|
|
} else if (rcu_access_pointer(tmp->pub.beacon_ies)) {
|
2013-01-31 17:19:48 -07:00
|
|
|
const struct cfg80211_bss_ies *old;
|
2013-01-31 18:06:18 -07:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
|
|
|
|
if (found->pub.hidden_beacon_bss &&
|
|
|
|
!list_empty(&found->hidden_list)) {
|
2013-03-06 02:31:05 -07:00
|
|
|
const struct cfg80211_bss_ies *f;
|
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
/*
|
|
|
|
* The found BSS struct is one of the probe
|
|
|
|
* response members of a group, but we're
|
|
|
|
* receiving a beacon (beacon_ies in the tmp
|
|
|
|
* bss is used). This can only mean that the
|
|
|
|
* AP changed its beacon from not having an
|
|
|
|
* SSID to showing it, which is confusing so
|
|
|
|
* drop this information.
|
|
|
|
*/
|
2013-03-06 02:31:05 -07:00
|
|
|
|
|
|
|
f = rcu_access_pointer(tmp->pub.beacon_ies);
|
|
|
|
kfree_rcu((struct cfg80211_bss_ies *)f,
|
|
|
|
rcu_head);
|
2013-01-31 18:06:18 -07:00
|
|
|
goto drop;
|
|
|
|
}
|
2012-11-28 14:39:37 -07:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
old = rcu_access_pointer(found->pub.beacon_ies);
|
|
|
|
|
|
|
|
rcu_assign_pointer(found->pub.beacon_ies,
|
|
|
|
tmp->pub.beacon_ies);
|
2010-12-09 07:05:24 -07:00
|
|
|
|
|
|
|
/* Override IEs if they were from a beacon before */
|
2013-01-31 17:19:48 -07:00
|
|
|
if (old == rcu_access_pointer(found->pub.ies))
|
2012-11-28 17:25:20 -07:00
|
|
|
rcu_assign_pointer(found->pub.ies,
|
|
|
|
tmp->pub.beacon_ies);
|
2009-04-16 07:00:58 -06:00
|
|
|
|
2013-01-31 18:06:18 -07:00
|
|
|
/* Assign beacon IEs to all sub entries */
|
|
|
|
list_for_each_entry(bss, &found->hidden_list,
|
|
|
|
hidden_list) {
|
|
|
|
const struct cfg80211_bss_ies *ies;
|
|
|
|
|
|
|
|
ies = rcu_access_pointer(bss->pub.beacon_ies);
|
|
|
|
WARN_ON(ies != old);
|
|
|
|
|
|
|
|
rcu_assign_pointer(bss->pub.beacon_ies,
|
|
|
|
tmp->pub.beacon_ies);
|
|
|
|
}
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
if (old)
|
|
|
|
kfree_rcu((struct cfg80211_bss_ies *)old,
|
|
|
|
rcu_head);
|
|
|
|
}
|
2013-03-06 02:31:05 -07:00
|
|
|
|
|
|
|
found->pub.beacon_interval = tmp->pub.beacon_interval;
|
2014-03-04 07:50:13 -07:00
|
|
|
/*
|
|
|
|
* don't update the signal if beacon was heard on
|
|
|
|
* adjacent channel.
|
|
|
|
*/
|
|
|
|
if (signal_valid)
|
|
|
|
found->pub.signal = tmp->pub.signal;
|
2013-03-06 02:31:05 -07:00
|
|
|
found->pub.capability = tmp->pub.capability;
|
|
|
|
found->ts = tmp->ts;
|
2009-02-10 13:25:55 -07:00
|
|
|
} else {
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_internal_bss *new;
|
2011-11-04 10:12:07 -06:00
|
|
|
struct cfg80211_internal_bss *hidden;
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_bss_ies *ies;
|
2011-11-04 10:12:07 -06:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
/*
|
|
|
|
* create a copy -- the "res" variable that is passed in
|
|
|
|
* is allocated on the stack since it's not needed in the
|
|
|
|
* more common case of an update
|
|
|
|
*/
|
2014-04-20 22:53:02 -06:00
|
|
|
new = kzalloc(sizeof(*new) + rdev->wiphy.bss_priv_size,
|
2012-11-28 17:25:20 -07:00
|
|
|
GFP_ATOMIC);
|
|
|
|
if (!new) {
|
|
|
|
ies = (void *)rcu_dereference(tmp->pub.beacon_ies);
|
|
|
|
if (ies)
|
|
|
|
kfree_rcu(ies, rcu_head);
|
|
|
|
ies = (void *)rcu_dereference(tmp->pub.proberesp_ies);
|
|
|
|
if (ies)
|
|
|
|
kfree_rcu(ies, rcu_head);
|
2013-01-31 18:06:18 -07:00
|
|
|
goto drop;
|
2012-11-28 17:25:20 -07:00
|
|
|
}
|
|
|
|
memcpy(new, tmp, sizeof(*new));
|
2013-01-31 18:06:18 -07:00
|
|
|
new->refcount = 1;
|
|
|
|
INIT_LIST_HEAD(&new->hidden_list);
|
|
|
|
|
|
|
|
if (rcu_access_pointer(tmp->pub.proberesp_ies)) {
|
2014-04-20 22:53:02 -06:00
|
|
|
hidden = rb_find_bss(rdev, tmp, BSS_CMP_HIDE_ZLEN);
|
2013-01-31 18:06:18 -07:00
|
|
|
if (!hidden)
|
2014-04-20 22:53:02 -06:00
|
|
|
hidden = rb_find_bss(rdev, tmp,
|
2013-01-31 18:06:18 -07:00
|
|
|
BSS_CMP_HIDE_NUL);
|
|
|
|
if (hidden) {
|
|
|
|
new->pub.hidden_beacon_bss = &hidden->pub;
|
|
|
|
list_add(&new->hidden_list,
|
|
|
|
&hidden->hidden_list);
|
|
|
|
hidden->refcount++;
|
|
|
|
rcu_assign_pointer(new->pub.beacon_ies,
|
|
|
|
hidden->pub.beacon_ies);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Ok so we found a beacon, and don't have an entry. If
|
|
|
|
* it's a beacon with hidden SSID, we might be in for an
|
|
|
|
* expensive search for any probe responses that should
|
|
|
|
* be grouped with this beacon for updates ...
|
|
|
|
*/
|
2014-04-20 22:53:02 -06:00
|
|
|
if (!cfg80211_combine_bsses(rdev, new)) {
|
2013-01-31 18:06:18 -07:00
|
|
|
kfree(new);
|
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
list_add_tail(&new->list, &rdev->bss_list);
|
|
|
|
rb_insert_bss(rdev, new);
|
2012-11-28 17:25:20 -07:00
|
|
|
found = new;
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
rdev->bss_generation++;
|
|
|
|
bss_ref_get(rdev, found);
|
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
return found;
|
2013-01-31 18:06:18 -07:00
|
|
|
drop:
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2013-01-31 18:06:18 -07:00
|
|
|
return NULL;
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
|
2012-11-23 06:23:30 -07:00
|
|
|
static struct ieee80211_channel *
|
|
|
|
cfg80211_get_bss_channel(struct wiphy *wiphy, const u8 *ie, size_t ielen,
|
|
|
|
struct ieee80211_channel *channel)
|
|
|
|
{
|
|
|
|
const u8 *tmp;
|
|
|
|
u32 freq;
|
|
|
|
int channel_number = -1;
|
|
|
|
|
|
|
|
tmp = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ie, ielen);
|
|
|
|
if (tmp && tmp[1] == 1) {
|
|
|
|
channel_number = tmp[2];
|
|
|
|
} else {
|
|
|
|
tmp = cfg80211_find_ie(WLAN_EID_HT_OPERATION, ie, ielen);
|
|
|
|
if (tmp && tmp[1] >= sizeof(struct ieee80211_ht_operation)) {
|
|
|
|
struct ieee80211_ht_operation *htop = (void *)(tmp + 2);
|
|
|
|
|
|
|
|
channel_number = htop->primary_chan;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (channel_number < 0)
|
|
|
|
return channel;
|
|
|
|
|
|
|
|
freq = ieee80211_channel_to_frequency(channel_number, channel->band);
|
|
|
|
channel = ieee80211_get_channel(wiphy, freq);
|
|
|
|
if (!channel)
|
|
|
|
return NULL;
|
|
|
|
if (channel->flags & IEEE80211_CHAN_DISABLED)
|
|
|
|
return NULL;
|
|
|
|
return channel;
|
|
|
|
}
|
|
|
|
|
2013-06-19 15:06:27 -06:00
|
|
|
/* Returned bss is reference counted and must be cleaned up appropriately. */
|
2009-03-26 15:40:09 -06:00
|
|
|
struct cfg80211_bss*
|
2013-07-08 08:55:49 -06:00
|
|
|
cfg80211_inform_bss_width(struct wiphy *wiphy,
|
2014-03-04 07:50:13 -07:00
|
|
|
struct ieee80211_channel *rx_channel,
|
2013-07-08 08:55:49 -06:00
|
|
|
enum nl80211_bss_scan_width scan_width,
|
2014-08-12 13:01:28 -06:00
|
|
|
enum cfg80211_bss_frame_type ftype,
|
2013-07-08 08:55:49 -06:00
|
|
|
const u8 *bssid, u64 tsf, u16 capability,
|
|
|
|
u16 beacon_interval, const u8 *ie, size_t ielen,
|
|
|
|
s32 signal, gfp_t gfp)
|
2009-03-26 15:40:09 -06:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_bss_ies *ies;
|
2014-03-04 07:50:13 -07:00
|
|
|
struct ieee80211_channel *channel;
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_internal_bss tmp = {}, *res;
|
2014-05-18 01:15:24 -06:00
|
|
|
bool signal_valid;
|
2009-03-26 15:40:09 -06:00
|
|
|
|
|
|
|
if (WARN_ON(!wiphy))
|
|
|
|
return NULL;
|
|
|
|
|
2010-05-12 23:04:08 -06:00
|
|
|
if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
|
2009-03-26 15:40:09 -06:00
|
|
|
(signal < 0 || signal > 100)))
|
|
|
|
return NULL;
|
|
|
|
|
2014-03-04 07:50:13 -07:00
|
|
|
channel = cfg80211_get_bss_channel(wiphy, ie, ielen, rx_channel);
|
2012-11-23 06:23:30 -07:00
|
|
|
if (!channel)
|
|
|
|
return NULL;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
memcpy(tmp.pub.bssid, bssid, ETH_ALEN);
|
|
|
|
tmp.pub.channel = channel;
|
2013-07-08 08:55:49 -06:00
|
|
|
tmp.pub.scan_width = scan_width;
|
2012-11-28 17:25:20 -07:00
|
|
|
tmp.pub.signal = signal;
|
|
|
|
tmp.pub.beacon_interval = beacon_interval;
|
|
|
|
tmp.pub.capability = capability;
|
2010-01-06 07:19:24 -07:00
|
|
|
/*
|
2014-08-12 13:01:28 -06:00
|
|
|
* If we do not know here whether the IEs are from a Beacon or Probe
|
2010-01-06 07:19:24 -07:00
|
|
|
* Response frame, we need to pick one of the options and only use it
|
|
|
|
* with the driver that does not provide the full Beacon/Probe Response
|
|
|
|
* frame. Use Beacon frame pointer to avoid indicating that this should
|
2013-01-30 13:33:19 -07:00
|
|
|
* override the IEs pointer should we have received an earlier
|
2012-11-28 17:25:20 -07:00
|
|
|
* indication of Probe Response data.
|
2010-01-06 07:19:24 -07:00
|
|
|
*/
|
2014-08-12 12:34:30 -06:00
|
|
|
ies = kzalloc(sizeof(*ies) + ielen, gfp);
|
2012-11-28 17:25:20 -07:00
|
|
|
if (!ies)
|
|
|
|
return NULL;
|
|
|
|
ies->len = ielen;
|
2013-02-05 08:54:31 -07:00
|
|
|
ies->tsf = tsf;
|
2014-08-12 12:34:30 -06:00
|
|
|
ies->from_beacon = false;
|
2012-11-28 17:25:20 -07:00
|
|
|
memcpy(ies->data, ie, ielen);
|
2009-03-26 15:40:09 -06:00
|
|
|
|
2014-08-12 13:01:28 -06:00
|
|
|
switch (ftype) {
|
|
|
|
case CFG80211_BSS_FTYPE_BEACON:
|
|
|
|
ies->from_beacon = true;
|
|
|
|
/* fall through to assign */
|
|
|
|
case CFG80211_BSS_FTYPE_UNKNOWN:
|
|
|
|
rcu_assign_pointer(tmp.pub.beacon_ies, ies);
|
|
|
|
break;
|
|
|
|
case CFG80211_BSS_FTYPE_PRESP:
|
|
|
|
rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
|
|
|
|
break;
|
|
|
|
}
|
2012-11-28 17:25:20 -07:00
|
|
|
rcu_assign_pointer(tmp.pub.ies, ies);
|
2009-03-26 15:40:09 -06:00
|
|
|
|
2014-05-18 01:15:24 -06:00
|
|
|
signal_valid = abs(rx_channel->center_freq - channel->center_freq) <=
|
|
|
|
wiphy->max_adj_channel_rssi_comp;
|
|
|
|
res = cfg80211_bss_update(wiphy_to_rdev(wiphy), &tmp, signal_valid);
|
2009-03-26 15:40:09 -06:00
|
|
|
if (!res)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (res->pub.capability & WLAN_CAPABILITY_ESS)
|
|
|
|
regulatory_hint_found_beacon(wiphy, channel, gfp);
|
|
|
|
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_return_bss(&res->pub);
|
2009-03-26 15:40:09 -06:00
|
|
|
/* cfg80211_bss_update gives us a referenced result */
|
|
|
|
return &res->pub;
|
|
|
|
}
|
2013-07-08 08:55:49 -06:00
|
|
|
EXPORT_SYMBOL(cfg80211_inform_bss_width);
|
2009-03-26 15:40:09 -06:00
|
|
|
|
2013-06-19 15:06:27 -06:00
|
|
|
/* Returned bss is reference counted and must be cleaned up appropriately. */
|
2009-02-10 13:25:55 -07:00
|
|
|
struct cfg80211_bss *
|
2013-07-08 08:55:49 -06:00
|
|
|
cfg80211_inform_bss_width_frame(struct wiphy *wiphy,
|
2014-03-04 07:50:13 -07:00
|
|
|
struct ieee80211_channel *rx_channel,
|
2013-07-08 08:55:49 -06:00
|
|
|
enum nl80211_bss_scan_width scan_width,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len,
|
|
|
|
s32 signal, gfp_t gfp)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
struct cfg80211_internal_bss tmp = {}, *res;
|
|
|
|
struct cfg80211_bss_ies *ies;
|
2014-03-04 07:50:13 -07:00
|
|
|
struct ieee80211_channel *channel;
|
2014-05-18 01:15:24 -06:00
|
|
|
bool signal_valid;
|
2009-02-10 13:25:55 -07:00
|
|
|
size_t ielen = len - offsetof(struct ieee80211_mgmt,
|
|
|
|
u.probe_resp.variable);
|
2011-03-26 12:26:55 -06:00
|
|
|
|
2012-11-23 06:23:30 -07:00
|
|
|
BUILD_BUG_ON(offsetof(struct ieee80211_mgmt, u.probe_resp.variable) !=
|
|
|
|
offsetof(struct ieee80211_mgmt, u.beacon.variable));
|
|
|
|
|
2014-03-04 07:50:13 -07:00
|
|
|
trace_cfg80211_inform_bss_width_frame(wiphy, rx_channel, scan_width, mgmt,
|
2013-07-08 08:55:49 -06:00
|
|
|
len, signal);
|
2012-08-27 03:49:39 -06:00
|
|
|
|
2011-03-26 12:26:55 -06:00
|
|
|
if (WARN_ON(!mgmt))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (WARN_ON(!wiphy))
|
|
|
|
return NULL;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2010-05-12 23:04:08 -06:00
|
|
|
if (WARN_ON(wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
|
2012-08-26 02:00:28 -06:00
|
|
|
(signal < 0 || signal > 100)))
|
2009-02-10 13:25:55 -07:00
|
|
|
return NULL;
|
|
|
|
|
2011-03-26 12:26:55 -06:00
|
|
|
if (WARN_ON(len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable)))
|
2009-02-10 13:25:55 -07:00
|
|
|
return NULL;
|
|
|
|
|
2012-11-23 06:23:30 -07:00
|
|
|
channel = cfg80211_get_bss_channel(wiphy, mgmt->u.beacon.variable,
|
2014-03-04 07:50:13 -07:00
|
|
|
ielen, rx_channel);
|
2012-11-23 06:23:30 -07:00
|
|
|
if (!channel)
|
|
|
|
return NULL;
|
|
|
|
|
2014-08-12 12:34:30 -06:00
|
|
|
ies = kzalloc(sizeof(*ies) + ielen, gfp);
|
2012-11-28 17:25:20 -07:00
|
|
|
if (!ies)
|
2009-02-10 13:25:55 -07:00
|
|
|
return NULL;
|
2012-11-28 17:25:20 -07:00
|
|
|
ies->len = ielen;
|
2013-02-05 08:54:31 -07:00
|
|
|
ies->tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp);
|
2014-08-12 12:34:30 -06:00
|
|
|
ies->from_beacon = ieee80211_is_beacon(mgmt->frame_control);
|
2012-11-28 17:25:20 -07:00
|
|
|
memcpy(ies->data, mgmt->u.probe_resp.variable, ielen);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
if (ieee80211_is_probe_resp(mgmt->frame_control))
|
|
|
|
rcu_assign_pointer(tmp.pub.proberesp_ies, ies);
|
|
|
|
else
|
|
|
|
rcu_assign_pointer(tmp.pub.beacon_ies, ies);
|
|
|
|
rcu_assign_pointer(tmp.pub.ies, ies);
|
|
|
|
|
|
|
|
memcpy(tmp.pub.bssid, mgmt->bssid, ETH_ALEN);
|
|
|
|
tmp.pub.channel = channel;
|
2013-07-08 08:55:49 -06:00
|
|
|
tmp.pub.scan_width = scan_width;
|
2012-11-28 17:25:20 -07:00
|
|
|
tmp.pub.signal = signal;
|
|
|
|
tmp.pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int);
|
|
|
|
tmp.pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info);
|
|
|
|
|
2014-05-18 01:15:24 -06:00
|
|
|
signal_valid = abs(rx_channel->center_freq - channel->center_freq) <=
|
|
|
|
wiphy->max_adj_channel_rssi_comp;
|
|
|
|
res = cfg80211_bss_update(wiphy_to_rdev(wiphy), &tmp, signal_valid);
|
2009-02-10 13:25:55 -07:00
|
|
|
if (!res)
|
|
|
|
return NULL;
|
|
|
|
|
2009-02-20 22:20:39 -07:00
|
|
|
if (res->pub.capability & WLAN_CAPABILITY_ESS)
|
|
|
|
regulatory_hint_found_beacon(wiphy, channel, gfp);
|
|
|
|
|
2012-08-27 03:49:39 -06:00
|
|
|
trace_cfg80211_return_bss(&res->pub);
|
2009-02-10 13:25:55 -07:00
|
|
|
/* cfg80211_bss_update gives us a referenced result */
|
|
|
|
return &res->pub;
|
|
|
|
}
|
2013-07-08 08:55:49 -06:00
|
|
|
EXPORT_SYMBOL(cfg80211_inform_bss_width_frame);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2013-01-31 17:49:58 -07:00
|
|
|
void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
|
2012-01-20 05:55:26 -07:00
|
|
|
{
|
2014-04-20 22:53:03 -06:00
|
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
|
2012-01-20 05:55:26 -07:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
|
|
|
|
if (!pub)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bss = container_of(pub, struct cfg80211_internal_bss, pub);
|
2013-01-31 18:06:18 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
bss_ref_get(rdev, bss);
|
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2012-01-20 05:55:26 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_ref_bss);
|
|
|
|
|
2013-01-31 17:49:58 -07:00
|
|
|
void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2014-04-20 22:53:03 -06:00
|
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
|
2009-02-10 13:25:55 -07:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
|
|
|
|
if (!pub)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bss = container_of(pub, struct cfg80211_internal_bss, pub);
|
2013-01-31 18:06:18 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
bss_ref_put(rdev, bss);
|
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_put_bss);
|
|
|
|
|
2009-02-10 13:25:58 -07:00
|
|
|
void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub)
|
|
|
|
{
|
2014-04-20 22:53:03 -06:00
|
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
|
2009-02-10 13:25:58 -07:00
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
|
|
|
|
if (WARN_ON(!pub))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bss = container_of(pub, struct cfg80211_internal_bss, pub);
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
2010-10-06 13:18:04 -06:00
|
|
|
if (!list_empty(&bss->list)) {
|
2014-04-20 22:53:02 -06:00
|
|
|
if (__cfg80211_unlink_bss(rdev, bss))
|
|
|
|
rdev->bss_generation++;
|
2010-10-06 13:18:04 -06:00
|
|
|
}
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:58 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(cfg80211_unlink_bss);
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
2013-05-08 13:34:22 -06:00
|
|
|
static struct cfg80211_registered_device *
|
|
|
|
cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
|
|
|
|
{
|
2013-05-08 13:45:15 -06:00
|
|
|
struct cfg80211_registered_device *rdev;
|
2013-05-08 13:34:22 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
|
2013-05-08 13:45:15 -06:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2013-05-08 13:34:22 -06:00
|
|
|
dev = dev_get_by_index(net, ifindex);
|
|
|
|
if (!dev)
|
2013-05-08 13:45:15 -06:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
if (dev->ieee80211_ptr)
|
2014-04-20 22:53:03 -06:00
|
|
|
rdev = wiphy_to_rdev(dev->ieee80211_ptr->wiphy);
|
2013-05-08 13:45:15 -06:00
|
|
|
else
|
2013-05-08 13:34:22 -06:00
|
|
|
rdev = ERR_PTR(-ENODEV);
|
|
|
|
dev_put(dev);
|
|
|
|
return rdev;
|
|
|
|
}
|
|
|
|
|
2009-02-10 13:25:55 -07:00
|
|
|
int cfg80211_wext_siwscan(struct net_device *dev,
|
|
|
|
struct iw_request_info *info,
|
|
|
|
union iwreq_data *wrqu, char *extra)
|
|
|
|
{
|
|
|
|
struct cfg80211_registered_device *rdev;
|
|
|
|
struct wiphy *wiphy;
|
|
|
|
struct iw_scan_req *wreq = NULL;
|
2009-12-23 07:33:35 -07:00
|
|
|
struct cfg80211_scan_request *creq = NULL;
|
2009-02-10 13:25:55 -07:00
|
|
|
int i, err, n_channels = 0;
|
|
|
|
enum ieee80211_band band;
|
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
return -ENETDOWN;
|
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
if (wrqu->data.length == sizeof(struct iw_scan_req))
|
|
|
|
wreq = (struct iw_scan_req *)extra;
|
|
|
|
|
2009-07-13 16:33:35 -06:00
|
|
|
rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
if (IS_ERR(rdev))
|
|
|
|
return PTR_ERR(rdev);
|
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
if (rdev->scan_req || rdev->scan_msg) {
|
2009-02-10 13:25:55 -07:00
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
wiphy = &rdev->wiphy;
|
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
/* Determine number of channels, needed to allocate creq */
|
|
|
|
if (wreq && wreq->num_channels)
|
|
|
|
n_channels = wreq->num_channels;
|
2014-01-09 02:37:23 -07:00
|
|
|
else
|
|
|
|
n_channels = ieee80211_get_num_supported_channels(wiphy);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
|
|
|
|
n_channels * sizeof(void *),
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (!creq) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
creq->wiphy = wiphy;
|
2012-06-18 11:17:03 -06:00
|
|
|
creq->wdev = dev->ieee80211_ptr;
|
2009-08-07 09:54:07 -06:00
|
|
|
/* SSIDs come after channels */
|
|
|
|
creq->ssids = (void *)&creq->channels[n_channels];
|
2009-02-10 13:25:55 -07:00
|
|
|
creq->n_channels = n_channels;
|
|
|
|
creq->n_ssids = 1;
|
2012-10-11 22:03:34 -06:00
|
|
|
creq->scan_start = jiffies;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
/* translate "Scan on frequencies" request */
|
2009-02-10 13:25:55 -07:00
|
|
|
i = 0;
|
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
|
|
|
int j;
|
2009-11-02 05:32:03 -07:00
|
|
|
|
2009-02-10 13:25:55 -07:00
|
|
|
if (!wiphy->bands[band])
|
|
|
|
continue;
|
2009-11-02 05:32:03 -07:00
|
|
|
|
2009-02-10 13:25:55 -07:00
|
|
|
for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
|
2009-11-02 05:32:03 -07:00
|
|
|
/* ignore disabled channels */
|
|
|
|
if (wiphy->bands[band]->channels[j].flags &
|
|
|
|
IEEE80211_CHAN_DISABLED)
|
|
|
|
continue;
|
2009-09-09 05:09:54 -06:00
|
|
|
|
|
|
|
/* If we have a wireless request structure and the
|
|
|
|
* wireless request specifies frequencies, then search
|
|
|
|
* for the matching hardware channel.
|
|
|
|
*/
|
|
|
|
if (wreq && wreq->num_channels) {
|
|
|
|
int k;
|
|
|
|
int wiphy_freq = wiphy->bands[band]->channels[j].center_freq;
|
|
|
|
for (k = 0; k < wreq->num_channels; k++) {
|
2014-04-08 19:28:06 -06:00
|
|
|
struct iw_freq *freq =
|
|
|
|
&wreq->channel_list[k];
|
|
|
|
int wext_freq =
|
|
|
|
cfg80211_wext_freq(freq);
|
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
if (wext_freq == wiphy_freq)
|
|
|
|
goto wext_freq_found;
|
|
|
|
}
|
|
|
|
goto wext_freq_not_found;
|
|
|
|
}
|
|
|
|
|
|
|
|
wext_freq_found:
|
2009-02-10 13:25:55 -07:00
|
|
|
creq->channels[i] = &wiphy->bands[band]->channels[j];
|
|
|
|
i++;
|
2009-09-09 05:09:54 -06:00
|
|
|
wext_freq_not_found: ;
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
}
|
2009-09-11 02:13:55 -06:00
|
|
|
/* No channels found? */
|
|
|
|
if (!i) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
/* Set real number of channels specified in creq->channels[] */
|
|
|
|
creq->n_channels = i;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-09-09 05:09:54 -06:00
|
|
|
/* translate "Scan for SSID" request */
|
|
|
|
if (wreq) {
|
2009-02-10 13:25:55 -07:00
|
|
|
if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
|
2009-12-23 07:33:35 -07:00
|
|
|
if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
|
|
|
|
creq->ssids[0].ssid_len = wreq->essid_len;
|
|
|
|
}
|
|
|
|
if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE)
|
|
|
|
creq->n_ssids = 0;
|
|
|
|
}
|
|
|
|
|
2011-07-18 10:08:35 -06:00
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++)
|
2011-07-19 16:52:16 -06:00
|
|
|
if (wiphy->bands[i])
|
|
|
|
creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
|
2011-07-18 10:08:35 -06:00
|
|
|
|
2009-02-10 13:25:55 -07:00
|
|
|
rdev->scan_req = creq;
|
2012-06-27 08:19:42 -06:00
|
|
|
err = rdev_scan(rdev, creq);
|
2009-02-10 13:25:55 -07:00
|
|
|
if (err) {
|
|
|
|
rdev->scan_req = NULL;
|
2009-12-23 07:33:35 -07:00
|
|
|
/* creq will be freed below */
|
2009-07-13 16:33:35 -06:00
|
|
|
} else {
|
2012-06-18 11:17:03 -06:00
|
|
|
nl80211_send_scan_start(rdev, dev->ieee80211_ptr);
|
2009-12-23 07:33:35 -07:00
|
|
|
/* creq now owned by driver */
|
|
|
|
creq = NULL;
|
2009-07-13 16:33:35 -06:00
|
|
|
dev_hold(dev);
|
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
out:
|
2009-12-23 07:33:35 -07:00
|
|
|
kfree(creq);
|
2009-02-10 13:25:55 -07:00
|
|
|
return err;
|
|
|
|
}
|
2009-04-20 10:49:39 -06:00
|
|
|
EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
static void ieee80211_scan_add_ies(struct iw_request_info *info,
|
2012-11-28 17:25:20 -07:00
|
|
|
const struct cfg80211_bss_ies *ies,
|
2009-02-10 13:25:55 -07:00
|
|
|
char **current_ev, char *end_buf)
|
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
const u8 *pos, *end, *next;
|
2009-02-10 13:25:55 -07:00
|
|
|
struct iw_event iwe;
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
if (!ies)
|
2009-02-10 13:25:55 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If needed, fragment the IEs buffer (at IE boundaries) into short
|
|
|
|
* enough fragments to fit into IW_GENERIC_IE_MAX octet messages.
|
|
|
|
*/
|
2012-11-28 17:25:20 -07:00
|
|
|
pos = ies->data;
|
|
|
|
end = pos + ies->len;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
while (end - pos > IW_GENERIC_IE_MAX) {
|
|
|
|
next = pos + 2 + pos[1];
|
|
|
|
while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX)
|
|
|
|
next = next + 2 + next[1];
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVGENIE;
|
|
|
|
iwe.u.data.length = next - pos;
|
|
|
|
*current_ev = iwe_stream_add_point(info, *current_ev,
|
2012-11-28 17:25:20 -07:00
|
|
|
end_buf, &iwe,
|
|
|
|
(void *)pos);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
pos = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end > pos) {
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVGENIE;
|
|
|
|
iwe.u.data.length = end - pos;
|
|
|
|
*current_ev = iwe_stream_add_point(info, *current_ev,
|
2012-11-28 17:25:20 -07:00
|
|
|
end_buf, &iwe,
|
|
|
|
(void *)pos);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2009-02-18 10:45:06 -07:00
|
|
|
ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
|
|
|
|
struct cfg80211_internal_bss *bss, char *current_ev,
|
|
|
|
char *end_buf)
|
2009-02-10 13:25:55 -07:00
|
|
|
{
|
2012-11-28 17:25:20 -07:00
|
|
|
const struct cfg80211_bss_ies *ies;
|
2009-02-10 13:25:55 -07:00
|
|
|
struct iw_event iwe;
|
2012-11-28 17:25:20 -07:00
|
|
|
const u8 *ie;
|
2009-02-10 13:25:55 -07:00
|
|
|
u8 *buf, *cfg, *p;
|
2012-11-28 17:25:20 -07:00
|
|
|
int rem, i, sig;
|
2009-02-10 13:25:55 -07:00
|
|
|
bool ismesh = false;
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWAP;
|
|
|
|
iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
|
|
|
|
memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN);
|
|
|
|
current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
|
|
|
|
IW_EV_ADDR_LEN);
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWFREQ;
|
|
|
|
iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq);
|
|
|
|
iwe.u.freq.e = 0;
|
|
|
|
current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
|
|
|
|
IW_EV_FREQ_LEN);
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWFREQ;
|
|
|
|
iwe.u.freq.m = bss->pub.channel->center_freq;
|
|
|
|
iwe.u.freq.e = 6;
|
|
|
|
current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
|
|
|
|
IW_EV_FREQ_LEN);
|
|
|
|
|
2009-02-18 10:45:06 -07:00
|
|
|
if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) {
|
2009-02-10 13:25:55 -07:00
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVQUAL;
|
|
|
|
iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED |
|
|
|
|
IW_QUAL_NOISE_INVALID |
|
2009-02-18 10:27:22 -07:00
|
|
|
IW_QUAL_QUAL_UPDATED;
|
2009-02-18 10:45:06 -07:00
|
|
|
switch (wiphy->signal_type) {
|
2009-02-10 13:25:55 -07:00
|
|
|
case CFG80211_SIGNAL_TYPE_MBM:
|
2009-02-18 10:27:22 -07:00
|
|
|
sig = bss->pub.signal / 100;
|
|
|
|
iwe.u.qual.level = sig;
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.qual.updated |= IW_QUAL_DBM;
|
2009-02-18 10:27:22 -07:00
|
|
|
if (sig < -110) /* rather bad */
|
|
|
|
sig = -110;
|
|
|
|
else if (sig > -40) /* perfect */
|
|
|
|
sig = -40;
|
|
|
|
/* will give a range of 0 .. 70 */
|
|
|
|
iwe.u.qual.qual = sig + 110;
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
case CFG80211_SIGNAL_TYPE_UNSPEC:
|
|
|
|
iwe.u.qual.level = bss->pub.signal;
|
2009-02-18 10:27:22 -07:00
|
|
|
/* will give range 0 .. 100 */
|
|
|
|
iwe.u.qual.qual = bss->pub.signal;
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* not reached */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
current_ev = iwe_stream_add_event(info, current_ev, end_buf,
|
|
|
|
&iwe, IW_EV_QUAL_LEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWENCODE;
|
|
|
|
if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY)
|
|
|
|
iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
|
|
|
|
else
|
|
|
|
iwe.u.data.flags = IW_ENCODE_DISABLED;
|
|
|
|
iwe.u.data.length = 0;
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev, end_buf,
|
|
|
|
&iwe, "");
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
ies = rcu_dereference(bss->pub.ies);
|
2013-02-05 08:51:29 -07:00
|
|
|
rem = ies->len;
|
|
|
|
ie = ies->data;
|
2012-11-28 17:25:20 -07:00
|
|
|
|
2013-02-05 08:51:29 -07:00
|
|
|
while (rem >= 2) {
|
2009-02-10 13:25:55 -07:00
|
|
|
/* invalid data */
|
|
|
|
if (ie[1] > rem - 2)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (ie[0]) {
|
|
|
|
case WLAN_EID_SSID:
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWESSID;
|
|
|
|
iwe.u.data.length = ie[1];
|
|
|
|
iwe.u.data.flags = 1;
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev, end_buf,
|
2012-11-28 17:25:20 -07:00
|
|
|
&iwe, (u8 *)ie + 2);
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWESSID;
|
|
|
|
iwe.u.data.length = ie[1];
|
|
|
|
iwe.u.data.flags = 1;
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev, end_buf,
|
2012-11-28 17:25:20 -07:00
|
|
|
&iwe, (u8 *)ie + 2);
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
ismesh = true;
|
2009-11-18 11:40:00 -07:00
|
|
|
if (ie[1] != sizeof(struct ieee80211_meshconf_ie))
|
2009-02-10 13:25:55 -07:00
|
|
|
break;
|
|
|
|
buf = kmalloc(50, GFP_ATOMIC);
|
|
|
|
if (!buf)
|
|
|
|
break;
|
2012-11-28 17:25:20 -07:00
|
|
|
cfg = (u8 *)ie + 2;
|
2009-02-10 13:25:55 -07:00
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVCUSTOM;
|
2009-11-18 11:22:59 -07:00
|
|
|
sprintf(buf, "Mesh Network Path Selection Protocol ID: "
|
|
|
|
"0x%02X", cfg[0]);
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
2009-11-18 11:22:59 -07:00
|
|
|
sprintf(buf, "Path Selection Metric ID: 0x%02X",
|
|
|
|
cfg[1]);
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
2009-11-18 11:22:59 -07:00
|
|
|
sprintf(buf, "Congestion Control Mode ID: 0x%02X",
|
|
|
|
cfg[2]);
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
2009-11-18 11:22:59 -07:00
|
|
|
sprintf(buf, "Synchronization ID: 0x%02X", cfg[3]);
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
2009-11-18 11:22:59 -07:00
|
|
|
sprintf(buf, "Authentication ID: 0x%02X", cfg[4]);
|
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
|
|
|
sprintf(buf, "Formation Info: 0x%02X", cfg[5]);
|
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
|
|
|
sprintf(buf, "Capabilities: 0x%02X", cfg[6]);
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf,
|
|
|
|
&iwe, buf);
|
|
|
|
kfree(buf);
|
|
|
|
break;
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
/* display all supported rates in readable format */
|
|
|
|
p = current_ev + iwe_stream_lcp_len(info);
|
|
|
|
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWRATE;
|
|
|
|
/* Those two flags are ignored... */
|
|
|
|
iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ie[1]; i++) {
|
|
|
|
iwe.u.bitrate.value =
|
|
|
|
((ie[i + 2] & 0x7f) * 500000);
|
|
|
|
p = iwe_stream_add_value(info, current_ev, p,
|
|
|
|
end_buf, &iwe, IW_EV_PARAM_LEN);
|
|
|
|
}
|
|
|
|
current_ev = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
rem -= ie[1] + 2;
|
|
|
|
ie += ie[1] + 2;
|
|
|
|
}
|
|
|
|
|
2009-11-29 17:55:45 -07:00
|
|
|
if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
|
|
|
|
ismesh) {
|
2009-02-10 13:25:55 -07:00
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = SIOCGIWMODE;
|
|
|
|
if (ismesh)
|
|
|
|
iwe.u.mode = IW_MODE_MESH;
|
|
|
|
else if (bss->pub.capability & WLAN_CAPABILITY_ESS)
|
|
|
|
iwe.u.mode = IW_MODE_MASTER;
|
|
|
|
else
|
|
|
|
iwe.u.mode = IW_MODE_ADHOC;
|
|
|
|
current_ev = iwe_stream_add_event(info, current_ev, end_buf,
|
|
|
|
&iwe, IW_EV_UINT_LEN);
|
|
|
|
}
|
|
|
|
|
2013-01-23 23:40:00 -07:00
|
|
|
buf = kmalloc(31, GFP_ATOMIC);
|
2009-02-10 13:25:55 -07:00
|
|
|
if (buf) {
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVCUSTOM;
|
2013-02-05 08:54:31 -07:00
|
|
|
sprintf(buf, "tsf=%016llx", (unsigned long long)(ies->tsf));
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev, end_buf,
|
|
|
|
&iwe, buf);
|
|
|
|
memset(&iwe, 0, sizeof(iwe));
|
|
|
|
iwe.cmd = IWEVCUSTOM;
|
2009-02-11 15:14:43 -07:00
|
|
|
sprintf(buf, " Last beacon: %ums ago",
|
|
|
|
elapsed_jiffies_msecs(bss->ts));
|
2009-02-10 13:25:55 -07:00
|
|
|
iwe.u.data.length = strlen(buf);
|
|
|
|
current_ev = iwe_stream_add_point(info, current_ev,
|
|
|
|
end_buf, &iwe, buf);
|
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
|
2012-11-28 17:25:20 -07:00
|
|
|
ieee80211_scan_add_ies(info, ies, ¤t_ev, end_buf);
|
|
|
|
rcu_read_unlock();
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
return current_ev;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
static int ieee80211_scan_results(struct cfg80211_registered_device *rdev,
|
2009-02-10 13:25:55 -07:00
|
|
|
struct iw_request_info *info,
|
|
|
|
char *buf, size_t len)
|
|
|
|
{
|
|
|
|
char *current_ev = buf;
|
|
|
|
char *end_buf = buf + len;
|
|
|
|
struct cfg80211_internal_bss *bss;
|
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_lock_bh(&rdev->bss_lock);
|
|
|
|
cfg80211_bss_expire(rdev);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2014-04-20 22:53:02 -06:00
|
|
|
list_for_each_entry(bss, &rdev->bss_list, list) {
|
2009-02-10 13:25:55 -07:00
|
|
|
if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
return -E2BIG;
|
|
|
|
}
|
2014-04-20 22:53:02 -06:00
|
|
|
current_ev = ieee80211_bss(&rdev->wiphy, info, bss,
|
2009-02-18 10:45:06 -07:00
|
|
|
current_ev, end_buf);
|
2009-02-10 13:25:55 -07:00
|
|
|
}
|
2014-04-20 22:53:02 -06:00
|
|
|
spin_unlock_bh(&rdev->bss_lock);
|
2009-02-10 13:25:55 -07:00
|
|
|
return current_ev - buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int cfg80211_wext_giwscan(struct net_device *dev,
|
|
|
|
struct iw_request_info *info,
|
|
|
|
struct iw_point *data, char *extra)
|
|
|
|
{
|
|
|
|
struct cfg80211_registered_device *rdev;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
return -ENETDOWN;
|
|
|
|
|
2009-07-13 16:33:35 -06:00
|
|
|
rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
if (IS_ERR(rdev))
|
|
|
|
return PTR_ERR(rdev);
|
|
|
|
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 02:14:19 -07:00
|
|
|
if (rdev->scan_req || rdev->scan_msg)
|
2013-05-08 13:45:15 -06:00
|
|
|
return -EAGAIN;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
res = ieee80211_scan_results(rdev, info, extra, data->length);
|
|
|
|
data->length = 0;
|
|
|
|
if (res >= 0) {
|
|
|
|
data->length = res;
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2009-04-20 10:49:39 -06:00
|
|
|
EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
|
2009-02-10 13:25:55 -07:00
|
|
|
#endif
|