io/net80211/net80211_node.c

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2001 Atsushi Onoe
 * Copyright (c) 2002-2008 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.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * 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.
 */

/*
 * Node management routines
 */

#include "net80211_impl.h"

static ieee80211_node_t *ieee80211_node_alloc(ieee80211com_t *);
static void ieee80211_node_cleanup(ieee80211_node_t *);
static void ieee80211_node_free(ieee80211_node_t *);
static uint8_t ieee80211_node_getrssi(const ieee80211_node_t *);
static void ieee80211_setup_node(ieee80211com_t *, ieee80211_node_table_t *,
    ieee80211_node_t *, const uint8_t *);
static void ieee80211_node_reclaim(ieee80211_node_table_t *,
    ieee80211_node_t *);
static void ieee80211_free_node_locked(ieee80211_node_t *);
static void ieee80211_free_allnodes(ieee80211_node_table_t *);
static void ieee80211_node_leave(ieee80211com_t *, ieee80211_node_t *);
static void ieee80211_timeout_scan_candidates(ieee80211_node_table_t *);
static void ieee80211_timeout_stations(ieee80211_node_table_t *);
static void ieee80211_node_table_init(ieee80211com_t *,
    ieee80211_node_table_t *, const char *, int, int,
    void (*timeout)(ieee80211_node_table_t *));
static void ieee80211_node_table_cleanup(ieee80211_node_table_t *);

/*
 * association failures before ignored
 * The failure may be caused by the response frame is lost for
 * environmental reason. So Try associate more than once before
 * ignore the node
 */
#define	IEEE80211_STA_FAILS_MAX	2

/*
 * Initialize node database management callbacks for the interface.
 * This function is called by ieee80211_attach(). These callback
 * functions may be overridden in special circumstances, as long as
 * as this is done after calling ieee80211_attach() and prior to any
 * other call which may allocate a node
 */
void
ieee80211_node_attach(ieee80211com_t *ic)
{
	struct ieee80211_impl *im = ic->ic_private;

	ic->ic_node_alloc = ieee80211_node_alloc;
	ic->ic_node_free = ieee80211_node_free;
	ic->ic_node_cleanup = ieee80211_node_cleanup;
	ic->ic_node_getrssi = ieee80211_node_getrssi;

	/* default station inactivity timer setings */
	im->im_inact_init = IEEE80211_INACT_INIT;
	im->im_inact_assoc = IEEE80211_INACT_ASSOC;
	im->im_inact_run = IEEE80211_INACT_RUN;
	im->im_inact_probe = IEEE80211_INACT_PROBE;
}

/*
 * Initialize node databases and the ic_bss node element.
 */
void
ieee80211_node_lateattach(ieee80211com_t *ic)
{
	/*
	 * Calculate ic_tim_bitmap size in bytes
	 * IEEE80211_AID_MAX defines maximum bits in ic_tim_bitmap
	 */
	ic->ic_tim_len = howmany(IEEE80211_AID_MAX, 8) * sizeof (uint8_t);

	ieee80211_node_table_init(ic, &ic->ic_sta, "station",
	    IEEE80211_INACT_INIT, IEEE80211_WEP_NKID,
	    ieee80211_timeout_stations);
	ieee80211_node_table_init(ic, &ic->ic_scan, "scan",
	    IEEE80211_INACT_SCAN, 0, ieee80211_timeout_scan_candidates);

	ieee80211_reset_bss(ic);
}

/*
 * Destroy all node databases and is usually called during device detach
 */
void
ieee80211_node_detach(ieee80211com_t *ic)
{
	/* Node Detach */
	if (ic->ic_bss != NULL) {
		ieee80211_free_node(ic->ic_bss);
		ic->ic_bss = NULL;
	}
	ieee80211_node_table_cleanup(&ic->ic_scan);
	ieee80211_node_table_cleanup(&ic->ic_sta);
}

/*
 * Increase a node's reference count
 *
 * Return pointer to the node
 */
ieee80211_node_t *
ieee80211_ref_node(ieee80211_node_t *in)
{
	ieee80211_node_incref(in);
	return (in);
}

/*
 * Dexrease a node's reference count
 */
void
ieee80211_unref_node(ieee80211_node_t **in)
{
	ieee80211_node_decref(*in);
	*in = NULL;			/* guard against use */
}

/*
 * Mark ports authorized for data traffic. This function is usually
 * used by 802.1x authenticator.
 */
void
ieee80211_node_authorize(ieee80211_node_t *in)
{
	ieee80211_impl_t *im = in->in_ic->ic_private;

	in->in_flags |= IEEE80211_NODE_AUTH;
	in->in_inact_reload = im->im_inact_run;
	in->in_inact = in->in_inact_reload;
}

/*
 * Mark ports unauthorized for data traffic. This function is usually
 * used by 802.1x authenticator.
 */
void
ieee80211_node_unauthorize(ieee80211_node_t *in)
{
	in->in_flags &= ~IEEE80211_NODE_AUTH;
}

/*
 * Set/change the channel.  The rate set is also updated as
 * to insure a consistent view by drivers.
 */
static void
ieee80211_node_setchan(ieee80211com_t *ic, ieee80211_node_t *in,
    struct ieee80211_channel *chan)
{
	if (chan == IEEE80211_CHAN_ANYC)
		chan = ic->ic_curchan;
	in->in_chan = chan;
	if (IEEE80211_IS_CHAN_HT(chan)) {
		/*
		 * Gotta be careful here; the rate set returned by
		 * ieee80211_get_suprates is actually any HT rate
		 * set so blindly copying it will be bad.  We must
		 * install the legacy rate est in ni_rates and the
		 * HT rate set in ni_htrates.
		 */
		in->in_htrates = *ieee80211_get_suphtrates(ic, chan);
	}
	in->in_rates = *ieee80211_get_suprates(ic, chan);
	/* in->in_rates = ic->ic_sup_rates[ieee80211_chan2mode(ic, chan)]; */
}

/*
 * Initialize the channel set to scan based on the available channels
 * and the current PHY mode.
 */
static void
ieee80211_reset_scan(ieee80211com_t *ic)
{
	ieee80211_impl_t	*im = ic->ic_private;

	if (ic->ic_des_chan != IEEE80211_CHAN_ANYC) {
		(void) memset(im->im_chan_scan, 0, sizeof (im->im_chan_scan));
		ieee80211_setbit(im->im_chan_scan,
		    ieee80211_chan2ieee(ic, ic->ic_des_chan));
	} else {
		bcopy(ic->ic_chan_active, im->im_chan_scan,
		    sizeof (ic->ic_chan_active));
	}
	ieee80211_dbg(IEEE80211_MSG_SCAN, "ieee80211_reset_scan(): "
	    "start chan %u\n", ieee80211_chan2ieee(ic, ic->ic_curchan));
}

/*
 * Begin an active scan. Initialize the node cache. The scan
 * begins on the next radio channel by calling ieee80211_next_scan().
 * The actual scanning is not automated. The driver itself
 * only handles setting the radio frequency and stepping through
 * the channels.
 */
void
ieee80211_begin_scan(ieee80211com_t *ic, boolean_t reset)
{
	IEEE80211_LOCK(ic);

	if (ic->ic_opmode != IEEE80211_M_HOSTAP)
		ic->ic_flags |= IEEE80211_F_ASCAN;
	ieee80211_dbg(IEEE80211_MSG_SCAN,
	    "begin %s scan in %s mode on channel %u\n",
	    (ic->ic_flags & IEEE80211_F_ASCAN) ?  "active" : "passive",
	    ieee80211_phymode_name[ic->ic_curmode],
	    ieee80211_chan2ieee(ic, ic->ic_curchan));

	/*
	 * Clear scan state and flush any previously seen AP's.
	 */
	ieee80211_reset_scan(ic);
	if (reset)
		ieee80211_free_allnodes(&ic->ic_scan);

	ic->ic_flags |= IEEE80211_F_SCAN;
	IEEE80211_UNLOCK(ic);

	/* Scan the next channel. */
	ieee80211_next_scan(ic);
}

/*
 * Switch to the next channel marked for scanning.
 * A driver is expected to first call ieee80211_begin_scan(),
 * to initialize the node cache, then set the radio channel
 * on the device. And then after a certain time has elapsed,
 * call ieee80211_next_scan() to move to the next channel.
 * Typically, a timeout routine is used to automate this process.
 */
void
ieee80211_next_scan(ieee80211com_t *ic)
{
	ieee80211_impl_t *im = ic->ic_private;
	struct ieee80211_channel *chan;

	IEEE80211_LOCK(ic);
	/*
	 * Insure any previous mgt frame timeouts don't fire.
	 * This assumes the driver does the right thing in
	 * flushing anything queued in the driver and below.
	 */
	im->im_mgt_timer = 0;

	chan = ic->ic_curchan;
	do {
		if (++chan > &ic->ic_sup_channels[IEEE80211_CHAN_MAX])
			chan = &ic->ic_sup_channels[0];
		if (ieee80211_isset(im->im_chan_scan,
		    ieee80211_chan2ieee(ic, chan))) {
			ieee80211_clrbit(im->im_chan_scan,
			    ieee80211_chan2ieee(ic, chan));
			ieee80211_dbg(IEEE80211_MSG_SCAN,
			    "ieee80211_next_scan: chan %d->%d\n",
			    ieee80211_chan2ieee(ic, ic->ic_curchan),
			    ieee80211_chan2ieee(ic, chan));
			ic->ic_curchan = chan;
			/*
			 * drivers should do this as needed,
			 * for now maintain compatibility
			 */
			ic->ic_bss->in_rates =
			    ic->ic_sup_rates[ieee80211_chan2mode(ic, chan)];
			IEEE80211_UNLOCK(ic);
			ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
			return;
		}
	} while (chan != ic->ic_curchan);
	IEEE80211_UNLOCK(ic);
	ieee80211_end_scan(ic);
}

/*
 * Copy useful state from node obss into nbss.
 */
static void
ieee80211_copy_bss(ieee80211_node_t *nbss, const ieee80211_node_t *obss)
{
	/* propagate useful state */
	nbss->in_authmode = obss->in_authmode;
	nbss->in_txpower = obss->in_txpower;
	nbss->in_vlan = obss->in_vlan;
}

/*
 * Setup the net80211 specific portion of an interface's softc, ic,
 * for use in IBSS mode
 */
void
ieee80211_create_ibss(ieee80211com_t *ic, struct ieee80211_channel *chan)
{
	ieee80211_impl_t *im = ic->ic_private;
	ieee80211_node_table_t *nt;
	ieee80211_node_t *in;

	IEEE80211_LOCK_ASSERT(ic);
	ieee80211_dbg(IEEE80211_MSG_SCAN, "ieee80211_create_ibss: "
	    "creating ibss\n");

	/*
	 * Create the station/neighbor table.  Note that for adhoc
	 * mode we make the initial inactivity timer longer since
	 * we create nodes only through discovery and they typically
	 * are long-lived associations.
	 */
	nt = &ic->ic_sta;
	IEEE80211_NODE_LOCK(nt);
	nt->nt_name = "neighbor";
	nt->nt_inact_init = im->im_inact_run;
	IEEE80211_NODE_UNLOCK(nt);

	in = ieee80211_alloc_node(ic, &ic->ic_sta, ic->ic_macaddr);
	if (in == NULL) {
		ieee80211_err("ieee80211_create_ibss(): alloc node failed\n");
		return;
	}
	IEEE80211_ADDR_COPY(in->in_bssid, ic->ic_macaddr);
	in->in_esslen = ic->ic_des_esslen;
	(void) memcpy(in->in_essid, ic->ic_des_essid, in->in_esslen);
	ieee80211_copy_bss(in, ic->ic_bss);
	in->in_intval = ic->ic_bintval;
	if (ic->ic_flags & IEEE80211_F_PRIVACY)
		in->in_capinfo |= IEEE80211_CAPINFO_PRIVACY;
	if (ic->ic_phytype == IEEE80211_T_FH) {
		in->in_fhdwell = 200;
		in->in_fhindex = 1;
	}
	switch (ic->ic_opmode) {
	case IEEE80211_M_IBSS:
		ic->ic_flags |= IEEE80211_F_SIBSS;
		in->in_capinfo |= IEEE80211_CAPINFO_IBSS;
		if (ic->ic_flags & IEEE80211_F_DESBSSID)
			IEEE80211_ADDR_COPY(in->in_bssid, ic->ic_des_bssid);
		else
			in->in_bssid[0] |= 0x02;	/* local bit for IBSS */
		break;
	case IEEE80211_M_AHDEMO:
		if (ic->ic_flags & IEEE80211_F_DESBSSID)
			IEEE80211_ADDR_COPY(in->in_bssid, ic->ic_des_bssid);
		else
			(void) memset(in->in_bssid, 0, IEEE80211_ADDR_LEN);
		break;
	default:
		ieee80211_err("ieee80211_create_ibss(): "
		    "wrong opmode %u to creat IBSS, abort\n",
		    ic->ic_opmode);
		ieee80211_free_node(in);
		return;
	}

	/*
	 * Fix the channel and related attributes.
	 */
	ieee80211_node_setchan(ic, in, chan);
	ic->ic_curchan = chan;
	ic->ic_curmode = ieee80211_chan2mode(ic, chan);
	/*
	 * Do mode-specific rate setup.
	 */
	ieee80211_setbasicrates(&in->in_rates, ic->ic_curmode);
	IEEE80211_UNLOCK(ic);
	ieee80211_sta_join(ic, ieee80211_ref_node(in));
	IEEE80211_LOCK(ic);
}

void
ieee80211_reset_bss(ieee80211com_t *ic)
{
	ieee80211_node_t *in;
	ieee80211_node_t *obss;

	ieee80211_node_table_reset(&ic->ic_sta);
	ieee80211_reset_erp(ic);

	in = ieee80211_alloc_node(ic, &ic->ic_scan, ic->ic_macaddr);
	ASSERT(in != NULL);
	obss = ic->ic_bss;
	ic->ic_bss = ieee80211_ref_node(in);
	if (obss != NULL) {
		ieee80211_copy_bss(in, obss);
		in->in_intval = ic->ic_bintval;
		ieee80211_free_node(obss);
	}
}

static int
ieee80211_match_bss(ieee80211com_t *ic, ieee80211_node_t *in)
{
	uint8_t rate;
	int fail;

	fail = 0;
	if (ieee80211_isclr(ic->ic_chan_active,
	    ieee80211_chan2ieee(ic, in->in_chan))) {
		fail |= IEEE80211_BADCHAN;
	}
	if (ic->ic_des_chan != IEEE80211_CHAN_ANYC &&
	    in->in_chan != ic->ic_des_chan) {
		fail |= IEEE80211_BADCHAN;
	}
	if (ic->ic_opmode == IEEE80211_M_IBSS) {
		if (!(in->in_capinfo & IEEE80211_CAPINFO_IBSS))
			fail |= IEEE80211_BADOPMODE;
	} else {
		if (!(in->in_capinfo & IEEE80211_CAPINFO_ESS))
			fail |= IEEE80211_BADOPMODE;
	}
	if (ic->ic_flags & IEEE80211_F_PRIVACY) {
		if (!(in->in_capinfo & IEEE80211_CAPINFO_PRIVACY))
			fail |= IEEE80211_BADPRIVACY;
	} else {
		if (in->in_capinfo & IEEE80211_CAPINFO_PRIVACY)
			fail |= IEEE80211_BADPRIVACY;
	}
	rate = ieee80211_fix_rate(in, &in->in_rates,
	    IEEE80211_F_DONEGO | IEEE80211_F_DOFRATE);
	if (rate & IEEE80211_RATE_BASIC)
		fail |= IEEE80211_BADRATE;
	if (ic->ic_des_esslen != 0 &&
	    (in->in_esslen != ic->ic_des_esslen ||
	    memcmp(in->in_essid, ic->ic_des_essid, ic->ic_des_esslen) != 0)) {
		fail |= IEEE80211_BADESSID;
	}
	if ((ic->ic_flags & IEEE80211_F_DESBSSID) &&
	    !IEEE80211_ADDR_EQ(ic->ic_des_bssid, in->in_bssid)) {
		fail |= IEEE80211_BADBSSID;
	}
	if (in->in_fails >= IEEE80211_STA_FAILS_MAX)
		fail |= IEEE80211_NODEFAIL;

	return (fail);
}

#define	IEEE80211_MAXRATE(_rs) \
	((_rs).ir_rates[(_rs).ir_nrates - 1] & IEEE80211_RATE_VAL)

/*
 * Compare the capabilities of node a with node b and decide which is
 * more desirable (return b if b is considered better than a).  Note
 * that we assume compatibility/usability has already been checked
 * so we don't need to (e.g. validate whether privacy is supported).
 * Used to select the best scan candidate for association in a BSS.
 *
 * Return desired node
 */
static ieee80211_node_t *
ieee80211_node_compare(ieee80211com_t *ic, ieee80211_node_t *a,
    ieee80211_node_t *b)
{
	uint8_t maxa;
	uint8_t maxb;
	uint8_t rssia;
	uint8_t rssib;

	/* privacy support preferred */
	if ((a->in_capinfo & IEEE80211_CAPINFO_PRIVACY) &&
	    !(b->in_capinfo & IEEE80211_CAPINFO_PRIVACY)) {
		return (a);
	}
	if (!(a->in_capinfo & IEEE80211_CAPINFO_PRIVACY) &&
	    (b->in_capinfo & IEEE80211_CAPINFO_PRIVACY)) {
		return (b);
	}

	/* compare count of previous failures */
	if (b->in_fails != a->in_fails)
		return ((a->in_fails > b->in_fails) ? b : a);

	rssia = ic->ic_node_getrssi(a);
	rssib = ic->ic_node_getrssi(b);
	if (ABS(rssib - rssia) < IEEE80211_RSSI_CMP_THRESHOLD) {
		/* best/max rate preferred if signal level close enough */
		maxa = IEEE80211_MAXRATE(a->in_rates);
		maxb = IEEE80211_MAXRATE(b->in_rates);
		if (maxa != maxb)
			return ((maxb > maxa) ? b : a);
		/* for now just prefer 5Ghz band to all other bands */
		if (IEEE80211_IS_CHAN_5GHZ(a->in_chan) &&
		    !IEEE80211_IS_CHAN_5GHZ(b->in_chan)) {
			return (a);
		}
		if (!IEEE80211_IS_CHAN_5GHZ(a->in_chan) &&
		    IEEE80211_IS_CHAN_5GHZ(b->in_chan)) {
			return (b);
		}
	}
	/* all things being equal, compare signal level */
	return ((rssib > rssia) ? b : a);
}

/*
 * Mark an ongoing scan stopped.
 */
void
ieee80211_cancel_scan(ieee80211com_t *ic)
{
	IEEE80211_LOCK(ic);
	ieee80211_dbg(IEEE80211_MSG_SCAN, "ieee80211_cancel_scan()"
	    "end %s scan\n",
	    (ic->ic_flags & IEEE80211_F_ASCAN) ?  "active" : "passive");
	ic->ic_flags &= ~(IEEE80211_F_SCAN | IEEE80211_F_ASCAN);
	cv_broadcast(&((ieee80211_impl_t *)ic->ic_private)->im_scan_cv);
	IEEE80211_UNLOCK(ic);
}

/*
 * Complete a scan of potential channels. It is called by
 * ieee80211_next_scan() when the state machine has performed
 * a full cycle of scaning on all available radio channels.
 * ieee80211_end_scan() will inspect the node cache for suitable
 * APs found during scaning, and associate with one, should
 * the parameters of the node match those of the configuration
 * requested from userland.
 */
void
ieee80211_end_scan(ieee80211com_t *ic)
{
	ieee80211_node_table_t *nt = &ic->ic_scan;
	ieee80211_node_t *in;
	ieee80211_node_t *selbs;

	ieee80211_cancel_scan(ic);
	/* notify SCAN done */
	ieee80211_notify(ic, EVENT_SCAN_RESULTS);
	IEEE80211_LOCK(ic);

	/*
	 * Automatic sequencing; look for a candidate and
	 * if found join the network.
	 */
	/* NB: unlocked read should be ok */
	in = list_head(&nt->nt_node);
	if (in == NULL && (ic->ic_flags & IEEE80211_F_WPA) == 0) {
		ieee80211_dbg(IEEE80211_MSG_SCAN, "ieee80211_end_scan: "
		    "no scan candidate\n");
	notfound:
		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);
			IEEE80211_UNLOCK(ic);
			return;
		}

		/*
		 * Reset the list of channels to scan and start again.
		 */
		ieee80211_reset_scan(ic);
		ic->ic_flags |= IEEE80211_F_SCAN | IEEE80211_F_ASCAN;
		IEEE80211_UNLOCK(ic);

		ieee80211_next_scan(ic);
		return;
	}

	if (ic->ic_flags & IEEE80211_F_SCANONLY ||
	    ic->ic_flags & IEEE80211_F_WPA) {	/* scan only */
		ic->ic_flags &= ~IEEE80211_F_SCANONLY;
		IEEE80211_UNLOCK(ic);
		ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
		return;
	}

	selbs = NULL;
	IEEE80211_NODE_LOCK(nt);
	while (in != NULL) {
		if (in->in_fails >= IEEE80211_STA_FAILS_MAX) {
			ieee80211_node_t *tmpin = in;

			/*
			 * 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.
			 */
			in = list_next(&nt->nt_node, tmpin);
			ieee80211_node_reclaim(nt, tmpin);
			continue;
		}
		/*
		 * It's possible at some special moments, the in_chan will
		 * be none. Need to skip the null node.
		 */
		if (in->in_chan == IEEE80211_CHAN_ANYC) {
			in = list_next(&nt->nt_node, in);
			continue;
		}
		if (ieee80211_match_bss(ic, in) == 0) {
			if (selbs == NULL)
				selbs = in;
			else
				selbs = ieee80211_node_compare(ic, selbs, in);
		}
		in = list_next(&nt->nt_node, in);
	}
	if (selbs != NULL)	/* grab ref while dropping lock */
		(void) ieee80211_ref_node(selbs);
	IEEE80211_NODE_UNLOCK(nt);
	if (selbs == NULL)
		goto notfound;
	IEEE80211_UNLOCK(ic);
	ieee80211_sta_join(ic, selbs);
}


/*
 * Handle 802.11 ad hoc network merge.  The convention, set by the
 * Wireless Ethernet Compatibility Alliance (WECA), is that an 802.11
 * station will change its BSSID to match the "oldest" 802.11 ad hoc
 * network, on the same channel, that has the station's desired SSID.
 * The "oldest" 802.11 network sends beacons with the greatest TSF
 * timestamp.
 * The caller is assumed to validate TSF's before attempting a merge.
 *
 * Return B_TRUE if the BSSID changed, B_FALSE otherwise.
 */
boolean_t
ieee80211_ibss_merge(ieee80211_node_t *in)
{
	ieee80211com_t *ic = in->in_ic;

	if (in == ic->ic_bss ||
	    IEEE80211_ADDR_EQ(in->in_bssid, ic->ic_bss->in_bssid)) {
		/* unchanged, nothing to do */
		return (B_FALSE);
	}
	if (ieee80211_match_bss(ic, in) != 0) {	/* capabilities mismatch */
		ieee80211_dbg(IEEE80211_MSG_ASSOC, "ieee80211_ibss_merge: "
		    " merge failed, capabilities mismatch\n");
		return (B_FALSE);
	}
	ieee80211_dbg(IEEE80211_MSG_ASSOC, "ieee80211_ibss_merge: "
	    "new bssid %s: %s preamble, %s slot time%s\n",
	    ieee80211_macaddr_sprintf(in->in_bssid),
	    (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "short" : "long",
	    (ic->ic_flags & IEEE80211_F_SHSLOT) ? "short" : "long",
	    (ic->ic_flags&IEEE80211_F_USEPROT) ? ", protection" : "");
	ieee80211_sta_join(ic, ieee80211_ref_node(in));
	return (B_TRUE);
}

/*
 * Change the bss channel.
 */
void
ieee80211_setcurchan(ieee80211com_t *ic, struct ieee80211_channel *c)
{
	ic->ic_curchan = c;
	ic->ic_curmode = ieee80211_chan2mode(ic, ic->ic_curchan);
	if (ic->ic_set_channel != NULL)
		ic->ic_set_channel(ic);
}

/*
 * Join the specified IBSS/BSS network.  The node is assumed to
 * be passed in with a held reference.
 */
void
ieee80211_sta_join(ieee80211com_t *ic, ieee80211_node_t *selbs)
{
	ieee80211_impl_t *im = ic->ic_private;
	ieee80211_node_t *obss;

	IEEE80211_LOCK(ic);
	if (ic->ic_opmode == IEEE80211_M_IBSS) {
		ieee80211_node_table_t *nt;

		/*
		 * Delete unusable rates; we've already checked
		 * that the negotiated rate set is acceptable.
		 */
		(void) ieee80211_fix_rate(selbs, &selbs->in_rates,
		    IEEE80211_F_DODEL);
		/*
		 * Fillin the neighbor table
		 */
		nt = &ic->ic_sta;
		IEEE80211_NODE_LOCK(nt);
		nt->nt_name = "neighbor";
		nt->nt_inact_init = im->im_inact_run;
		IEEE80211_NODE_UNLOCK(nt);
	}

	/*
	 * Committed to selbs, setup state.
	 */
	obss = ic->ic_bss;
	ic->ic_bss = selbs;	/* caller assumed to bump refcnt */
	if (obss != NULL) {
		ieee80211_copy_bss(selbs, obss);
		ieee80211_free_node(obss);
	}
	ic->ic_curmode = ieee80211_chan2mode(ic, selbs->in_chan);
	ic->ic_curchan = selbs->in_chan;
	ic->ic_phytype = selbs->in_phytype;
	/*
	 * Set the erp state (mostly the slot time) to deal with
	 * the auto-select case; this should be redundant if the
	 * mode is locked.
	 */
	ieee80211_reset_erp(ic);
	ieee80211_wme_initparams(ic);

	IEEE80211_UNLOCK(ic);
	if (ic->ic_opmode == IEEE80211_M_STA)
		ieee80211_new_state(ic, IEEE80211_S_AUTH, -1);
	else
		ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
}

/*
 * Leave the specified IBSS/BSS network.  The node is assumed to
 * be passed in with a held reference.
 */
void
ieee80211_sta_leave(ieee80211com_t *ic, ieee80211_node_t *in)
{
	IEEE80211_LOCK(ic);
	ic->ic_node_cleanup(in);
	ieee80211_notify_node_leave(ic, in);
	IEEE80211_UNLOCK(ic);
}

/*
 * Allocate a node. This is the default callback function for
 * ic_node_alloc. This function may be overridden by the driver
 * to allocate device specific node structure.
 */
/* ARGSUSED */
static ieee80211_node_t *
ieee80211_node_alloc(ieee80211com_t *ic)
{
	return (kmem_zalloc(sizeof (ieee80211_node_t), KM_SLEEP));
}

/*
 * Cleanup a node, free any memory associated with the node.
 * This is the default callback function for ic_node_cleanup
 * and may be overridden by the driver.
 */
static void
ieee80211_node_cleanup(ieee80211_node_t *in)
{
	in->in_associd = 0;
	in->in_rssi = 0;
	in->in_rstamp = 0;
	if (in->in_challenge != NULL) {
		kmem_free(in->in_challenge, IEEE80211_CHALLENGE_LEN);
		in->in_challenge = NULL;
	}
	if (in->in_rxfrag != NULL) {
		freemsg(in->in_rxfrag);
		in->in_rxfrag = NULL;
	}
}

/*
 * Free a node. This is the default callback function for ic_node_free
 * and may be overridden by the driver to free memory used by device
 * specific node structure
 */
static void
ieee80211_node_free(ieee80211_node_t *in)
{
	ieee80211com_t *ic = in->in_ic;

	ic->ic_node_cleanup(in);
	if (in->in_wpa_ie != NULL)
		ieee80211_free(in->in_wpa_ie);
	if (in->in_wme_ie != NULL)
		ieee80211_free(in->in_wme_ie);
	if (in->in_htcap_ie != NULL)
		ieee80211_free(in->in_htcap_ie);
	kmem_free(in, sizeof (ieee80211_node_t));
}

/*
 * Get a node current RSSI value. This is the default callback function
 * for ic_node_getrssi and may be overridden by the driver to provide
 * device specific RSSI calculation algorithm.
 */
static uint8_t
ieee80211_node_getrssi(const ieee80211_node_t *in)
{
	return (in->in_rssi);
}

/* Free fragment if not needed anymore */
static void
node_cleanfrag(ieee80211_node_t *in)
{
	clock_t ticks;

	ticks = ddi_get_lbolt();
	if (in->in_rxfrag != NULL && ticks > (in->in_rxfragstamp + hz)) {
		freemsg(in->in_rxfrag);
		in->in_rxfrag = NULL;
	}
}

/*
 * Setup a node. Initialize the node with specified macaddr. Associate
 * with the interface softc, ic, and add it to the specified node
 * database.
 */
static void
ieee80211_setup_node(ieee80211com_t *ic, ieee80211_node_table_t *nt,
    ieee80211_node_t *in, const uint8_t *macaddr)
{
	int32_t hash;

	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_setup_node(): "
	    "%p<%s> in %s table\n", in,
	    ieee80211_macaddr_sprintf(macaddr),
	    (nt != NULL) ? nt->nt_name : "NULL");

	in->in_ic = ic;
	IEEE80211_ADDR_COPY(in->in_macaddr, macaddr);
	hash = ieee80211_node_hash(macaddr);
	ieee80211_node_initref(in);		/* mark referenced */
	in->in_authmode = IEEE80211_AUTH_OPEN;
	in->in_txpower = ic->ic_txpowlimit;	/* max power */
	in->in_chan = IEEE80211_CHAN_ANYC;
	in->in_inact_reload = IEEE80211_INACT_INIT;
	in->in_inact = in->in_inact_reload;
	ieee80211_crypto_resetkey(ic, &in->in_ucastkey, IEEE80211_KEYIX_NONE);

	if (nt != NULL) {
		IEEE80211_NODE_LOCK(nt);
		list_insert_tail(&nt->nt_node, in);
		list_insert_tail(&nt->nt_hash[hash], in);
		in->in_table = nt;
		in->in_inact_reload = nt->nt_inact_init;
		IEEE80211_NODE_UNLOCK(nt);
	}
}

/*
 * Allocates and initialize a node with specified MAC address.
 * Associate the node with the interface ic. If the allocation
 * is successful, the node structure is initialized by
 * ieee80211_setup_node(); otherwise, NULL is returned
 */
ieee80211_node_t *
ieee80211_alloc_node(ieee80211com_t *ic, ieee80211_node_table_t *nt,
    const uint8_t *macaddr)
{
	ieee80211_node_t *in;

	in = ic->ic_node_alloc(ic);
	if (in != NULL)
		ieee80211_setup_node(ic, nt, in, macaddr);
	return (in);
}

/*
 * Craft a temporary node suitable for sending a management frame
 * to the specified station.  We craft only as much state as we
 * need to do the work since the node will be immediately reclaimed
 * once the send completes.
 */
ieee80211_node_t *
ieee80211_tmp_node(ieee80211com_t *ic, const uint8_t *macaddr)
{
	ieee80211_node_t *in;

	in = ic->ic_node_alloc(ic);
	if (in != NULL) {
		ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_tmp_node: "
		    "%p<%s>\n", in, ieee80211_macaddr_sprintf(macaddr));

		IEEE80211_ADDR_COPY(in->in_macaddr, macaddr);
		IEEE80211_ADDR_COPY(in->in_bssid, ic->ic_bss->in_bssid);
		ieee80211_node_initref(in);		/* mark referenced */
		in->in_txpower = ic->ic_bss->in_txpower;
		/* NB: required by ieee80211_fix_rate */
		ieee80211_node_setchan(ic, in, ic->ic_bss->in_chan);
		ieee80211_crypto_resetkey(ic, &in->in_ucastkey,
		    IEEE80211_KEYIX_NONE);

		in->in_table = NULL;		/* NB: pedantic */
		in->in_ic = ic;
	}

	return (in);
}

/*
 * ieee80211_dup_bss() is similar to ieee80211_alloc_node(),
 * but is instead used to create a node database entry for
 * the specified BSSID. If the allocation is successful, the
 * node is initialized,  otherwise, NULL is returned.
 */
ieee80211_node_t *
ieee80211_dup_bss(ieee80211_node_table_t *nt, const uint8_t *macaddr)
{
	ieee80211com_t *ic = nt->nt_ic;
	ieee80211_node_t *in;

	in = ieee80211_alloc_node(ic, nt, macaddr);
	if (in != NULL) {
		/*
		 * Inherit from ic_bss.
		 */
		ieee80211_copy_bss(in, ic->ic_bss);
		IEEE80211_ADDR_COPY(in->in_bssid, ic->ic_bss->in_bssid);
		ieee80211_node_setchan(ic, in, ic->ic_bss->in_chan);
	}

	return (in);
}

/*
 * Iterate through the node table, searching for a node entry which
 * matches macaddr. If the entry is found, its reference count is
 * incremented, and a pointer to the node is returned; otherwise,
 * NULL will be returned.
 * The node table lock is acquired by the caller.
 */
static ieee80211_node_t *
ieee80211_find_node_locked(ieee80211_node_table_t *nt, const uint8_t *macaddr)
{
	ieee80211_node_t *in;
	int hash;

	ASSERT(IEEE80211_NODE_IS_LOCKED(nt));

	hash = ieee80211_node_hash(macaddr);
	in = list_head(&nt->nt_hash[hash]);
	while (in != NULL) {
		if (IEEE80211_ADDR_EQ(in->in_macaddr, macaddr))
			return (ieee80211_ref_node(in)); /* mark referenced */
		in = list_next(&nt->nt_hash[hash], in);
	}
	return (NULL);
}

/*
 * Iterate through the node table, searching for a node entry
 * which match specified mac address.
 * Return NULL if no matching node found.
 */
ieee80211_node_t *
ieee80211_find_node(ieee80211_node_table_t *nt, const uint8_t *macaddr)
{
	ieee80211_node_t *in;

	IEEE80211_NODE_LOCK(nt);
	in = ieee80211_find_node_locked(nt, macaddr);
	IEEE80211_NODE_UNLOCK(nt);
	return (in);
}

/*
 * Like find but search based on the ssid too.
 */
ieee80211_node_t *
ieee80211_find_node_with_ssid(ieee80211_node_table_t *nt,
	const uint8_t *macaddr, uint32_t ssidlen, const uint8_t *ssid)
{
	ieee80211_node_t *in;
	int hash;

	IEEE80211_NODE_LOCK(nt);

	hash = ieee80211_node_hash(macaddr);
	in = list_head(&nt->nt_hash[hash]);
	while (in != NULL) {
		if (IEEE80211_ADDR_EQ(in->in_macaddr, macaddr) &&
		    in->in_esslen == ssidlen &&
		    memcmp(in->in_essid, ssid, ssidlen) == 0)
			break;
		in = list_next(&nt->nt_hash[hash], in);
	}
	if (in != NULL) {
		(void) ieee80211_ref_node(in); /* mark referenced */
	}
	IEEE80211_NODE_UNLOCK(nt);

	return (in);
}

/*
 * Fake up a node; this handles node discovery in adhoc mode.
 * Note that for the driver's benefit we treat this like an
 * association so the driver has an opportunity to setup it's
 * private state.
 */
ieee80211_node_t *
ieee80211_fakeup_adhoc_node(ieee80211_node_table_t *nt, const uint8_t *macaddr)
{
	ieee80211com_t *ic = nt->nt_ic;
	ieee80211_node_t *in;

	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_fakeup_adhoc_node: "
	    "mac<%s>\n", ieee80211_macaddr_sprintf(macaddr));
	in = ieee80211_dup_bss(nt, macaddr);
	if (in != NULL) {
		/* no rate negotiation; just dup */
		in->in_rates = ic->ic_bss->in_rates;
		if (ic->ic_node_newassoc != NULL)
			ic->ic_node_newassoc(in, 1);
		ieee80211_node_authorize(in);
	}
	return (in);
}

static void
ieee80211_saveie(uint8_t **iep, const uint8_t *ie)
{
	uint_t ielen = ie[1]+2;
	/*
	 * Record information element for later use.
	 */
	if (*iep == NULL || (*iep)[1] != ie[1]) {
		if (*iep != NULL)
			ieee80211_free(*iep);
		*iep = ieee80211_malloc(ielen);
	}
	if (*iep != NULL)
		(void) memcpy(*iep, ie, ielen);
}

static void
saveie(uint8_t **iep, const uint8_t *ie)
{
	if (ie == NULL) {
		if (*iep != NULL)
			ieee80211_free(*iep);
		*iep = NULL;
	}
	else
		ieee80211_saveie(iep, ie);
}

/*
 * Process a beacon or probe response frame.
 */
void
ieee80211_add_scan(ieee80211com_t *ic, const struct ieee80211_scanparams *sp,
    const struct ieee80211_frame *wh, int subtype, int rssi, int rstamp)
{
	ieee80211_node_table_t *nt = &ic->ic_scan;
	ieee80211_node_t *in;
	boolean_t newnode = B_FALSE;

	in = ieee80211_find_node(nt, wh->i_addr3);
	if (in == NULL) {
		/*
		 * Create a new entry.
		 */
		in = ieee80211_alloc_node(ic, nt, wh->i_addr3);
		if (in == NULL) {
			ieee80211_dbg(IEEE80211_MSG_ANY, "ieee80211_add_scan: "
			    "alloc node failed\n");
			return;
		}
		/*
		 * inherit from ic_bss.
		 */
		ieee80211_copy_bss(in, ic->ic_bss);
		ieee80211_node_setchan(ic, in, ic->ic_curchan);
		newnode = B_TRUE;
	}

	/* ap beaconing multiple ssid w/ same bssid */

	/*
	 * sp->ssid[0] - element ID
	 * sp->ssid[1] - length
	 * sp->ssid[2]... - ssid
	 */
	if (sp->ssid[1] != 0 &&
	    subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP ||
	    in->in_esslen == 0) {
		in->in_esslen = sp->ssid[1];
		bzero(in->in_essid, sizeof (in->in_essid));
		bcopy(sp->ssid + 2, in->in_essid, sp->ssid[1]);
	}
	IEEE80211_ADDR_COPY(in->in_bssid, wh->i_addr3);
	in->in_rssi = (uint8_t)rssi;
	in->in_rstamp = rstamp;
	bcopy(sp->tstamp, in->in_tstamp.data, sizeof (in->in_tstamp));
	in->in_intval = sp->bintval;
	in->in_capinfo = sp->capinfo;
	in->in_chan = &ic->ic_sup_channels[sp->chan];
	in->in_phytype = sp->phytype;
	in->in_fhdwell = sp->fhdwell;
	in->in_fhindex = sp->fhindex;
	in->in_erp = sp->erp;
	if (sp->tim != NULL) {
		struct ieee80211_tim_ie *ie;

		ie = (struct ieee80211_tim_ie *)sp->tim;
		in->in_dtim_count = ie->tim_count;
		in->in_dtim_period = ie->tim_period;
	}
	/*
	 * Record the byte offset from the mac header to
	 * the start of the TIM information element for
	 * use by hardware and/or to speedup software
	 * processing of beacon frames.
	 */
	in->in_tim_off = sp->timoff;
	/*
	 * Record optional information elements that might be
	 * used by applications or drivers.
	 */
	saveie(&in->in_wme_ie, sp->wme);
	saveie(&in->in_wpa_ie, sp->wpa);
	saveie(&in->in_htcap_ie, sp->htcap);
	/* parsed in ieee80211_sta_join() */
	if (sp->htcap != NULL)
		ieee80211_parse_htcap(in, in->in_htcap_ie);

	/* NB: must be after in_chan is setup */
	(void) ieee80211_setup_rates(in, sp->rates, sp->xrates,
	    IEEE80211_F_DOSORT);

	if (!newnode)
		ieee80211_free_node(in);
}

/*
 * Initialize/update an ad-hoc node with contents from a received
 * beacon frame.
 */
void
ieee80211_init_neighbor(ieee80211_node_t *in, const struct ieee80211_frame *wh,
    const struct ieee80211_scanparams *sp)
{
	in->in_esslen = sp->ssid[1];
	(void) memcpy(in->in_essid, sp->ssid + 2, sp->ssid[1]);
	IEEE80211_ADDR_COPY(in->in_bssid, wh->i_addr3);
	(void) memcpy(in->in_tstamp.data, sp->tstamp, sizeof (in->in_tstamp));
	in->in_intval = sp->bintval;
	in->in_capinfo = sp->capinfo;
	in->in_chan = in->in_ic->ic_curchan;
	in->in_fhdwell = sp->fhdwell;
	in->in_fhindex = sp->fhindex;
	in->in_erp = sp->erp;
	in->in_tim_off = sp->timoff;
	if (sp->wme != NULL)
		ieee80211_saveie(&in->in_wme_ie, sp->wme);

	/* NB: must be after in_chan is setup */
	(void) ieee80211_setup_rates(in, sp->rates, sp->xrates,
	    IEEE80211_F_DOSORT);
}

/*
 * Do node discovery in adhoc mode on receipt of a beacon
 * or probe response frame.  Note that for the driver's
 * benefit we we treat this like an association so the
 * driver has an opportuinty to setup it's private state.
 */
ieee80211_node_t *
ieee80211_add_neighbor(ieee80211com_t *ic, const struct ieee80211_frame *wh,
    const struct ieee80211_scanparams *sp)
{
	ieee80211_node_t *in;

	in = ieee80211_dup_bss(&ic->ic_sta, wh->i_addr2);
	if (in != NULL) {
		ieee80211_init_neighbor(in, wh, sp);
		if (ic->ic_node_newassoc != NULL)
			ic->ic_node_newassoc(in, 1);
	}
	return (in);
}

#define	IEEE80211_IS_CTL(wh)	\
	((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_CTL)

#define	IEEE80211_IS_PSPOLL(wh)	\
	((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==	\
	    IEEE80211_FC0_SUBTYPE_PS_POLL)

#define	IEEE80211_IS_BAR(wh)	\
	((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==	\
	    IEEE80211_FC0_SUBTYPE_BAR)

/*
 * Locate the node for sender, track state, and then pass the
 * (referenced) node up to the 802.11 layer for its use.  We
 * are required to pass some node so we fall back to ic_bss
 * when this frame is from an unknown sender.  The 802.11 layer
 * knows this means the sender wasn't in the node table and
 * acts accordingly.
 */
ieee80211_node_t *
ieee80211_find_rxnode(ieee80211com_t *ic, const struct ieee80211_frame *wh)
{
	ieee80211_node_table_t *nt;
	ieee80211_node_t *in;

	/* may want scanned nodes in the neighbor table for adhoc */
	if (ic->ic_opmode == IEEE80211_M_STA ||
	    (ic->ic_flags & IEEE80211_F_SCAN)) {
		nt = &ic->ic_scan;
	} else {
		nt = &ic->ic_sta;
	}

	IEEE80211_NODE_LOCK(nt);
	if (IEEE80211_IS_CTL(wh) &&
	    !IEEE80211_IS_PSPOLL(wh) && !IEEE80211_IS_BAR(wh))
		in = ieee80211_find_node_locked(nt, wh->i_addr1);
	else
		in = ieee80211_find_node_locked(nt, wh->i_addr2);
	IEEE80211_NODE_UNLOCK(nt);

	if (in == NULL)
		in = ieee80211_ref_node(ic->ic_bss);

	return (in);
}

#undef IEEE80211_IS_BAR
#undef IEEE80211_IS_PSPOLL
#undef IEEE80211_IS_CTL

/*
 * Return a reference to the appropriate node for sending
 * a data frame.  This handles node discovery in adhoc networks.
 */
ieee80211_node_t *
ieee80211_find_txnode(ieee80211com_t *ic, const uint8_t *daddr)
{
	ieee80211_node_table_t *nt = &ic->ic_sta;
	ieee80211_node_t *in;

	/*
	 * The destination address should be in the node table
	 * unless this is a multicast/broadcast frame.  We can
	 * also optimize station mode operation, all frames go
	 * to the bss node.
	 */
	IEEE80211_NODE_LOCK(nt);
	if (ic->ic_opmode == IEEE80211_M_STA || IEEE80211_IS_MULTICAST(daddr))
		in = ieee80211_ref_node(ic->ic_bss);
	else
		in = ieee80211_find_node_locked(nt, daddr);
	IEEE80211_NODE_UNLOCK(nt);

	if (in == NULL) {
		if (ic->ic_opmode == IEEE80211_M_IBSS) {
			/*
			 * In adhoc mode cons up a node for the destination.
			 * Note that we need an additional reference for the
			 * caller to be consistent with
			 * ieee80211_find_node_locked
			 * can't hold lock across ieee80211_dup_bss 'cuz of
			 * recursive locking
			 */
			in = ieee80211_fakeup_adhoc_node(nt, daddr);
			if (in != NULL)
				(void) ieee80211_ref_node(in);
		} else {
			ieee80211_dbg(IEEE80211_MSG_OUTPUT,
			    "ieee80211_find_txnode: "
			    "[%s] no node, discard frame\n",
			    ieee80211_macaddr_sprintf(daddr));
		}
	}
	return (in);
}

/*
 * Remove a node from the node database entries and free memory
 * associated with the node. The node table lock is acquired by
 * the caller.
 */
static void
ieee80211_free_node_locked(ieee80211_node_t *in)
{
	ieee80211com_t *ic = in->in_ic;
	ieee80211_node_table_t *nt = in->in_table;
	int32_t hash;

	if (nt != NULL) {
		hash = ieee80211_node_hash(in->in_macaddr);
		list_remove(&nt->nt_hash[hash], in);
		list_remove(&nt->nt_node, in);
	}
	ic->ic_node_free(in);
}

/*
 * Remove a node from the node database entries and free any
 * memory associated with the node.
 * This method can be overridden in ieee80211_attach()
 */
void
ieee80211_free_node(ieee80211_node_t *in)
{
	ieee80211_node_table_t *nt = in->in_table;

	if (nt != NULL)
		IEEE80211_NODE_LOCK(nt);
	if (ieee80211_node_decref_nv(in) == 0)
		ieee80211_free_node_locked(in);
	if (nt != NULL)
		IEEE80211_NODE_UNLOCK(nt);
}

/*
 * Reclaim a node.  If this is the last reference count then
 * do the normal free work.  Otherwise remove it from the node
 * table and mark it gone by clearing the back-reference.
 */
static void
ieee80211_node_reclaim(ieee80211_node_table_t *nt, ieee80211_node_t *in)
{
	int32_t hash;

	IEEE80211_NODE_LOCK_ASSERT(nt);
	ieee80211_dbg(IEEE80211_MSG_NODE, "node_reclaim: "
	    " remove %p<%s> from %s table, refcnt %d\n",
	    in, ieee80211_macaddr_sprintf(in->in_macaddr), nt->nt_name,
	    ieee80211_node_refcnt(in));

	if (ieee80211_node_decref_nv(in) != 0) {
		/*
		 * Clear any entry in the unicast key mapping table.
		 * We need to do it here so rx lookups don't find it
		 * in the mapping table even if it's not in the hash
		 * table.  We cannot depend on the mapping table entry
		 * being cleared because the node may not be free'd.
		 */
		hash = ieee80211_node_hash(in->in_macaddr);
		list_remove(&nt->nt_hash[hash], in);
		list_remove(&nt->nt_node, in);
		in->in_table = NULL;
	} else {
		ieee80211_free_node_locked(in);
	}
}

/*
 * Iterate through the node list and reclaim all node in the node table.
 * The node table lock is acquired by the caller
 */
static void
ieee80211_free_allnodes_locked(ieee80211_node_table_t *nt)
{
	ieee80211_node_t *in;

	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_free_allnodes_locked(): "
	    "free all nodes in %s table\n", nt->nt_name);

	in = list_head(&nt->nt_node);
	while (in != NULL) {
		ieee80211_node_reclaim(nt, in);
		in = list_head(&nt->nt_node);
	}
	ieee80211_reset_erp(nt->nt_ic);
}

/*
 * Iterate through the node list, calling ieee80211_node_reclaim() for
 * all nodes associated with the interface.
 */
static void
ieee80211_free_allnodes(ieee80211_node_table_t *nt)
{
	IEEE80211_NODE_LOCK(nt);
	ieee80211_free_allnodes_locked(nt);
	IEEE80211_NODE_UNLOCK(nt);
}

/*
 * Timeout entries in the scan cache. This is the timeout callback
 * function of node table ic_scan which is called when the inactivity
 * timer expires.
 */
static void
ieee80211_timeout_scan_candidates(ieee80211_node_table_t *nt)
{
	ieee80211com_t *ic = nt->nt_ic;
	ieee80211_node_t *in;

	IEEE80211_NODE_LOCK(nt);
	in = ic->ic_bss;
	node_cleanfrag(in);	/* Free fragment if not needed */
	nt->nt_inact_timer = IEEE80211_INACT_WAIT;
	IEEE80211_NODE_UNLOCK(nt);
}

/*
 * Timeout inactive stations and do related housekeeping.
 * Note that we cannot hold the node lock while sending a
 * frame as this would lead to a LOR.  Instead we use a
 * generation number to mark nodes that we've scanned and
 * drop the lock and restart a scan if we have to time out
 * a node.  Since we are single-threaded by virtue of
 * controlling the inactivity timer we can be sure this will
 * process each node only once.
 */
static void
ieee80211_timeout_stations(ieee80211_node_table_t *nt)
{
	ieee80211com_t *ic = nt->nt_ic;
	ieee80211_impl_t *im = ic->ic_private;
	ieee80211_node_t *in = NULL;
	uint32_t gen;
	boolean_t isadhoc;

	IEEE80211_LOCK_ASSERT(ic);
	isadhoc = (ic->ic_opmode == IEEE80211_M_IBSS ||
	    ic->ic_opmode == IEEE80211_M_AHDEMO);
	IEEE80211_SCAN_LOCK(nt);
	gen = ++nt->nt_scangen;
restart:
	IEEE80211_NODE_LOCK(nt);
	for (in = list_head(&nt->nt_node); in != NULL;
	    in = list_next(&nt->nt_node, in)) {
		if (in->in_scangen == gen)	/* previously handled */
			continue;
		in->in_scangen = gen;
		node_cleanfrag(in);	/* free fragment if not needed */

		/*
		 * Special case ourself; we may be idle for extended periods
		 * of time and regardless reclaiming our state is wrong.
		 */
		if (in == ic->ic_bss)
			continue;
		in->in_inact--;
		if (in->in_associd != 0 || isadhoc) {
			/*
			 * Probe the station before time it out.  We
			 * send a null data frame which may not be
			 * uinversally supported by drivers (need it
			 * for ps-poll support so it should be...).
			 */
			if (0 < in->in_inact &&
			    in->in_inact <= im->im_inact_probe) {
				ieee80211_dbg(IEEE80211_MSG_NODE, "net80211: "
				    "probe station due to inactivity\n");
				IEEE80211_NODE_UNLOCK(nt);
				IEEE80211_UNLOCK(ic);
				(void) ieee80211_send_nulldata(in);
				IEEE80211_LOCK(ic);
				goto restart;
			}
		}
		if (in->in_inact <= 0) {
			ieee80211_dbg(IEEE80211_MSG_NODE, "net80211: "
			    "station timed out due to inact (refcnt %u)\n",
			    ieee80211_node_refcnt(in));
			/*
			 * Send a deauthenticate frame and drop the station.
			 * This is somewhat complicated due to reference counts
			 * and locking.  At this point a station will typically
			 * have a reference count of 1.  ieee80211_node_leave
			 * will do a "free" of the node which will drop the
			 * reference count.  But in the meantime a reference
			 * wil be held by the deauth frame.  The actual reclaim
			 * of the node will happen either after the tx is
			 * completed or by ieee80211_node_leave.
			 *
			 * Separately we must drop the node lock before sending
			 * in case the driver takes a lock, as this will result
			 * in  LOR between the node lock and the driver lock.
			 */
			IEEE80211_NODE_UNLOCK(nt);
			if (in->in_associd != 0) {
				IEEE80211_UNLOCK(ic);
				IEEE80211_SEND_MGMT(ic, in,
				    IEEE80211_FC0_SUBTYPE_DEAUTH,
				    IEEE80211_REASON_AUTH_EXPIRE);
				IEEE80211_LOCK(ic);
			}
			ieee80211_node_leave(ic, in);
			goto restart;
		}
	}
	IEEE80211_NODE_UNLOCK(nt);

	IEEE80211_SCAN_UNLOCK(nt);

	nt->nt_inact_timer = IEEE80211_INACT_WAIT;
}

/*
 * Call the user-defined call back function for all nodes in
 * the node cache. The callback is invoked with the user-supplied
 * value and a pointer to the current node.
 */
void
ieee80211_iterate_nodes(ieee80211_node_table_t *nt, ieee80211_iter_func *f,
    void *arg)
{
	ieee80211_node_t *in;

	IEEE80211_NODE_LOCK(nt);
	in = list_head(&nt->nt_node);
	while (in != NULL) {
		if (in->in_chan == IEEE80211_CHAN_ANYC) {
			in = list_next(&nt->nt_node, in);
			continue;
		}
		(void) ieee80211_ref_node(in);
		IEEE80211_NODE_UNLOCK(nt);
		(*f)(arg, in);
		ieee80211_free_node(in);
		IEEE80211_NODE_LOCK(nt);
		in = list_next(&nt->nt_node, in);
	}
	IEEE80211_NODE_UNLOCK(nt);
}

/*
 * Handle bookkeeping for station deauthentication/disassociation
 * when operating as an ap.
 */
static void
ieee80211_node_leave(ieee80211com_t *ic, ieee80211_node_t *in)
{
	ieee80211_node_table_t *nt = in->in_table;

	ASSERT(ic->ic_opmode == IEEE80211_M_IBSS);

	/*
	 * Remove the node from any table it's recorded in and
	 * drop the caller's reference.  Removal from the table
	 * is important to insure the node is not reprocessed
	 * for inactivity.
	 */
	if (nt != NULL) {
		IEEE80211_NODE_LOCK(nt);
		ieee80211_node_reclaim(nt, in);
		IEEE80211_NODE_UNLOCK(nt);
	} else {
		ieee80211_free_node(in);
	}
}

/*
 * Initialize a node table with specified name, inactivity timer value
 * and callback inactivity timeout function. Associate the node table
 * with interface softc, ic.
 */
static void
ieee80211_node_table_init(ieee80211com_t *ic, ieee80211_node_table_t *nt,
    const char *name, int inact, int keyixmax,
    void (*timeout)(ieee80211_node_table_t *))
{
	int i;

	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_node_table_init():"
	    "%s table, inact %d\n", name, inact);

	nt->nt_ic = ic;
	nt->nt_name = name;
	nt->nt_inact_timer = 0;
	nt->nt_inact_init = inact;
	nt->nt_timeout = timeout;
	nt->nt_keyixmax = keyixmax;
	nt->nt_scangen = 1;
	mutex_init(&nt->nt_scanlock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&nt->nt_nodelock, NULL, MUTEX_DRIVER, NULL);

	list_create(&nt->nt_node, sizeof (ieee80211_node_t),
	    offsetof(ieee80211_node_t, in_node));
	for (i = 0; i < IEEE80211_NODE_HASHSIZE; i++) {
		list_create(&nt->nt_hash[i], sizeof (ieee80211_node_t),
		    offsetof(ieee80211_node_t, in_hash));
	}
}

/*
 * Reset a node table. Clean its inactivity timer and call
 * ieee80211_free_allnodes_locked() to free all nodes in the
 * node table.
 */
void
ieee80211_node_table_reset(ieee80211_node_table_t *nt)
{
	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_node_table_reset(): "
	    "%s table\n", nt->nt_name);

	IEEE80211_NODE_LOCK(nt);
	nt->nt_inact_timer = 0;
	ieee80211_free_allnodes_locked(nt);
	IEEE80211_NODE_UNLOCK(nt);
}

/*
 * Destroy a node table. Free all nodes in the node table.
 * This function is usually called by node detach function.
 */
static void
ieee80211_node_table_cleanup(ieee80211_node_table_t *nt)
{
	ieee80211_dbg(IEEE80211_MSG_NODE, "ieee80211_node_table_cleanup(): "
	    "%s table\n", nt->nt_name);

	IEEE80211_NODE_LOCK(nt);
	ieee80211_free_allnodes_locked(nt);
	IEEE80211_NODE_UNLOCK(nt);
	mutex_destroy(&nt->nt_nodelock);
	mutex_destroy(&nt->nt_scanlock);
}