Home | History | Annotate | Line # | Download | only in net80211
ieee80211_proto.c revision 1.26
      1 /*	$NetBSD: ieee80211_proto.c,v 1.26 2006/08/30 15:40:00 christos Exp $	*/
      2 /*-
      3  * Copyright (c) 2001 Atsushi Onoe
      4  * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. The name of the author may not be used to endorse or promote products
     16  *    derived from this software without specific prior written permission.
     17  *
     18  * Alternatively, this software may be distributed under the terms of the
     19  * GNU General Public License ("GPL") version 2 as published by the Free
     20  * Software Foundation.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 #ifdef __FreeBSD__
     36 __FBSDID("$FreeBSD: src/sys/net80211/ieee80211_proto.c,v 1.23 2005/08/10 16:22:29 sam Exp $");
     37 #endif
     38 #ifdef __NetBSD__
     39 __KERNEL_RCSID(0, "$NetBSD: ieee80211_proto.c,v 1.26 2006/08/30 15:40:00 christos Exp $");
     40 #endif
     41 
     42 /*
     43  * IEEE 802.11 protocol support.
     44  */
     45 
     46 #include "opt_inet.h"
     47 
     48 #include <sys/param.h>
     49 #include <sys/kernel.h>
     50 #include <sys/systm.h>
     51 
     52 #include <sys/socket.h>
     53 #include <sys/sockio.h>
     54 #include <sys/endian.h>
     55 #include <sys/errno.h>
     56 #include <sys/proc.h>
     57 #include <sys/sysctl.h>
     58 
     59 #include <net/if.h>
     60 #include <net/if_media.h>
     61 #include <net/if_arp.h>
     62 #include <net/if_ether.h>
     63 #include <net/if_llc.h>
     64 
     65 #include <net80211/ieee80211_netbsd.h>
     66 #include <net80211/ieee80211_var.h>
     67 
     68 #include <net/bpf.h>
     69 
     70 #ifdef INET
     71 #include <netinet/in.h>
     72 #include <net/if_ether.h>
     73 #endif
     74 
     75 #include <net/route.h>
     76 /* XXX tunables */
     77 #define	AGGRESSIVE_MODE_SWITCH_HYSTERESIS	3	/* pkts / 100ms */
     78 #define	HIGH_PRI_SWITCH_THRESH			10	/* pkts / 100ms */
     79 
     80 #define	IEEE80211_RATE2MBS(r)	(((r) & IEEE80211_RATE_VAL) / 2)
     81 
     82 const char *ieee80211_mgt_subtype_name[] = {
     83 	"assoc_req",	"assoc_resp",	"reassoc_req",	"reassoc_resp",
     84 	"probe_req",	"probe_resp",	"reserved#6",	"reserved#7",
     85 	"beacon",	"atim",		"disassoc",	"auth",
     86 	"deauth",	"reserved#13",	"reserved#14",	"reserved#15"
     87 };
     88 const char *ieee80211_ctl_subtype_name[] = {
     89 	"reserved#0",	"reserved#1",	"reserved#2",	"reserved#3",
     90 	"reserved#3",	"reserved#5",	"reserved#6",	"reserved#7",
     91 	"reserved#8",	"reserved#9",	"ps_poll",	"rts",
     92 	"cts",		"ack",		"cf_end",	"cf_end_ack"
     93 };
     94 const char *ieee80211_state_name[IEEE80211_S_MAX] = {
     95 	"INIT",		/* IEEE80211_S_INIT */
     96 	"SCAN",		/* IEEE80211_S_SCAN */
     97 	"AUTH",		/* IEEE80211_S_AUTH */
     98 	"ASSOC",	/* IEEE80211_S_ASSOC */
     99 	"RUN"		/* IEEE80211_S_RUN */
    100 };
    101 const char *ieee80211_wme_acnames[] = {
    102 	"WME_AC_BE",
    103 	"WME_AC_BK",
    104 	"WME_AC_VI",
    105 	"WME_AC_VO",
    106 	"WME_UPSD",
    107 };
    108 
    109 static int ieee80211_newstate(struct ieee80211com *, enum ieee80211_state, int);
    110 
    111 void
    112 ieee80211_proto_attach(struct ieee80211com *ic)
    113 {
    114 	struct ifnet *ifp = ic->ic_ifp;
    115 
    116 	/* XXX room for crypto  */
    117 	ifp->if_hdrlen = sizeof(struct ieee80211_qosframe_addr4);
    118 
    119 	ic->ic_rtsthreshold = IEEE80211_RTS_DEFAULT;
    120 	ic->ic_fragthreshold = IEEE80211_FRAG_DEFAULT;
    121 	ic->ic_fixed_rate = IEEE80211_FIXED_RATE_NONE;
    122 	ic->ic_bmiss_max = IEEE80211_BMISS_MAX;
    123 	ic->ic_mcast_rate = IEEE80211_MCAST_RATE_DEFAULT;
    124 	ic->ic_protmode = IEEE80211_PROT_CTSONLY;
    125 	ic->ic_roaming = IEEE80211_ROAMING_AUTO;
    126 
    127 	ic->ic_wme.wme_hipri_switch_hysteresis =
    128 		AGGRESSIVE_MODE_SWITCH_HYSTERESIS;
    129 
    130 	/* protocol state change handler */
    131 	ic->ic_newstate = ieee80211_newstate;
    132 
    133 	/* initialize management frame handlers */
    134 	ic->ic_recv_mgmt = ieee80211_recv_mgmt;
    135 	ic->ic_send_mgmt = ieee80211_send_mgmt;
    136 }
    137 
    138 void
    139 ieee80211_proto_detach(struct ieee80211com *ic)
    140 {
    141 
    142 	/*
    143 	 * This should not be needed as we detach when reseting
    144 	 * the state but be conservative here since the
    145 	 * authenticator may do things like spawn kernel threads.
    146 	 */
    147 	if (ic->ic_auth->ia_detach)
    148 		ic->ic_auth->ia_detach(ic);
    149 
    150 	IF_PURGE(&ic->ic_mgtq);
    151 
    152 	/*
    153 	 * Detach any ACL'ator.
    154 	 */
    155 	if (ic->ic_acl != NULL)
    156 		ic->ic_acl->iac_detach(ic);
    157 }
    158 
    159 /*
    160  * Simple-minded authenticator module support.
    161  */
    162 
    163 #define	IEEE80211_AUTH_MAX	(IEEE80211_AUTH_WPA+1)
    164 /* XXX well-known names */
    165 static const char *auth_modnames[IEEE80211_AUTH_MAX] = {
    166 	"wlan_internal",	/* IEEE80211_AUTH_NONE */
    167 	"wlan_internal",	/* IEEE80211_AUTH_OPEN */
    168 	"wlan_internal",	/* IEEE80211_AUTH_SHARED */
    169 	"wlan_xauth",		/* IEEE80211_AUTH_8021X	 */
    170 	"wlan_internal",	/* IEEE80211_AUTH_AUTO */
    171 	"wlan_xauth",		/* IEEE80211_AUTH_WPA */
    172 };
    173 static const struct ieee80211_authenticator *authenticators[IEEE80211_AUTH_MAX];
    174 
    175 static const struct ieee80211_authenticator auth_internal = {
    176 	.ia_name		= "wlan_internal",
    177 	.ia_attach		= NULL,
    178 	.ia_detach		= NULL,
    179 	.ia_node_join		= NULL,
    180 	.ia_node_leave		= NULL,
    181 };
    182 
    183 /*
    184  * Setup internal authenticators once; they are never unregistered.
    185  */
    186 static void
    187 ieee80211_auth_setup(void)
    188 {
    189 	ieee80211_authenticator_register(IEEE80211_AUTH_OPEN, &auth_internal);
    190 	ieee80211_authenticator_register(IEEE80211_AUTH_SHARED, &auth_internal);
    191 	ieee80211_authenticator_register(IEEE80211_AUTH_AUTO, &auth_internal);
    192 }
    193 
    194 const struct ieee80211_authenticator *
    195 ieee80211_authenticator_get(int auth)
    196 {
    197 	static int initialized = 0;
    198 	if (!initialized) {
    199 		ieee80211_auth_setup();
    200 		initialized = 1;
    201 	}
    202 	if (auth >= IEEE80211_AUTH_MAX)
    203 		return NULL;
    204 	if (authenticators[auth] == NULL)
    205 		ieee80211_load_module(auth_modnames[auth]);
    206 	return authenticators[auth];
    207 }
    208 
    209 void
    210 ieee80211_authenticator_register(int type,
    211 	const struct ieee80211_authenticator *auth)
    212 {
    213 	if (type >= IEEE80211_AUTH_MAX)
    214 		return;
    215 	authenticators[type] = auth;
    216 }
    217 
    218 void
    219 ieee80211_authenticator_unregister(int type)
    220 {
    221 
    222 	if (type >= IEEE80211_AUTH_MAX)
    223 		return;
    224 	authenticators[type] = NULL;
    225 }
    226 
    227 /*
    228  * Very simple-minded ACL module support.
    229  */
    230 /* XXX just one for now */
    231 static	const struct ieee80211_aclator *acl = NULL;
    232 
    233 void
    234 ieee80211_aclator_register(const struct ieee80211_aclator *iac)
    235 {
    236 	printf("wlan: %s acl policy registered\n", iac->iac_name);
    237 	acl = iac;
    238 }
    239 
    240 void
    241 ieee80211_aclator_unregister(const struct ieee80211_aclator *iac)
    242 {
    243 	if (acl == iac)
    244 		acl = NULL;
    245 	printf("wlan: %s acl policy unregistered\n", iac->iac_name);
    246 }
    247 
    248 const struct ieee80211_aclator *
    249 ieee80211_aclator_get(const char *name)
    250 {
    251 	if (acl == NULL)
    252 		ieee80211_load_module("wlan_acl");
    253 	return acl != NULL && strcmp(acl->iac_name, name) == 0 ? acl : NULL;
    254 }
    255 
    256 void
    257 ieee80211_print_essid(const u_int8_t *essid, int len)
    258 {
    259 	const u_int8_t *p;
    260 	int i;
    261 
    262 	if (len > IEEE80211_NWID_LEN)
    263 		len = IEEE80211_NWID_LEN;
    264 	/* determine printable or not */
    265 	for (i = 0, p = essid; i < len; i++, p++) {
    266 		if (*p < ' ' || *p > 0x7e)
    267 			break;
    268 	}
    269 	if (i == len) {
    270 		printf("\"");
    271 		for (i = 0, p = essid; i < len; i++, p++)
    272 			printf("%c", *p);
    273 		printf("\"");
    274 	} else {
    275 		printf("0x");
    276 		for (i = 0, p = essid; i < len; i++, p++)
    277 			printf("%02x", *p);
    278 	}
    279 }
    280 
    281 void
    282 ieee80211_dump_pkt(const u_int8_t *buf, int len, int rate, int rssi)
    283 {
    284 	const struct ieee80211_frame *wh;
    285 	int i;
    286 
    287 	wh = (const struct ieee80211_frame *)buf;
    288 	switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
    289 	case IEEE80211_FC1_DIR_NODS:
    290 		printf("NODS %s", ether_sprintf(wh->i_addr2));
    291 		printf("->%s", ether_sprintf(wh->i_addr1));
    292 		printf("(%s)", ether_sprintf(wh->i_addr3));
    293 		break;
    294 	case IEEE80211_FC1_DIR_TODS:
    295 		printf("TODS %s", ether_sprintf(wh->i_addr2));
    296 		printf("->%s", ether_sprintf(wh->i_addr3));
    297 		printf("(%s)", ether_sprintf(wh->i_addr1));
    298 		break;
    299 	case IEEE80211_FC1_DIR_FROMDS:
    300 		printf("FRDS %s", ether_sprintf(wh->i_addr3));
    301 		printf("->%s", ether_sprintf(wh->i_addr1));
    302 		printf("(%s)", ether_sprintf(wh->i_addr2));
    303 		break;
    304 	case IEEE80211_FC1_DIR_DSTODS:
    305 		printf("DSDS %s", ether_sprintf((const u_int8_t *)&wh[1]));
    306 		printf("->%s", ether_sprintf(wh->i_addr3));
    307 		printf("(%s", ether_sprintf(wh->i_addr2));
    308 		printf("->%s)", ether_sprintf(wh->i_addr1));
    309 		break;
    310 	}
    311 	switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
    312 	case IEEE80211_FC0_TYPE_DATA:
    313 		printf(" data");
    314 		break;
    315 	case IEEE80211_FC0_TYPE_MGT:
    316 		printf(" %s", ieee80211_mgt_subtype_name[
    317 		    (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK)
    318 		    >> IEEE80211_FC0_SUBTYPE_SHIFT]);
    319 		break;
    320 	default:
    321 		printf(" type#%d", wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK);
    322 		break;
    323 	}
    324 	if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
    325 		printf(" WEP [IV");
    326 		for (i = 0; i < IEEE80211_WEP_IVLEN; i++)
    327 			printf(" %.02x", buf[sizeof(*wh)+i]);
    328 		printf(" KID %u]", buf[sizeof(*wh)+i] >> 6);
    329 	}
    330 	if (rate >= 0)
    331 		printf(" %dM", rate / 2);
    332 	if (rssi >= 0)
    333 		printf(" +%d", rssi);
    334 	printf("\n");
    335 	if (len > 0) {
    336 		for (i = 0; i < len; i++) {
    337 			if ((i & 1) == 0)
    338 				printf(" ");
    339 			printf("%02x", buf[i]);
    340 		}
    341 		printf("\n");
    342 	}
    343 }
    344 
    345 int
    346 ieee80211_fix_rate(struct ieee80211_node *ni, int flags)
    347 {
    348 #define	RV(v)	((v) & IEEE80211_RATE_VAL)
    349 	struct ieee80211com *ic = ni->ni_ic;
    350 	int i, j, ignore, error;
    351 	int okrate, badrate, fixedrate;
    352 	struct ieee80211_rateset *srs, *nrs;
    353 	u_int8_t r;
    354 
    355 	/*
    356 	 * If the fixed rate check was requested but no
    357 	 * fixed has been defined then just remove it.
    358 	 */
    359 	if ((flags & IEEE80211_F_DOFRATE) &&
    360 	    ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE)
    361 		flags &= ~IEEE80211_F_DOFRATE;
    362 	error = 0;
    363 	okrate = badrate = fixedrate = 0;
    364 	srs = &ic->ic_sup_rates[ieee80211_chan2mode(ic, ni->ni_chan)];
    365 	nrs = &ni->ni_rates;
    366 	for (i = 0; i < nrs->rs_nrates; ) {
    367 		ignore = 0;
    368 		if (flags & IEEE80211_F_DOSORT) {
    369 			/*
    370 			 * Sort rates.
    371 			 */
    372 			for (j = i + 1; j < nrs->rs_nrates; j++) {
    373 				if (RV(nrs->rs_rates[i]) > RV(nrs->rs_rates[j])) {
    374 					r = nrs->rs_rates[i];
    375 					nrs->rs_rates[i] = nrs->rs_rates[j];
    376 					nrs->rs_rates[j] = r;
    377 				}
    378 			}
    379 		}
    380 		r = nrs->rs_rates[i] & IEEE80211_RATE_VAL;
    381 		badrate = r;
    382 		if (flags & IEEE80211_F_DOFRATE) {
    383 			/*
    384 			 * Check any fixed rate is included.
    385 			 */
    386 			if (r == RV(srs->rs_rates[ic->ic_fixed_rate]))
    387 				fixedrate = r;
    388 		}
    389 		if (flags & IEEE80211_F_DONEGO) {
    390 			/*
    391 			 * Check against supported rates.
    392 			 */
    393 			for (j = 0; j < srs->rs_nrates; j++) {
    394 				if (r == RV(srs->rs_rates[j])) {
    395 					/*
    396 					 * Overwrite with the supported rate
    397 					 * value so any basic rate bit is set.
    398 					 * This insures that response we send
    399 					 * to stations have the necessary basic
    400 					 * rate bit set.
    401 					 */
    402 					nrs->rs_rates[i] = srs->rs_rates[j];
    403 					break;
    404 				}
    405 			}
    406 			if (j == srs->rs_nrates) {
    407 				/*
    408 				 * A rate in the node's rate set is not
    409 				 * supported.  If this is a basic rate and we
    410 				 * are operating as an AP then this is an error.
    411 				 * Otherwise we just discard/ignore the rate.
    412 				 * Note that this is important for 11b stations
    413 				 * when they want to associate with an 11g AP.
    414 				 */
    415 #ifndef IEEE80211_NO_HOSTAP
    416 				if (ic->ic_opmode == IEEE80211_M_HOSTAP &&
    417 				    (nrs->rs_rates[i] & IEEE80211_RATE_BASIC))
    418 					error++;
    419 #endif /* !IEEE80211_NO_HOSTAP */
    420 				ignore++;
    421 			}
    422 		}
    423 		if (flags & IEEE80211_F_DODEL) {
    424 			/*
    425 			 * Delete unacceptable rates.
    426 			 */
    427 			if (ignore) {
    428 				nrs->rs_nrates--;
    429 				for (j = i; j < nrs->rs_nrates; j++)
    430 					nrs->rs_rates[j] = nrs->rs_rates[j + 1];
    431 				nrs->rs_rates[j] = 0;
    432 				continue;
    433 			}
    434 		}
    435 		if (!ignore) {
    436 			okrate = nrs->rs_rates[i];
    437 			ni->ni_txrate = i;
    438 		}
    439 		i++;
    440 	}
    441 	if (okrate == 0 || error != 0 ||
    442 	    ((flags & IEEE80211_F_DOFRATE) && fixedrate == 0))
    443 		return badrate | IEEE80211_RATE_BASIC;
    444 	else
    445 		return RV(okrate);
    446 #undef RV
    447 }
    448 
    449 /*
    450  * Reset 11g-related state.
    451  */
    452 void
    453 ieee80211_reset_erp(struct ieee80211com *ic)
    454 {
    455 	ic->ic_flags &= ~IEEE80211_F_USEPROT;
    456 	ic->ic_nonerpsta = 0;
    457 	ic->ic_longslotsta = 0;
    458 	/*
    459 	 * Short slot time is enabled only when operating in 11g
    460 	 * and not in an IBSS.  We must also honor whether or not
    461 	 * the driver is capable of doing it.
    462 	 */
    463 	ieee80211_set_shortslottime(ic,
    464 		ic->ic_curmode == IEEE80211_MODE_11A ||
    465 		(ic->ic_curmode == IEEE80211_MODE_11G &&
    466 		ic->ic_opmode == IEEE80211_M_HOSTAP &&
    467 		(ic->ic_caps & IEEE80211_C_SHSLOT)));
    468 	/*
    469 	 * Set short preamble and ERP barker-preamble flags.
    470 	 */
    471 	if (ic->ic_curmode == IEEE80211_MODE_11A ||
    472 	    (ic->ic_caps & IEEE80211_C_SHPREAMBLE)) {
    473 		ic->ic_flags |= IEEE80211_F_SHPREAMBLE;
    474 		ic->ic_flags &= ~IEEE80211_F_USEBARKER;
    475 	} else {
    476 		ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE;
    477 		ic->ic_flags |= IEEE80211_F_USEBARKER;
    478 	}
    479 }
    480 
    481 /*
    482  * Set the short slot time state and notify the driver.
    483  */
    484 void
    485 ieee80211_set_shortslottime(struct ieee80211com *ic, int onoff)
    486 {
    487 	if (onoff)
    488 		ic->ic_flags |= IEEE80211_F_SHSLOT;
    489 	else
    490 		ic->ic_flags &= ~IEEE80211_F_SHSLOT;
    491 	/* notify driver */
    492 	if (ic->ic_updateslot != NULL)
    493 		ic->ic_updateslot(ic->ic_ifp);
    494 }
    495 
    496 /*
    497  * Check if the specified rate set supports ERP.
    498  * NB: the rate set is assumed to be sorted.
    499  */
    500 int
    501 ieee80211_iserp_rateset(struct ieee80211com *ic, struct ieee80211_rateset *rs)
    502 {
    503 #define N(a)	(sizeof(a) / sizeof(a[0]))
    504 	static const int rates[] = { 2, 4, 11, 22, 12, 24, 48 };
    505 	int i, j;
    506 
    507 	if (rs->rs_nrates < N(rates))
    508 		return 0;
    509 	for (i = 0; i < N(rates); i++) {
    510 		for (j = 0; j < rs->rs_nrates; j++) {
    511 			int r = rs->rs_rates[j] & IEEE80211_RATE_VAL;
    512 			if (rates[i] == r)
    513 				goto next;
    514 			if (r > rates[i])
    515 				return 0;
    516 		}
    517 		return 0;
    518 	next:
    519 		;
    520 	}
    521 	return 1;
    522 #undef N
    523 }
    524 
    525 /*
    526  * Mark the basic rates for the 11g rate table based on the
    527  * operating mode.  For real 11g we mark all the 11b rates
    528  * and 6, 12, and 24 OFDM.  For 11b compatibility we mark only
    529  * 11b rates.  There's also a pseudo 11a-mode used to mark only
    530  * the basic OFDM rates.
    531  */
    532 void
    533 ieee80211_set11gbasicrates(struct ieee80211_rateset *rs, enum ieee80211_phymode mode)
    534 {
    535 	static const struct ieee80211_rateset basic[] = {
    536 	    { .rs_nrates = 0 },		/* IEEE80211_MODE_AUTO */
    537 	    { 3, { 12, 24, 48 } },	/* IEEE80211_MODE_11A */
    538 	    { 2, { 2, 4 } },		/* IEEE80211_MODE_11B */
    539 	    { 4, { 2, 4, 11, 22 } },	/* IEEE80211_MODE_11G (mixed b/g) */
    540 	    { .rs_nrates = 0 },		/* IEEE80211_MODE_FH */
    541 					/* IEEE80211_MODE_PUREG (not yet) */
    542 	    { 7, { 2, 4, 11, 22, 12, 24, 48 } },
    543 	};
    544 	int i, j;
    545 
    546 	for (i = 0; i < rs->rs_nrates; i++) {
    547 		rs->rs_rates[i] &= IEEE80211_RATE_VAL;
    548 		for (j = 0; j < basic[mode].rs_nrates; j++)
    549 			if (basic[mode].rs_rates[j] == rs->rs_rates[i]) {
    550 				rs->rs_rates[i] |= IEEE80211_RATE_BASIC;
    551 				break;
    552 			}
    553 	}
    554 }
    555 
    556 /*
    557  * WME protocol support.  The following parameters come from the spec.
    558  */
    559 typedef struct phyParamType {
    560 	u_int8_t aifsn;
    561 	u_int8_t logcwmin;
    562 	u_int8_t logcwmax;
    563 	u_int16_t txopLimit;
    564 	u_int8_t acm;
    565 } paramType;
    566 
    567 static const struct phyParamType phyParamForAC_BE[IEEE80211_MODE_MAX] = {
    568 	{ 3, 4, 6, 0, 0, },		/* IEEE80211_MODE_AUTO */
    569 	{ 3, 4, 6, 0, 0, },		/* IEEE80211_MODE_11A */
    570 	{ 3, 5, 7, 0, 0, },		/* IEEE80211_MODE_11B */
    571 	{ 3, 4, 6, 0, 0, },		/* IEEE80211_MODE_11G */
    572 	{ 3, 5, 7, 0, 0, },		/* IEEE80211_MODE_FH */
    573 	{ 2, 3, 5, 0, 0, },		/* IEEE80211_MODE_TURBO_A */
    574 	{ 2, 3, 5, 0, 0, },		/* IEEE80211_MODE_TURBO_G */
    575 };
    576 static const struct phyParamType phyParamForAC_BK[IEEE80211_MODE_MAX] = {
    577 	{ 7, 4, 10, 0, 0, },		/* IEEE80211_MODE_AUTO */
    578 	{ 7, 4, 10, 0, 0, },		/* IEEE80211_MODE_11A */
    579 	{ 7, 5, 10, 0, 0, },		/* IEEE80211_MODE_11B */
    580 	{ 7, 4, 10, 0, 0, },		/* IEEE80211_MODE_11G */
    581 	{ 7, 5, 10, 0, 0, },		/* IEEE80211_MODE_FH */
    582 	{ 7, 3, 10, 0, 0, },		/* IEEE80211_MODE_TURBO_A */
    583 	{ 7, 3, 10, 0, 0, },		/* IEEE80211_MODE_TURBO_G */
    584 };
    585 static const struct phyParamType phyParamForAC_VI[IEEE80211_MODE_MAX] = {
    586 	{ 1, 3, 4,  94, 0, },	/* IEEE80211_MODE_AUTO */
    587 	{ 1, 3, 4,  94, 0, },	/* IEEE80211_MODE_11A */
    588 	{ 1, 4, 5, 188, 0, },	/* IEEE80211_MODE_11B */
    589 	{ 1, 3, 4,  94, 0, },	/* IEEE80211_MODE_11G */
    590 	{ 1, 4, 5, 188, 0, },	/* IEEE80211_MODE_FH */
    591 	{ 1, 2, 3,  94, 0, },	/* IEEE80211_MODE_TURBO_A */
    592 	{ 1, 2, 3,  94, 0, },	/* IEEE80211_MODE_TURBO_G */
    593 };
    594 static const struct phyParamType phyParamForAC_VO[IEEE80211_MODE_MAX] = {
    595 	{ 1, 2, 3,  47, 0, },	/* IEEE80211_MODE_AUTO */
    596 	{ 1, 2, 3,  47, 0, },	/* IEEE80211_MODE_11A */
    597 	{ 1, 3, 4, 102, 0, },	/* IEEE80211_MODE_11B */
    598 	{ 1, 2, 3,  47, 0, },	/* IEEE80211_MODE_11G */
    599 	{ 1, 3, 4, 102, 0, },	/* IEEE80211_MODE_FH */
    600 	{ 1, 2, 2,  47, 0, },	/* IEEE80211_MODE_TURBO_A */
    601 	{ 1, 2, 2,  47, 0, },	/* IEEE80211_MODE_TURBO_G */
    602 };
    603 
    604 static const struct phyParamType bssPhyParamForAC_BE[IEEE80211_MODE_MAX] = {
    605 	{ 3, 4, 10, 0, 0, },		/* IEEE80211_MODE_AUTO */
    606 	{ 3, 4, 10, 0, 0, },		/* IEEE80211_MODE_11A */
    607 	{ 3, 5, 10, 0, 0, },		/* IEEE80211_MODE_11B */
    608 	{ 3, 4, 10, 0, 0, },		/* IEEE80211_MODE_11G */
    609 	{ 3, 5, 10, 0, 0, },		/* IEEE80211_MODE_FH */
    610 	{ 2, 3, 10, 0, 0, },		/* IEEE80211_MODE_TURBO_A */
    611 	{ 2, 3, 10, 0, 0, },		/* IEEE80211_MODE_TURBO_G */
    612 };
    613 static const struct phyParamType bssPhyParamForAC_VI[IEEE80211_MODE_MAX] = {
    614 	{ 2, 3, 4,  94, 0, },	/* IEEE80211_MODE_AUTO */
    615 	{ 2, 3, 4,  94, 0, },	/* IEEE80211_MODE_11A */
    616 	{ 2, 4, 5, 188, 0, },	/* IEEE80211_MODE_11B */
    617 	{ 2, 3, 4,  94, 0, },	/* IEEE80211_MODE_11G */
    618 	{ 2, 4, 5, 188, 0, },	/* IEEE80211_MODE_FH */
    619 	{ 2, 2, 3,  94, 0, },	/* IEEE80211_MODE_TURBO_A */
    620 	{ 2, 2, 3,  94, 0, },	/* IEEE80211_MODE_TURBO_G */
    621 };
    622 static const struct phyParamType bssPhyParamForAC_VO[IEEE80211_MODE_MAX] = {
    623 	{ 2, 2, 3,  47, 0, },	/* IEEE80211_MODE_AUTO */
    624 	{ 2, 2, 3,  47, 0, },	/* IEEE80211_MODE_11A */
    625 	{ 2, 3, 4, 102, 0, },	/* IEEE80211_MODE_11B */
    626 	{ 2, 2, 3,  47, 0, },	/* IEEE80211_MODE_11G */
    627 	{ 2, 3, 4, 102, 0, },	/* IEEE80211_MODE_FH */
    628 	{ 1, 2, 2,  47, 0, },	/* IEEE80211_MODE_TURBO_A */
    629 	{ 1, 2, 2,  47, 0, },	/* IEEE80211_MODE_TURBO_G */
    630 };
    631 
    632 void
    633 ieee80211_wme_initparams(struct ieee80211com *ic)
    634 {
    635 	struct ieee80211_wme_state *wme = &ic->ic_wme;
    636 	const paramType *pPhyParam, *pBssPhyParam;
    637 	struct wmeParams *wmep;
    638 	int i;
    639 
    640 	if ((ic->ic_caps & IEEE80211_C_WME) == 0)
    641 		return;
    642 
    643 	for (i = 0; i < WME_NUM_AC; i++) {
    644 		switch (i) {
    645 		case WME_AC_BK:
    646 			pPhyParam = &phyParamForAC_BK[ic->ic_curmode];
    647 			pBssPhyParam = &phyParamForAC_BK[ic->ic_curmode];
    648 			break;
    649 		case WME_AC_VI:
    650 			pPhyParam = &phyParamForAC_VI[ic->ic_curmode];
    651 			pBssPhyParam = &bssPhyParamForAC_VI[ic->ic_curmode];
    652 			break;
    653 		case WME_AC_VO:
    654 			pPhyParam = &phyParamForAC_VO[ic->ic_curmode];
    655 			pBssPhyParam = &bssPhyParamForAC_VO[ic->ic_curmode];
    656 			break;
    657 		case WME_AC_BE:
    658 		default:
    659 			pPhyParam = &phyParamForAC_BE[ic->ic_curmode];
    660 			pBssPhyParam = &bssPhyParamForAC_BE[ic->ic_curmode];
    661 			break;
    662 		}
    663 
    664 		wmep = &wme->wme_wmeChanParams.cap_wmeParams[i];
    665 		if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
    666 			wmep->wmep_acm = pPhyParam->acm;
    667 			wmep->wmep_aifsn = pPhyParam->aifsn;
    668 			wmep->wmep_logcwmin = pPhyParam->logcwmin;
    669 			wmep->wmep_logcwmax = pPhyParam->logcwmax;
    670 			wmep->wmep_txopLimit = pPhyParam->txopLimit;
    671 		} else {
    672 			wmep->wmep_acm = pBssPhyParam->acm;
    673 			wmep->wmep_aifsn = pBssPhyParam->aifsn;
    674 			wmep->wmep_logcwmin = pBssPhyParam->logcwmin;
    675 			wmep->wmep_logcwmax = pBssPhyParam->logcwmax;
    676 			wmep->wmep_txopLimit = pBssPhyParam->txopLimit;
    677 
    678 		}
    679 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME,
    680 			"%s: %s chan [acm %u aifsn %u log2(cwmin) %u "
    681 			"log2(cwmax) %u txpoLimit %u]\n", __func__
    682 			, ieee80211_wme_acnames[i]
    683 			, wmep->wmep_acm
    684 			, wmep->wmep_aifsn
    685 			, wmep->wmep_logcwmin
    686 			, wmep->wmep_logcwmax
    687 			, wmep->wmep_txopLimit
    688 		);
    689 
    690 		wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[i];
    691 		wmep->wmep_acm = pBssPhyParam->acm;
    692 		wmep->wmep_aifsn = pBssPhyParam->aifsn;
    693 		wmep->wmep_logcwmin = pBssPhyParam->logcwmin;
    694 		wmep->wmep_logcwmax = pBssPhyParam->logcwmax;
    695 		wmep->wmep_txopLimit = pBssPhyParam->txopLimit;
    696 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME,
    697 			"%s: %s  bss [acm %u aifsn %u log2(cwmin) %u "
    698 			"log2(cwmax) %u txpoLimit %u]\n", __func__
    699 			, ieee80211_wme_acnames[i]
    700 			, wmep->wmep_acm
    701 			, wmep->wmep_aifsn
    702 			, wmep->wmep_logcwmin
    703 			, wmep->wmep_logcwmax
    704 			, wmep->wmep_txopLimit
    705 		);
    706 	}
    707 	/* NB: check ic_bss to avoid NULL deref on initial attach */
    708 	if (ic->ic_bss != NULL) {
    709 		/*
    710 		 * Calculate agressive mode switching threshold based
    711 		 * on beacon interval.  This doesn't need locking since
    712 		 * we're only called before entering the RUN state at
    713 		 * which point we start sending beacon frames.
    714 		 */
    715 		wme->wme_hipri_switch_thresh =
    716 			(HIGH_PRI_SWITCH_THRESH * ic->ic_bss->ni_intval) / 100;
    717 		ieee80211_wme_updateparams(ic);
    718 	}
    719 }
    720 
    721 /*
    722  * Update WME parameters for ourself and the BSS.
    723  */
    724 void
    725 ieee80211_wme_updateparams_locked(struct ieee80211com *ic)
    726 {
    727 	static const paramType phyParam[IEEE80211_MODE_MAX] = {
    728 		{ 2, 4, 10, 64, 0, },	/* IEEE80211_MODE_AUTO */
    729 		{ 2, 4, 10, 64, 0, },	/* IEEE80211_MODE_11A */
    730 		{ 2, 5, 10, 64, 0, },	/* IEEE80211_MODE_11B */
    731 		{ 2, 4, 10, 64, 0, },	/* IEEE80211_MODE_11G */
    732 		{ 2, 5, 10, 64, 0, },	/* IEEE80211_MODE_FH */
    733 		{ 1, 3, 10, 64, 0, },	/* IEEE80211_MODE_TURBO_A */
    734 		{ 1, 3, 10, 64, 0, },	/* IEEE80211_MODE_TURBO_G */
    735 	};
    736 	struct ieee80211_wme_state *wme = &ic->ic_wme;
    737 	const struct wmeParams *wmep;
    738 	struct wmeParams *chanp, *bssp;
    739 	int i;
    740 
    741        	/* set up the channel access parameters for the physical device */
    742 	for (i = 0; i < WME_NUM_AC; i++) {
    743 		chanp = &wme->wme_chanParams.cap_wmeParams[i];
    744 		wmep = &wme->wme_wmeChanParams.cap_wmeParams[i];
    745 		chanp->wmep_aifsn = wmep->wmep_aifsn;
    746 		chanp->wmep_logcwmin = wmep->wmep_logcwmin;
    747 		chanp->wmep_logcwmax = wmep->wmep_logcwmax;
    748 		chanp->wmep_txopLimit = wmep->wmep_txopLimit;
    749 
    750 		chanp = &wme->wme_bssChanParams.cap_wmeParams[i];
    751 		wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[i];
    752 		chanp->wmep_aifsn = wmep->wmep_aifsn;
    753 		chanp->wmep_logcwmin = wmep->wmep_logcwmin;
    754 		chanp->wmep_logcwmax = wmep->wmep_logcwmax;
    755 		chanp->wmep_txopLimit = wmep->wmep_txopLimit;
    756 	}
    757 
    758 	/*
    759 	 * This implements agressive mode as found in certain
    760 	 * vendors' AP's.  When there is significant high
    761 	 * priority (VI/VO) traffic in the BSS throttle back BE
    762 	 * traffic by using conservative parameters.  Otherwise
    763 	 * BE uses agressive params to optimize performance of
    764 	 * legacy/non-QoS traffic.
    765 	 */
    766         if ((ic->ic_opmode == IEEE80211_M_HOSTAP &&
    767 	     (wme->wme_flags & WME_F_AGGRMODE) == 0) ||
    768 	    (ic->ic_opmode != IEEE80211_M_HOSTAP &&
    769 	     (ic->ic_bss->ni_flags & IEEE80211_NODE_QOS) == 0) ||
    770 	    (ic->ic_flags & IEEE80211_F_WME) == 0) {
    771 		chanp = &wme->wme_chanParams.cap_wmeParams[WME_AC_BE];
    772 		bssp = &wme->wme_bssChanParams.cap_wmeParams[WME_AC_BE];
    773 
    774 		chanp->wmep_aifsn = bssp->wmep_aifsn =
    775 			phyParam[ic->ic_curmode].aifsn;
    776 		chanp->wmep_logcwmin = bssp->wmep_logcwmin =
    777 			phyParam[ic->ic_curmode].logcwmin;
    778 		chanp->wmep_logcwmax = bssp->wmep_logcwmax =
    779 			phyParam[ic->ic_curmode].logcwmax;
    780 		chanp->wmep_txopLimit = bssp->wmep_txopLimit =
    781 			(ic->ic_caps & IEEE80211_C_BURST) ?
    782 				phyParam[ic->ic_curmode].txopLimit : 0;
    783 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME,
    784 			"%s: %s [acm %u aifsn %u log2(cwmin) %u "
    785 			"log2(cwmax) %u txpoLimit %u]\n", __func__
    786 			, ieee80211_wme_acnames[WME_AC_BE]
    787 			, chanp->wmep_acm
    788 			, chanp->wmep_aifsn
    789 			, chanp->wmep_logcwmin
    790 			, chanp->wmep_logcwmax
    791 			, chanp->wmep_txopLimit
    792 		);
    793 	}
    794 
    795 #ifndef IEEE80211_NO_HOSTAP
    796 	if (ic->ic_opmode == IEEE80211_M_HOSTAP &&
    797 	    ic->ic_sta_assoc < 2 && (wme->wme_flags & WME_F_AGGRMODE) == 0) {
    798         	static const u_int8_t logCwMin[IEEE80211_MODE_MAX] = {
    799               		3,	/* IEEE80211_MODE_AUTO */
    800               		3,	/* IEEE80211_MODE_11A */
    801               		4,	/* IEEE80211_MODE_11B */
    802               		3,	/* IEEE80211_MODE_11G */
    803               		4,	/* IEEE80211_MODE_FH */
    804               		3,	/* IEEE80211_MODE_TURBO_A */
    805               		3,	/* IEEE80211_MODE_TURBO_G */
    806 		};
    807 		chanp = &wme->wme_chanParams.cap_wmeParams[WME_AC_BE];
    808 		bssp = &wme->wme_bssChanParams.cap_wmeParams[WME_AC_BE];
    809 
    810 		chanp->wmep_logcwmin = bssp->wmep_logcwmin =
    811 			logCwMin[ic->ic_curmode];
    812 		IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME,
    813 			"%s: %s log2(cwmin) %u\n", __func__
    814 			, ieee80211_wme_acnames[WME_AC_BE]
    815 			, chanp->wmep_logcwmin
    816 		);
    817     	}
    818 	if (ic->ic_opmode == IEEE80211_M_HOSTAP) {	/* XXX ibss? */
    819 		/*
    820 		 * Arrange for a beacon update and bump the parameter
    821 		 * set number so associated stations load the new values.
    822 		 */
    823 		wme->wme_bssChanParams.cap_info =
    824 			(wme->wme_bssChanParams.cap_info+1) & WME_QOSINFO_COUNT;
    825 		ic->ic_flags |= IEEE80211_F_WMEUPDATE;
    826 	}
    827 #endif /* !IEEE80211_NO_HOSTAP */
    828 
    829 	wme->wme_update(ic);
    830 
    831 	IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME,
    832 		"%s: WME params updated, cap_info 0x%x\n", __func__,
    833 		ic->ic_opmode == IEEE80211_M_STA ?
    834 			wme->wme_wmeChanParams.cap_info :
    835 			wme->wme_bssChanParams.cap_info);
    836 }
    837 
    838 void
    839 ieee80211_wme_updateparams(struct ieee80211com *ic)
    840 {
    841 
    842 	if (ic->ic_caps & IEEE80211_C_WME) {
    843 		IEEE80211_BEACON_LOCK(ic);
    844 		ieee80211_wme_updateparams_locked(ic);
    845 		IEEE80211_BEACON_UNLOCK(ic);
    846 	}
    847 }
    848 
    849 #ifndef IEEE80211_NO_HOSTAP
    850 static void
    851 sta_disassoc(void *arg, struct ieee80211_node *ni)
    852 {
    853 	struct ieee80211com *ic = arg;
    854 
    855 	if (ni->ni_associd != 0) {
    856 		IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DISASSOC,
    857 			IEEE80211_REASON_ASSOC_LEAVE);
    858 		ieee80211_node_leave(ic, ni);
    859 	}
    860 }
    861 #endif /* !IEEE80211_NO_HOSTAP */
    862 
    863 void
    864 ieee80211_beacon_miss(struct ieee80211com *ic)
    865 {
    866 
    867 	if (ic->ic_flags & IEEE80211_F_SCAN) {
    868 		/* XXX check ic_curchan != ic_bsschan? */
    869 		return;
    870 	}
    871 	IEEE80211_DPRINTF(ic,
    872 		IEEE80211_MSG_STATE | IEEE80211_MSG_DEBUG,
    873 		"%s\n", "beacon miss");
    874 
    875 	/*
    876 	 * Our handling is only meaningful for stations that are
    877 	 * associated; any other conditions else will be handled
    878 	 * through different means (e.g. the tx timeout on mgt frames).
    879 	 */
    880 	if (ic->ic_opmode != IEEE80211_M_STA || ic->ic_state != IEEE80211_S_RUN)
    881 		return;
    882 
    883 	if (++ic->ic_bmiss_count < ic->ic_bmiss_max) {
    884 		/*
    885 		 * Send a directed probe req before falling back to a scan;
    886 		 * if we receive a response ic_bmiss_count will be reset.
    887 		 * Some cards mistakenly report beacon miss so this avoids
    888 		 * the expensive scan if the ap is still there.
    889 		 */
    890 		ieee80211_send_probereq(ic->ic_bss, ic->ic_myaddr,
    891 			ic->ic_bss->ni_bssid, ic->ic_bss->ni_bssid,
    892 			ic->ic_bss->ni_essid, ic->ic_bss->ni_esslen,
    893 			ic->ic_opt_ie, ic->ic_opt_ie_len);
    894 		return;
    895 	}
    896 	ic->ic_bmiss_count = 0;
    897 	ieee80211_new_state(ic, IEEE80211_S_SCAN, 0);
    898 }
    899 
    900 #ifndef IEEE80211_NO_HOSTAP
    901 static void
    902 sta_deauth(void *arg, struct ieee80211_node *ni)
    903 {
    904 	struct ieee80211com *ic = arg;
    905 
    906 	IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH,
    907 		IEEE80211_REASON_ASSOC_LEAVE);
    908 }
    909 #endif /* !IEEE80211_NO_HOSTAP */
    910 
    911 static int
    912 ieee80211_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
    913 {
    914 	struct ifnet *ifp = ic->ic_ifp;
    915 	struct ieee80211_node *ni;
    916 	enum ieee80211_state ostate;
    917 
    918 	ostate = ic->ic_state;
    919 	IEEE80211_DPRINTF(ic, IEEE80211_MSG_STATE, "%s: %s -> %s\n", __func__,
    920 		ieee80211_state_name[ostate], ieee80211_state_name[nstate]);
    921 	ic->ic_state = nstate;			/* state transition */
    922 	ni = ic->ic_bss;			/* NB: no reference held */
    923 	switch (nstate) {
    924 	case IEEE80211_S_INIT:
    925 		switch (ostate) {
    926 		case IEEE80211_S_INIT:
    927 			break;
    928 		case IEEE80211_S_RUN:
    929 			switch (ic->ic_opmode) {
    930 			case IEEE80211_M_STA:
    931 				IEEE80211_SEND_MGMT(ic, ni,
    932 				    IEEE80211_FC0_SUBTYPE_DISASSOC,
    933 				    IEEE80211_REASON_ASSOC_LEAVE);
    934 				ieee80211_sta_leave(ic, ni);
    935 				break;
    936 			case IEEE80211_M_HOSTAP:
    937 #ifndef IEEE80211_NO_HOSTAP
    938 				ieee80211_iterate_nodes(&ic->ic_sta,
    939 					sta_disassoc, ic);
    940 #endif /* !IEEE80211_NO_HOSTAP */
    941 				break;
    942 			default:
    943 				break;
    944 			}
    945 			goto reset;
    946 		case IEEE80211_S_ASSOC:
    947 			switch (ic->ic_opmode) {
    948 			case IEEE80211_M_STA:
    949 				IEEE80211_SEND_MGMT(ic, ni,
    950 				    IEEE80211_FC0_SUBTYPE_DEAUTH,
    951 				    IEEE80211_REASON_AUTH_LEAVE);
    952 				break;
    953 			case IEEE80211_M_HOSTAP:
    954 #ifndef IEEE80211_NO_HOSTAP
    955 				ieee80211_iterate_nodes(&ic->ic_sta,
    956 					sta_deauth, ic);
    957 #endif /* !IEEE80211_NO_HOSTAP */
    958 				break;
    959 			default:
    960 				break;
    961 			}
    962 			goto reset;
    963 		case IEEE80211_S_SCAN:
    964 			ieee80211_cancel_scan(ic);
    965 			goto reset;
    966 		case IEEE80211_S_AUTH:
    967 		reset:
    968 			ic->ic_mgt_timer = 0;
    969 			IF_PURGE(&ic->ic_mgtq);
    970 			ieee80211_reset_bss(ic);
    971 			break;
    972 		}
    973 		if (ic->ic_auth->ia_detach != NULL)
    974 			ic->ic_auth->ia_detach(ic);
    975 		break;
    976 	case IEEE80211_S_SCAN:
    977 		switch (ostate) {
    978 		case IEEE80211_S_INIT:
    979 			if ((ic->ic_opmode == IEEE80211_M_HOSTAP ||
    980 			     ic->ic_opmode == IEEE80211_M_IBSS ||
    981 			     ic->ic_opmode == IEEE80211_M_AHDEMO) &&
    982 			    ic->ic_des_chan != IEEE80211_CHAN_ANYC) {
    983 				/*
    984 				 * AP operation and we already have a channel;
    985 				 * bypass the scan and startup immediately.
    986 				 */
    987 				ieee80211_create_ibss(ic, ic->ic_des_chan);
    988 			} else {
    989 				ieee80211_begin_scan(ic, arg);
    990 			}
    991 			break;
    992 		case IEEE80211_S_SCAN:
    993 			/*
    994 			 * Scan next. If doing an active scan probe
    995 			 * for the requested ap (if any).
    996 			 */
    997 			if (ic->ic_flags & IEEE80211_F_ASCAN)
    998 				ieee80211_probe_curchan(ic, 0);
    999 			break;
   1000 		case IEEE80211_S_RUN:
   1001 			/* beacon miss */
   1002 			IEEE80211_DPRINTF(ic, IEEE80211_MSG_STATE,
   1003 				"no recent beacons from %s; rescanning\n",
   1004 				ether_sprintf(ic->ic_bss->ni_bssid));
   1005 			ieee80211_sta_leave(ic, ni);
   1006 			ic->ic_flags &= ~IEEE80211_F_SIBSS;	/* XXX */
   1007 			/* FALLTHRU */
   1008 		case IEEE80211_S_AUTH:
   1009 		case IEEE80211_S_ASSOC:
   1010 			/* timeout restart scan */
   1011 			ni = ieee80211_find_node(&ic->ic_scan,
   1012 				ic->ic_bss->ni_macaddr);
   1013 			if (ni != NULL) {
   1014 				ni->ni_fails++;
   1015 				ieee80211_unref_node(&ni);
   1016 			}
   1017 			if (ic->ic_roaming == IEEE80211_ROAMING_AUTO)
   1018 				ieee80211_begin_scan(ic, arg);
   1019 			break;
   1020 		}
   1021 		break;
   1022 	case IEEE80211_S_AUTH:
   1023 		switch (ostate) {
   1024 		case IEEE80211_S_INIT:
   1025 		case IEEE80211_S_SCAN:
   1026 			IEEE80211_SEND_MGMT(ic, ni,
   1027 			    IEEE80211_FC0_SUBTYPE_AUTH, 1);
   1028 			break;
   1029 		case IEEE80211_S_AUTH:
   1030 		case IEEE80211_S_ASSOC:
   1031 			switch (arg) {
   1032 			case IEEE80211_FC0_SUBTYPE_AUTH:
   1033 				/* ??? */
   1034 				IEEE80211_SEND_MGMT(ic, ni,
   1035 				    IEEE80211_FC0_SUBTYPE_AUTH, 2);
   1036 				break;
   1037 			case IEEE80211_FC0_SUBTYPE_DEAUTH:
   1038 				/* ignore and retry scan on timeout */
   1039 				break;
   1040 			}
   1041 			break;
   1042 		case IEEE80211_S_RUN:
   1043 			switch (arg) {
   1044 			case IEEE80211_FC0_SUBTYPE_AUTH:
   1045 				IEEE80211_SEND_MGMT(ic, ni,
   1046 				    IEEE80211_FC0_SUBTYPE_AUTH, 2);
   1047 				ic->ic_state = ostate;	/* stay RUN */
   1048 				break;
   1049 			case IEEE80211_FC0_SUBTYPE_DEAUTH:
   1050 				ieee80211_sta_leave(ic, ni);
   1051 				if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) {
   1052 					/* try to reauth */
   1053 					IEEE80211_SEND_MGMT(ic, ni,
   1054 					    IEEE80211_FC0_SUBTYPE_AUTH, 1);
   1055 				}
   1056 				break;
   1057 			}
   1058 			break;
   1059 		}
   1060 		break;
   1061 	case IEEE80211_S_ASSOC:
   1062 		switch (ostate) {
   1063 		case IEEE80211_S_INIT:
   1064 		case IEEE80211_S_SCAN:
   1065 		case IEEE80211_S_ASSOC:
   1066 			IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
   1067 				"%s: invalid transition\n", __func__);
   1068 			break;
   1069 		case IEEE80211_S_AUTH:
   1070 			IEEE80211_SEND_MGMT(ic, ni,
   1071 			    IEEE80211_FC0_SUBTYPE_ASSOC_REQ, 0);
   1072 			break;
   1073 		case IEEE80211_S_RUN:
   1074 			ieee80211_sta_leave(ic, ni);
   1075 			if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) {
   1076 				IEEE80211_SEND_MGMT(ic, ni,
   1077 				    IEEE80211_FC0_SUBTYPE_ASSOC_REQ, 1);
   1078 			}
   1079 			break;
   1080 		}
   1081 		break;
   1082 	case IEEE80211_S_RUN:
   1083 		if (ic->ic_flags & IEEE80211_F_WPA) {
   1084 			/* XXX validate prerequisites */
   1085 		}
   1086 		switch (ostate) {
   1087 		case IEEE80211_S_INIT:
   1088 			if (ic->ic_opmode == IEEE80211_M_MONITOR)
   1089 				break;
   1090 			/* fall thru... */
   1091 		case IEEE80211_S_AUTH:
   1092 			IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
   1093 				"%s: invalid transition\n", __func__);
   1094 			/* fall thru... */
   1095 		case IEEE80211_S_RUN:
   1096 			break;
   1097 		case IEEE80211_S_SCAN:		/* adhoc/hostap mode */
   1098 		case IEEE80211_S_ASSOC:		/* infra mode */
   1099 			IASSERT(ni->ni_txrate < ni->ni_rates.rs_nrates,
   1100 				("%s: bogus xmit rate %u setup\n", __func__,
   1101 					ni->ni_txrate));
   1102 #ifdef IEEE80211_DEBUG
   1103 			if (ieee80211_msg_debug(ic)) {
   1104 				if (ic->ic_opmode == IEEE80211_M_STA)
   1105 					if_printf(ifp, "associated ");
   1106 				else
   1107 					if_printf(ifp, "synchronized ");
   1108 				printf("with %s ssid ",
   1109 				    ether_sprintf(ni->ni_bssid));
   1110 				ieee80211_print_essid(ic->ic_bss->ni_essid,
   1111 				    ni->ni_esslen);
   1112 				printf(" channel %d start %uMb\n",
   1113 					ieee80211_chan2ieee(ic, ic->ic_curchan),
   1114 					IEEE80211_RATE2MBS(ni->ni_rates.rs_rates[ni->ni_txrate]));
   1115 			}
   1116 #endif
   1117 			ic->ic_mgt_timer = 0;
   1118 			if (ic->ic_opmode == IEEE80211_M_STA)
   1119 				ieee80211_notify_node_join(ic, ni,
   1120 					arg == IEEE80211_FC0_SUBTYPE_ASSOC_RESP);
   1121 			(*ifp->if_start)(ifp);	/* XXX not authorized yet */
   1122 			break;
   1123 		}
   1124 		/*
   1125 		 * Start/stop the authenticator when operating as an
   1126 		 * AP.  We delay until here to allow configuration to
   1127 		 * happen out of order.
   1128 		 */
   1129 		if (ic->ic_opmode == IEEE80211_M_HOSTAP && /* XXX IBSS/AHDEMO */
   1130 		    ic->ic_auth->ia_attach != NULL) {
   1131 			/* XXX check failure */
   1132 			ic->ic_auth->ia_attach(ic);
   1133 		} else if (ic->ic_auth->ia_detach != NULL) {
   1134 			ic->ic_auth->ia_detach(ic);
   1135 		}
   1136 		/*
   1137 		 * When 802.1x is not in use mark the port authorized
   1138 		 * at this point so traffic can flow.
   1139 		 */
   1140 		if (ni->ni_authmode != IEEE80211_AUTH_8021X)
   1141 			ieee80211_node_authorize(ni);
   1142 		/*
   1143 		 * Enable inactivity processing.
   1144 		 * XXX
   1145 		 */
   1146 		ic->ic_scan.nt_inact_timer = IEEE80211_INACT_WAIT;
   1147 		ic->ic_sta.nt_inact_timer = IEEE80211_INACT_WAIT;
   1148 		break;
   1149 	}
   1150 	return 0;
   1151 }
   1152