xref: /freebsd/sys/net80211/ieee80211_node.c (revision da5069e1f7daaef1e7157876d6044de6f3a08ce2)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2001 Atsushi Onoe
5  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include "opt_wlan.h"
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/mbuf.h>
37 #include <sys/malloc.h>
38 #include <sys/kernel.h>
39 
40 #include <sys/socket.h>
41 
42 #include <net/if.h>
43 #include <net/if_var.h>
44 #include <net/if_media.h>
45 #include <net/ethernet.h>
46 
47 #include <net80211/ieee80211_var.h>
48 #include <net80211/ieee80211_input.h>
49 #ifdef IEEE80211_SUPPORT_SUPERG
50 #include <net80211/ieee80211_superg.h>
51 #endif
52 #ifdef IEEE80211_SUPPORT_TDMA
53 #include <net80211/ieee80211_tdma.h>
54 #endif
55 #include <net80211/ieee80211_wds.h>
56 #include <net80211/ieee80211_mesh.h>
57 #include <net80211/ieee80211_ratectl.h>
58 #include <net80211/ieee80211_vht.h>
59 
60 #include <net/bpf.h>
61 
62 /*
63  * IEEE80211_NODE_HASHSIZE must be a power of 2.
64  */
65 CTASSERT((IEEE80211_NODE_HASHSIZE & (IEEE80211_NODE_HASHSIZE-1)) == 0);
66 
67 /*
68  * Association id's are managed with a bit vector.
69  */
70 #define	IEEE80211_AID_SET(_vap, b) \
71 	((_vap)->iv_aid_bitmap[IEEE80211_AID(b) / 32] |= \
72 		(1 << (IEEE80211_AID(b) % 32)))
73 #define	IEEE80211_AID_CLR(_vap, b) \
74 	((_vap)->iv_aid_bitmap[IEEE80211_AID(b) / 32] &= \
75 		~(1 << (IEEE80211_AID(b) % 32)))
76 #define	IEEE80211_AID_ISSET(_vap, b) \
77 	((_vap)->iv_aid_bitmap[IEEE80211_AID(b) / 32] & (1 << (IEEE80211_AID(b) % 32)))
78 
79 static int ieee80211_sta_join1(struct ieee80211_node *);
80 
81 static struct ieee80211_node *node_alloc(struct ieee80211vap *,
82 	const uint8_t [IEEE80211_ADDR_LEN]);
83 static void node_cleanup(struct ieee80211_node *);
84 static void node_free(struct ieee80211_node *);
85 static void node_age(struct ieee80211_node *);
86 static int8_t node_getrssi(const struct ieee80211_node *);
87 static void node_getsignal(const struct ieee80211_node *, int8_t *, int8_t *);
88 static void node_getmimoinfo(const struct ieee80211_node *,
89 	struct ieee80211_mimo_info *);
90 
91 static void _ieee80211_free_node(struct ieee80211_node *);
92 
93 static void node_reclaim(struct ieee80211_node_table *nt,
94 	struct ieee80211_node *ni);
95 static void ieee80211_node_table_init(struct ieee80211com *ic,
96 	struct ieee80211_node_table *nt, const char *name,
97 	int inact, int keymaxix);
98 static void ieee80211_node_table_reset(struct ieee80211_node_table *,
99 	struct ieee80211vap *);
100 static void ieee80211_node_table_cleanup(struct ieee80211_node_table *nt);
101 static void ieee80211_erp_timeout(struct ieee80211com *);
102 
103 MALLOC_DEFINE(M_80211_NODE, "80211node", "802.11 node state");
104 MALLOC_DEFINE(M_80211_NODE_IE, "80211nodeie", "802.11 node ie");
105 
106 void
107 ieee80211_node_attach(struct ieee80211com *ic)
108 {
109 	/* XXX really want maxlen enforced per-sta */
110 	ieee80211_ageq_init(&ic->ic_stageq, ic->ic_max_keyix * 8,
111 	    "802.11 staging q");
112 	ieee80211_node_table_init(ic, &ic->ic_sta, "station",
113 		IEEE80211_INACT_INIT, ic->ic_max_keyix);
114 	callout_init(&ic->ic_inact, 1);
115 	callout_reset(&ic->ic_inact, IEEE80211_INACT_WAIT*hz,
116 		ieee80211_node_timeout, ic);
117 
118 	ic->ic_node_alloc = node_alloc;
119 	ic->ic_node_free = node_free;
120 	ic->ic_node_cleanup = node_cleanup;
121 	ic->ic_node_age = node_age;
122 	ic->ic_node_drain = node_age;		/* NB: same as age */
123 	ic->ic_node_getrssi = node_getrssi;
124 	ic->ic_node_getsignal = node_getsignal;
125 	ic->ic_node_getmimoinfo = node_getmimoinfo;
126 
127 	/*
128 	 * Set flags to be propagated to all vap's;
129 	 * these define default behaviour/configuration.
130 	 */
131 	ic->ic_flags_ext |= IEEE80211_FEXT_INACT; /* inactivity processing */
132 }
133 
134 void
135 ieee80211_node_detach(struct ieee80211com *ic)
136 {
137 
138 	callout_drain(&ic->ic_inact);
139 	ieee80211_node_table_cleanup(&ic->ic_sta);
140 	ieee80211_ageq_drain(&ic->ic_stageq);
141 	ieee80211_ageq_cleanup(&ic->ic_stageq);
142 }
143 
144 void
145 ieee80211_node_vattach(struct ieee80211vap *vap)
146 {
147 	/* NB: driver can override */
148 	vap->iv_max_aid = IEEE80211_AID_DEF;
149 
150 	/* default station inactivity timer setings */
151 	vap->iv_inact_init = IEEE80211_INACT_INIT;
152 	vap->iv_inact_auth = IEEE80211_INACT_AUTH;
153 	vap->iv_inact_run = IEEE80211_INACT_RUN;
154 	vap->iv_inact_probe = IEEE80211_INACT_PROBE;
155 
156 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_INACT,
157 	    "%s: init %u auth %u run %u probe %u\n", __func__,
158 	    vap->iv_inact_init, vap->iv_inact_auth,
159 	    vap->iv_inact_run, vap->iv_inact_probe);
160 }
161 
162 void
163 ieee80211_node_latevattach(struct ieee80211vap *vap)
164 {
165 	if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
166 		/* XXX should we allow max aid to be zero? */
167 		if (vap->iv_max_aid < IEEE80211_AID_MIN) {
168 			vap->iv_max_aid = IEEE80211_AID_MIN;
169 			if_printf(vap->iv_ifp,
170 			    "WARNING: max aid too small, changed to %d\n",
171 			    vap->iv_max_aid);
172 		}
173 		vap->iv_aid_bitmap = (uint32_t *) IEEE80211_MALLOC(
174 			howmany(vap->iv_max_aid, 32) * sizeof(uint32_t),
175 			M_80211_NODE,
176 			IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
177 		if (vap->iv_aid_bitmap == NULL) {
178 			/* XXX no way to recover */
179 			printf("%s: no memory for AID bitmap, max aid %d!\n",
180 			    __func__, vap->iv_max_aid);
181 			vap->iv_max_aid = 0;
182 		}
183 	}
184 
185 	ieee80211_reset_bss(vap);
186 
187 	vap->iv_auth = ieee80211_authenticator_get(vap->iv_bss->ni_authmode);
188 }
189 
190 void
191 ieee80211_node_vdetach(struct ieee80211vap *vap)
192 {
193 	struct ieee80211com *ic = vap->iv_ic;
194 
195 	ieee80211_node_table_reset(&ic->ic_sta, vap);
196 	if (vap->iv_bss != NULL) {
197 		ieee80211_free_node(vap->iv_bss);
198 		vap->iv_bss = NULL;
199 	}
200 	if (vap->iv_aid_bitmap != NULL) {
201 		IEEE80211_FREE(vap->iv_aid_bitmap, M_80211_NODE);
202 		vap->iv_aid_bitmap = NULL;
203 	}
204 }
205 
206 /*
207  * Port authorize/unauthorize interfaces for use by an authenticator.
208  */
209 
210 void
211 ieee80211_node_authorize(struct ieee80211_node *ni)
212 {
213 	struct ieee80211vap *vap = ni->ni_vap;
214 
215 	ni->ni_flags |= IEEE80211_NODE_AUTH;
216 	ni->ni_inact_reload = vap->iv_inact_run;
217 	ni->ni_inact = ni->ni_inact_reload;
218 
219 	IEEE80211_NOTE(vap, IEEE80211_MSG_INACT, ni,
220 	    "%s: inact_reload %u", __func__, ni->ni_inact_reload);
221 }
222 
223 void
224 ieee80211_node_unauthorize(struct ieee80211_node *ni)
225 {
226 	struct ieee80211vap *vap = ni->ni_vap;
227 
228 	ni->ni_flags &= ~IEEE80211_NODE_AUTH;
229 	ni->ni_inact_reload = vap->iv_inact_auth;
230 	if (ni->ni_inact > ni->ni_inact_reload)
231 		ni->ni_inact = ni->ni_inact_reload;
232 
233 	IEEE80211_NOTE(vap, IEEE80211_MSG_INACT, ni,
234 	    "%s: inact_reload %u inact %u", __func__,
235 	    ni->ni_inact_reload, ni->ni_inact);
236 }
237 
238 /*
239  * Fix tx parameters for a node according to ``association state''.
240  */
241 void
242 ieee80211_node_setuptxparms(struct ieee80211_node *ni)
243 {
244 	struct ieee80211vap *vap = ni->ni_vap;
245 	enum ieee80211_phymode mode;
246 
247 	if (ni->ni_flags & IEEE80211_NODE_VHT) {
248 		if (IEEE80211_IS_CHAN_5GHZ(ni->ni_chan))
249 			mode = IEEE80211_MODE_VHT_5GHZ;
250 		else
251 			mode = IEEE80211_MODE_VHT_2GHZ;
252 	} else if (ni->ni_flags & IEEE80211_NODE_HT) {
253 		if (IEEE80211_IS_CHAN_5GHZ(ni->ni_chan))
254 			mode = IEEE80211_MODE_11NA;
255 		else
256 			mode = IEEE80211_MODE_11NG;
257 	} else {				/* legacy rate handling */
258 		if (IEEE80211_IS_CHAN_ST(ni->ni_chan))
259 			mode = IEEE80211_MODE_STURBO_A;
260 		else if (IEEE80211_IS_CHAN_HALF(ni->ni_chan))
261 			mode = IEEE80211_MODE_HALF;
262 		else if (IEEE80211_IS_CHAN_QUARTER(ni->ni_chan))
263 			mode = IEEE80211_MODE_QUARTER;
264 		/* NB: 108A should be handled as 11a */
265 		else if (IEEE80211_IS_CHAN_A(ni->ni_chan))
266 			mode = IEEE80211_MODE_11A;
267 		else if (IEEE80211_IS_CHAN_108G(ni->ni_chan) ||
268 		    (ni->ni_flags & IEEE80211_NODE_ERP))
269 			mode = IEEE80211_MODE_11G;
270 		else
271 			mode = IEEE80211_MODE_11B;
272 	}
273 	ni->ni_txparms = &vap->iv_txparms[mode];
274 }
275 
276 /*
277  * Set/change the channel.  The rate set is also updated as
278  * to insure a consistent view by drivers.
279  * XXX should be private but hostap needs it to deal with CSA
280  */
281 void
282 ieee80211_node_set_chan(struct ieee80211_node *ni,
283 	struct ieee80211_channel *chan)
284 {
285 	struct ieee80211com *ic = ni->ni_ic;
286 	struct ieee80211vap *vap = ni->ni_vap;
287 	enum ieee80211_phymode mode;
288 
289 	KASSERT(chan != IEEE80211_CHAN_ANYC, ("no channel"));
290 
291 	ni->ni_chan = chan;
292 	mode = ieee80211_chan2mode(chan);
293 	if (IEEE80211_IS_CHAN_HT(chan)) {
294 		/*
295 		 * We must install the legacy rate est in ni_rates and the
296 		 * HT rate set in ni_htrates.
297 		 */
298 		ni->ni_htrates = *ieee80211_get_suphtrates(ic, chan);
299 		/*
300 		 * Setup bss tx parameters based on operating mode.  We
301 		 * use legacy rates when operating in a mixed HT+non-HT bss
302 		 * and non-ERP rates in 11g for mixed ERP+non-ERP bss.
303 		 */
304 		if (mode == IEEE80211_MODE_11NA &&
305 		    (vap->iv_flags_ht & IEEE80211_FHT_PUREN) == 0)
306 			mode = IEEE80211_MODE_11A;
307 		else if (mode == IEEE80211_MODE_11NG &&
308 		    (vap->iv_flags_ht & IEEE80211_FHT_PUREN) == 0)
309 			mode = IEEE80211_MODE_11G;
310 		if (mode == IEEE80211_MODE_11G &&
311 		    (vap->iv_flags & IEEE80211_F_PUREG) == 0)
312 			mode = IEEE80211_MODE_11B;
313 	}
314 	ni->ni_txparms = &vap->iv_txparms[mode];
315 	ni->ni_rates = *ieee80211_get_suprates(ic, chan);
316 }
317 
318 static __inline void
319 copy_bss(struct ieee80211_node *nbss, const struct ieee80211_node *obss)
320 {
321 	/* propagate useful state */
322 	nbss->ni_authmode = obss->ni_authmode;
323 	nbss->ni_txpower = obss->ni_txpower;
324 	nbss->ni_vlan = obss->ni_vlan;
325 	/* XXX statistics? */
326 	/* XXX legacy WDS bssid? */
327 }
328 
329 void
330 ieee80211_create_ibss(struct ieee80211vap* vap, struct ieee80211_channel *chan)
331 {
332 	struct ieee80211com *ic = vap->iv_ic;
333 	struct ieee80211_node *ni;
334 
335 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
336 		"%s: creating %s on channel %u%c flags 0x%08x\n", __func__,
337 		ieee80211_opmode_name[vap->iv_opmode],
338 		ieee80211_chan2ieee(ic, chan),
339 		ieee80211_channel_type_char(chan),
340 		chan->ic_flags);
341 
342 	ni = ieee80211_alloc_node(&ic->ic_sta, vap, vap->iv_myaddr);
343 	if (ni == NULL) {
344 		/* XXX recovery? */
345 		return;
346 	}
347 	IEEE80211_ADDR_COPY(ni->ni_bssid, vap->iv_myaddr);
348 	ni->ni_esslen = vap->iv_des_ssid[0].len;
349 	memcpy(ni->ni_essid, vap->iv_des_ssid[0].ssid, ni->ni_esslen);
350 	if (vap->iv_bss != NULL)
351 		copy_bss(ni, vap->iv_bss);
352 	ni->ni_intval = ic->ic_bintval;
353 	if (vap->iv_flags & IEEE80211_F_PRIVACY)
354 		ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY;
355 	if (ic->ic_phytype == IEEE80211_T_FH) {
356 		ni->ni_fhdwell = 200;	/* XXX */
357 		ni->ni_fhindex = 1;
358 	}
359 	if (vap->iv_opmode == IEEE80211_M_IBSS) {
360 		ni->ni_capinfo |= IEEE80211_CAPINFO_IBSS;	/* XXX */
361 		if (vap->iv_flags & IEEE80211_F_DESBSSID)
362 			IEEE80211_ADDR_COPY(ni->ni_bssid, vap->iv_des_bssid);
363 		else {
364 			get_random_bytes(ni->ni_bssid, IEEE80211_ADDR_LEN);
365 			/* clear group bit, add local bit */
366 			ni->ni_bssid[0] = (ni->ni_bssid[0] &~ 0x01) | 0x02;
367 		}
368 	} else if (vap->iv_opmode == IEEE80211_M_AHDEMO) {
369 		if (vap->iv_flags & IEEE80211_F_DESBSSID)
370 			IEEE80211_ADDR_COPY(ni->ni_bssid, vap->iv_des_bssid);
371 		else
372 #ifdef IEEE80211_SUPPORT_TDMA
373 		if ((vap->iv_caps & IEEE80211_C_TDMA) == 0)
374 #endif
375 			memset(ni->ni_bssid, 0, IEEE80211_ADDR_LEN);
376 #ifdef IEEE80211_SUPPORT_MESH
377 	} else if (vap->iv_opmode == IEEE80211_M_MBSS) {
378 		ni->ni_meshidlen = vap->iv_mesh->ms_idlen;
379 		memcpy(ni->ni_meshid, vap->iv_mesh->ms_id, ni->ni_meshidlen);
380 #endif
381 	}
382 	/*
383 	 * Fix the channel and related attributes.
384 	 */
385 	/* clear DFS CAC state on previous channel */
386 	if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
387 	    ic->ic_bsschan->ic_freq != chan->ic_freq &&
388 	    IEEE80211_IS_CHAN_CACDONE(ic->ic_bsschan))
389 		ieee80211_dfs_cac_clear(ic, ic->ic_bsschan);
390 	ic->ic_bsschan = chan;
391 	ieee80211_node_set_chan(ni, chan);
392 	ic->ic_curmode = ieee80211_chan2mode(chan);
393 	/*
394 	 * Do mode-specific setup.
395 	 */
396 	if (IEEE80211_IS_CHAN_FULL(chan)) {
397 		if (IEEE80211_IS_CHAN_ANYG(chan)) {
398 			/*
399 			 * Use a mixed 11b/11g basic rate set.
400 			 */
401 			ieee80211_setbasicrates(&ni->ni_rates,
402 			    IEEE80211_MODE_11G);
403 			if (vap->iv_flags & IEEE80211_F_PUREG) {
404 				/*
405 				 * Also mark OFDM rates basic so 11b
406 				 * stations do not join (WiFi compliance).
407 				 */
408 				ieee80211_addbasicrates(&ni->ni_rates,
409 				    IEEE80211_MODE_11A);
410 			}
411 		} else if (IEEE80211_IS_CHAN_B(chan)) {
412 			/*
413 			 * Force pure 11b rate set.
414 			 */
415 			ieee80211_setbasicrates(&ni->ni_rates,
416 				IEEE80211_MODE_11B);
417 		}
418 	}
419 
420 	/* XXX TODO: other bits and pieces - eg fast-frames? */
421 
422 	/* If we're an 11n channel then initialise the 11n bits */
423 	if (IEEE80211_IS_CHAN_VHT(ni->ni_chan)) {
424 		/* XXX what else? */
425 		ieee80211_ht_node_init(ni);
426 		ieee80211_vht_node_init(ni);
427 	} else if (IEEE80211_IS_CHAN_HT(ni->ni_chan)) {
428 		/* XXX what else? */
429 		ieee80211_ht_node_init(ni);
430 	}
431 
432 	(void) ieee80211_sta_join1(ieee80211_ref_node(ni));
433 }
434 
435 /*
436  * Reset bss state on transition to the INIT state.
437  * Clear any stations from the table (they have been
438  * deauth'd) and reset the bss node (clears key, rate
439  * etc. state).
440  */
441 void
442 ieee80211_reset_bss(struct ieee80211vap *vap)
443 {
444 	struct ieee80211com *ic = vap->iv_ic;
445 	struct ieee80211_node *ni, *obss;
446 
447 	ieee80211_node_table_reset(&ic->ic_sta, vap);
448 	/* XXX multi-bss: wrong */
449 	ieee80211_reset_erp(ic);
450 
451 	ni = ieee80211_alloc_node(&ic->ic_sta, vap, vap->iv_myaddr);
452 	KASSERT(ni != NULL, ("unable to setup initial BSS node"));
453 	obss = vap->iv_bss;
454 	vap->iv_bss = ieee80211_ref_node(ni);
455 	if (obss != NULL) {
456 		copy_bss(ni, obss);
457 		ni->ni_intval = ic->ic_bintval;
458 		ieee80211_free_node(obss);
459 	} else
460 		IEEE80211_ADDR_COPY(ni->ni_bssid, vap->iv_myaddr);
461 }
462 
463 static int
464 match_ssid(const struct ieee80211_node *ni,
465 	int nssid, const struct ieee80211_scan_ssid ssids[])
466 {
467 	int i;
468 
469 	for (i = 0; i < nssid; i++) {
470 		if (ni->ni_esslen == ssids[i].len &&
471 		     memcmp(ni->ni_essid, ssids[i].ssid, ni->ni_esslen) == 0)
472 			return 1;
473 	}
474 	return 0;
475 }
476 
477 /*
478  * Test a node for suitability/compatibility.
479  */
480 static int
481 check_bss(struct ieee80211vap *vap, struct ieee80211_node *ni)
482 {
483 	struct ieee80211com *ic = ni->ni_ic;
484         uint8_t rate;
485 
486 	if (isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ni->ni_chan)))
487 		return 0;
488 	if (vap->iv_opmode == IEEE80211_M_IBSS) {
489 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) == 0)
490 			return 0;
491 	} else {
492 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_ESS) == 0)
493 			return 0;
494 	}
495 	if (vap->iv_flags & IEEE80211_F_PRIVACY) {
496 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) == 0)
497 			return 0;
498 	} else {
499 		/* XXX does this mean privacy is supported or required? */
500 		if (ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY)
501 			return 0;
502 	}
503 	rate = ieee80211_fix_rate(ni, &ni->ni_rates,
504 	    IEEE80211_F_JOIN | IEEE80211_F_DONEGO | IEEE80211_F_DOFRATE);
505 	if (rate & IEEE80211_RATE_BASIC)
506 		return 0;
507 	if (vap->iv_des_nssid != 0 &&
508 	    !match_ssid(ni, vap->iv_des_nssid, vap->iv_des_ssid))
509 		return 0;
510 	if ((vap->iv_flags & IEEE80211_F_DESBSSID) &&
511 	    !IEEE80211_ADDR_EQ(vap->iv_des_bssid, ni->ni_bssid))
512 		return 0;
513 	return 1;
514 }
515 
516 #ifdef IEEE80211_DEBUG
517 /*
518  * Display node suitability/compatibility.
519  */
520 static void
521 check_bss_debug(struct ieee80211vap *vap, struct ieee80211_node *ni)
522 {
523 	struct ieee80211com *ic = ni->ni_ic;
524         uint8_t rate;
525         int fail;
526 
527 	fail = 0;
528 	if (isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ni->ni_chan)))
529 		fail |= 0x01;
530 	if (vap->iv_opmode == IEEE80211_M_IBSS) {
531 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) == 0)
532 			fail |= 0x02;
533 	} else {
534 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_ESS) == 0)
535 			fail |= 0x02;
536 	}
537 	if (vap->iv_flags & IEEE80211_F_PRIVACY) {
538 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) == 0)
539 			fail |= 0x04;
540 	} else {
541 		/* XXX does this mean privacy is supported or required? */
542 		if (ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY)
543 			fail |= 0x04;
544 	}
545 	rate = ieee80211_fix_rate(ni, &ni->ni_rates,
546 	     IEEE80211_F_JOIN | IEEE80211_F_DONEGO | IEEE80211_F_DOFRATE);
547 	if (rate & IEEE80211_RATE_BASIC)
548 		fail |= 0x08;
549 	if (vap->iv_des_nssid != 0 &&
550 	    !match_ssid(ni, vap->iv_des_nssid, vap->iv_des_ssid))
551 		fail |= 0x10;
552 	if ((vap->iv_flags & IEEE80211_F_DESBSSID) &&
553 	    !IEEE80211_ADDR_EQ(vap->iv_des_bssid, ni->ni_bssid))
554 		fail |= 0x20;
555 
556 	printf(" %c %s", fail ? '-' : '+', ether_sprintf(ni->ni_macaddr));
557 	printf(" %s%c", ether_sprintf(ni->ni_bssid), fail & 0x20 ? '!' : ' ');
558 	printf(" %3d%c",
559 	    ieee80211_chan2ieee(ic, ni->ni_chan), fail & 0x01 ? '!' : ' ');
560 	printf(" %2dM%c", (rate & IEEE80211_RATE_VAL) / 2,
561 	    fail & 0x08 ? '!' : ' ');
562 	printf(" %4s%c",
563 	    (ni->ni_capinfo & IEEE80211_CAPINFO_ESS) ? "ess" :
564 	    (ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) ? "ibss" :
565 	    "????",
566 	    fail & 0x02 ? '!' : ' ');
567 	printf(" %3s%c ",
568 	    (ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) ?  "wep" : "no",
569 	    fail & 0x04 ? '!' : ' ');
570 	ieee80211_print_essid(ni->ni_essid, ni->ni_esslen);
571 	printf("%s\n", fail & 0x10 ? "!" : "");
572 }
573 #endif /* IEEE80211_DEBUG */
574 
575 
576 int
577 ieee80211_ibss_merge_check(struct ieee80211_node *ni)
578 {
579 	struct ieee80211vap *vap = ni->ni_vap;
580 
581 	if (ni == vap->iv_bss ||
582 	    IEEE80211_ADDR_EQ(ni->ni_bssid, vap->iv_bss->ni_bssid)) {
583 		/* unchanged, nothing to do */
584 		return 0;
585 	}
586 
587 	if (!check_bss(vap, ni)) {
588 		/* capabilities mismatch */
589 		IEEE80211_DPRINTF(vap, IEEE80211_MSG_ASSOC,
590 		    "%s: merge failed, capabilities mismatch\n", __func__);
591 #ifdef IEEE80211_DEBUG
592 		if (ieee80211_msg_assoc(vap))
593 			check_bss_debug(vap, ni);
594 #endif
595 		vap->iv_stats.is_ibss_capmismatch++;
596 		return 0;
597 	}
598 
599 	return 1;
600 }
601 
602 /*
603  * Check if the given node should populate the node table.
604  *
605  * We need to be in "see all beacons for all ssids" mode in order
606  * to do IBSS merges, however this means we will populate nodes for
607  * /all/ IBSS SSIDs, versus just the one we care about.
608  *
609  * So this check ensures the node can actually belong to our IBSS
610  * configuration.  For now it simply checks the SSID.
611  */
612 int
613 ieee80211_ibss_node_check_new(struct ieee80211_node *ni,
614     const struct ieee80211_scanparams *scan)
615 {
616 	struct ieee80211vap *vap = ni->ni_vap;
617 	int i;
618 
619 	/*
620 	 * If we have no SSID and no scan SSID, return OK.
621 	 */
622 	if (vap->iv_des_nssid == 0 && scan->ssid == NULL)
623 		goto ok;
624 
625 	/*
626 	 * If we have one of (SSID, scan SSID) then return error.
627 	 */
628 	if (!! (vap->iv_des_nssid == 0) != !! (scan->ssid == NULL))
629 		goto mismatch;
630 
631 	/*
632 	 * Double-check - we need scan SSID.
633 	 */
634 	if (scan->ssid == NULL)
635 		goto mismatch;
636 
637 	/*
638 	 * Check if the scan SSID matches the SSID list for the VAP.
639 	 */
640 	for (i = 0; i < vap->iv_des_nssid; i++) {
641 
642 		/* Sanity length check */
643 		if (vap->iv_des_ssid[i].len != scan->ssid[1])
644 			continue;
645 
646 		/* Note: SSID in the scan entry is the IE format */
647 		if (memcmp(vap->iv_des_ssid[i].ssid, scan->ssid + 2,
648 		    vap->iv_des_ssid[i].len) == 0)
649 			goto ok;
650 	}
651 
652 mismatch:
653 	return (0);
654 ok:
655 	return (1);
656 }
657 
658 /*
659  * Handle 802.11 ad hoc network merge.  The
660  * convention, set by the Wireless Ethernet Compatibility Alliance
661  * (WECA), is that an 802.11 station will change its BSSID to match
662  * the "oldest" 802.11 ad hoc network, on the same channel, that
663  * has the station's desired SSID.  The "oldest" 802.11 network
664  * sends beacons with the greatest TSF timestamp.
665  *
666  * The caller is assumed to validate TSF's before attempting a merge.
667  *
668  * Return !0 if the BSSID changed, 0 otherwise.
669  */
670 int
671 ieee80211_ibss_merge(struct ieee80211_node *ni)
672 {
673 #ifdef IEEE80211_DEBUG
674 	struct ieee80211vap *vap = ni->ni_vap;
675 	struct ieee80211com *ic = ni->ni_ic;
676 #endif
677 
678 	if (! ieee80211_ibss_merge_check(ni))
679 		return 0;
680 
681 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_ASSOC,
682 		"%s: new bssid %s: %s preamble, %s slot time%s\n", __func__,
683 		ether_sprintf(ni->ni_bssid),
684 		ic->ic_flags&IEEE80211_F_SHPREAMBLE ? "short" : "long",
685 		ic->ic_flags&IEEE80211_F_SHSLOT ? "short" : "long",
686 		ic->ic_flags&IEEE80211_F_USEPROT ? ", protection" : ""
687 	);
688 	return ieee80211_sta_join1(ieee80211_ref_node(ni));
689 }
690 
691 /*
692  * Calculate HT channel promotion flags for all vaps.
693  * This assumes ni_chan have been setup for each vap.
694  */
695 static int
696 gethtadjustflags(struct ieee80211com *ic)
697 {
698 	struct ieee80211vap *vap;
699 	int flags;
700 
701 	flags = 0;
702 	/* XXX locking */
703 	TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
704 		if (vap->iv_state < IEEE80211_S_RUN)
705 			continue;
706 		switch (vap->iv_opmode) {
707 		case IEEE80211_M_WDS:
708 		case IEEE80211_M_STA:
709 		case IEEE80211_M_AHDEMO:
710 		case IEEE80211_M_HOSTAP:
711 		case IEEE80211_M_IBSS:
712 		case IEEE80211_M_MBSS:
713 			flags |= ieee80211_htchanflags(vap->iv_bss->ni_chan);
714 			break;
715 		default:
716 			break;
717 		}
718 	}
719 	return flags;
720 }
721 
722 /*
723  * Calculate VHT channel promotion flags for all vaps.
724  * This assumes ni_chan have been setup for each vap.
725  */
726 static int
727 getvhtadjustflags(struct ieee80211com *ic)
728 {
729 	struct ieee80211vap *vap;
730 	int flags;
731 
732 	flags = 0;
733 	/* XXX locking */
734 	TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
735 		if (vap->iv_state < IEEE80211_S_RUN)
736 			continue;
737 		switch (vap->iv_opmode) {
738 		case IEEE80211_M_WDS:
739 		case IEEE80211_M_STA:
740 		case IEEE80211_M_AHDEMO:
741 		case IEEE80211_M_HOSTAP:
742 		case IEEE80211_M_IBSS:
743 		case IEEE80211_M_MBSS:
744 			flags |= ieee80211_vhtchanflags(vap->iv_bss->ni_chan);
745 			break;
746 		default:
747 			break;
748 		}
749 	}
750 	return flags;
751 }
752 
753 /*
754  * Check if the current channel needs to change based on whether
755  * any vap's are using HT20/HT40.  This is used to sync the state
756  * of ic_curchan after a channel width change on a running vap.
757  *
758  * Same applies for VHT.
759  */
760 void
761 ieee80211_sync_curchan(struct ieee80211com *ic)
762 {
763 	struct ieee80211_channel *c;
764 
765 	c = ieee80211_ht_adjust_channel(ic, ic->ic_curchan, gethtadjustflags(ic));
766 	c = ieee80211_vht_adjust_channel(ic, c, getvhtadjustflags(ic));
767 
768 	if (c != ic->ic_curchan) {
769 		ic->ic_curchan = c;
770 		ic->ic_curmode = ieee80211_chan2mode(ic->ic_curchan);
771 		ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan);
772 		IEEE80211_UNLOCK(ic);
773 		ic->ic_set_channel(ic);
774 		ieee80211_radiotap_chan_change(ic);
775 		IEEE80211_LOCK(ic);
776 	}
777 }
778 
779 /*
780  * Setup the current channel.  The request channel may be
781  * promoted if other vap's are operating with HT20/HT40.
782  */
783 void
784 ieee80211_setupcurchan(struct ieee80211com *ic, struct ieee80211_channel *c)
785 {
786 	if (ic->ic_htcaps & IEEE80211_HTC_HT) {
787 		int flags = gethtadjustflags(ic);
788 		/*
789 		 * Check for channel promotion required to support the
790 		 * set of running vap's.  This assumes we are called
791 		 * after ni_chan is setup for each vap.
792 		 */
793 		/* XXX VHT? */
794 		/* NB: this assumes IEEE80211_FHT_USEHT40 > IEEE80211_FHT_HT */
795 		if (flags > ieee80211_htchanflags(c))
796 			c = ieee80211_ht_adjust_channel(ic, c, flags);
797 	}
798 
799 	/*
800 	 * VHT promotion - this will at least promote to VHT20/40
801 	 * based on what HT has done; it may further promote the
802 	 * channel to VHT80 or above.
803 	 */
804 	if (ic->ic_vhtcaps != 0) {
805 		int flags = getvhtadjustflags(ic);
806 		if (flags > ieee80211_vhtchanflags(c))
807 			c = ieee80211_vht_adjust_channel(ic, c, flags);
808 	}
809 
810 	ic->ic_bsschan = ic->ic_curchan = c;
811 	ic->ic_curmode = ieee80211_chan2mode(ic->ic_curchan);
812 	ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan);
813 }
814 
815 /*
816  * Change the current channel.  The channel change is guaranteed to have
817  * happened before the next state change.
818  */
819 void
820 ieee80211_setcurchan(struct ieee80211com *ic, struct ieee80211_channel *c)
821 {
822 	ieee80211_setupcurchan(ic, c);
823 	ieee80211_runtask(ic, &ic->ic_chan_task);
824 }
825 
826 void
827 ieee80211_update_chw(struct ieee80211com *ic)
828 {
829 
830 	ieee80211_setupcurchan(ic, ic->ic_curchan);
831 	ieee80211_runtask(ic, &ic->ic_chw_task);
832 }
833 
834 /*
835  * Join the specified IBSS/BSS network.  The node is assumed to
836  * be passed in with a held reference.
837  */
838 static int
839 ieee80211_sta_join1(struct ieee80211_node *selbs)
840 {
841 	struct ieee80211vap *vap = selbs->ni_vap;
842 	struct ieee80211com *ic = selbs->ni_ic;
843 	struct ieee80211_node *obss;
844 	int canreassoc;
845 
846 	/*
847 	 * Committed to selbs, setup state.
848 	 */
849 	obss = vap->iv_bss;
850 	/*
851 	 * Check if old+new node have the same address in which
852 	 * case we can reassociate when operating in sta mode.
853 	 */
854 	canreassoc = (obss != NULL &&
855 		vap->iv_state == IEEE80211_S_RUN &&
856 		IEEE80211_ADDR_EQ(obss->ni_macaddr, selbs->ni_macaddr));
857 	vap->iv_bss = selbs;		/* NB: caller assumed to bump refcnt */
858 	if (obss != NULL) {
859 		struct ieee80211_node_table *nt = obss->ni_table;
860 
861 		copy_bss(selbs, obss);
862 		ieee80211_node_decref(obss);	/* iv_bss reference */
863 
864 		IEEE80211_NODE_LOCK(nt);
865 		node_reclaim(nt, obss);		/* station table reference */
866 		IEEE80211_NODE_UNLOCK(nt);
867 
868 		obss = NULL;		/* NB: guard against later use */
869 	}
870 
871 	/*
872 	 * Delete unusable rates; we've already checked
873 	 * that the negotiated rate set is acceptable.
874 	 */
875 	ieee80211_fix_rate(vap->iv_bss, &vap->iv_bss->ni_rates,
876 		IEEE80211_F_DODEL | IEEE80211_F_JOIN);
877 
878 	ieee80211_setcurchan(ic, selbs->ni_chan);
879 	/*
880 	 * Set the erp state (mostly the slot time) to deal with
881 	 * the auto-select case; this should be redundant if the
882 	 * mode is locked.
883 	 */
884 	ieee80211_reset_erp(ic);
885 	ieee80211_wme_initparams(vap);
886 
887 	if (vap->iv_opmode == IEEE80211_M_STA) {
888 		if (canreassoc) {
889 			/* Reassociate */
890 			ieee80211_new_state(vap, IEEE80211_S_ASSOC, 1);
891 		} else {
892 			/*
893 			 * Act as if we received a DEAUTH frame in case we
894 			 * are invoked from the RUN state.  This will cause
895 			 * us to try to re-authenticate if we are operating
896 			 * as a station.
897 			 */
898 			ieee80211_new_state(vap, IEEE80211_S_AUTH,
899 				IEEE80211_FC0_SUBTYPE_DEAUTH);
900 		}
901 	} else
902 		ieee80211_new_state(vap, IEEE80211_S_RUN, -1);
903 	return 1;
904 }
905 
906 int
907 ieee80211_sta_join(struct ieee80211vap *vap, struct ieee80211_channel *chan,
908 	const struct ieee80211_scan_entry *se)
909 {
910 	struct ieee80211com *ic = vap->iv_ic;
911 	struct ieee80211_node *ni;
912 	int do_ht = 0;
913 
914 	ni = ieee80211_alloc_node(&ic->ic_sta, vap, se->se_macaddr);
915 	if (ni == NULL) {
916 		/* XXX msg */
917 		return 0;
918 	}
919 
920 	/*
921 	 * Expand scan state into node's format.
922 	 * XXX may not need all this stuff
923 	 */
924 	IEEE80211_ADDR_COPY(ni->ni_bssid, se->se_bssid);
925 	ni->ni_esslen = se->se_ssid[1];
926 	memcpy(ni->ni_essid, se->se_ssid+2, ni->ni_esslen);
927 	ni->ni_tstamp.tsf = se->se_tstamp.tsf;
928 	ni->ni_intval = se->se_intval;
929 	ni->ni_capinfo = se->se_capinfo;
930 	ni->ni_chan = chan;
931 	ni->ni_timoff = se->se_timoff;
932 	ni->ni_fhdwell = se->se_fhdwell;
933 	ni->ni_fhindex = se->se_fhindex;
934 	ni->ni_erp = se->se_erp;
935 	IEEE80211_RSSI_LPF(ni->ni_avgrssi, se->se_rssi);
936 	ni->ni_noise = se->se_noise;
937 	if (vap->iv_opmode == IEEE80211_M_STA) {
938 		/* NB: only infrastructure mode requires an associd */
939 		ni->ni_flags |= IEEE80211_NODE_ASSOCID;
940 	}
941 
942 	if (ieee80211_ies_init(&ni->ni_ies, se->se_ies.data, se->se_ies.len)) {
943 		ieee80211_ies_expand(&ni->ni_ies);
944 #ifdef IEEE80211_SUPPORT_SUPERG
945 		if (ni->ni_ies.ath_ie != NULL)
946 			ieee80211_parse_ath(ni, ni->ni_ies.ath_ie);
947 #endif
948 		if (ni->ni_ies.htcap_ie != NULL)
949 			ieee80211_parse_htcap(ni, ni->ni_ies.htcap_ie);
950 		if (ni->ni_ies.htinfo_ie != NULL)
951 			ieee80211_parse_htinfo(ni, ni->ni_ies.htinfo_ie);
952 #ifdef IEEE80211_SUPPORT_MESH
953 		if (ni->ni_ies.meshid_ie != NULL)
954 			ieee80211_parse_meshid(ni, ni->ni_ies.meshid_ie);
955 #endif
956 #ifdef IEEE80211_SUPPORT_TDMA
957 		if (ni->ni_ies.tdma_ie != NULL)
958 			ieee80211_parse_tdma(ni, ni->ni_ies.tdma_ie);
959 #endif
960 		if (ni->ni_ies.vhtcap_ie != NULL)
961 			ieee80211_parse_vhtcap(ni, ni->ni_ies.vhtcap_ie);
962 		if (ni->ni_ies.vhtopmode_ie != NULL)
963 			ieee80211_parse_vhtopmode(ni, ni->ni_ies.vhtopmode_ie);
964 
965 		/* XXX parse BSSLOAD IE */
966 		/* XXX parse TXPWRENV IE */
967 		/* XXX parse APCHANREP IE */
968 	}
969 
970 	vap->iv_dtim_period = se->se_dtimperiod;
971 	vap->iv_dtim_count = 0;
972 
973 	/* NB: must be after ni_chan is setup */
974 	ieee80211_setup_rates(ni, se->se_rates, se->se_xrates,
975 		IEEE80211_F_DOSORT);
976 	if (ieee80211_iserp_rateset(&ni->ni_rates))
977 		ni->ni_flags |= IEEE80211_NODE_ERP;
978 
979 	/*
980 	 * Setup HT state for this node if it's available, otherwise
981 	 * non-STA modes won't pick this state up.
982 	 *
983 	 * For IBSS and related modes that don't go through an
984 	 * association request/response, the only appropriate place
985 	 * to setup the HT state is here.
986 	 */
987 	if (ni->ni_ies.htinfo_ie != NULL &&
988 	    ni->ni_ies.htcap_ie != NULL &&
989 	    vap->iv_flags_ht & IEEE80211_FHT_HT) {
990 		ieee80211_ht_node_init(ni);
991 		ieee80211_ht_updateparams(ni,
992 		    ni->ni_ies.htcap_ie,
993 		    ni->ni_ies.htinfo_ie);
994 		do_ht = 1;
995 	}
996 
997 	/*
998 	 * Setup VHT state for this node if it's available.
999 	 * Same as the above.
1000 	 *
1001 	 * For now, don't allow 2GHz VHT operation.
1002 	 */
1003 	if (ni->ni_ies.vhtopmode_ie != NULL &&
1004 	    ni->ni_ies.vhtcap_ie != NULL &&
1005 	    vap->iv_flags_vht & IEEE80211_FVHT_VHT) {
1006 		if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) {
1007 			printf("%s: BSS %6D: 2GHz channel, VHT info; ignoring\n",
1008 			    __func__,
1009 			    ni->ni_macaddr,
1010 			    ":");
1011 		} else {
1012 			ieee80211_vht_node_init(ni);
1013 			ieee80211_vht_updateparams(ni,
1014 			    ni->ni_ies.vhtcap_ie,
1015 			    ni->ni_ies.vhtopmode_ie);
1016 			ieee80211_setup_vht_rates(ni, ni->ni_ies.vhtcap_ie,
1017 			    ni->ni_ies.vhtopmode_ie);
1018 			do_ht = 1;
1019 		}
1020 	}
1021 
1022 	/* Finally do the node channel change */
1023 	if (do_ht) {
1024 		ieee80211_ht_updateparams_final(ni, ni->ni_ies.htcap_ie,
1025 		    ni->ni_ies.htinfo_ie);
1026 		ieee80211_setup_htrates(ni, ni->ni_ies.htcap_ie,
1027 		    IEEE80211_F_JOIN | IEEE80211_F_DOBRS);
1028 		ieee80211_setup_basic_htrates(ni, ni->ni_ies.htinfo_ie);
1029 	}
1030 
1031 	/* XXX else check for ath FF? */
1032 	/* XXX QoS? Difficult given that WME config is specific to a master */
1033 
1034 	ieee80211_node_setuptxparms(ni);
1035 	ieee80211_ratectl_node_init(ni);
1036 
1037 	return ieee80211_sta_join1(ieee80211_ref_node(ni));
1038 }
1039 
1040 /*
1041  * Leave the specified IBSS/BSS network.  The node is assumed to
1042  * be passed in with a held reference.
1043  */
1044 void
1045 ieee80211_sta_leave(struct ieee80211_node *ni)
1046 {
1047 	struct ieee80211com *ic = ni->ni_ic;
1048 
1049 	ic->ic_node_cleanup(ni);
1050 	ieee80211_notify_node_leave(ni);
1051 }
1052 
1053 /*
1054  * Send a deauthenticate frame and drop the station.
1055  */
1056 void
1057 ieee80211_node_deauth(struct ieee80211_node *ni, int reason)
1058 {
1059 	/* NB: bump the refcnt to be sure temporary nodes are not reclaimed */
1060 	ieee80211_ref_node(ni);
1061 	if (ni->ni_associd != 0)
1062 		IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_DEAUTH, reason);
1063 	ieee80211_node_leave(ni);
1064 	ieee80211_free_node(ni);
1065 }
1066 
1067 static struct ieee80211_node *
1068 node_alloc(struct ieee80211vap *vap, const uint8_t macaddr[IEEE80211_ADDR_LEN])
1069 {
1070 	struct ieee80211_node *ni;
1071 
1072 	ni = (struct ieee80211_node *) IEEE80211_MALLOC(sizeof(struct ieee80211_node),
1073 		M_80211_NODE, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
1074 	return ni;
1075 }
1076 
1077 /*
1078  * Initialize an ie blob with the specified data.  If previous
1079  * data exists re-use the data block.  As a side effect we clear
1080  * all references to specific ie's; the caller is required to
1081  * recalculate them.
1082  */
1083 int
1084 ieee80211_ies_init(struct ieee80211_ies *ies, const uint8_t *data, int len)
1085 {
1086 	/* NB: assumes data+len are the last fields */
1087 	memset(ies, 0, offsetof(struct ieee80211_ies, data));
1088 	if (ies->data != NULL && ies->len != len) {
1089 		/* data size changed */
1090 		IEEE80211_FREE(ies->data, M_80211_NODE_IE);
1091 		ies->data = NULL;
1092 	}
1093 	if (ies->data == NULL) {
1094 		ies->data = (uint8_t *) IEEE80211_MALLOC(len, M_80211_NODE_IE,
1095 		    IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
1096 		if (ies->data == NULL) {
1097 			ies->len = 0;
1098 			/* NB: pointers have already been zero'd above */
1099 			return 0;
1100 		}
1101 	}
1102 	memcpy(ies->data, data, len);
1103 	ies->len = len;
1104 	return 1;
1105 }
1106 
1107 /*
1108  * Reclaim storage for an ie blob.
1109  */
1110 void
1111 ieee80211_ies_cleanup(struct ieee80211_ies *ies)
1112 {
1113 	if (ies->data != NULL)
1114 		IEEE80211_FREE(ies->data, M_80211_NODE_IE);
1115 }
1116 
1117 /*
1118  * Expand an ie blob data contents and to fillin individual
1119  * ie pointers.  The data blob is assumed to be well-formed;
1120  * we don't do any validity checking of ie lengths.
1121  */
1122 void
1123 ieee80211_ies_expand(struct ieee80211_ies *ies)
1124 {
1125 	uint8_t *ie;
1126 	int ielen;
1127 
1128 	ie = ies->data;
1129 	ielen = ies->len;
1130 	while (ielen > 0) {
1131 		switch (ie[0]) {
1132 		case IEEE80211_ELEMID_VENDOR:
1133 			if (iswpaoui(ie))
1134 				ies->wpa_ie = ie;
1135 			else if (iswmeoui(ie))
1136 				ies->wme_ie = ie;
1137 #ifdef IEEE80211_SUPPORT_SUPERG
1138 			else if (isatherosoui(ie))
1139 				ies->ath_ie = ie;
1140 #endif
1141 #ifdef IEEE80211_SUPPORT_TDMA
1142 			else if (istdmaoui(ie))
1143 				ies->tdma_ie = ie;
1144 #endif
1145 			break;
1146 		case IEEE80211_ELEMID_RSN:
1147 			ies->rsn_ie = ie;
1148 			break;
1149 		case IEEE80211_ELEMID_HTCAP:
1150 			ies->htcap_ie = ie;
1151 			break;
1152 		case IEEE80211_ELEMID_HTINFO:
1153 			ies->htinfo_ie = ie;
1154 			break;
1155 #ifdef IEEE80211_SUPPORT_MESH
1156 		case IEEE80211_ELEMID_MESHID:
1157 			ies->meshid_ie = ie;
1158 			break;
1159 #endif
1160 		case IEEE80211_ELEMID_VHT_CAP:
1161 			ies->vhtcap_ie = ie;
1162 			break;
1163 		case IEEE80211_ELEMID_VHT_OPMODE:
1164 			ies->vhtopmode_ie = ie;
1165 			break;
1166 		case IEEE80211_ELEMID_VHT_PWR_ENV:
1167 			ies->vhtpwrenv_ie = ie;
1168 			break;
1169 		case IEEE80211_ELEMID_BSSLOAD:
1170 			ies->bssload_ie = ie;
1171 			break;
1172 		case IEEE80211_ELEMID_APCHANREP:
1173 			ies->apchanrep_ie = ie;
1174 			break;
1175 		}
1176 		ielen -= 2 + ie[1];
1177 		ie += 2 + ie[1];
1178 	}
1179 }
1180 
1181 /*
1182  * Reclaim any resources in a node and reset any critical
1183  * state.  Typically nodes are free'd immediately after,
1184  * but in some cases the storage may be reused so we need
1185  * to insure consistent state (should probably fix that).
1186  */
1187 static void
1188 node_cleanup(struct ieee80211_node *ni)
1189 {
1190 	struct ieee80211vap *vap = ni->ni_vap;
1191 	struct ieee80211com *ic = ni->ni_ic;
1192 	int i;
1193 
1194 	/* NB: preserve ni_table */
1195 	if (ni->ni_flags & IEEE80211_NODE_PWR_MGT) {
1196 		if (vap->iv_opmode != IEEE80211_M_STA)
1197 			vap->iv_ps_sta--;
1198 		ni->ni_flags &= ~IEEE80211_NODE_PWR_MGT;
1199 		IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni,
1200 		    "power save mode off, %u sta's in ps mode", vap->iv_ps_sta);
1201 	}
1202 	/*
1203 	 * Cleanup any VHT and HT-related state.
1204 	 */
1205 	if (ni->ni_flags & IEEE80211_NODE_VHT)
1206 		ieee80211_vht_node_cleanup(ni);
1207 	if (ni->ni_flags & IEEE80211_NODE_HT)
1208 		ieee80211_ht_node_cleanup(ni);
1209 #ifdef IEEE80211_SUPPORT_SUPERG
1210 	/* Always do FF node cleanup; for A-MSDU */
1211 	ieee80211_ff_node_cleanup(ni);
1212 #endif
1213 #ifdef IEEE80211_SUPPORT_MESH
1214 	/*
1215 	 * Cleanup any mesh-related state.
1216 	 */
1217 	if (vap->iv_opmode == IEEE80211_M_MBSS)
1218 		ieee80211_mesh_node_cleanup(ni);
1219 #endif
1220 	/*
1221 	 * Clear any staging queue entries.
1222 	 */
1223 	ieee80211_ageq_drain_node(&ic->ic_stageq, ni);
1224 
1225 	/*
1226 	 * Clear AREF flag that marks the authorization refcnt bump
1227 	 * has happened.  This is probably not needed as the node
1228 	 * should always be removed from the table so not found but
1229 	 * do it just in case.
1230 	 * Likewise clear the ASSOCID flag as these flags are intended
1231 	 * to be managed in tandem.
1232 	 */
1233 	ni->ni_flags &= ~(IEEE80211_NODE_AREF | IEEE80211_NODE_ASSOCID);
1234 
1235 	/*
1236 	 * Drain power save queue and, if needed, clear TIM.
1237 	 */
1238 	if (ieee80211_node_psq_drain(ni) != 0 && vap->iv_set_tim != NULL)
1239 		vap->iv_set_tim(ni, 0);
1240 
1241 	ni->ni_associd = 0;
1242 	if (ni->ni_challenge != NULL) {
1243 		IEEE80211_FREE(ni->ni_challenge, M_80211_NODE);
1244 		ni->ni_challenge = NULL;
1245 	}
1246 	/*
1247 	 * Preserve SSID, WPA, and WME ie's so the bss node is
1248 	 * reusable during a re-auth/re-assoc state transition.
1249 	 * If we remove these data they will not be recreated
1250 	 * because they come from a probe-response or beacon frame
1251 	 * which cannot be expected prior to the association-response.
1252 	 * This should not be an issue when operating in other modes
1253 	 * as stations leaving always go through a full state transition
1254 	 * which will rebuild this state.
1255 	 *
1256 	 * XXX does this leave us open to inheriting old state?
1257 	 */
1258 	for (i = 0; i < nitems(ni->ni_rxfrag); i++)
1259 		if (ni->ni_rxfrag[i] != NULL) {
1260 			m_freem(ni->ni_rxfrag[i]);
1261 			ni->ni_rxfrag[i] = NULL;
1262 		}
1263 	/*
1264 	 * Must be careful here to remove any key map entry w/o a LOR.
1265 	 */
1266 	ieee80211_node_delucastkey(ni);
1267 }
1268 
1269 static void
1270 node_free(struct ieee80211_node *ni)
1271 {
1272 	struct ieee80211com *ic = ni->ni_ic;
1273 
1274 	ieee80211_ratectl_node_deinit(ni);
1275 	ic->ic_node_cleanup(ni);
1276 	ieee80211_ies_cleanup(&ni->ni_ies);
1277 	ieee80211_psq_cleanup(&ni->ni_psq);
1278 	IEEE80211_FREE(ni, M_80211_NODE);
1279 }
1280 
1281 static void
1282 node_age(struct ieee80211_node *ni)
1283 {
1284 	struct ieee80211vap *vap = ni->ni_vap;
1285 
1286 	/*
1287 	 * Age frames on the power save queue.
1288 	 */
1289 	if (ieee80211_node_psq_age(ni) != 0 &&
1290 	    ni->ni_psq.psq_len == 0 && vap->iv_set_tim != NULL)
1291 		vap->iv_set_tim(ni, 0);
1292 	/*
1293 	 * Age out HT resources (e.g. frames on the
1294 	 * A-MPDU reorder queues).
1295 	 */
1296 	if (ni->ni_associd != 0 && (ni->ni_flags & IEEE80211_NODE_HT))
1297 		ieee80211_ht_node_age(ni);
1298 }
1299 
1300 static int8_t
1301 node_getrssi(const struct ieee80211_node *ni)
1302 {
1303 	uint32_t avgrssi = ni->ni_avgrssi;
1304 	int32_t rssi;
1305 
1306 	if (avgrssi == IEEE80211_RSSI_DUMMY_MARKER)
1307 		return 0;
1308 	rssi = IEEE80211_RSSI_GET(avgrssi);
1309 	return rssi < 0 ? 0 : rssi > 127 ? 127 : rssi;
1310 }
1311 
1312 static void
1313 node_getsignal(const struct ieee80211_node *ni, int8_t *rssi, int8_t *noise)
1314 {
1315 	*rssi = node_getrssi(ni);
1316 	*noise = ni->ni_noise;
1317 }
1318 
1319 static void
1320 node_getmimoinfo(const struct ieee80211_node *ni,
1321 	struct ieee80211_mimo_info *info)
1322 {
1323 	int i;
1324 	uint32_t avgrssi;
1325 	int32_t rssi;
1326 
1327 	bzero(info, sizeof(*info));
1328 
1329 	for (i = 0; i < MIN(IEEE80211_MAX_CHAINS, ni->ni_mimo_chains); i++) {
1330 		/* Note: for now, just pri20 channel info */
1331 		avgrssi = ni->ni_mimo_rssi_ctl[i];
1332 		if (avgrssi == IEEE80211_RSSI_DUMMY_MARKER) {
1333 			info->ch[i].rssi[0] = 0;
1334 		} else {
1335 			rssi = IEEE80211_RSSI_GET(avgrssi);
1336 			info->ch[i].rssi[0] = rssi < 0 ? 0 : rssi > 127 ? 127 : rssi;
1337 		}
1338 		info->ch[i].noise[0] = ni->ni_mimo_noise_ctl[i];
1339 	}
1340 
1341 	/* XXX ext radios? */
1342 
1343 	/* XXX EVM? */
1344 }
1345 
1346 static void
1347 ieee80211_add_node_nt(struct ieee80211_node_table *nt,
1348     struct ieee80211_node *ni)
1349 {
1350 	struct ieee80211com *ic = nt->nt_ic;
1351 	int hash;
1352 
1353 	IEEE80211_NODE_LOCK_ASSERT(nt);
1354 
1355 	hash = IEEE80211_NODE_HASH(ic, ni->ni_macaddr);
1356 	(void) ic;	/* XXX IEEE80211_NODE_HASH */
1357 	TAILQ_INSERT_TAIL(&nt->nt_node, ni, ni_list);
1358 	LIST_INSERT_HEAD(&nt->nt_hash[hash], ni, ni_hash);
1359 	nt->nt_count++;
1360 	ni->ni_table = nt;
1361 }
1362 
1363 static void
1364 ieee80211_del_node_nt(struct ieee80211_node_table *nt,
1365     struct ieee80211_node *ni)
1366 {
1367 
1368 	IEEE80211_NODE_LOCK_ASSERT(nt);
1369 
1370 	TAILQ_REMOVE(&nt->nt_node, ni, ni_list);
1371 	LIST_REMOVE(ni, ni_hash);
1372 	nt->nt_count--;
1373 	KASSERT(nt->nt_count >= 0,
1374 	    ("nt_count is negative (%d)!\n", nt->nt_count));
1375 	ni->ni_table = NULL;
1376 }
1377 
1378 struct ieee80211_node *
1379 ieee80211_alloc_node(struct ieee80211_node_table *nt,
1380 	struct ieee80211vap *vap, const uint8_t macaddr[IEEE80211_ADDR_LEN])
1381 {
1382 	struct ieee80211com *ic = nt->nt_ic;
1383 	struct ieee80211_node *ni;
1384 
1385 	ni = ic->ic_node_alloc(vap, macaddr);
1386 	if (ni == NULL) {
1387 		vap->iv_stats.is_rx_nodealloc++;
1388 		return NULL;
1389 	}
1390 
1391 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_NODE,
1392 		"%s %p<%s> in %s table\n", __func__, ni,
1393 		ether_sprintf(macaddr), nt->nt_name);
1394 
1395 	IEEE80211_ADDR_COPY(ni->ni_macaddr, macaddr);
1396 	ieee80211_node_initref(ni);		/* mark referenced */
1397 	ni->ni_chan = IEEE80211_CHAN_ANYC;
1398 	ni->ni_authmode = IEEE80211_AUTH_OPEN;
1399 	ni->ni_txpower = ic->ic_txpowlimit;	/* max power */
1400 	ni->ni_txparms = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
1401 	ieee80211_crypto_resetkey(vap, &ni->ni_ucastkey, IEEE80211_KEYIX_NONE);
1402 	ni->ni_avgrssi = IEEE80211_RSSI_DUMMY_MARKER;
1403 	ni->ni_inact_reload = nt->nt_inact_init;
1404 	ni->ni_inact = ni->ni_inact_reload;
1405 	ni->ni_ath_defkeyix = 0x7fff;
1406 	ieee80211_psq_init(&ni->ni_psq, "unknown");
1407 #ifdef IEEE80211_SUPPORT_MESH
1408 	if (vap->iv_opmode == IEEE80211_M_MBSS)
1409 		ieee80211_mesh_node_init(vap, ni);
1410 #endif
1411 	IEEE80211_NODE_LOCK(nt);
1412 	ieee80211_add_node_nt(nt, ni);
1413 	ni->ni_vap = vap;
1414 	ni->ni_ic = ic;
1415 	IEEE80211_NODE_UNLOCK(nt);
1416 
1417 	IEEE80211_NOTE(vap, IEEE80211_MSG_INACT, ni,
1418 	    "%s: inact_reload %u", __func__, ni->ni_inact_reload);
1419 
1420 	return ni;
1421 }
1422 
1423 /*
1424  * Craft a temporary node suitable for sending a management frame
1425  * to the specified station.  We craft only as much state as we
1426  * need to do the work since the node will be immediately reclaimed
1427  * once the send completes.
1428  */
1429 struct ieee80211_node *
1430 ieee80211_tmp_node(struct ieee80211vap *vap,
1431 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1432 {
1433 	struct ieee80211com *ic = vap->iv_ic;
1434 	struct ieee80211_node *ni;
1435 
1436 	ni = ic->ic_node_alloc(vap, macaddr);
1437 	if (ni != NULL) {
1438 		struct ieee80211_node *bss = vap->iv_bss;
1439 
1440 		IEEE80211_DPRINTF(vap, IEEE80211_MSG_NODE,
1441 			"%s %p<%s>\n", __func__, ni, ether_sprintf(macaddr));
1442 
1443 		ni->ni_table = NULL;		/* NB: pedantic */
1444 		ni->ni_ic = ic;			/* NB: needed to set channel */
1445 		ni->ni_vap = vap;
1446 
1447 		IEEE80211_ADDR_COPY(ni->ni_macaddr, macaddr);
1448 		IEEE80211_ADDR_COPY(ni->ni_bssid, bss->ni_bssid);
1449 		ieee80211_node_initref(ni);		/* mark referenced */
1450 		/* NB: required by ieee80211_fix_rate */
1451 		ieee80211_node_set_chan(ni, bss->ni_chan);
1452 		ieee80211_crypto_resetkey(vap, &ni->ni_ucastkey,
1453 			IEEE80211_KEYIX_NONE);
1454 		ni->ni_txpower = bss->ni_txpower;
1455 		/* XXX optimize away */
1456 		ieee80211_psq_init(&ni->ni_psq, "unknown");
1457 
1458 		ieee80211_ratectl_node_init(ni);
1459 	} else {
1460 		/* XXX msg */
1461 		vap->iv_stats.is_rx_nodealloc++;
1462 	}
1463 	return ni;
1464 }
1465 
1466 struct ieee80211_node *
1467 ieee80211_dup_bss(struct ieee80211vap *vap,
1468 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1469 {
1470 	struct ieee80211com *ic = vap->iv_ic;
1471 	struct ieee80211_node *ni;
1472 
1473 	ni = ieee80211_alloc_node(&ic->ic_sta, vap, macaddr);
1474 	if (ni != NULL) {
1475 		struct ieee80211_node *bss = vap->iv_bss;
1476 		/*
1477 		 * Inherit from iv_bss.
1478 		 */
1479 		copy_bss(ni, bss);
1480 		IEEE80211_ADDR_COPY(ni->ni_bssid, bss->ni_bssid);
1481 		ieee80211_node_set_chan(ni, bss->ni_chan);
1482 	}
1483 	return ni;
1484 }
1485 
1486 /*
1487  * Create a bss node for a legacy WDS vap.  The far end does
1488  * not associate so we just create create a new node and
1489  * simulate an association.  The caller is responsible for
1490  * installing the node as the bss node and handling any further
1491  * setup work like authorizing the port.
1492  */
1493 struct ieee80211_node *
1494 ieee80211_node_create_wds(struct ieee80211vap *vap,
1495 	const uint8_t bssid[IEEE80211_ADDR_LEN], struct ieee80211_channel *chan)
1496 {
1497 	struct ieee80211com *ic = vap->iv_ic;
1498 	struct ieee80211_node *ni;
1499 
1500 	/* XXX check if node already in sta table? */
1501 	ni = ieee80211_alloc_node(&ic->ic_sta, vap, bssid);
1502 	if (ni != NULL) {
1503 		ni->ni_wdsvap = vap;
1504 		IEEE80211_ADDR_COPY(ni->ni_bssid, bssid);
1505 		/*
1506 		 * Inherit any manually configured settings.
1507 		 */
1508 		copy_bss(ni, vap->iv_bss);
1509 		ieee80211_node_set_chan(ni, chan);
1510 		/* NB: propagate ssid so available to WPA supplicant */
1511 		ni->ni_esslen = vap->iv_des_ssid[0].len;
1512 		memcpy(ni->ni_essid, vap->iv_des_ssid[0].ssid, ni->ni_esslen);
1513 		/* NB: no associd for peer */
1514 		/*
1515 		 * There are no management frames to use to
1516 		 * discover neighbor capabilities, so blindly
1517 		 * propagate the local configuration.
1518 		 */
1519 		if (vap->iv_flags & IEEE80211_F_WME)
1520 			ni->ni_flags |= IEEE80211_NODE_QOS;
1521 #ifdef IEEE80211_SUPPORT_SUPERG
1522 		if (vap->iv_flags & IEEE80211_F_FF)
1523 			ni->ni_flags |= IEEE80211_NODE_FF;
1524 #endif
1525 		/* XXX VHT */
1526 		if ((ic->ic_htcaps & IEEE80211_HTC_HT) &&
1527 		    (vap->iv_flags_ht & IEEE80211_FHT_HT)) {
1528 			/*
1529 			 * Device is HT-capable and HT is enabled for
1530 			 * the vap; setup HT operation.  On return
1531 			 * ni_chan will be adjusted to an HT channel.
1532 			 */
1533 			ieee80211_ht_wds_init(ni);
1534 			if (vap->iv_flags_vht & IEEE80211_FVHT_VHT) {
1535 				printf("%s: TODO: vht_wds_init\n", __func__);
1536 			}
1537 		} else {
1538 			struct ieee80211_channel *c = ni->ni_chan;
1539 			/*
1540 			 * Force a legacy channel to be used.
1541 			 */
1542 			c = ieee80211_find_channel(ic,
1543 			    c->ic_freq, c->ic_flags &~ IEEE80211_CHAN_HT);
1544 			KASSERT(c != NULL, ("no legacy channel, %u/%x",
1545 			    ni->ni_chan->ic_freq, ni->ni_chan->ic_flags));
1546 			ni->ni_chan = c;
1547 		}
1548 	}
1549 	return ni;
1550 }
1551 
1552 struct ieee80211_node *
1553 #ifdef IEEE80211_DEBUG_REFCNT
1554 ieee80211_find_node_locked_debug(struct ieee80211_node_table *nt,
1555 	const uint8_t macaddr[IEEE80211_ADDR_LEN], const char *func, int line)
1556 #else
1557 ieee80211_find_node_locked(struct ieee80211_node_table *nt,
1558 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1559 #endif
1560 {
1561 	struct ieee80211_node *ni;
1562 	int hash;
1563 
1564 	IEEE80211_NODE_LOCK_ASSERT(nt);
1565 
1566 	hash = IEEE80211_NODE_HASH(nt->nt_ic, macaddr);
1567 	LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) {
1568 		if (IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr)) {
1569 			ieee80211_ref_node(ni);	/* mark referenced */
1570 #ifdef IEEE80211_DEBUG_REFCNT
1571 			IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
1572 			    "%s (%s:%u) %p<%s> refcnt %d\n", __func__,
1573 			    func, line,
1574 			    ni, ether_sprintf(ni->ni_macaddr),
1575 			    ieee80211_node_refcnt(ni));
1576 #endif
1577 			return ni;
1578 		}
1579 	}
1580 	return NULL;
1581 }
1582 
1583 struct ieee80211_node *
1584 #ifdef IEEE80211_DEBUG_REFCNT
1585 ieee80211_find_node_debug(struct ieee80211_node_table *nt,
1586 	const uint8_t macaddr[IEEE80211_ADDR_LEN], const char *func, int line)
1587 #else
1588 ieee80211_find_node(struct ieee80211_node_table *nt,
1589 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1590 #endif
1591 {
1592 	struct ieee80211_node *ni;
1593 
1594 	IEEE80211_NODE_LOCK(nt);
1595 	ni = ieee80211_find_node_locked(nt, macaddr);
1596 	IEEE80211_NODE_UNLOCK(nt);
1597 	return ni;
1598 }
1599 
1600 struct ieee80211_node *
1601 #ifdef IEEE80211_DEBUG_REFCNT
1602 ieee80211_find_vap_node_locked_debug(struct ieee80211_node_table *nt,
1603 	const struct ieee80211vap *vap,
1604 	const uint8_t macaddr[IEEE80211_ADDR_LEN], const char *func, int line)
1605 #else
1606 ieee80211_find_vap_node_locked(struct ieee80211_node_table *nt,
1607 	const struct ieee80211vap *vap,
1608 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1609 #endif
1610 {
1611 	struct ieee80211_node *ni;
1612 	int hash;
1613 
1614 	IEEE80211_NODE_LOCK_ASSERT(nt);
1615 
1616 	hash = IEEE80211_NODE_HASH(nt->nt_ic, macaddr);
1617 	LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) {
1618 		if (ni->ni_vap == vap &&
1619 		    IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr)) {
1620 			ieee80211_ref_node(ni);	/* mark referenced */
1621 #ifdef IEEE80211_DEBUG_REFCNT
1622 			IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
1623 			    "%s (%s:%u) %p<%s> refcnt %d\n", __func__,
1624 			    func, line,
1625 			    ni, ether_sprintf(ni->ni_macaddr),
1626 			    ieee80211_node_refcnt(ni));
1627 #endif
1628 			return ni;
1629 		}
1630 	}
1631 	return NULL;
1632 }
1633 
1634 struct ieee80211_node *
1635 #ifdef IEEE80211_DEBUG_REFCNT
1636 ieee80211_find_vap_node_debug(struct ieee80211_node_table *nt,
1637 	const struct ieee80211vap *vap,
1638 	const uint8_t macaddr[IEEE80211_ADDR_LEN], const char *func, int line)
1639 #else
1640 ieee80211_find_vap_node(struct ieee80211_node_table *nt,
1641 	const struct ieee80211vap *vap,
1642 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1643 #endif
1644 {
1645 	struct ieee80211_node *ni;
1646 
1647 	IEEE80211_NODE_LOCK(nt);
1648 	ni = ieee80211_find_vap_node_locked(nt, vap, macaddr);
1649 	IEEE80211_NODE_UNLOCK(nt);
1650 	return ni;
1651 }
1652 
1653 /*
1654  * Fake up a node; this handles node discovery in adhoc mode.
1655  * Note that for the driver's benefit we we treat this like
1656  * an association so the driver has an opportunity to setup
1657  * it's private state.
1658  */
1659 struct ieee80211_node *
1660 ieee80211_fakeup_adhoc_node(struct ieee80211vap *vap,
1661 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
1662 {
1663 	struct ieee80211_node *ni;
1664 
1665 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_NODE | IEEE80211_MSG_ASSOC,
1666 	    "%s: mac<%s>\n", __func__, ether_sprintf(macaddr));
1667 	ni = ieee80211_dup_bss(vap, macaddr);
1668 	if (ni != NULL) {
1669 		struct ieee80211com *ic = vap->iv_ic;
1670 
1671 		/* XXX no rate negotiation; just dup */
1672 		ni->ni_rates = vap->iv_bss->ni_rates;
1673 		if (ieee80211_iserp_rateset(&ni->ni_rates))
1674 			ni->ni_flags |= IEEE80211_NODE_ERP;
1675 		if (vap->iv_opmode == IEEE80211_M_AHDEMO) {
1676 			/*
1677 			 * In adhoc demo mode there are no management
1678 			 * frames to use to discover neighbor capabilities,
1679 			 * so blindly propagate the local configuration
1680 			 * so we can do interesting things (e.g. use
1681 			 * WME to disable ACK's).
1682 			 */
1683 			/*
1684 			 * XXX TODO: 11n?
1685 			 */
1686 			if (vap->iv_flags & IEEE80211_F_WME)
1687 				ni->ni_flags |= IEEE80211_NODE_QOS;
1688 #ifdef IEEE80211_SUPPORT_SUPERG
1689 			if (vap->iv_flags & IEEE80211_F_FF)
1690 				ni->ni_flags |= IEEE80211_NODE_FF;
1691 #endif
1692 		}
1693 		ieee80211_node_setuptxparms(ni);
1694 		ieee80211_ratectl_node_init(ni);
1695 
1696 		/*
1697 		 * XXX TODO: 11n? At least 20MHz, at least A-MPDU RX,
1698 		 * not A-MPDU TX; not 11n rates, etc.  We'll cycle
1699 		 * that after we hear that we can indeed do 11n
1700 		 * (either by a beacon frame or by a probe response.)
1701 		 */
1702 
1703 		/*
1704 		 * This is the first time we see the node.
1705 		 */
1706 		if (ic->ic_newassoc != NULL)
1707 			ic->ic_newassoc(ni, 1);
1708 
1709 		/*
1710 		 * Kick off a probe request to the given node;
1711 		 * we will then use the probe response to update
1712 		 * 11n/etc configuration state.
1713 		 *
1714 		 * XXX TODO: this isn't guaranteed, and until we get
1715 		 * a probe response, we won't be able to actually
1716 		 * do anything 802.11n related to the node.
1717 		 * So if this does indeed work, maybe we should hold
1718 		 * off on sending responses until we get the probe
1719 		 * response, or just default to some sensible subset
1720 		 * of 802.11n behaviour (eg always allow aggregation
1721 		 * negotiation TO us, but not FROM us, etc) so we
1722 		 * aren't entirely busted.
1723 		 */
1724 		if (vap->iv_opmode == IEEE80211_M_IBSS) {
1725 			ieee80211_send_probereq(ni, /* node */
1726 				vap->iv_myaddr, /* SA */
1727 				ni->ni_macaddr, /* DA */
1728 				vap->iv_bss->ni_bssid, /* BSSID */
1729 				vap->iv_bss->ni_essid,
1730 				vap->iv_bss->ni_esslen); /* SSID */
1731 		}
1732 
1733 		/* XXX not right for 802.1x/WPA */
1734 		ieee80211_node_authorize(ni);
1735 	}
1736 	return ni;
1737 }
1738 
1739 void
1740 ieee80211_init_neighbor(struct ieee80211_node *ni,
1741 	const struct ieee80211_frame *wh,
1742 	const struct ieee80211_scanparams *sp)
1743 {
1744 	int do_ht_setup = 0, do_vht_setup = 0;
1745 
1746 	ni->ni_esslen = sp->ssid[1];
1747 	memcpy(ni->ni_essid, sp->ssid + 2, sp->ssid[1]);
1748 	IEEE80211_ADDR_COPY(ni->ni_bssid, wh->i_addr3);
1749 	memcpy(ni->ni_tstamp.data, sp->tstamp, sizeof(ni->ni_tstamp));
1750 	ni->ni_intval = sp->bintval;
1751 	ni->ni_capinfo = sp->capinfo;
1752 	ni->ni_chan = ni->ni_ic->ic_curchan;
1753 	ni->ni_fhdwell = sp->fhdwell;
1754 	ni->ni_fhindex = sp->fhindex;
1755 	ni->ni_erp = sp->erp;
1756 	ni->ni_timoff = sp->timoff;
1757 #ifdef IEEE80211_SUPPORT_MESH
1758 	if (ni->ni_vap->iv_opmode == IEEE80211_M_MBSS)
1759 		ieee80211_mesh_init_neighbor(ni, wh, sp);
1760 #endif
1761 	if (ieee80211_ies_init(&ni->ni_ies, sp->ies, sp->ies_len)) {
1762 		ieee80211_ies_expand(&ni->ni_ies);
1763 		if (ni->ni_ies.wme_ie != NULL)
1764 			ni->ni_flags |= IEEE80211_NODE_QOS;
1765 		else
1766 			ni->ni_flags &= ~IEEE80211_NODE_QOS;
1767 #ifdef IEEE80211_SUPPORT_SUPERG
1768 		if (ni->ni_ies.ath_ie != NULL)
1769 			ieee80211_parse_ath(ni, ni->ni_ies.ath_ie);
1770 #endif
1771 		if (ni->ni_ies.htcap_ie != NULL)
1772 			ieee80211_parse_htcap(ni, ni->ni_ies.htcap_ie);
1773 		if (ni->ni_ies.htinfo_ie != NULL)
1774 			ieee80211_parse_htinfo(ni, ni->ni_ies.htinfo_ie);
1775 
1776 		if (ni->ni_ies.vhtcap_ie != NULL)
1777 			ieee80211_parse_vhtcap(ni, ni->ni_ies.vhtcap_ie);
1778 		if (ni->ni_ies.vhtopmode_ie != NULL)
1779 			ieee80211_parse_vhtopmode(ni, ni->ni_ies.vhtopmode_ie);
1780 
1781 		if ((ni->ni_ies.htcap_ie != NULL) &&
1782 		    (ni->ni_ies.htinfo_ie != NULL) &&
1783 		    (ni->ni_vap->iv_flags_ht & IEEE80211_FHT_HT)) {
1784 			do_ht_setup = 1;
1785 		}
1786 
1787 		if ((ni->ni_ies.vhtcap_ie != NULL) &&
1788 		    (ni->ni_ies.vhtopmode_ie != NULL) &&
1789 		    (ni->ni_vap->iv_flags_vht & IEEE80211_FVHT_VHT)) {
1790 			do_vht_setup = 1;
1791 		}
1792 
1793 	}
1794 
1795 	/* NB: must be after ni_chan is setup */
1796 	ieee80211_setup_rates(ni, sp->rates, sp->xrates,
1797 		IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE |
1798 		IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
1799 
1800 	/*
1801 	 * If the neighbor is HT compatible, flip that on.
1802 	 */
1803 	if (do_ht_setup) {
1804 		IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_ASSOC,
1805 		    "%s: doing HT setup\n", __func__);
1806 		ieee80211_ht_node_init(ni);
1807 		ieee80211_ht_updateparams(ni,
1808 		    ni->ni_ies.htcap_ie,
1809 		    ni->ni_ies.htinfo_ie);
1810 
1811 		if (do_vht_setup) {
1812 			if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) {
1813 				printf("%s: BSS %6D: 2GHz channel, VHT info; ignoring\n",
1814 				    __func__,
1815 				    ni->ni_macaddr,
1816 				    ":");
1817 			} else {
1818 				ieee80211_vht_node_init(ni);
1819 				ieee80211_vht_updateparams(ni,
1820 				    ni->ni_ies.vhtcap_ie,
1821 				    ni->ni_ies.vhtopmode_ie);
1822 				ieee80211_setup_vht_rates(ni,
1823 				    ni->ni_ies.vhtcap_ie,
1824 				    ni->ni_ies.vhtopmode_ie);
1825 			}
1826 		}
1827 
1828 		/*
1829 		 * Finally do the channel upgrade/change based
1830 		 * on the HT/VHT configuration.
1831 		 */
1832 		ieee80211_ht_updateparams_final(ni, ni->ni_ies.htcap_ie,
1833 		    ni->ni_ies.htinfo_ie);
1834 		ieee80211_setup_htrates(ni,
1835 		    ni->ni_ies.htcap_ie,
1836 		    IEEE80211_F_JOIN | IEEE80211_F_DOBRS);
1837 		ieee80211_setup_basic_htrates(ni,
1838 		    ni->ni_ies.htinfo_ie);
1839 
1840 		ieee80211_node_setuptxparms(ni);
1841 		ieee80211_ratectl_node_init(ni);
1842 
1843 		/* Reassociate; we're now 11n/11ac */
1844 		/*
1845 		 * XXX TODO: this is the wrong thing to do -
1846 		 * we're calling it with isnew=1 so the ath(4)
1847 		 * driver reinitialises the rate tables.
1848 		 * This "mostly" works for ath(4), but it won't
1849 		 * be right for firmware devices which allocate
1850 		 * node states.
1851 		 *
1852 		 * So, do we just create a new node and delete
1853 		 * the old one? Or?
1854 		 */
1855 		if (ni->ni_ic->ic_newassoc)
1856 			ni->ni_ic->ic_newassoc(ni, 1);
1857 	}
1858 }
1859 
1860 /*
1861  * Do node discovery in adhoc mode on receipt of a beacon
1862  * or probe response frame.  Note that for the driver's
1863  * benefit we we treat this like an association so the
1864  * driver has an opportunity to setup it's private state.
1865  */
1866 struct ieee80211_node *
1867 ieee80211_add_neighbor(struct ieee80211vap *vap,
1868 	const struct ieee80211_frame *wh,
1869 	const struct ieee80211_scanparams *sp)
1870 {
1871 	struct ieee80211_node *ni;
1872 
1873 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_ASSOC,
1874 	    "%s: mac<%s>\n", __func__, ether_sprintf(wh->i_addr2));
1875 	ni = ieee80211_dup_bss(vap, wh->i_addr2);/* XXX alloc_node? */
1876 	if (ni != NULL) {
1877 		struct ieee80211com *ic = vap->iv_ic;
1878 
1879 		ieee80211_init_neighbor(ni, wh, sp);
1880 		if (ieee80211_iserp_rateset(&ni->ni_rates))
1881 			ni->ni_flags |= IEEE80211_NODE_ERP;
1882 		ieee80211_node_setuptxparms(ni);
1883 		ieee80211_ratectl_node_init(ni);
1884 		if (ic->ic_newassoc != NULL)
1885 			ic->ic_newassoc(ni, 1);
1886 		/* XXX not right for 802.1x/WPA */
1887 		ieee80211_node_authorize(ni);
1888 	}
1889 	return ni;
1890 }
1891 
1892 #define	IS_PROBEREQ(wh) \
1893 	((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK|IEEE80211_FC0_SUBTYPE_MASK)) \
1894 	    == (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_REQ))
1895 #define	IS_BCAST_PROBEREQ(wh) \
1896 	(IS_PROBEREQ(wh) && IEEE80211_IS_MULTICAST( \
1897 	    ((const struct ieee80211_frame *)(wh))->i_addr3))
1898 
1899 static __inline struct ieee80211_node *
1900 _find_rxnode(struct ieee80211_node_table *nt,
1901     const struct ieee80211_frame_min *wh)
1902 {
1903 	if (IS_BCAST_PROBEREQ(wh))
1904 		return NULL;		/* spam bcast probe req to all vap's */
1905 	return ieee80211_find_node_locked(nt, wh->i_addr2);
1906 }
1907 
1908 /*
1909  * Locate the node for sender, track state, and then pass the
1910  * (referenced) node up to the 802.11 layer for its use.  Note
1911  * we can return NULL if the sender is not in the table.
1912  */
1913 struct ieee80211_node *
1914 #ifdef IEEE80211_DEBUG_REFCNT
1915 ieee80211_find_rxnode_debug(struct ieee80211com *ic,
1916 	const struct ieee80211_frame_min *wh, const char *func, int line)
1917 #else
1918 ieee80211_find_rxnode(struct ieee80211com *ic,
1919 	const struct ieee80211_frame_min *wh)
1920 #endif
1921 {
1922 	struct ieee80211_node_table *nt;
1923 	struct ieee80211_node *ni;
1924 
1925 	nt = &ic->ic_sta;
1926 	IEEE80211_NODE_LOCK(nt);
1927 	ni = _find_rxnode(nt, wh);
1928 	IEEE80211_NODE_UNLOCK(nt);
1929 
1930 	return ni;
1931 }
1932 
1933 /*
1934  * Like ieee80211_find_rxnode but use the supplied h/w
1935  * key index as a hint to locate the node in the key
1936  * mapping table.  If an entry is present at the key
1937  * index we return it; otherwise do a normal lookup and
1938  * update the mapping table if the station has a unicast
1939  * key assigned to it.
1940  */
1941 struct ieee80211_node *
1942 #ifdef IEEE80211_DEBUG_REFCNT
1943 ieee80211_find_rxnode_withkey_debug(struct ieee80211com *ic,
1944 	const struct ieee80211_frame_min *wh, ieee80211_keyix keyix,
1945 	const char *func, int line)
1946 #else
1947 ieee80211_find_rxnode_withkey(struct ieee80211com *ic,
1948 	const struct ieee80211_frame_min *wh, ieee80211_keyix keyix)
1949 #endif
1950 {
1951 	struct ieee80211_node_table *nt;
1952 	struct ieee80211_node *ni;
1953 
1954 	nt = &ic->ic_sta;
1955 	IEEE80211_NODE_LOCK(nt);
1956 	if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax)
1957 		ni = nt->nt_keyixmap[keyix];
1958 	else
1959 		ni = NULL;
1960 	if (ni == NULL) {
1961 		ni = _find_rxnode(nt, wh);
1962 		if (ni != NULL && nt->nt_keyixmap != NULL) {
1963 			/*
1964 			 * If the station has a unicast key cache slot
1965 			 * assigned update the key->node mapping table.
1966 			 */
1967 			keyix = ni->ni_ucastkey.wk_rxkeyix;
1968 			/* XXX can keyixmap[keyix] != NULL? */
1969 			if (keyix < nt->nt_keyixmax &&
1970 			    nt->nt_keyixmap[keyix] == NULL) {
1971 				IEEE80211_DPRINTF(ni->ni_vap,
1972 				    IEEE80211_MSG_NODE,
1973 				    "%s: add key map entry %p<%s> refcnt %d\n",
1974 				    __func__, ni, ether_sprintf(ni->ni_macaddr),
1975 				    ieee80211_node_refcnt(ni)+1);
1976 				nt->nt_keyixmap[keyix] = ieee80211_ref_node(ni);
1977 			}
1978 		}
1979 	} else {
1980 		if (IS_BCAST_PROBEREQ(wh))
1981 			ni = NULL;	/* spam bcast probe req to all vap's */
1982 		else
1983 			ieee80211_ref_node(ni);
1984 	}
1985 	IEEE80211_NODE_UNLOCK(nt);
1986 
1987 	return ni;
1988 }
1989 #undef IS_BCAST_PROBEREQ
1990 #undef IS_PROBEREQ
1991 
1992 /*
1993  * Return a reference to the appropriate node for sending
1994  * a data frame.  This handles node discovery in adhoc networks.
1995  */
1996 struct ieee80211_node *
1997 #ifdef IEEE80211_DEBUG_REFCNT
1998 ieee80211_find_txnode_debug(struct ieee80211vap *vap,
1999 	const uint8_t macaddr[IEEE80211_ADDR_LEN],
2000 	const char *func, int line)
2001 #else
2002 ieee80211_find_txnode(struct ieee80211vap *vap,
2003 	const uint8_t macaddr[IEEE80211_ADDR_LEN])
2004 #endif
2005 {
2006 	struct ieee80211_node_table *nt = &vap->iv_ic->ic_sta;
2007 	struct ieee80211_node *ni;
2008 
2009 	/*
2010 	 * The destination address should be in the node table
2011 	 * unless this is a multicast/broadcast frame.  We can
2012 	 * also optimize station mode operation, all frames go
2013 	 * to the bss node.
2014 	 */
2015 	/* XXX can't hold lock across dup_bss 'cuz of recursive locking */
2016 	IEEE80211_NODE_LOCK(nt);
2017 	if (vap->iv_opmode == IEEE80211_M_STA ||
2018 	    vap->iv_opmode == IEEE80211_M_WDS ||
2019 	    IEEE80211_IS_MULTICAST(macaddr))
2020 		ni = ieee80211_ref_node(vap->iv_bss);
2021 	else
2022 		ni = ieee80211_find_node_locked(nt, macaddr);
2023 	IEEE80211_NODE_UNLOCK(nt);
2024 
2025 	if (ni == NULL) {
2026 		if (vap->iv_opmode == IEEE80211_M_IBSS ||
2027 		    vap->iv_opmode == IEEE80211_M_AHDEMO) {
2028 			/*
2029 			 * In adhoc mode cons up a node for the destination.
2030 			 * Note that we need an additional reference for the
2031 			 * caller to be consistent with
2032 			 * ieee80211_find_node_locked.
2033 			 */
2034 			/*
2035 			 * XXX TODO: this doesn't fake up 11n state; we need
2036 			 * to find another way to get it upgraded.
2037 			 */
2038 			ni = ieee80211_fakeup_adhoc_node(vap, macaddr);
2039 			if (ni != NULL)
2040 				(void) ieee80211_ref_node(ni);
2041 		} else {
2042 			IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_OUTPUT, macaddr,
2043 			    "no node, discard frame (%s)", __func__);
2044 			vap->iv_stats.is_tx_nonode++;
2045 		}
2046 	}
2047 	return ni;
2048 }
2049 
2050 static void
2051 _ieee80211_free_node(struct ieee80211_node *ni)
2052 {
2053 	struct ieee80211_node_table *nt = ni->ni_table;
2054 
2055 	/*
2056 	 * NB: careful about referencing the vap as it may be
2057 	 * gone if the last reference was held by a driver.
2058 	 * We know the com will always be present so it's safe
2059 	 * to use ni_ic below to reclaim resources.
2060 	 */
2061 #if 0
2062 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_NODE,
2063 		"%s %p<%s> in %s table\n", __func__, ni,
2064 		ether_sprintf(ni->ni_macaddr),
2065 		nt != NULL ? nt->nt_name : "<gone>");
2066 #endif
2067 	if (ni->ni_associd != 0) {
2068 		struct ieee80211vap *vap = ni->ni_vap;
2069 		if (vap->iv_aid_bitmap != NULL)
2070 			IEEE80211_AID_CLR(vap, ni->ni_associd);
2071 	}
2072 	if (nt != NULL)
2073 		ieee80211_del_node_nt(nt, ni);
2074 	ni->ni_ic->ic_node_free(ni);
2075 }
2076 
2077 /*
2078  * Clear any entry in the unicast key mapping table.
2079  */
2080 static int
2081 node_clear_keyixmap(struct ieee80211_node_table *nt, struct ieee80211_node *ni)
2082 {
2083 	ieee80211_keyix keyix;
2084 
2085 	keyix = ni->ni_ucastkey.wk_rxkeyix;
2086 	if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax &&
2087 	    nt->nt_keyixmap[keyix] == ni) {
2088 		IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
2089 			"%s: %p<%s> clear key map entry %u\n",
2090 			__func__, ni, ether_sprintf(ni->ni_macaddr), keyix);
2091 		nt->nt_keyixmap[keyix] = NULL;
2092 		ieee80211_node_decref(ni);
2093 		return 1;
2094 	}
2095 
2096 	return 0;
2097 }
2098 
2099 void
2100 #ifdef IEEE80211_DEBUG_REFCNT
2101 ieee80211_free_node_debug(struct ieee80211_node *ni, const char *func, int line)
2102 #else
2103 ieee80211_free_node(struct ieee80211_node *ni)
2104 #endif
2105 {
2106 	struct ieee80211_node_table *nt = ni->ni_table;
2107 
2108 #ifdef IEEE80211_DEBUG_REFCNT
2109 	IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
2110 		"%s (%s:%u) %p<%s> refcnt %d\n", __func__, func, line, ni,
2111 		 ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni)-1);
2112 #endif
2113 	if (nt != NULL) {
2114 		IEEE80211_NODE_LOCK(nt);
2115 		if (ieee80211_node_dectestref(ni)) {
2116 			/*
2117 			 * Last reference, reclaim state.
2118 			 */
2119 			_ieee80211_free_node(ni);
2120 		} else if (ieee80211_node_refcnt(ni) == 1)
2121 			if (node_clear_keyixmap(nt, ni))
2122 				_ieee80211_free_node(ni);
2123 		IEEE80211_NODE_UNLOCK(nt);
2124 	} else {
2125 		if (ieee80211_node_dectestref(ni))
2126 			_ieee80211_free_node(ni);
2127 	}
2128 }
2129 
2130 /*
2131  * Reclaim a unicast key and clear any key cache state.
2132  */
2133 int
2134 ieee80211_node_delucastkey(struct ieee80211_node *ni)
2135 {
2136 	struct ieee80211com *ic = ni->ni_ic;
2137 	struct ieee80211_node_table *nt = &ic->ic_sta;
2138 	struct ieee80211_node *nikey;
2139 	ieee80211_keyix keyix;
2140 	int isowned, status;
2141 
2142 	/*
2143 	 * NB: We must beware of LOR here; deleting the key
2144 	 * can cause the crypto layer to block traffic updates
2145 	 * which can generate a LOR against the node table lock;
2146 	 * grab it here and stash the key index for our use below.
2147 	 *
2148 	 * Must also beware of recursion on the node table lock.
2149 	 * When called from node_cleanup we may already have
2150 	 * the node table lock held.  Unfortunately there's no
2151 	 * way to separate out this path so we must do this
2152 	 * conditionally.
2153 	 */
2154 	isowned = IEEE80211_NODE_IS_LOCKED(nt);
2155 	if (!isowned)
2156 		IEEE80211_NODE_LOCK(nt);
2157 	nikey = NULL;
2158 	status = 1;		/* NB: success */
2159 	if (ni->ni_ucastkey.wk_keyix != IEEE80211_KEYIX_NONE) {
2160 		keyix = ni->ni_ucastkey.wk_rxkeyix;
2161 		status = ieee80211_crypto_delkey(ni->ni_vap, &ni->ni_ucastkey);
2162 		if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax) {
2163 			nikey = nt->nt_keyixmap[keyix];
2164 			nt->nt_keyixmap[keyix] = NULL;
2165 		}
2166 	}
2167 	if (!isowned)
2168 		IEEE80211_NODE_UNLOCK(nt);
2169 
2170 	if (nikey != NULL) {
2171 		KASSERT(nikey == ni,
2172 			("key map out of sync, ni %p nikey %p", ni, nikey));
2173 		IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
2174 			"%s: delete key map entry %p<%s> refcnt %d\n",
2175 			__func__, ni, ether_sprintf(ni->ni_macaddr),
2176 			ieee80211_node_refcnt(ni)-1);
2177 		ieee80211_free_node(ni);
2178 	}
2179 	return status;
2180 }
2181 
2182 /*
2183  * Reclaim a node.  If this is the last reference count then
2184  * do the normal free work.  Otherwise remove it from the node
2185  * table and mark it gone by clearing the back-reference.
2186  */
2187 static void
2188 node_reclaim(struct ieee80211_node_table *nt, struct ieee80211_node *ni)
2189 {
2190 
2191 	IEEE80211_NODE_LOCK_ASSERT(nt);
2192 
2193 	IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
2194 		"%s: remove %p<%s> from %s table, refcnt %d\n",
2195 		__func__, ni, ether_sprintf(ni->ni_macaddr),
2196 		nt->nt_name, ieee80211_node_refcnt(ni)-1);
2197 	/*
2198 	 * Clear any entry in the unicast key mapping table.
2199 	 * We need to do it here so rx lookups don't find it
2200 	 * in the mapping table even if it's not in the hash
2201 	 * table.  We cannot depend on the mapping table entry
2202 	 * being cleared because the node may not be free'd.
2203 	 */
2204 	(void)node_clear_keyixmap(nt, ni);
2205 	if (!ieee80211_node_dectestref(ni)) {
2206 		/*
2207 		 * Other references are present, just remove the
2208 		 * node from the table so it cannot be found.  When
2209 		 * the references are dropped storage will be
2210 		 * reclaimed.
2211 		 */
2212 		ieee80211_del_node_nt(nt, ni);
2213 	} else
2214 		_ieee80211_free_node(ni);
2215 }
2216 
2217 /*
2218  * Node table support.
2219  */
2220 
2221 static void
2222 ieee80211_node_table_init(struct ieee80211com *ic,
2223 	struct ieee80211_node_table *nt,
2224 	const char *name, int inact, int keyixmax)
2225 {
2226 
2227 	nt->nt_ic = ic;
2228 	IEEE80211_NODE_LOCK_INIT(nt, ic->ic_name);
2229 	TAILQ_INIT(&nt->nt_node);
2230 	nt->nt_count = 0;
2231 	nt->nt_name = name;
2232 	nt->nt_inact_init = inact;
2233 	nt->nt_keyixmax = keyixmax;
2234 	if (nt->nt_keyixmax > 0) {
2235 		nt->nt_keyixmap = (struct ieee80211_node **) IEEE80211_MALLOC(
2236 			keyixmax * sizeof(struct ieee80211_node *),
2237 			M_80211_NODE,
2238 			IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
2239 		if (nt->nt_keyixmap == NULL)
2240 			ic_printf(ic,
2241 			    "Cannot allocate key index map with %u entries\n",
2242 			    keyixmax);
2243 	} else
2244 		nt->nt_keyixmap = NULL;
2245 }
2246 
2247 static void
2248 ieee80211_node_table_reset(struct ieee80211_node_table *nt,
2249 	struct ieee80211vap *match)
2250 {
2251 	struct ieee80211_node *ni, *next;
2252 
2253 	IEEE80211_NODE_LOCK(nt);
2254 	TAILQ_FOREACH_SAFE(ni, &nt->nt_node, ni_list, next) {
2255 		if (match != NULL && ni->ni_vap != match)
2256 			continue;
2257 		/* XXX can this happen?  if so need's work */
2258 		if (ni->ni_associd != 0) {
2259 			struct ieee80211vap *vap = ni->ni_vap;
2260 
2261 			if (vap->iv_auth->ia_node_leave != NULL)
2262 				vap->iv_auth->ia_node_leave(ni);
2263 			if (vap->iv_aid_bitmap != NULL)
2264 				IEEE80211_AID_CLR(vap, ni->ni_associd);
2265 		}
2266 		ni->ni_wdsvap = NULL;		/* clear reference */
2267 		node_reclaim(nt, ni);
2268 	}
2269 	if (match != NULL && match->iv_opmode == IEEE80211_M_WDS) {
2270 		/*
2271 		 * Make a separate pass to clear references to this vap
2272 		 * held by DWDS entries.  They will not be matched above
2273 		 * because ni_vap will point to the ap vap but we still
2274 		 * need to clear ni_wdsvap when the WDS vap is destroyed
2275 		 * and/or reset.
2276 		 */
2277 		TAILQ_FOREACH_SAFE(ni, &nt->nt_node, ni_list, next)
2278 			if (ni->ni_wdsvap == match)
2279 				ni->ni_wdsvap = NULL;
2280 	}
2281 	IEEE80211_NODE_UNLOCK(nt);
2282 }
2283 
2284 static void
2285 ieee80211_node_table_cleanup(struct ieee80211_node_table *nt)
2286 {
2287 	ieee80211_node_table_reset(nt, NULL);
2288 	if (nt->nt_keyixmap != NULL) {
2289 #ifdef DIAGNOSTIC
2290 		/* XXX verify all entries are NULL */
2291 		int i;
2292 		for (i = 0; i < nt->nt_keyixmax; i++)
2293 			if (nt->nt_keyixmap[i] != NULL)
2294 				printf("%s: %s[%u] still active\n", __func__,
2295 					nt->nt_name, i);
2296 #endif
2297 		IEEE80211_FREE(nt->nt_keyixmap, M_80211_NODE);
2298 		nt->nt_keyixmap = NULL;
2299 	}
2300 	IEEE80211_NODE_LOCK_DESTROY(nt);
2301 }
2302 
2303 static void
2304 timeout_stations(void *arg __unused, struct ieee80211_node *ni)
2305 {
2306 	struct ieee80211com *ic = ni->ni_ic;
2307 	struct ieee80211vap *vap = ni->ni_vap;
2308 
2309 	/*
2310 	 * Only process stations when in RUN state.  This
2311 	 * insures, for example, that we don't timeout an
2312 	 * inactive station during CAC.  Note that CSA state
2313 	 * is actually handled in ieee80211_node_timeout as
2314 	 * it applies to more than timeout processing.
2315 	 */
2316 	if (vap->iv_state != IEEE80211_S_RUN)
2317 		return;
2318 	/*
2319 	 * Ignore entries for which have yet to receive an
2320 	 * authentication frame.  These are transient and
2321 	 * will be reclaimed when the last reference to them
2322 	 * goes away (when frame xmits complete).
2323 	 */
2324 	if ((vap->iv_opmode == IEEE80211_M_HOSTAP ||
2325 	     vap->iv_opmode == IEEE80211_M_STA) &&
2326 	    (ni->ni_flags & IEEE80211_NODE_AREF) == 0)
2327 		return;
2328 	/*
2329 	 * Free fragment if not needed anymore
2330 	 * (last fragment older than 1s).
2331 	 * XXX doesn't belong here, move to node_age
2332 	 */
2333 	if (ni->ni_rxfrag[0] != NULL &&
2334 	    ticks > ni->ni_rxfragstamp + hz) {
2335 		m_freem(ni->ni_rxfrag[0]);
2336 		ni->ni_rxfrag[0] = NULL;
2337 	}
2338 	if (ni->ni_inact > 0) {
2339 		ni->ni_inact--;
2340 		IEEE80211_NOTE(vap, IEEE80211_MSG_INACT, ni,
2341 		    "%s: inact %u inact_reload %u nrates %u",
2342 		    __func__, ni->ni_inact, ni->ni_inact_reload,
2343 		    ni->ni_rates.rs_nrates);
2344 	}
2345 	/*
2346 	 * Special case ourself; we may be idle for extended periods
2347 	 * of time and regardless reclaiming our state is wrong.
2348 	 * XXX run ic_node_age
2349 	 */
2350 	/* XXX before inact decrement? */
2351 	if (ni == vap->iv_bss)
2352 		return;
2353 	if (ni->ni_associd != 0 ||
2354 	    (vap->iv_opmode == IEEE80211_M_IBSS ||
2355 	     vap->iv_opmode == IEEE80211_M_AHDEMO)) {
2356 		/*
2357 		 * Age/drain resources held by the station.
2358 		 */
2359 		ic->ic_node_age(ni);
2360 		/*
2361 		 * Probe the station before time it out.  We
2362 		 * send a null data frame which may not be
2363 		 * universally supported by drivers (need it
2364 		 * for ps-poll support so it should be...).
2365 		 *
2366 		 * XXX don't probe the station unless we've
2367 		 *     received a frame from them (and have
2368 		 *     some idea of the rates they are capable
2369 		 *     of); this will get fixed more properly
2370 		 *     soon with better handling of the rate set.
2371 		 */
2372 		if ((vap->iv_flags_ext & IEEE80211_FEXT_INACT) &&
2373 		    (0 < ni->ni_inact &&
2374 		     ni->ni_inact <= vap->iv_inact_probe) &&
2375 		    ni->ni_rates.rs_nrates != 0) {
2376 			IEEE80211_NOTE(vap,
2377 			    IEEE80211_MSG_INACT | IEEE80211_MSG_NODE,
2378 			    ni, "%s",
2379 			    "probe station due to inactivity");
2380 			/*
2381 			 * Grab a reference so the node cannot
2382 			 * be reclaimed before we send the frame.
2383 			 * ieee80211_send_nulldata understands
2384 			 * we've done this and reclaims the
2385 			 * ref for us as needed.
2386 			 */
2387 			/* XXX fix this (not required anymore). */
2388 			ieee80211_ref_node(ni);
2389 			/* XXX useless */
2390 			ieee80211_send_nulldata(ni);
2391 			/* XXX stat? */
2392 			return;
2393 		}
2394 	}
2395 	if ((vap->iv_flags_ext & IEEE80211_FEXT_INACT) &&
2396 	    ni->ni_inact <= 0) {
2397 		IEEE80211_NOTE(vap,
2398 		    IEEE80211_MSG_INACT | IEEE80211_MSG_NODE, ni,
2399 		    "station timed out due to inactivity "
2400 		    "(refcnt %u)", ieee80211_node_refcnt(ni));
2401 		/*
2402 		 * Send a deauthenticate frame and drop the station.
2403 		 * This is somewhat complicated due to reference counts
2404 		 * and locking.  At this point a station will typically
2405 		 * have a reference count of 2.  ieee80211_node_leave
2406 		 * will do a "free" of the node which will drop the
2407 		 * reference count.  But in the meantime a reference
2408 		 * wil be held by the deauth frame.  The actual reclaim
2409 		 * of the node will happen either after the tx is
2410 		 * completed or by ieee80211_node_leave.
2411 		 */
2412 		if (ni->ni_associd != 0) {
2413 			IEEE80211_SEND_MGMT(ni,
2414 			    IEEE80211_FC0_SUBTYPE_DEAUTH,
2415 			    IEEE80211_REASON_AUTH_EXPIRE);
2416 		}
2417 		ieee80211_node_leave(ni);
2418 		vap->iv_stats.is_node_timeout++;
2419 	}
2420 }
2421 
2422 /*
2423  * Timeout inactive stations and do related housekeeping.
2424  */
2425 static void
2426 ieee80211_timeout_stations(struct ieee80211com *ic)
2427 {
2428 	struct ieee80211_node_table *nt = &ic->ic_sta;
2429 
2430 	ieee80211_iterate_nodes(nt, timeout_stations, NULL);
2431 }
2432 
2433 /*
2434  * Aggressively reclaim resources.  This should be used
2435  * only in a critical situation to reclaim mbuf resources.
2436  */
2437 void
2438 ieee80211_drain(struct ieee80211com *ic)
2439 {
2440 	struct ieee80211_node_table *nt = &ic->ic_sta;
2441 	struct ieee80211vap *vap;
2442 	struct ieee80211_node *ni;
2443 
2444 	IEEE80211_NODE_LOCK(nt);
2445 	TAILQ_FOREACH(ni, &nt->nt_node, ni_list) {
2446 		/*
2447 		 * Ignore entries for which have yet to receive an
2448 		 * authentication frame.  These are transient and
2449 		 * will be reclaimed when the last reference to them
2450 		 * goes away (when frame xmits complete).
2451 		 */
2452 		vap = ni->ni_vap;
2453 		/*
2454 		 * Only process stations when in RUN state.  This
2455 		 * insures, for example, that we don't timeout an
2456 		 * inactive station during CAC.  Note that CSA state
2457 		 * is actually handled in ieee80211_node_timeout as
2458 		 * it applies to more than timeout processing.
2459 		 */
2460 		if (vap->iv_state != IEEE80211_S_RUN)
2461 			continue;
2462 		/* XXX can vap be NULL? */
2463 		if ((vap->iv_opmode == IEEE80211_M_HOSTAP ||
2464 		     vap->iv_opmode == IEEE80211_M_STA) &&
2465 		    (ni->ni_flags & IEEE80211_NODE_AREF) == 0)
2466 			continue;
2467 		/*
2468 		 * Free fragments.
2469 		 * XXX doesn't belong here, move to node_drain
2470 		 */
2471 		if (ni->ni_rxfrag[0] != NULL) {
2472 			m_freem(ni->ni_rxfrag[0]);
2473 			ni->ni_rxfrag[0] = NULL;
2474 		}
2475 		/*
2476 		 * Drain resources held by the station.
2477 		 */
2478 		ic->ic_node_drain(ni);
2479 	}
2480 	IEEE80211_NODE_UNLOCK(nt);
2481 }
2482 
2483 /*
2484  * Per-ieee80211com inactivity timer callback.
2485  */
2486 void
2487 ieee80211_node_timeout(void *arg)
2488 {
2489 	struct ieee80211com *ic = arg;
2490 
2491 	/*
2492 	 * Defer timeout processing if a channel switch is pending.
2493 	 * We typically need to be mute so not doing things that
2494 	 * might generate frames is good to handle in one place.
2495 	 * Suppressing the station timeout processing may extend the
2496 	 * lifetime of inactive stations (by not decrementing their
2497 	 * idle counters) but this should be ok unless the CSA is
2498 	 * active for an unusually long time.
2499 	 */
2500 	if ((ic->ic_flags & IEEE80211_F_CSAPENDING) == 0) {
2501 		ieee80211_scan_timeout(ic);
2502 		ieee80211_timeout_stations(ic);
2503 		ieee80211_ageq_age(&ic->ic_stageq, IEEE80211_INACT_WAIT);
2504 
2505 		IEEE80211_LOCK(ic);
2506 		ieee80211_erp_timeout(ic);
2507 		ieee80211_ht_timeout(ic);
2508 		ieee80211_vht_timeout(ic);
2509 		IEEE80211_UNLOCK(ic);
2510 	}
2511 	callout_reset(&ic->ic_inact, IEEE80211_INACT_WAIT*hz,
2512 		ieee80211_node_timeout, ic);
2513 }
2514 
2515 /*
2516  * The same as ieee80211_iterate_nodes(), but for one vap only.
2517  */
2518 int
2519 ieee80211_iterate_nodes_vap(struct ieee80211_node_table *nt,
2520     struct ieee80211vap *vap, ieee80211_iter_func *f, void *arg)
2521 {
2522 	struct ieee80211_node **ni_arr;
2523 	struct ieee80211_node *ni;
2524 	size_t size;
2525 	int count, i;
2526 
2527 	/*
2528 	 * Iterate over the node table and save an array of ref'ed nodes.
2529 	 *
2530 	 * This is separated out from calling the actual node function so that
2531 	 * no LORs will occur.
2532 	 */
2533 	IEEE80211_NODE_LOCK(nt);
2534 	count = nt->nt_count;
2535 	size = count * sizeof(struct ieee80211_node *);
2536 	ni_arr = (struct ieee80211_node **) IEEE80211_MALLOC(size, M_80211_NODE,
2537 	    IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
2538 	if (ni_arr == NULL) {
2539 		IEEE80211_NODE_UNLOCK(nt);
2540 		return (ENOMEM);
2541 	}
2542 
2543 	i = 0;
2544 	TAILQ_FOREACH(ni, &nt->nt_node, ni_list) {
2545 		if (vap != NULL && ni->ni_vap != vap)
2546 			continue;
2547 		KASSERT(i < count,
2548 		    ("node array overflow (vap %p, i %d, count %d)\n",
2549 		    vap, i, count));
2550 		ni_arr[i] = ieee80211_ref_node(ni);
2551 		i++;
2552 	}
2553 	IEEE80211_NODE_UNLOCK(nt);
2554 
2555 	for (i = 0; i < count; i++) {
2556 		if (ni_arr[i] == NULL)	/* end of the list */
2557 			break;
2558 		(*f)(arg, ni_arr[i]);
2559 		/* ieee80211_free_node() locks by itself */
2560 		ieee80211_free_node(ni_arr[i]);
2561 	}
2562 
2563 	IEEE80211_FREE(ni_arr, M_80211_NODE);
2564 
2565 	return (0);
2566 }
2567 
2568 /*
2569  * Just a wrapper, so we don't have to change every ieee80211_iterate_nodes()
2570  * reference in the source.
2571  */
2572 void
2573 ieee80211_iterate_nodes(struct ieee80211_node_table *nt,
2574 	ieee80211_iter_func *f, void *arg)
2575 {
2576 	/* XXX no way to pass error to the caller. */
2577 	(void) ieee80211_iterate_nodes_vap(nt, NULL, f, arg);
2578 }
2579 
2580 void
2581 ieee80211_dump_node(struct ieee80211_node_table *nt, struct ieee80211_node *ni)
2582 {
2583 	printf("0x%p: mac %s refcnt %d\n", ni,
2584 		ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni));
2585 	printf("\tauthmode %u flags 0x%x\n",
2586 		ni->ni_authmode, ni->ni_flags);
2587 	printf("\tassocid 0x%x txpower %u vlan %u\n",
2588 		ni->ni_associd, ni->ni_txpower, ni->ni_vlan);
2589 	printf("\ttxseq %u rxseq %u fragno %u rxfragstamp %u\n",
2590 		ni->ni_txseqs[IEEE80211_NONQOS_TID],
2591 		ni->ni_rxseqs[IEEE80211_NONQOS_TID] >> IEEE80211_SEQ_SEQ_SHIFT,
2592 		ni->ni_rxseqs[IEEE80211_NONQOS_TID] & IEEE80211_SEQ_FRAG_MASK,
2593 		ni->ni_rxfragstamp);
2594 	printf("\trssi %d noise %d intval %u capinfo 0x%x\n",
2595 		node_getrssi(ni), ni->ni_noise,
2596 		ni->ni_intval, ni->ni_capinfo);
2597 	printf("\tbssid %s essid \"%.*s\" channel %u:0x%x\n",
2598 		ether_sprintf(ni->ni_bssid),
2599 		ni->ni_esslen, ni->ni_essid,
2600 		ni->ni_chan->ic_freq, ni->ni_chan->ic_flags);
2601 	printf("\tinact %u inact_reload %u txrate %u\n",
2602 		ni->ni_inact, ni->ni_inact_reload, ni->ni_txrate);
2603 	printf("\thtcap %x htparam %x htctlchan %u ht2ndchan %u\n",
2604 		ni->ni_htcap, ni->ni_htparam,
2605 		ni->ni_htctlchan, ni->ni_ht2ndchan);
2606 	printf("\thtopmode %x htstbc %x htchw %u\n",
2607 		ni->ni_htopmode, ni->ni_htstbc, ni->ni_chw);
2608 	printf("\tvhtcap %x freq1 %d freq2 %d vhtbasicmcs %x\n",
2609 		ni->ni_vhtcap, (int) ni->ni_vht_chan1, (int) ni->ni_vht_chan2,
2610 		(int) ni->ni_vht_basicmcs);
2611 	/* XXX VHT state */
2612 }
2613 
2614 void
2615 ieee80211_dump_nodes(struct ieee80211_node_table *nt)
2616 {
2617 	ieee80211_iterate_nodes(nt,
2618 		(ieee80211_iter_func *) ieee80211_dump_node, nt);
2619 }
2620 
2621 static void
2622 ieee80211_notify_erp_locked(struct ieee80211com *ic)
2623 {
2624 	struct ieee80211vap *vap;
2625 
2626 	IEEE80211_LOCK_ASSERT(ic);
2627 
2628 	TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
2629 		if (vap->iv_opmode == IEEE80211_M_HOSTAP)
2630 			ieee80211_beacon_notify(vap, IEEE80211_BEACON_ERP);
2631 }
2632 
2633 void
2634 ieee80211_notify_erp(struct ieee80211com *ic)
2635 {
2636 	IEEE80211_LOCK(ic);
2637 	ieee80211_notify_erp_locked(ic);
2638 	IEEE80211_UNLOCK(ic);
2639 }
2640 
2641 /*
2642  * Handle a station joining an 11g network.
2643  */
2644 static void
2645 ieee80211_node_join_11g(struct ieee80211_node *ni)
2646 {
2647 	struct ieee80211com *ic = ni->ni_ic;
2648 
2649 	IEEE80211_LOCK_ASSERT(ic);
2650 
2651 	/*
2652 	 * Station isn't capable of short slot time.  Bump
2653 	 * the count of long slot time stations and disable
2654 	 * use of short slot time.  Note that the actual switch
2655 	 * over to long slot time use may not occur until the
2656 	 * next beacon transmission (per sec. 7.3.1.4 of 11g).
2657 	 */
2658 	if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) == 0) {
2659 		ic->ic_longslotsta++;
2660 		IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_ASSOC, ni,
2661 		    "station needs long slot time, count %d",
2662 		    ic->ic_longslotsta);
2663 		/* XXX vap's w/ conflicting needs won't work */
2664 		if (!IEEE80211_IS_CHAN_108G(ic->ic_bsschan)) {
2665 			/*
2666 			 * Don't force slot time when switched to turbo
2667 			 * mode as non-ERP stations won't be present; this
2668 			 * need only be done when on the normal G channel.
2669 			 */
2670 			ieee80211_set_shortslottime(ic, 0);
2671 		}
2672 	}
2673 	/*
2674 	 * If the new station is not an ERP station
2675 	 * then bump the counter and enable protection
2676 	 * if configured.
2677 	 */
2678 	if (!ieee80211_iserp_rateset(&ni->ni_rates)) {
2679 		ic->ic_nonerpsta++;
2680 		IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_ASSOC, ni,
2681 		    "station is !ERP, %d non-ERP stations associated",
2682 		    ic->ic_nonerpsta);
2683 		/*
2684 		 * If station does not support short preamble
2685 		 * then we must enable use of Barker preamble.
2686 		 */
2687 		if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE) == 0) {
2688 			IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_ASSOC, ni,
2689 			    "%s", "station needs long preamble");
2690 			ic->ic_flags |= IEEE80211_F_USEBARKER;
2691 			ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE;
2692 		}
2693 		/*
2694 		 * If protection is configured and this is the first
2695 		 * indication we should use protection, enable it.
2696 		 */
2697 		if (ic->ic_protmode != IEEE80211_PROT_NONE &&
2698 		    ic->ic_nonerpsta == 1 &&
2699 		    (ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) == 0) {
2700 			IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_ASSOC,
2701 			    "%s: enable use of protection\n", __func__);
2702 			ic->ic_flags |= IEEE80211_F_USEPROT;
2703 			ieee80211_notify_erp_locked(ic);
2704 		}
2705 	} else
2706 		ni->ni_flags |= IEEE80211_NODE_ERP;
2707 }
2708 
2709 void
2710 ieee80211_node_join(struct ieee80211_node *ni, int resp)
2711 {
2712 	struct ieee80211com *ic = ni->ni_ic;
2713 	struct ieee80211vap *vap = ni->ni_vap;
2714 	int newassoc;
2715 
2716 	if (ni->ni_associd == 0) {
2717 		uint16_t aid;
2718 
2719 		KASSERT(vap->iv_aid_bitmap != NULL, ("no aid bitmap"));
2720 		/*
2721 		 * It would be good to search the bitmap
2722 		 * more efficiently, but this will do for now.
2723 		 */
2724 		for (aid = 1; aid < vap->iv_max_aid; aid++) {
2725 			if (!IEEE80211_AID_ISSET(vap, aid))
2726 				break;
2727 		}
2728 		if (aid >= vap->iv_max_aid) {
2729 			IEEE80211_SEND_MGMT(ni, resp, IEEE80211_STATUS_TOOMANY);
2730 			ieee80211_node_leave(ni);
2731 			return;
2732 		}
2733 		ni->ni_associd = aid | 0xc000;
2734 		ni->ni_jointime = time_uptime;
2735 		IEEE80211_LOCK(ic);
2736 		IEEE80211_AID_SET(vap, ni->ni_associd);
2737 		vap->iv_sta_assoc++;
2738 		ic->ic_sta_assoc++;
2739 
2740 		if (IEEE80211_IS_CHAN_HT(ic->ic_bsschan))
2741 			ieee80211_ht_node_join(ni);
2742 		if (IEEE80211_IS_CHAN_VHT(ic->ic_bsschan))
2743 			ieee80211_vht_node_join(ni);
2744 		if (IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
2745 		    IEEE80211_IS_CHAN_FULL(ic->ic_bsschan))
2746 			ieee80211_node_join_11g(ni);
2747 		IEEE80211_UNLOCK(ic);
2748 
2749 		newassoc = 1;
2750 	} else
2751 		newassoc = 0;
2752 
2753 	/*
2754 	 * XXX VHT - should log VHT channel width, etc
2755 	 */
2756 	IEEE80211_NOTE(vap, IEEE80211_MSG_ASSOC | IEEE80211_MSG_DEBUG, ni,
2757 	    "station associated at aid %d: %s preamble, %s slot time%s%s%s%s%s%s%s%s",
2758 	    IEEE80211_NODE_AID(ni),
2759 	    ic->ic_flags & IEEE80211_F_SHPREAMBLE ? "short" : "long",
2760 	    ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long",
2761 	    ic->ic_flags & IEEE80211_F_USEPROT ? ", protection" : "",
2762 	    ni->ni_flags & IEEE80211_NODE_QOS ? ", QoS" : "",
2763 	    /* XXX update for VHT string */
2764 	    ni->ni_flags & IEEE80211_NODE_HT ?
2765 		(ni->ni_chw == 40 ? ", HT40" : ", HT20") : "",
2766 	    ni->ni_flags & IEEE80211_NODE_AMPDU ? " (+AMPDU)" : "",
2767 	    ni->ni_flags & IEEE80211_NODE_MIMO_RTS ? " (+SMPS-DYN)" :
2768 	        ni->ni_flags & IEEE80211_NODE_MIMO_PS ? " (+SMPS)" : "",
2769 	    ni->ni_flags & IEEE80211_NODE_RIFS ? " (+RIFS)" : "",
2770 	    IEEE80211_ATH_CAP(vap, ni, IEEE80211_NODE_FF) ?
2771 		", fast-frames" : "",
2772 	    IEEE80211_ATH_CAP(vap, ni, IEEE80211_NODE_TURBOP) ?
2773 		", turbo" : ""
2774 	);
2775 
2776 	ieee80211_node_setuptxparms(ni);
2777 	ieee80211_ratectl_node_init(ni);
2778 	/* give driver a chance to setup state like ni_txrate */
2779 	if (ic->ic_newassoc != NULL)
2780 		ic->ic_newassoc(ni, newassoc);
2781 	IEEE80211_SEND_MGMT(ni, resp, IEEE80211_STATUS_SUCCESS);
2782 	/* tell the authenticator about new station */
2783 	if (vap->iv_auth->ia_node_join != NULL)
2784 		vap->iv_auth->ia_node_join(ni);
2785 	ieee80211_notify_node_join(ni,
2786 	    resp == IEEE80211_FC0_SUBTYPE_ASSOC_RESP);
2787 }
2788 
2789 static void
2790 disable_protection(struct ieee80211com *ic)
2791 {
2792 	KASSERT(ic->ic_nonerpsta == 0 &&
2793 	    (ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) == 0,
2794 	   ("%d non ERP stations, flags 0x%x", ic->ic_nonerpsta,
2795 	   ic->ic_flags_ext));
2796 
2797 	ic->ic_flags &= ~IEEE80211_F_USEPROT;
2798 	/* XXX verify mode? */
2799 	if (ic->ic_caps & IEEE80211_C_SHPREAMBLE) {
2800 		ic->ic_flags |= IEEE80211_F_SHPREAMBLE;
2801 		ic->ic_flags &= ~IEEE80211_F_USEBARKER;
2802 	}
2803 	ieee80211_notify_erp_locked(ic);
2804 }
2805 
2806 /*
2807  * Handle a station leaving an 11g network.
2808  */
2809 static void
2810 ieee80211_node_leave_11g(struct ieee80211_node *ni)
2811 {
2812 	struct ieee80211com *ic = ni->ni_ic;
2813 
2814 	IEEE80211_LOCK_ASSERT(ic);
2815 
2816 	KASSERT(IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan),
2817 	     ("not in 11g, bss %u:0x%x", ic->ic_bsschan->ic_freq,
2818 	      ic->ic_bsschan->ic_flags));
2819 
2820 	/*
2821 	 * If a long slot station do the slot time bookkeeping.
2822 	 */
2823 	if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) == 0) {
2824 		KASSERT(ic->ic_longslotsta > 0,
2825 		    ("bogus long slot station count %d", ic->ic_longslotsta));
2826 		ic->ic_longslotsta--;
2827 		IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_ASSOC, ni,
2828 		    "long slot time station leaves, count now %d",
2829 		    ic->ic_longslotsta);
2830 		if (ic->ic_longslotsta == 0) {
2831 			/*
2832 			 * Re-enable use of short slot time if supported
2833 			 * and not operating in IBSS mode (per spec).
2834 			 */
2835 			if ((ic->ic_caps & IEEE80211_C_SHSLOT) &&
2836 			    ic->ic_opmode != IEEE80211_M_IBSS) {
2837 				IEEE80211_DPRINTF(ni->ni_vap,
2838 				    IEEE80211_MSG_ASSOC,
2839 				    "%s: re-enable use of short slot time\n",
2840 				    __func__);
2841 				ieee80211_set_shortslottime(ic, 1);
2842 			}
2843 		}
2844 	}
2845 	/*
2846 	 * If a non-ERP station do the protection-related bookkeeping.
2847 	 */
2848 	if ((ni->ni_flags & IEEE80211_NODE_ERP) == 0) {
2849 		KASSERT(ic->ic_nonerpsta > 0,
2850 		    ("bogus non-ERP station count %d", ic->ic_nonerpsta));
2851 		ic->ic_nonerpsta--;
2852 		IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_ASSOC, ni,
2853 		    "non-ERP station leaves, count now %d%s", ic->ic_nonerpsta,
2854 		    (ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) ?
2855 			" (non-ERP sta present)" : "");
2856 		if (ic->ic_nonerpsta == 0 &&
2857 		    (ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) == 0) {
2858 			IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_ASSOC,
2859 				"%s: disable use of protection\n", __func__);
2860 			disable_protection(ic);
2861 		}
2862 	}
2863 }
2864 
2865 /*
2866  * Time out presence of an overlapping bss with non-ERP
2867  * stations.  When operating in hostap mode we listen for
2868  * beacons from other stations and if we identify a non-ERP
2869  * station is present we enable protection.  To identify
2870  * when all non-ERP stations are gone we time out this
2871  * condition.
2872  */
2873 static void
2874 ieee80211_erp_timeout(struct ieee80211com *ic)
2875 {
2876 
2877 	IEEE80211_LOCK_ASSERT(ic);
2878 
2879 	if ((ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) &&
2880 	    ieee80211_time_after(ticks, ic->ic_lastnonerp + IEEE80211_NONERP_PRESENT_AGE)) {
2881 #if 0
2882 		IEEE80211_NOTE(vap, IEEE80211_MSG_ASSOC, ni,
2883 		    "%s", "age out non-ERP sta present on channel");
2884 #endif
2885 		ic->ic_flags_ext &= ~IEEE80211_FEXT_NONERP_PR;
2886 		if (ic->ic_nonerpsta == 0)
2887 			disable_protection(ic);
2888 	}
2889 }
2890 
2891 /*
2892  * Handle bookkeeping for station deauthentication/disassociation
2893  * when operating as an ap.
2894  */
2895 void
2896 ieee80211_node_leave(struct ieee80211_node *ni)
2897 {
2898 	struct ieee80211com *ic = ni->ni_ic;
2899 	struct ieee80211vap *vap = ni->ni_vap;
2900 	struct ieee80211_node_table *nt = ni->ni_table;
2901 
2902 	IEEE80211_NOTE(vap, IEEE80211_MSG_ASSOC | IEEE80211_MSG_DEBUG, ni,
2903 	    "station with aid %d leaves", IEEE80211_NODE_AID(ni));
2904 
2905 	KASSERT(vap->iv_opmode != IEEE80211_M_STA,
2906 		("unexpected operating mode %u", vap->iv_opmode));
2907 	/*
2908 	 * If node wasn't previously associated all
2909 	 * we need to do is reclaim the reference.
2910 	 */
2911 	/* XXX ibss mode bypasses 11g and notification */
2912 	if (ni->ni_associd == 0)
2913 		goto done;
2914 	/*
2915 	 * Tell the authenticator the station is leaving.
2916 	 * Note that we must do this before yanking the
2917 	 * association id as the authenticator uses the
2918 	 * associd to locate it's state block.
2919 	 */
2920 	if (vap->iv_auth->ia_node_leave != NULL)
2921 		vap->iv_auth->ia_node_leave(ni);
2922 
2923 	IEEE80211_LOCK(ic);
2924 	IEEE80211_AID_CLR(vap, ni->ni_associd);
2925 	vap->iv_sta_assoc--;
2926 	ic->ic_sta_assoc--;
2927 
2928 	if (IEEE80211_IS_CHAN_VHT(ic->ic_bsschan))
2929 		ieee80211_vht_node_leave(ni);
2930 	if (IEEE80211_IS_CHAN_HT(ic->ic_bsschan))
2931 		ieee80211_ht_node_leave(ni);
2932 	if (IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
2933 	    IEEE80211_IS_CHAN_FULL(ic->ic_bsschan))
2934 		ieee80211_node_leave_11g(ni);
2935 	IEEE80211_UNLOCK(ic);
2936 	/*
2937 	 * Cleanup station state.  In particular clear various
2938 	 * state that might otherwise be reused if the node
2939 	 * is reused before the reference count goes to zero
2940 	 * (and memory is reclaimed).
2941 	 */
2942 	ieee80211_sta_leave(ni);
2943 done:
2944 	/*
2945 	 * Remove the node from any table it's recorded in and
2946 	 * drop the caller's reference.  Removal from the table
2947 	 * is important to insure the node is not reprocessed
2948 	 * for inactivity.
2949 	 */
2950 	if (nt != NULL) {
2951 		IEEE80211_NODE_LOCK(nt);
2952 		node_reclaim(nt, ni);
2953 		IEEE80211_NODE_UNLOCK(nt);
2954 	} else
2955 		ieee80211_free_node(ni);
2956 }
2957 
2958 struct rssiinfo {
2959 	int	rssi_samples;
2960 	uint32_t rssi_total;
2961 };
2962 
2963 static void
2964 get_hostap_rssi(void *arg, struct ieee80211_node *ni)
2965 {
2966 	struct rssiinfo *info = arg;
2967 	struct ieee80211vap *vap = ni->ni_vap;
2968 	int8_t rssi;
2969 
2970 	/* only associated stations */
2971 	if (ni->ni_associd == 0)
2972 		return;
2973 	rssi = vap->iv_ic->ic_node_getrssi(ni);
2974 	if (rssi != 0) {
2975 		info->rssi_samples++;
2976 		info->rssi_total += rssi;
2977 	}
2978 }
2979 
2980 static void
2981 get_adhoc_rssi(void *arg, struct ieee80211_node *ni)
2982 {
2983 	struct rssiinfo *info = arg;
2984 	struct ieee80211vap *vap = ni->ni_vap;
2985 	int8_t rssi;
2986 
2987 	/* only neighbors */
2988 	/* XXX check bssid */
2989 	if ((ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) == 0)
2990 		return;
2991 	rssi = vap->iv_ic->ic_node_getrssi(ni);
2992 	if (rssi != 0) {
2993 		info->rssi_samples++;
2994 		info->rssi_total += rssi;
2995 	}
2996 }
2997 
2998 #ifdef IEEE80211_SUPPORT_MESH
2999 static void
3000 get_mesh_rssi(void *arg, struct ieee80211_node *ni)
3001 {
3002 	struct rssiinfo *info = arg;
3003 	struct ieee80211vap *vap = ni->ni_vap;
3004 	int8_t rssi;
3005 
3006 	/* only neighbors that peered successfully */
3007 	if (ni->ni_mlstate != IEEE80211_NODE_MESH_ESTABLISHED)
3008 		return;
3009 	rssi = vap->iv_ic->ic_node_getrssi(ni);
3010 	if (rssi != 0) {
3011 		info->rssi_samples++;
3012 		info->rssi_total += rssi;
3013 	}
3014 }
3015 #endif /* IEEE80211_SUPPORT_MESH */
3016 
3017 int8_t
3018 ieee80211_getrssi(struct ieee80211vap *vap)
3019 {
3020 #define	NZ(x)	((x) == 0 ? 1 : (x))
3021 	struct ieee80211com *ic = vap->iv_ic;
3022 	struct rssiinfo info;
3023 
3024 	info.rssi_total = 0;
3025 	info.rssi_samples = 0;
3026 	switch (vap->iv_opmode) {
3027 	case IEEE80211_M_IBSS:		/* average of all ibss neighbors */
3028 	case IEEE80211_M_AHDEMO:	/* average of all neighbors */
3029 		ieee80211_iterate_nodes_vap(&ic->ic_sta, vap, get_adhoc_rssi,
3030 		    &info);
3031 		break;
3032 	case IEEE80211_M_HOSTAP:	/* average of all associated stations */
3033 		ieee80211_iterate_nodes_vap(&ic->ic_sta, vap, get_hostap_rssi,
3034 		    &info);
3035 		break;
3036 #ifdef IEEE80211_SUPPORT_MESH
3037 	case IEEE80211_M_MBSS:		/* average of all mesh neighbors */
3038 		ieee80211_iterate_nodes_vap(&ic->ic_sta, vap, get_mesh_rssi,
3039 		    &info);
3040 		break;
3041 #endif
3042 	case IEEE80211_M_MONITOR:	/* XXX */
3043 	case IEEE80211_M_STA:		/* use stats from associated ap */
3044 	default:
3045 		if (vap->iv_bss != NULL)
3046 			info.rssi_total = ic->ic_node_getrssi(vap->iv_bss);
3047 		info.rssi_samples = 1;
3048 		break;
3049 	}
3050 	return info.rssi_total / NZ(info.rssi_samples);
3051 #undef NZ
3052 }
3053 
3054 void
3055 ieee80211_getsignal(struct ieee80211vap *vap, int8_t *rssi, int8_t *noise)
3056 {
3057 
3058 	if (vap->iv_bss == NULL)		/* NB: shouldn't happen */
3059 		return;
3060 	vap->iv_ic->ic_node_getsignal(vap->iv_bss, rssi, noise);
3061 	/* for non-station mode return avg'd rssi accounting */
3062 	if (vap->iv_opmode != IEEE80211_M_STA)
3063 		*rssi = ieee80211_getrssi(vap);
3064 }
3065