static void
tdma_beacon_miss(struct ieee80211vap *vap)
{
struct ieee80211_tdma_state *ts = vap->iv_tdma;
KASSERT((vap->iv_ic->ic_flags & IEEE80211_F_SCAN) == 0, ("scanning"));
KASSERT(vap->iv_state == IEEE80211_S_RUN,
("wrong state %d", vap->iv_state));
IEEE80211_DPRINTF(vap,
IEEE80211_MSG_STATE | IEEE80211_MSG_TDMA | IEEE80211_MSG_DEBUG,
"beacon miss, mode %u state %s\n",
vap->iv_opmode, ieee80211_state_name[vap->iv_state]);
callout_stop(&vap->iv_swbmiss);
if (ts->tdma_peer != NULL) { /* XXX? can this be null? */
ieee80211_notify_node_leave(vap->iv_bss);
ts->tdma_peer = NULL;
/*
* Treat beacon miss like an associate failure wrt the
* scan policy; this forces the entry in the scan cache
* to be ignored after several tries.
*/
ieee80211_scan_assoc_fail(vap, vap->iv_bss->ni_macaddr,
IEEE80211_STATUS_TIMEOUT);
}
#if 0
ts->tdma_inuse = 0; /* clear slot usage */
#endif
ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
}
void
ieee80211_watchdog(struct ieee80211com *ic)
{
struct ieee80211_node_table *nt;
int need_inact_timer = 0;
if (ic->ic_state != IEEE80211_S_INIT) {
if (ic->ic_mgt_timer && --ic->ic_mgt_timer == 0)
ieee80211_new_state(ic, IEEE80211_S_SCAN, 0);
nt = &ic->ic_scan;
if (nt->nt_inact_timer) {
if (--nt->nt_inact_timer == 0)
nt->nt_timeout(nt);
need_inact_timer += nt->nt_inact_timer;
}
nt = &ic->ic_sta;
if (nt->nt_inact_timer) {
if (--nt->nt_inact_timer == 0)
nt->nt_timeout(nt);
need_inact_timer += nt->nt_inact_timer;
}
}
if (ic->ic_mgt_timer != 0 || need_inact_timer)
ic->ic_ifp->if_timer = 1;
}
void
an_stop(struct ifnet *ifp, int disable)
{
struct an_softc *sc = ifp->if_softc;
int i, s;
if (!sc->sc_enabled)
return;
DPRINTF(("an_stop: disable %d\n", disable));
s = splnet();
ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
if (!sc->sc_invalid) {
an_cmd(sc, AN_CMD_FORCE_SYNCLOSS, 0);
CSR_WRITE_2(sc, AN_INT_EN, 0);
an_cmd(sc, AN_CMD_DISABLE, 0);
for (i = 0; i < AN_TX_RING_CNT; i++)
an_cmd(sc, AN_CMD_DEALLOC_MEM, sc->sc_txd[i].d_fid);
}
sc->sc_tx_timer = 0;
ifp->if_timer = 0;
ifp->if_flags &= ~IFF_RUNNING;
ifq_clr_oactive(&ifp->if_snd);
if (disable) {
if (sc->sc_disable)
(*sc->sc_disable)(sc);
sc->sc_enabled = 0;
}
splx(s);
}
/*
* Switch to the next channel marked for scanning.
*/
void
ieee80211_next_scan(struct ifnet *ifp)
{
struct ieee80211com *ic = (void *)ifp;
struct ieee80211_channel *chan;
chan = ic->ic_bss->ni_chan;
for (;;) {
if (++chan > &ic->ic_channels[IEEE80211_CHAN_MAX])
chan = &ic->ic_channels[0];
if (isset(ic->ic_chan_scan, ieee80211_chan2ieee(ic, chan))) {
/*
* Ignore channels marked passive-only
* during an active scan.
*/
if ((ic->ic_flags & IEEE80211_F_ASCAN) == 0 ||
(chan->ic_flags & IEEE80211_CHAN_PASSIVE) == 0)
break;
}
if (chan == ic->ic_bss->ni_chan) {
ieee80211_end_scan(ifp);
return;
}
}
clrbit(ic->ic_chan_scan, ieee80211_chan2ieee(ic, chan));
DPRINTF(("chan %d->%d\n",
ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan),
ieee80211_chan2ieee(ic, chan)));
ic->ic_bss->ni_chan = chan;
ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
}
void
ieee80211_create_ibss(struct ieee80211com* ic, struct ieee80211_channel *chan)
{
struct ieee80211_node *ni;
struct ifnet *ifp = &ic->ic_if;
ni = ic->ic_bss;
if (ifp->if_flags & IFF_DEBUG)
printf("%s: creating ibss\n", ifp->if_xname);
ic->ic_flags |= IEEE80211_F_SIBSS;
ni->ni_chan = chan;
ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2mode(ic, ni->ni_chan)];
IEEE80211_ADDR_COPY(ni->ni_macaddr, ic->ic_myaddr);
IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_myaddr);
if (ic->ic_opmode == IEEE80211_M_IBSS) {
if ((ic->ic_flags & IEEE80211_F_DESBSSID) != 0)
IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_des_bssid);
else
ni->ni_bssid[0] |= 0x02; /* local bit for IBSS */
}
ni->ni_esslen = ic->ic_des_esslen;
memcpy(ni->ni_essid, ic->ic_des_essid, ni->ni_esslen);
ni->ni_rssi = 0;
ni->ni_rstamp = 0;
memset(ni->ni_tstamp, 0, sizeof(ni->ni_tstamp));
ni->ni_intval = ic->ic_lintval;
ni->ni_capinfo = IEEE80211_CAPINFO_IBSS;
if (ic->ic_flags & IEEE80211_F_WEPON)
ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY;
if (ic->ic_phytype == IEEE80211_T_FH) {
ni->ni_fhdwell = 200; /* XXX */
ni->ni_fhindex = 1;
}
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
}
void
ieee80211_watchdog(struct ifnet *ifp)
{
struct ieee80211com *ic = (void *)ifp;
if (ic->ic_mgt_timer && --ic->ic_mgt_timer == 0)
ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
if (ic->ic_mgt_timer != 0)
ifp->if_timer = 1;
}
static void
cac_timeout_callout(void *arg)
{
struct ieee80211vap *vap = arg;
struct ieee80211com *ic;
struct ieee80211_dfs_state *dfs;
int i;
wlan_serialize_enter();
ic = vap->iv_ic;
dfs = &ic->ic_dfs;
if (vap->iv_state != IEEE80211_S_CAC) { /* NB: just in case */
wlan_serialize_exit();
return;
}
/*
* When radar is detected during a CAC we are woken
* up prematurely to switch to a new channel.
* Check the channel to decide how to act.
*/
if (IEEE80211_IS_CHAN_RADAR(ic->ic_curchan)) {
ieee80211_notify_cac(ic, ic->ic_curchan,
IEEE80211_NOTIFY_CAC_RADAR);
if_printf(vap->iv_ifp,
"CAC timer on channel %u (%u MHz) stopped due to radar\n",
ic->ic_curchan->ic_ieee, ic->ic_curchan->ic_freq);
/* XXX clobbers any existing desired channel */
/* NB: dfs->newchan may be NULL, that's ok */
vap->iv_des_chan = dfs->newchan;
/* XXX recursive lock need ieee80211_new_state_locked */
ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
} else {
if_printf(vap->iv_ifp,
"CAC timer on channel %u (%u MHz) expired; "
"no radar detected\n",
ic->ic_curchan->ic_ieee, ic->ic_curchan->ic_freq);
/*
* Mark all channels with the current frequency
* as having completed CAC; this keeps us from
* doing it again until we change channels.
*/
for (i = 0; i < ic->ic_nchans; i++) {
struct ieee80211_channel *c = &ic->ic_channels[i];
if (c->ic_freq == ic->ic_curchan->ic_freq)
c->ic_state |= IEEE80211_CHANSTATE_CACDONE;
}
ieee80211_notify_cac(ic, ic->ic_curchan,
IEEE80211_NOTIFY_CAC_EXPIRE);
ieee80211_cac_completeswitch(vap);
}
wlan_serialize_exit();
}
void
an_linkstat_intr(struct an_softc *sc)
{
struct ieee80211com *ic = &sc->sc_ic;
u_int16_t status;
status = CSR_READ_2(sc, AN_LINKSTAT);
CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_LINKSTAT);
DPRINTF(("an_linkstat_intr: status 0x%x\n", status));
if (status == AN_LINKSTAT_ASSOCIATED) {
if (ic->ic_state != IEEE80211_S_RUN
#ifndef IEEE80211_STA_ONLY
|| ic->ic_opmode == IEEE80211_M_IBSS
#endif
)
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
} else {
if (ic->ic_opmode == IEEE80211_M_STA)
ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
}
}
int
ieee80211_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
struct ieee80211com *ic = (void *)ifp;
struct ifreq *ifr = (struct ifreq *)data;
int i, error = 0;
struct ieee80211_nwid nwid;
struct ieee80211_wpapsk *psk;
struct ieee80211_wmmparams *wmm;
struct ieee80211_power *power;
struct ieee80211_bssid *bssid;
struct ieee80211chanreq *chanreq;
struct ieee80211_channel *chan;
struct ieee80211_txpower *txpower;
static const u_int8_t empty_macaddr[IEEE80211_ADDR_LEN] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
struct ieee80211_nodereq *nr, nrbuf;
struct ieee80211_nodereq_all *na;
struct ieee80211_node *ni;
u_int32_t flags;
switch (cmd) {
case SIOCSIFADDR:
case SIOCGIFADDR:
error = ether_ioctl(ifp, &ic->ic_ac, cmd, data);
break;
case SIOCSIFMEDIA:
case SIOCGIFMEDIA:
error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
break;
case SIOCS80211NWID:
if ((error = suser(curproc, 0)) != 0)
break;
if ((error = copyin(ifr->ifr_data, &nwid, sizeof(nwid))) != 0)
break;
if (nwid.i_len > IEEE80211_NWID_LEN) {
error = EINVAL;
break;
}
memset(ic->ic_des_essid, 0, IEEE80211_NWID_LEN);
ic->ic_des_esslen = nwid.i_len;
memcpy(ic->ic_des_essid, nwid.i_nwid, nwid.i_len);
error = ENETRESET;
break;
case SIOCG80211NWID:
memset(&nwid, 0, sizeof(nwid));
switch (ic->ic_state) {
case IEEE80211_S_INIT:
case IEEE80211_S_SCAN:
nwid.i_len = ic->ic_des_esslen;
memcpy(nwid.i_nwid, ic->ic_des_essid, nwid.i_len);
break;
default:
nwid.i_len = ic->ic_bss->ni_esslen;
memcpy(nwid.i_nwid, ic->ic_bss->ni_essid, nwid.i_len);
break;
}
error = copyout(&nwid, ifr->ifr_data, sizeof(nwid));
break;
case SIOCS80211NWKEY:
if ((error = suser(curproc, 0)) != 0)
break;
error = ieee80211_ioctl_setnwkeys(ic, (void *)data);
break;
case SIOCG80211NWKEY:
error = ieee80211_ioctl_getnwkeys(ic, (void *)data);
break;
case SIOCS80211WMMPARMS:
if ((error = suser(curproc, 0)) != 0)
break;
if (!(ic->ic_flags & IEEE80211_C_QOS)) {
error = ENODEV;
break;
}
wmm = (struct ieee80211_wmmparams *)data;
if (wmm->i_enabled)
ic->ic_flags |= IEEE80211_F_QOS;
else
ic->ic_flags &= ~IEEE80211_F_QOS;
error = ENETRESET;
break;
case SIOCG80211WMMPARMS:
wmm = (struct ieee80211_wmmparams *)data;
wmm->i_enabled = (ic->ic_flags & IEEE80211_F_QOS) ? 1 : 0;
break;
case SIOCS80211WPAPARMS:
if ((error = suser(curproc, 0)) != 0)
break;
error = ieee80211_ioctl_setwpaparms(ic, (void *)data);
break;
case SIOCG80211WPAPARMS:
error = ieee80211_ioctl_getwpaparms(ic, (void *)data);
break;
case SIOCS80211WPAPSK:
if ((error = suser(curproc, 0)) != 0)
break;
psk = (struct ieee80211_wpapsk *)data;
if (psk->i_enabled) {
ic->ic_flags |= IEEE80211_F_PSK;
memcpy(ic->ic_psk, psk->i_psk, sizeof(ic->ic_psk));
} else {
ic->ic_flags &= ~IEEE80211_F_PSK;
memset(ic->ic_psk, 0, sizeof(ic->ic_psk));
}
error = ENETRESET;
break;
case SIOCG80211WPAPSK:
psk = (struct ieee80211_wpapsk *)data;
if (ic->ic_flags & IEEE80211_F_PSK) {
psk->i_enabled = 1;
/* do not show any keys to non-root user */
if (suser(curproc, 0) != 0) {
psk->i_enabled = 2;
memset(psk->i_psk, 0, sizeof(psk->i_psk));
break; /* return ok but w/o key */
}
memcpy(psk->i_psk, ic->ic_psk, sizeof(psk->i_psk));
} else
psk->i_enabled = 0;
break;
case SIOCS80211POWER:
if ((error = suser(curproc, 0)) != 0)
break;
power = (struct ieee80211_power *)data;
ic->ic_lintval = power->i_maxsleep;
if (power->i_enabled != 0) {
if ((ic->ic_caps & IEEE80211_C_PMGT) == 0)
error = EINVAL;
else if ((ic->ic_flags & IEEE80211_F_PMGTON) == 0) {
ic->ic_flags |= IEEE80211_F_PMGTON;
error = ENETRESET;
}
} else {
if (ic->ic_flags & IEEE80211_F_PMGTON) {
ic->ic_flags &= ~IEEE80211_F_PMGTON;
error = ENETRESET;
}
}
break;
case SIOCG80211POWER:
power = (struct ieee80211_power *)data;
power->i_enabled = (ic->ic_flags & IEEE80211_F_PMGTON) ? 1 : 0;
power->i_maxsleep = ic->ic_lintval;
break;
case SIOCS80211BSSID:
if ((error = suser(curproc, 0)) != 0)
break;
bssid = (struct ieee80211_bssid *)data;
if (IEEE80211_ADDR_EQ(bssid->i_bssid, empty_macaddr))
ic->ic_flags &= ~IEEE80211_F_DESBSSID;
else {
ic->ic_flags |= IEEE80211_F_DESBSSID;
IEEE80211_ADDR_COPY(ic->ic_des_bssid, bssid->i_bssid);
}
if (ic->ic_opmode == IEEE80211_M_HOSTAP)
break;
switch (ic->ic_state) {
case IEEE80211_S_INIT:
case IEEE80211_S_SCAN:
error = ENETRESET;
break;
default:
if ((ic->ic_flags & IEEE80211_F_DESBSSID) &&
!IEEE80211_ADDR_EQ(ic->ic_des_bssid,
ic->ic_bss->ni_bssid))
error = ENETRESET;
break;
}
break;
case SIOCG80211BSSID:
bssid = (struct ieee80211_bssid *)data;
switch (ic->ic_state) {
case IEEE80211_S_INIT:
case IEEE80211_S_SCAN:
if (ic->ic_opmode == IEEE80211_M_HOSTAP)
IEEE80211_ADDR_COPY(bssid->i_bssid,
ic->ic_myaddr);
else if (ic->ic_flags & IEEE80211_F_DESBSSID)
IEEE80211_ADDR_COPY(bssid->i_bssid,
ic->ic_des_bssid);
else
memset(bssid->i_bssid, 0, IEEE80211_ADDR_LEN);
break;
default:
IEEE80211_ADDR_COPY(bssid->i_bssid,
ic->ic_bss->ni_bssid);
break;
}
break;
case SIOCS80211CHANNEL:
if ((error = suser(curproc, 0)) != 0)
break;
chanreq = (struct ieee80211chanreq *)data;
if (chanreq->i_channel == IEEE80211_CHAN_ANY)
ic->ic_des_chan = IEEE80211_CHAN_ANYC;
else if (chanreq->i_channel > IEEE80211_CHAN_MAX ||
isclr(ic->ic_chan_active, chanreq->i_channel)) {
error = EINVAL;
break;
} else
ic->ic_ibss_chan = ic->ic_des_chan =
&ic->ic_channels[chanreq->i_channel];
switch (ic->ic_state) {
case IEEE80211_S_INIT:
case IEEE80211_S_SCAN:
error = ENETRESET;
break;
default:
if (ic->ic_opmode == IEEE80211_M_STA) {
if (ic->ic_des_chan != IEEE80211_CHAN_ANYC &&
ic->ic_bss->ni_chan != ic->ic_des_chan)
error = ENETRESET;
} else {
if (ic->ic_bss->ni_chan != ic->ic_ibss_chan)
error = ENETRESET;
}
break;
}
break;
case SIOCG80211CHANNEL:
chanreq = (struct ieee80211chanreq *)data;
switch (ic->ic_state) {
case IEEE80211_S_INIT:
case IEEE80211_S_SCAN:
if (ic->ic_opmode == IEEE80211_M_STA)
chan = ic->ic_des_chan;
else
chan = ic->ic_ibss_chan;
break;
default:
chan = ic->ic_bss->ni_chan;
break;
}
chanreq->i_channel = ieee80211_chan2ieee(ic, chan);
break;
#if 0
case SIOCG80211ZSTATS:
#endif
case SIOCG80211STATS:
ifr = (struct ifreq *)data;
copyout(&ic->ic_stats, ifr->ifr_data, sizeof (ic->ic_stats));
#if 0
if (cmd == SIOCG80211ZSTATS)
memset(&ic->ic_stats, 0, sizeof(ic->ic_stats));
#endif
break;
case SIOCS80211TXPOWER:
if ((error = suser(curproc, 0)) != 0)
break;
txpower = (struct ieee80211_txpower *)data;
if ((ic->ic_caps & IEEE80211_C_TXPMGT) == 0) {
error = EINVAL;
break;
}
if (IEEE80211_TXPOWER_MIN > txpower->i_val ||
txpower->i_val > IEEE80211_TXPOWER_MAX) {
error = EINVAL;
break;
}
ic->ic_txpower = txpower->i_val;
error = ENETRESET;
break;
case SIOCG80211TXPOWER:
txpower = (struct ieee80211_txpower *)data;
if ((ic->ic_caps & IEEE80211_C_TXPMGT) == 0)
error = EINVAL;
else
txpower->i_val = ic->ic_txpower;
break;
case SIOCSIFMTU:
ifr = (struct ifreq *)data;
if (!(IEEE80211_MTU_MIN <= ifr->ifr_mtu &&
ifr->ifr_mtu <= IEEE80211_MTU_MAX))
error = EINVAL;
else
ifp->if_mtu = ifr->ifr_mtu;
break;
case SIOCS80211SCAN:
if ((error = suser(curproc, 0)) != 0)
break;
if (ic->ic_opmode == IEEE80211_M_HOSTAP)
break;
if ((ifp->if_flags & IFF_UP) == 0) {
error = ENETDOWN;
break;
}
if ((ic->ic_scan_lock & IEEE80211_SCAN_REQUEST) == 0) {
if (ic->ic_scan_lock & IEEE80211_SCAN_LOCKED)
ic->ic_scan_lock |= IEEE80211_SCAN_RESUME;
ic->ic_scan_lock |= IEEE80211_SCAN_REQUEST;
if (ic->ic_state != IEEE80211_S_SCAN)
ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
}
/* Let the userspace process wait for completion */
error = tsleep(&ic->ic_scan_lock, PCATCH, "80211scan",
hz * IEEE80211_SCAN_TIMEOUT);
break;
case SIOCG80211NODE:
nr = (struct ieee80211_nodereq *)data;
ni = ieee80211_find_node(ic, nr->nr_macaddr);
if (ni == NULL) {
error = ENOENT;
break;
}
ieee80211_node2req(ic, ni, nr);
break;
case SIOCS80211NODE:
if ((error = suser(curproc, 0)) != 0)
break;
if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
error = EINVAL;
break;
}
nr = (struct ieee80211_nodereq *)data;
ni = ieee80211_find_node(ic, nr->nr_macaddr);
if (ni == NULL)
ni = ieee80211_alloc_node(ic, nr->nr_macaddr);
if (ni == NULL) {
error = ENOENT;
break;
}
if (nr->nr_flags & IEEE80211_NODEREQ_COPY)
ieee80211_req2node(ic, nr, ni);
break;
case SIOCS80211DELNODE:
if ((error = suser(curproc, 0)) != 0)
break;
nr = (struct ieee80211_nodereq *)data;
ni = ieee80211_find_node(ic, nr->nr_macaddr);
if (ni == NULL)
error = ENOENT;
else if (ni == ic->ic_bss)
error = EPERM;
else {
if (ni->ni_state == IEEE80211_STA_COLLECT)
break;
/* Disassociate station. */
if (ni->ni_state == IEEE80211_STA_ASSOC)
IEEE80211_SEND_MGMT(ic, ni,
IEEE80211_FC0_SUBTYPE_DISASSOC,
IEEE80211_REASON_ASSOC_LEAVE);
/* Deauth station. */
if (ni->ni_state >= IEEE80211_STA_AUTH)
IEEE80211_SEND_MGMT(ic, ni,
IEEE80211_FC0_SUBTYPE_DEAUTH,
IEEE80211_REASON_AUTH_LEAVE);
ieee80211_release_node(ic, ni);
}
break;
case SIOCG80211ALLNODES:
na = (struct ieee80211_nodereq_all *)data;
na->na_nodes = i = 0;
ni = RB_MIN(ieee80211_tree, &ic->ic_tree);
while (ni && na->na_size >=
i + sizeof(struct ieee80211_nodereq)) {
ieee80211_node2req(ic, ni, &nrbuf);
error = copyout(&nrbuf, (caddr_t)na->na_node + i,
sizeof(struct ieee80211_nodereq));
if (error)
break;
i += sizeof(struct ieee80211_nodereq);
na->na_nodes++;
ni = RB_NEXT(ieee80211_tree, &ic->ic_tree, ni);
}
break;
case SIOCG80211FLAGS:
flags = ic->ic_flags;
if (ic->ic_opmode != IEEE80211_M_HOSTAP)
flags &= ~IEEE80211_F_HOSTAPMASK;
ifr->ifr_flags = flags >> IEEE80211_F_USERSHIFT;
break;
case SIOCS80211FLAGS:
if ((error = suser(curproc, 0)) != 0)
break;
flags = (u_int32_t)ifr->ifr_flags << IEEE80211_F_USERSHIFT;
if (ic->ic_opmode != IEEE80211_M_HOSTAP &&
(flags & IEEE80211_F_HOSTAPMASK)) {
error = EINVAL;
break;
}
ic->ic_flags = (ic->ic_flags & ~IEEE80211_F_USERMASK) | flags;
error = ENETRESET;
break;
default:
error = ENOTTY;
break;
}
return error;
}
/*
* Complete a scan of potential channels.
*/
void
ieee80211_end_scan(struct ifnet *ifp)
{
struct ieee80211com *ic = (void *)ifp;
struct ieee80211_node *ni, *nextbs, *selbs;
if (ifp->if_flags & IFF_DEBUG)
printf("%s: end %s scan\n", ifp->if_xname,
(ic->ic_flags & IEEE80211_F_ASCAN) ?
"active" : "passive");
if (ic->ic_scan_count)
ic->ic_flags &= ~IEEE80211_F_ASCAN;
ni = RB_MIN(ieee80211_tree, &ic->ic_tree);
#ifndef IEEE80211_STA_ONLY
if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
/* XXX off stack? */
u_char occupied[howmany(IEEE80211_CHAN_MAX, NBBY)];
int i, fail;
/*
* The passive scan to look for existing AP's completed,
* select a channel to camp on. Identify the channels
* that already have one or more AP's and try to locate
* an unnoccupied one. If that fails, pick a random
* channel from the active set.
*/
memset(occupied, 0, sizeof(occupied));
RB_FOREACH(ni, ieee80211_tree, &ic->ic_tree)
setbit(occupied, ieee80211_chan2ieee(ic, ni->ni_chan));
for (i = 0; i < IEEE80211_CHAN_MAX; i++)
if (isset(ic->ic_chan_active, i) && isclr(occupied, i))
break;
if (i == IEEE80211_CHAN_MAX) {
fail = arc4random() & 3; /* random 0-3 */
for (i = 0; i < IEEE80211_CHAN_MAX; i++)
if (isset(ic->ic_chan_active, i) && fail-- == 0)
break;
}
ieee80211_create_ibss(ic, &ic->ic_channels[i]);
goto wakeup;
}
#endif
if (ni == NULL) {
DPRINTF(("no scan candidate\n"));
notfound:
#ifndef IEEE80211_STA_ONLY
if (ic->ic_opmode == IEEE80211_M_IBSS &&
(ic->ic_flags & IEEE80211_F_IBSSON) &&
ic->ic_des_esslen != 0) {
ieee80211_create_ibss(ic, ic->ic_ibss_chan);
goto wakeup;
}
#endif
/*
* Scan the next mode if nothing has been found. This
* is necessary if the device supports different
* incompatible modes in the same channel range, like
* like 11b and "pure" 11G mode. This will loop
* forever except for user-initiated scans.
*/
if (ieee80211_next_mode(ifp) == IEEE80211_MODE_AUTO) {
if (ic->ic_scan_lock & IEEE80211_SCAN_REQUEST &&
ic->ic_scan_lock & IEEE80211_SCAN_RESUME) {
ic->ic_scan_lock = IEEE80211_SCAN_LOCKED;
/* Return from an user-initiated scan */
wakeup(&ic->ic_scan_lock);
} else if (ic->ic_scan_lock & IEEE80211_SCAN_REQUEST)
goto wakeup;
ic->ic_scan_count++;
}
/*
* Reset the list of channels to scan and start again.
*/
ieee80211_next_scan(ifp);
return;
}
selbs = NULL;
for (; ni != NULL; ni = nextbs) {
nextbs = RB_NEXT(ieee80211_tree, &ic->ic_tree, ni);
if (ni->ni_fails) {
/*
* The configuration of the access points may change
* during my scan. So delete the entry for the AP
* and retry to associate if there is another beacon.
*/
if (ni->ni_fails++ > 2)
ieee80211_free_node(ic, ni);
continue;
}
if (ieee80211_match_bss(ic, ni) == 0) {
if (selbs == NULL)
selbs = ni;
else if (ni->ni_rssi > selbs->ni_rssi)
selbs = ni;
}
}
if (selbs == NULL)
goto notfound;
(*ic->ic_node_copy)(ic, ic->ic_bss, selbs);
ni = ic->ic_bss;
/*
* Set the erp state (mostly the slot time) to deal with
* the auto-select case; this should be redundant if the
* mode is locked.
*/
ic->ic_curmode = ieee80211_chan2mode(ic, ni->ni_chan);
ieee80211_reset_erp(ic);
if (ic->ic_flags & IEEE80211_F_RSNON)
ieee80211_choose_rsnparams(ic);
else if (ic->ic_flags & IEEE80211_F_WEPON)
ni->ni_rsncipher = IEEE80211_CIPHER_USEGROUP;
ieee80211_node_newstate(selbs, IEEE80211_STA_BSS);
#ifndef IEEE80211_STA_ONLY
if (ic->ic_opmode == IEEE80211_M_IBSS) {
ieee80211_fix_rate(ic, ni, IEEE80211_F_DOFRATE |
IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
if (ni->ni_rates.rs_nrates == 0)
goto notfound;
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
} else
#endif
ieee80211_new_state(ic, IEEE80211_S_AUTH, -1);
wakeup:
if (ic->ic_scan_lock & IEEE80211_SCAN_REQUEST) {
/* Return from an user-initiated scan */
wakeup(&ic->ic_scan_lock);
}
ic->ic_scan_lock = IEEE80211_SCAN_UNLOCKED;
}
void
ieee80211_create_ibss(struct ieee80211com* ic, struct ieee80211_channel *chan)
{
struct ieee80211_node *ni;
struct ifnet *ifp = &ic->ic_if;
ni = ic->ic_bss;
if (ifp->if_flags & IFF_DEBUG)
printf("%s: creating ibss\n", ifp->if_xname);
ic->ic_flags |= IEEE80211_F_SIBSS;
ni->ni_chan = chan;
ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2mode(ic, ni->ni_chan)];
ni->ni_txrate = 0;
IEEE80211_ADDR_COPY(ni->ni_macaddr, ic->ic_myaddr);
IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_myaddr);
if (ic->ic_opmode == IEEE80211_M_IBSS) {
if ((ic->ic_flags & IEEE80211_F_DESBSSID) != 0)
IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_des_bssid);
else
ni->ni_bssid[0] |= 0x02; /* local bit for IBSS */
}
ni->ni_esslen = ic->ic_des_esslen;
memcpy(ni->ni_essid, ic->ic_des_essid, ni->ni_esslen);
ni->ni_rssi = 0;
ni->ni_rstamp = 0;
memset(ni->ni_tstamp, 0, sizeof(ni->ni_tstamp));
ni->ni_intval = ic->ic_lintval;
ni->ni_capinfo = IEEE80211_CAPINFO_IBSS;
if (ic->ic_flags & IEEE80211_F_WEPON)
ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY;
if (ic->ic_flags & IEEE80211_F_RSNON) {
struct ieee80211_key *k;
/* initialize 256-bit global key counter to a random value */
arc4random_buf(ic->ic_globalcnt, EAPOL_KEY_NONCE_LEN);
ni->ni_rsnprotos = ic->ic_rsnprotos;
ni->ni_rsnakms = ic->ic_rsnakms;
ni->ni_rsnciphers = ic->ic_rsnciphers;
ni->ni_rsngroupcipher = ic->ic_rsngroupcipher;
ni->ni_rsngroupmgmtcipher = ic->ic_rsngroupmgmtcipher;
ni->ni_rsncaps = 0;
if (ic->ic_caps & IEEE80211_C_MFP) {
ni->ni_rsncaps |= IEEE80211_RSNCAP_MFPC;
if (ic->ic_flags & IEEE80211_F_MFPR)
ni->ni_rsncaps |= IEEE80211_RSNCAP_MFPR;
}
ic->ic_def_txkey = 1;
k = &ic->ic_nw_keys[ic->ic_def_txkey];
memset(k, 0, sizeof(*k));
k->k_id = ic->ic_def_txkey;
k->k_cipher = ni->ni_rsngroupcipher;
k->k_flags = IEEE80211_KEY_GROUP | IEEE80211_KEY_TX;
k->k_len = ieee80211_cipher_keylen(k->k_cipher);
arc4random_buf(k->k_key, k->k_len);
(*ic->ic_set_key)(ic, ni, k); /* XXX */
if (ic->ic_caps & IEEE80211_C_MFP) {
ic->ic_igtk_kid = 4;
k = &ic->ic_nw_keys[ic->ic_igtk_kid];
memset(k, 0, sizeof(*k));
k->k_id = ic->ic_igtk_kid;
k->k_cipher = ni->ni_rsngroupmgmtcipher;
k->k_flags = IEEE80211_KEY_IGTK | IEEE80211_KEY_TX;
k->k_len = 16;
arc4random_buf(k->k_key, k->k_len);
(*ic->ic_set_key)(ic, ni, k); /* XXX */
}
/*
* In HostAP mode, multicast traffic is sent using ic_bss
* as the Tx node, so mark our node as valid so we can send
* multicast frames using the group key we've just configured.
*/
ni->ni_port_valid = 1;
ni->ni_flags |= IEEE80211_NODE_TXPROT;
/* schedule a GTK/IGTK rekeying after 3600s */
timeout_add_sec(&ic->ic_rsn_timeout, 3600);
}
timeout_add_sec(&ic->ic_inact_timeout, IEEE80211_INACT_WAIT);
timeout_add_sec(&ic->ic_node_cache_timeout, IEEE80211_CACHE_WAIT);
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
}
int
an_init(struct ifnet *ifp)
{
struct an_softc *sc = ifp->if_softc;
struct ieee80211com *ic = &sc->sc_ic;
int i, error, fid;
DPRINTF(("an_init: enabled %d\n", sc->sc_enabled));
if (!sc->sc_enabled) {
if (sc->sc_enable)
(*sc->sc_enable)(sc);
an_wait(sc);
sc->sc_enabled = 1;
} else {
an_stop(ifp, 0);
if ((error = an_reset(sc)) != 0) {
printf("%s: failed to reset\n", ifp->if_xname);
an_stop(ifp, 1);
return error;
}
}
CSR_WRITE_2(sc, AN_SW0, AN_MAGIC);
/* Allocate the TX buffers */
for (i = 0; i < AN_TX_RING_CNT; i++) {
if ((error = an_alloc_nicmem(sc, AN_TX_MAX_LEN, &fid)) != 0) {
printf("%s: failed to allocate nic memory\n",
ifp->if_xname);
an_stop(ifp, 1);
return error;
}
DPRINTF2(("an_init: txbuf %d allocated %x\n", i, fid));
sc->sc_txd[i].d_fid = fid;
sc->sc_txd[i].d_inuse = 0;
}
sc->sc_txcur = sc->sc_txnext = 0;
IEEE80211_ADDR_COPY(sc->sc_config.an_macaddr, ic->ic_myaddr);
an_swap16((u_int16_t *)&sc->sc_config.an_macaddr, 3);
sc->sc_config.an_scanmode = AN_SCANMODE_ACTIVE;
sc->sc_config.an_authtype = AN_AUTHTYPE_OPEN; /*XXX*/
if (ic->ic_flags & IEEE80211_F_WEPON) {
sc->sc_config.an_authtype |=
AN_AUTHTYPE_PRIVACY_IN_USE;
}
sc->sc_config.an_listen_interval = ic->ic_lintval;
sc->sc_config.an_beacon_period = ic->ic_lintval;
if (ic->ic_flags & IEEE80211_F_PMGTON)
sc->sc_config.an_psave_mode = AN_PSAVE_PSP;
else
sc->sc_config.an_psave_mode = AN_PSAVE_CAM;
sc->sc_config.an_ds_channel =
ieee80211_chan2ieee(ic, ic->ic_ibss_chan);
switch (ic->ic_opmode) {
case IEEE80211_M_STA:
sc->sc_config.an_opmode =
AN_OPMODE_INFRASTRUCTURE_STATION;
sc->sc_config.an_rxmode = AN_RXMODE_BC_MC_ADDR;
break;
#ifndef IEEE80211_STA_ONLY
case IEEE80211_M_IBSS:
sc->sc_config.an_opmode = AN_OPMODE_IBSS_ADHOC;
sc->sc_config.an_rxmode = AN_RXMODE_BC_MC_ADDR;
break;
#endif
case IEEE80211_M_MONITOR:
sc->sc_config.an_opmode =
AN_OPMODE_INFRASTRUCTURE_STATION;
sc->sc_config.an_rxmode =
AN_RXMODE_80211_MONITOR_ANYBSS;
sc->sc_config.an_authtype = AN_AUTHTYPE_NONE;
if (ic->ic_flags & IEEE80211_F_WEPON)
sc->sc_config.an_authtype |=
AN_AUTHTYPE_PRIVACY_IN_USE |
AN_AUTHTYPE_ALLOW_UNENCRYPTED;
break;
default:
printf("%s: bad opmode %d\n", ifp->if_xname, ic->ic_opmode);
an_stop(ifp, 1);
return EIO;
}
sc->sc_config.an_rxmode |= AN_RXMODE_NO_8023_HEADER;
/* Set the ssid list */
memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_ssidlist));
sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid_len =
ic->ic_des_esslen;
if (ic->ic_des_esslen)
memcpy(sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid,
ic->ic_des_essid, ic->ic_des_esslen);
an_swap16((u_int16_t *)&sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid, 16);
if ((error = an_write_rid(sc, AN_RID_SSIDLIST, &sc->sc_buf,
sizeof(sc->sc_buf.sc_ssidlist)))) {
printf("%s: failed to write ssid list\n", ifp->if_xname);
an_stop(ifp, 1);
return error;
}
/* Set the AP list */
memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_aplist));
(void)an_write_rid(sc, AN_RID_APLIST, &sc->sc_buf,
sizeof(sc->sc_buf.sc_aplist));
/* Set the encapsulation */
for (i = 0; i < AN_ENCAP_NENTS; i++) {
sc->sc_buf.sc_encap.an_entry[i].an_ethertype = 0;
sc->sc_buf.sc_encap.an_entry[i].an_action =
AN_RXENCAP_RFC1024 | AN_TXENCAP_RFC1024;
}
(void)an_write_rid(sc, AN_RID_ENCAP, &sc->sc_buf,
sizeof(sc->sc_buf.sc_encap));
/* Set the WEP Keys */
if (ic->ic_flags & IEEE80211_F_WEPON)
an_write_wepkey(sc, AN_RID_WEP_VOLATILE, sc->sc_wepkeys,
sc->sc_tx_key);
/* Set the configuration */
if ((error = an_write_rid(sc, AN_RID_GENCONFIG, &sc->sc_config,
sizeof(sc->sc_config)))) {
printf("%s: failed to write config\n", ifp->if_xname);
an_stop(ifp, 1);
return error;
}
/* Enable the MAC */
if (an_cmd(sc, AN_CMD_ENABLE, 0)) {
printf("%s: failed to enable MAC\n", sc->sc_dev.dv_xname);
an_stop(ifp, 1);
return ENXIO;
}
if (ifp->if_flags & IFF_PROMISC)
an_cmd(sc, AN_CMD_SET_MODE, 0xffff);
ifp->if_flags |= IFF_RUNNING;
ifq_clr_oactive(&ifp->if_snd);
ic->ic_state = IEEE80211_S_INIT;
if (ic->ic_opmode == IEEE80211_M_MONITOR)
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
/* enable interrupts */
CSR_WRITE_2(sc, AN_INT_EN, AN_INTRS);
return 0;
}
