68e8e04e93
o major overhaul of the way channels are handled: channels are now
fully enumerated and uniquely identify the operating characteristics;
these changes are visible to user applications which require changes
o make scanning support independent of the state machine to enable
background scanning and roaming
o move scanning support into loadable modules based on the operating
mode to enable different policies and reduce the memory footprint
on systems w/ constrained resources
o add background scanning in station mode (no support for adhoc/ibss
mode yet)
o significantly speedup sta mode scanning with a variety of techniques
o add roaming support when background scanning is supported; for now
we use a simple algorithm to trigger a roam: we threshold the rssi
and tx rate, if either drops too low we try to roam to a new ap
o add tx fragmentation support
o add first cut at 802.11n support: this code works with forthcoming
drivers but is incomplete; it's included now to establish a baseline
for other drivers to be developed and for user applications
o adjust max_linkhdr et. al. to reflect 802.11 requirements; this eliminates
prepending mbufs for traffic generated locally
o add support for Atheros protocol extensions; mainly the fast frames
encapsulation (note this can be used with any card that can tx+rx
large frames correctly)
o add sta support for ap's that beacon both WPA1+2 support
o change all data types from bsd-style to posix-style
o propagate noise floor data from drivers to net80211 and on to user apps
o correct various issues in the sta mode state machine related to handling
authentication and association failures
o enable the addition of sta mode power save support for drivers that need
net80211 support (not in this commit)
o remove old WI compatibility ioctls (wicontrol is officially dead)
o change the data structures returned for get sta info and get scan
results so future additions will not break user apps
o fixed tx rate is now maintained internally as an ieee rate and not an
index into the rate set; this needs to be extended to deal with
multi-mode operation
o add extended channel specifications to radiotap to enable 11n sniffing
Drivers:
o ath: add support for bg scanning, tx fragmentation, fast frames,
dynamic turbo (lightly tested), 11n (sniffing only and needs
new hal)
o awi: compile tested only
o ndis: lightly tested
o ipw: lightly tested
o iwi: add support for bg scanning (well tested but may have some
rough edges)
o ral, ural, rum: add suppoort for bg scanning, calibrate rssi data
o wi: lightly tested
This work is based on contributions by Atheros, kmacy, sephe, thompsa,
mlaier, kevlo, and others. Much of the scanning work was supported by
Atheros. The 11n work was supported by Marvell.
408 lines
10 KiB
C
408 lines
10 KiB
C
/*-
|
|
* Copyright (c) 2002-2007 Sam Leffler, Errno Consulting
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* IEEE 802.11 ap scanning support.
|
|
*/
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_media.h>
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net80211/ieee80211_var.h>
|
|
|
|
#include <net/bpf.h>
|
|
|
|
struct ap_state {
|
|
int as_maxrssi[IEEE80211_CHAN_MAX];
|
|
};
|
|
|
|
static int ap_flush(struct ieee80211_scan_state *);
|
|
|
|
/* number of references from net80211 layer */
|
|
static int nrefs = 0;
|
|
|
|
/*
|
|
* Attach prior to any scanning work.
|
|
*/
|
|
static int
|
|
ap_attach(struct ieee80211_scan_state *ss)
|
|
{
|
|
struct ap_state *as;
|
|
|
|
MALLOC(as, struct ap_state *, sizeof(struct ap_state),
|
|
M_80211_SCAN, M_NOWAIT);
|
|
ss->ss_priv = as;
|
|
ap_flush(ss);
|
|
nrefs++; /* NB: we assume caller locking */
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Cleanup any private state.
|
|
*/
|
|
static int
|
|
ap_detach(struct ieee80211_scan_state *ss)
|
|
{
|
|
struct ap_state *as = ss->ss_priv;
|
|
|
|
if (as != NULL) {
|
|
KASSERT(nrefs > 0, ("imbalanced attach/detach"));
|
|
nrefs--; /* NB: we assume caller locking */
|
|
FREE(as, M_80211_SCAN);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Flush all per-scan state.
|
|
*/
|
|
static int
|
|
ap_flush(struct ieee80211_scan_state *ss)
|
|
{
|
|
struct ap_state *as = ss->ss_priv;
|
|
|
|
memset(as->as_maxrssi, 0, sizeof(as->as_maxrssi));
|
|
ss->ss_last = 0; /* insure no channel will be picked */
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
find11gchannel(struct ieee80211com *ic, int i, int freq)
|
|
{
|
|
const struct ieee80211_channel *c;
|
|
int j;
|
|
|
|
/*
|
|
* The normal ordering in the channel list is b channel
|
|
* immediately followed by g so optimize the search for
|
|
* this. We'll still do a full search just in case.
|
|
*/
|
|
for (j = i+1; j < ic->ic_nchans; j++) {
|
|
c = &ic->ic_channels[j];
|
|
if (c->ic_freq == freq && IEEE80211_IS_CHAN_ANYG(c))
|
|
return 1;
|
|
}
|
|
for (j = 0; j < i; j++) {
|
|
c = &ic->ic_channels[j];
|
|
if (c->ic_freq == freq && IEEE80211_IS_CHAN_ANYG(c))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Start an ap scan by populating the channel list.
|
|
*/
|
|
static int
|
|
ap_start(struct ieee80211_scan_state *ss, struct ieee80211com *ic)
|
|
{
|
|
struct ieee80211_channel *c;
|
|
int i;
|
|
|
|
ss->ss_last = 0;
|
|
if (ic->ic_des_mode == IEEE80211_MODE_AUTO) {
|
|
for (i = 0; i < ic->ic_nchans; i++) {
|
|
c = &ic->ic_channels[i];
|
|
if (IEEE80211_IS_CHAN_TURBO(c)) {
|
|
#ifdef IEEE80211_F_XR
|
|
/* XR is not supported on turbo channels */
|
|
if (ic->ic_flags & IEEE80211_F_XR)
|
|
continue;
|
|
#endif
|
|
/* dynamic channels are scanned in base mode */
|
|
if (!IEEE80211_IS_CHAN_ST(c))
|
|
continue;
|
|
} else if (IEEE80211_IS_CHAN_HT(c)) {
|
|
/* HT channels are scanned in legacy */
|
|
continue;
|
|
} else {
|
|
/*
|
|
* Use any 11g channel instead of 11b one.
|
|
*/
|
|
if (IEEE80211_IS_CHAN_B(c) &&
|
|
find11gchannel(ic, i, c->ic_freq))
|
|
continue;
|
|
}
|
|
if (ss->ss_last >= IEEE80211_SCAN_MAX)
|
|
break;
|
|
ss->ss_chans[ss->ss_last++] = c;
|
|
}
|
|
} else {
|
|
static const u_int chanflags[IEEE80211_MODE_MAX] = {
|
|
0, /* IEEE80211_MODE_AUTO */
|
|
IEEE80211_CHAN_A, /* IEEE80211_MODE_11A */
|
|
IEEE80211_CHAN_B, /* IEEE80211_MODE_11B */
|
|
IEEE80211_CHAN_G, /* IEEE80211_MODE_11G */
|
|
IEEE80211_CHAN_FHSS, /* IEEE80211_MODE_FH */
|
|
IEEE80211_CHAN_108A, /* IEEE80211_MODE_TURBO_A */
|
|
IEEE80211_CHAN_108G, /* IEEE80211_MODE_TURBO_G */
|
|
IEEE80211_CHAN_ST, /* IEEE80211_MODE_STURBO_A */
|
|
IEEE80211_CHAN_A, /* IEEE80211_MODE_11NA */
|
|
IEEE80211_CHAN_G, /* IEEE80211_MODE_11NG */
|
|
};
|
|
u_int modeflags;
|
|
|
|
modeflags = chanflags[ic->ic_des_mode];
|
|
if ((ic->ic_flags & IEEE80211_F_TURBOP) &&
|
|
modeflags != IEEE80211_CHAN_ST) {
|
|
if (ic->ic_des_mode == IEEE80211_MODE_11G)
|
|
modeflags = IEEE80211_CHAN_108G;
|
|
else
|
|
modeflags = IEEE80211_CHAN_108A;
|
|
}
|
|
for (i = 0; i < ic->ic_nchans; i++) {
|
|
c = &ic->ic_channels[i];
|
|
if ((c->ic_flags & modeflags) != modeflags)
|
|
continue;
|
|
#ifdef IEEE80211_F_XR
|
|
/* XR is not supported on turbo channels */
|
|
if (IEEE80211_IS_CHAN_TURBO(c) &&
|
|
(ic->ic_flags & IEEE80211_F_XR))
|
|
continue;
|
|
#endif
|
|
if (ss->ss_last >= IEEE80211_SCAN_MAX)
|
|
break;
|
|
/*
|
|
* Do not select static turbo channels if
|
|
* the mode is not static turbo.
|
|
*/
|
|
if (IEEE80211_IS_CHAN_STURBO(c) &&
|
|
ic->ic_des_mode != IEEE80211_MODE_STURBO_A)
|
|
continue;
|
|
ss->ss_chans[ss->ss_last++] = c;
|
|
}
|
|
}
|
|
ss->ss_next = 0;
|
|
/* XXX tunables */
|
|
ss->ss_mindwell = msecs_to_ticks(200); /* 200ms */
|
|
ss->ss_maxdwell = msecs_to_ticks(300); /* 300ms */
|
|
|
|
#ifdef IEEE80211_DEBUG
|
|
if (ieee80211_msg_scan(ic)) {
|
|
if_printf(ic->ic_ifp, "scan set ");
|
|
ieee80211_scan_dump_channels(ss);
|
|
printf(" dwell min %ld max %ld\n",
|
|
ss->ss_mindwell, ss->ss_maxdwell);
|
|
}
|
|
#endif /* IEEE80211_DEBUG */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Restart a bg scan.
|
|
*/
|
|
static int
|
|
ap_restart(struct ieee80211_scan_state *ss, struct ieee80211com *ic)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Cancel an ongoing scan.
|
|
*/
|
|
static int
|
|
ap_cancel(struct ieee80211_scan_state *ss, struct ieee80211com *ic)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Record max rssi on channel.
|
|
*/
|
|
static int
|
|
ap_add(struct ieee80211_scan_state *ss,
|
|
const struct ieee80211_scanparams *sp,
|
|
const struct ieee80211_frame *wh,
|
|
int subtype, int rssi, int noise, int rstamp)
|
|
{
|
|
struct ap_state *as = ss->ss_priv;
|
|
struct ieee80211com *ic = ss->ss_ic;
|
|
int chan;
|
|
|
|
chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
|
|
/* XXX better quantification of channel use? */
|
|
/* XXX count bss's? */
|
|
if (rssi > as->as_maxrssi[chan])
|
|
as->as_maxrssi[chan] = rssi;
|
|
/* XXX interference, turbo requirements */
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Pick a quiet channel to use for ap operation.
|
|
*/
|
|
static int
|
|
ap_end(struct ieee80211_scan_state *ss, struct ieee80211com *ic)
|
|
{
|
|
struct ap_state *as = ss->ss_priv;
|
|
int i, chan, bestchan, bestchanix;
|
|
|
|
KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP,
|
|
("wrong opmode %u", ic->ic_opmode));
|
|
/* XXX select channel more intelligently, e.g. channel spread, power */
|
|
bestchan = -1;
|
|
bestchanix = 0; /* NB: silence compiler */
|
|
/* NB: use scan list order to preserve channel preference */
|
|
for (i = 0; i < ss->ss_last; i++) {
|
|
/*
|
|
* If the channel is unoccupied the max rssi
|
|
* should be zero; just take it. Otherwise
|
|
* track the channel with the lowest rssi and
|
|
* use that when all channels appear occupied.
|
|
*/
|
|
/* XXX channel have interference? */
|
|
chan = ieee80211_chan2ieee(ic, ss->ss_chans[i]);
|
|
|
|
IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN,
|
|
"%s: channel %u rssi %d bestchan %d bestchan rssi %d\n",
|
|
__func__, chan, as->as_maxrssi[chan],
|
|
bestchan, bestchan != -1 ? as->as_maxrssi[bestchan] : 0);
|
|
|
|
if (as->as_maxrssi[chan] == 0) {
|
|
bestchan = chan;
|
|
bestchanix = i;
|
|
/* XXX use other considerations */
|
|
break;
|
|
}
|
|
if (bestchan == -1 ||
|
|
as->as_maxrssi[chan] < as->as_maxrssi[bestchan])
|
|
bestchan = chan;
|
|
}
|
|
if (bestchan == -1) {
|
|
/* no suitable channel, should not happen */
|
|
IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN,
|
|
"%s: no suitable channel! (should not happen)\n", __func__);
|
|
/* XXX print something? */
|
|
return 0; /* restart scan */
|
|
} else {
|
|
struct ieee80211_channel *c;
|
|
|
|
/* XXX notify all vap's? */
|
|
/*
|
|
* If this is a dynamic turbo frequency,
|
|
* start with normal mode first.
|
|
*/
|
|
c = ss->ss_chans[bestchanix];
|
|
if (IEEE80211_IS_CHAN_TURBO(c) &&
|
|
!IEEE80211_IS_CHAN_STURBO(c)) {
|
|
c = ieee80211_find_channel(ic, c->ic_freq,
|
|
c->ic_flags & ~IEEE80211_CHAN_TURBO);
|
|
if (c == NULL) {
|
|
/* should never happen ?? */
|
|
return 0;
|
|
}
|
|
}
|
|
ieee80211_create_ibss(ic, c);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ap_age(struct ieee80211_scan_state *ss)
|
|
{
|
|
/* XXX is there anything meaningful to do? */
|
|
}
|
|
|
|
static void
|
|
ap_iterate(struct ieee80211_scan_state *ss,
|
|
ieee80211_scan_iter_func *f, void *arg)
|
|
{
|
|
/* NB: nothing meaningful we can do */
|
|
}
|
|
|
|
static void
|
|
ap_assoc_success(struct ieee80211_scan_state *ss,
|
|
const uint8_t macaddr[IEEE80211_ADDR_LEN])
|
|
{
|
|
/* should not be called */
|
|
}
|
|
|
|
static void
|
|
ap_assoc_fail(struct ieee80211_scan_state *ss,
|
|
const uint8_t macaddr[IEEE80211_ADDR_LEN], int reason)
|
|
{
|
|
/* should not be called */
|
|
}
|
|
|
|
static const struct ieee80211_scanner ap_default = {
|
|
.scan_name = "default",
|
|
.scan_attach = ap_attach,
|
|
.scan_detach = ap_detach,
|
|
.scan_start = ap_start,
|
|
.scan_restart = ap_restart,
|
|
.scan_cancel = ap_cancel,
|
|
.scan_end = ap_end,
|
|
.scan_flush = ap_flush,
|
|
.scan_add = ap_add,
|
|
.scan_age = ap_age,
|
|
.scan_iterate = ap_iterate,
|
|
.scan_assoc_success = ap_assoc_success,
|
|
.scan_assoc_fail = ap_assoc_fail,
|
|
};
|
|
|
|
/*
|
|
* Module glue.
|
|
*/
|
|
static int
|
|
wlan_modevent(module_t mod, int type, void *unused)
|
|
{
|
|
switch (type) {
|
|
case MOD_LOAD:
|
|
ieee80211_scanner_register(IEEE80211_M_HOSTAP, &ap_default);
|
|
return 0;
|
|
case MOD_UNLOAD:
|
|
case MOD_QUIESCE:
|
|
if (nrefs) {
|
|
printf("wlan_scan_ap: still in use (%u dynamic refs)\n",
|
|
nrefs);
|
|
return EBUSY;
|
|
}
|
|
if (type == MOD_UNLOAD)
|
|
ieee80211_scanner_unregister_all(&ap_default);
|
|
return 0;
|
|
}
|
|
return EINVAL;
|
|
}
|
|
|
|
static moduledata_t wlan_mod = {
|
|
"wlan_scan_ap",
|
|
wlan_modevent,
|
|
0
|
|
};
|
|
DECLARE_MODULE(wlan_scan_ap, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
|
|
MODULE_VERSION(wlan_scan_ap, 1);
|
|
MODULE_DEPEND(wlan_scan_ap, wlan, 1, 1, 1);
|