11a1e1d21SSam Leffler /*- 27535e66aSSam Leffler * Copyright (c) 2001 Atsushi Onoe 31f1d7810SSam Leffler * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting 41a1e1d21SSam Leffler * All rights reserved. 51a1e1d21SSam Leffler * 61a1e1d21SSam Leffler * Redistribution and use in source and binary forms, with or without 71a1e1d21SSam Leffler * modification, are permitted provided that the following conditions 81a1e1d21SSam Leffler * are met: 91a1e1d21SSam Leffler * 1. Redistributions of source code must retain the above copyright 107535e66aSSam Leffler * notice, this list of conditions and the following disclaimer. 117535e66aSSam Leffler * 2. Redistributions in binary form must reproduce the above copyright 127535e66aSSam Leffler * notice, this list of conditions and the following disclaimer in the 137535e66aSSam Leffler * documentation and/or other materials provided with the distribution. 147535e66aSSam Leffler * 3. The name of the author may not be used to endorse or promote products 157535e66aSSam Leffler * derived from this software without specific prior written permission. 161a1e1d21SSam Leffler * 171a1e1d21SSam Leffler * Alternatively, this software may be distributed under the terms of the 181a1e1d21SSam Leffler * GNU General Public License ("GPL") version 2 as published by the Free 191a1e1d21SSam Leffler * Software Foundation. 201a1e1d21SSam Leffler * 217535e66aSSam Leffler * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 227535e66aSSam Leffler * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 237535e66aSSam Leffler * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 247535e66aSSam Leffler * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 257535e66aSSam Leffler * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 267535e66aSSam Leffler * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 277535e66aSSam Leffler * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 287535e66aSSam Leffler * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 297535e66aSSam Leffler * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 307535e66aSSam Leffler * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 311a1e1d21SSam Leffler */ 321a1e1d21SSam Leffler 331a1e1d21SSam Leffler #include <sys/cdefs.h> 341a1e1d21SSam Leffler __FBSDID("$FreeBSD$"); 351a1e1d21SSam Leffler 361a1e1d21SSam Leffler #include <sys/param.h> 371a1e1d21SSam Leffler #include <sys/systm.h> 381a1e1d21SSam Leffler #include <sys/mbuf.h> 391a1e1d21SSam Leffler #include <sys/malloc.h> 401a1e1d21SSam Leffler #include <sys/kernel.h> 411a1e1d21SSam Leffler 428a1b9b6aSSam Leffler #include <sys/socket.h> 431a1e1d21SSam Leffler 441a1e1d21SSam Leffler #include <net/if.h> 451a1e1d21SSam Leffler #include <net/if_media.h> 461a1e1d21SSam Leffler #include <net/ethernet.h> 471a1e1d21SSam Leffler 481a1e1d21SSam Leffler #include <net80211/ieee80211_var.h> 491a1e1d21SSam Leffler 501a1e1d21SSam Leffler #include <net/bpf.h> 511a1e1d21SSam Leffler 527268fa64SSam Leffler /* 537268fa64SSam Leffler * Association id's are managed with a bit vector. 547268fa64SSam Leffler */ 557268fa64SSam Leffler #define IEEE80211_AID_SET(b, w) \ 567268fa64SSam Leffler ((w)[IEEE80211_AID(b) / 32] |= (1 << (IEEE80211_AID(b) % 32))) 577268fa64SSam Leffler #define IEEE80211_AID_CLR(b, w) \ 587268fa64SSam Leffler ((w)[IEEE80211_AID(b) / 32] &= ~(1 << (IEEE80211_AID(b) % 32))) 597268fa64SSam Leffler #define IEEE80211_AID_ISSET(b, w) \ 607268fa64SSam Leffler ((w)[IEEE80211_AID(b) / 32] & (1 << (IEEE80211_AID(b) % 32))) 617268fa64SSam Leffler 628a1b9b6aSSam Leffler static struct ieee80211_node *node_alloc(struct ieee80211_node_table *); 638a1b9b6aSSam Leffler static void node_cleanup(struct ieee80211_node *); 648a1b9b6aSSam Leffler static void node_free(struct ieee80211_node *); 658a1b9b6aSSam Leffler static u_int8_t node_getrssi(const struct ieee80211_node *); 661a1e1d21SSam Leffler 678a1b9b6aSSam Leffler static void ieee80211_setup_node(struct ieee80211_node_table *, 688a1b9b6aSSam Leffler struct ieee80211_node *, const u_int8_t *); 698a1b9b6aSSam Leffler static void _ieee80211_free_node(struct ieee80211_node *); 708a1b9b6aSSam Leffler static void ieee80211_free_allnodes(struct ieee80211_node_table *); 71d1e61976SSam Leffler 728a1b9b6aSSam Leffler static void ieee80211_timeout_scan_candidates(struct ieee80211_node_table *); 738a1b9b6aSSam Leffler static void ieee80211_timeout_stations(struct ieee80211_node_table *); 748a1b9b6aSSam Leffler 75edfa57d0SSam Leffler static void ieee80211_set_tim(struct ieee80211_node *, int set); 768a1b9b6aSSam Leffler 778a1b9b6aSSam Leffler static void ieee80211_node_table_init(struct ieee80211com *ic, 788a1b9b6aSSam Leffler struct ieee80211_node_table *nt, const char *name, int inact, 798a1b9b6aSSam Leffler void (*timeout)(struct ieee80211_node_table *)); 808a1b9b6aSSam Leffler static void ieee80211_node_table_cleanup(struct ieee80211_node_table *nt); 811a1e1d21SSam Leffler 8232346d60SSam Leffler MALLOC_DEFINE(M_80211_NODE, "80211node", "802.11 node state"); 8337c150c4SSam Leffler 841a1e1d21SSam Leffler void 858a1b9b6aSSam Leffler ieee80211_node_attach(struct ieee80211com *ic) 861a1e1d21SSam Leffler { 871a1e1d21SSam Leffler 88acc4f7f5SSam Leffler ieee80211_node_table_init(ic, &ic->ic_sta, "station", 89acc4f7f5SSam Leffler IEEE80211_INACT_INIT, ieee80211_timeout_stations); 908a1b9b6aSSam Leffler ieee80211_node_table_init(ic, &ic->ic_scan, "scan", 918a1b9b6aSSam Leffler IEEE80211_INACT_SCAN, ieee80211_timeout_scan_candidates); 928a1b9b6aSSam Leffler 938a1b9b6aSSam Leffler ic->ic_node_alloc = node_alloc; 948a1b9b6aSSam Leffler ic->ic_node_free = node_free; 958a1b9b6aSSam Leffler ic->ic_node_cleanup = node_cleanup; 968a1b9b6aSSam Leffler ic->ic_node_getrssi = node_getrssi; 978a1b9b6aSSam Leffler 988a1b9b6aSSam Leffler /* default station inactivity timer setings */ 998a1b9b6aSSam Leffler ic->ic_inact_init = IEEE80211_INACT_INIT; 1008a1b9b6aSSam Leffler ic->ic_inact_auth = IEEE80211_INACT_AUTH; 1018a1b9b6aSSam Leffler ic->ic_inact_run = IEEE80211_INACT_RUN; 1028a1b9b6aSSam Leffler ic->ic_inact_probe = IEEE80211_INACT_PROBE; 1038a1b9b6aSSam Leffler 1048a1b9b6aSSam Leffler /* XXX defer */ 1058a1b9b6aSSam Leffler if (ic->ic_max_aid == 0) 1068a1b9b6aSSam Leffler ic->ic_max_aid = IEEE80211_AID_DEF; 1078a1b9b6aSSam Leffler else if (ic->ic_max_aid > IEEE80211_AID_MAX) 1088a1b9b6aSSam Leffler ic->ic_max_aid = IEEE80211_AID_MAX; 1098a1b9b6aSSam Leffler MALLOC(ic->ic_aid_bitmap, u_int32_t *, 1108a1b9b6aSSam Leffler howmany(ic->ic_max_aid, 32) * sizeof(u_int32_t), 1118a1b9b6aSSam Leffler M_DEVBUF, M_NOWAIT | M_ZERO); 1128a1b9b6aSSam Leffler if (ic->ic_aid_bitmap == NULL) { 1138a1b9b6aSSam Leffler /* XXX no way to recover */ 1148a1b9b6aSSam Leffler printf("%s: no memory for AID bitmap!\n", __func__); 1158a1b9b6aSSam Leffler ic->ic_max_aid = 0; 1168a1b9b6aSSam Leffler } 1178a1b9b6aSSam Leffler 1188a1b9b6aSSam Leffler /* XXX defer until using hostap/ibss mode */ 1198a1b9b6aSSam Leffler ic->ic_tim_len = howmany(ic->ic_max_aid, 8) * sizeof(u_int8_t); 1208a1b9b6aSSam Leffler MALLOC(ic->ic_tim_bitmap, u_int8_t *, ic->ic_tim_len, 1218a1b9b6aSSam Leffler M_DEVBUF, M_NOWAIT | M_ZERO); 1228a1b9b6aSSam Leffler if (ic->ic_tim_bitmap == NULL) { 1238a1b9b6aSSam Leffler /* XXX no way to recover */ 1248a1b9b6aSSam Leffler printf("%s: no memory for TIM bitmap!\n", __func__); 1258a1b9b6aSSam Leffler } 1268a1b9b6aSSam Leffler ic->ic_set_tim = ieee80211_set_tim; /* NB: driver should override */ 1272692bb26SSam Leffler } 1282692bb26SSam Leffler 1292692bb26SSam Leffler void 1308a1b9b6aSSam Leffler ieee80211_node_lateattach(struct ieee80211com *ic) 1312692bb26SSam Leffler { 132849b8980SSam Leffler struct ieee80211_node *ni; 1338a1b9b6aSSam Leffler struct ieee80211_rsnparms *rsn; 1342692bb26SSam Leffler 1358a1b9b6aSSam Leffler ni = ieee80211_alloc_node(&ic->ic_scan, ic->ic_myaddr); 136849b8980SSam Leffler KASSERT(ni != NULL, ("unable to setup inital BSS node")); 1378a1b9b6aSSam Leffler /* 1388a1b9b6aSSam Leffler * Setup "global settings" in the bss node so that 1398a1b9b6aSSam Leffler * each new station automatically inherits them. 1408a1b9b6aSSam Leffler */ 1418a1b9b6aSSam Leffler rsn = &ni->ni_rsn; 1428a1b9b6aSSam Leffler /* WEP, TKIP, and AES-CCM are always supported */ 1438a1b9b6aSSam Leffler rsn->rsn_ucastcipherset |= 1<<IEEE80211_CIPHER_WEP; 1448a1b9b6aSSam Leffler rsn->rsn_ucastcipherset |= 1<<IEEE80211_CIPHER_TKIP; 1458a1b9b6aSSam Leffler rsn->rsn_ucastcipherset |= 1<<IEEE80211_CIPHER_AES_CCM; 1468a1b9b6aSSam Leffler if (ic->ic_caps & IEEE80211_C_AES) 1478a1b9b6aSSam Leffler rsn->rsn_ucastcipherset |= 1<<IEEE80211_CIPHER_AES_OCB; 1488a1b9b6aSSam Leffler if (ic->ic_caps & IEEE80211_C_CKIP) 1498a1b9b6aSSam Leffler rsn->rsn_ucastcipherset |= 1<<IEEE80211_CIPHER_CKIP; 1508a1b9b6aSSam Leffler /* 1518a1b9b6aSSam Leffler * Default unicast cipher to WEP for 802.1x use. If 1528a1b9b6aSSam Leffler * WPA is enabled the management code will set these 1538a1b9b6aSSam Leffler * values to reflect. 1548a1b9b6aSSam Leffler */ 1558a1b9b6aSSam Leffler rsn->rsn_ucastcipher = IEEE80211_CIPHER_WEP; 1568a1b9b6aSSam Leffler rsn->rsn_ucastkeylen = 104 / NBBY; 1578a1b9b6aSSam Leffler /* 1588a1b9b6aSSam Leffler * WPA says the multicast cipher is the lowest unicast 1598a1b9b6aSSam Leffler * cipher supported. But we skip WEP which would 1608a1b9b6aSSam Leffler * otherwise be used based on this criteria. 1618a1b9b6aSSam Leffler */ 1628a1b9b6aSSam Leffler rsn->rsn_mcastcipher = IEEE80211_CIPHER_TKIP; 1638a1b9b6aSSam Leffler rsn->rsn_mcastkeylen = 128 / NBBY; 1648a1b9b6aSSam Leffler 1658a1b9b6aSSam Leffler /* 1668a1b9b6aSSam Leffler * We support both WPA-PSK and 802.1x; the one used 1678a1b9b6aSSam Leffler * is determined by the authentication mode and the 1688a1b9b6aSSam Leffler * setting of the PSK state. 1698a1b9b6aSSam Leffler */ 1708a1b9b6aSSam Leffler rsn->rsn_keymgmtset = WPA_ASE_8021X_UNSPEC | WPA_ASE_8021X_PSK; 1718a1b9b6aSSam Leffler rsn->rsn_keymgmt = WPA_ASE_8021X_PSK; 1728a1b9b6aSSam Leffler 1738a1b9b6aSSam Leffler ic->ic_bss = ieee80211_ref_node(ni); /* hold reference */ 1748a1b9b6aSSam Leffler ic->ic_auth = ieee80211_authenticator_get(ni->ni_authmode); 1751a1e1d21SSam Leffler } 1761a1e1d21SSam Leffler 1771a1e1d21SSam Leffler void 1788a1b9b6aSSam Leffler ieee80211_node_detach(struct ieee80211com *ic) 1791a1e1d21SSam Leffler { 1801a1e1d21SSam Leffler 1818a1b9b6aSSam Leffler if (ic->ic_bss != NULL) { 1828a1b9b6aSSam Leffler ieee80211_free_node(ic->ic_bss); 1838a1b9b6aSSam Leffler ic->ic_bss = NULL; 1848a1b9b6aSSam Leffler } 1858a1b9b6aSSam Leffler ieee80211_node_table_cleanup(&ic->ic_scan); 186acc4f7f5SSam Leffler ieee80211_node_table_cleanup(&ic->ic_sta); 1878a1b9b6aSSam Leffler if (ic->ic_aid_bitmap != NULL) { 1888a1b9b6aSSam Leffler FREE(ic->ic_aid_bitmap, M_DEVBUF); 1898a1b9b6aSSam Leffler ic->ic_aid_bitmap = NULL; 1908a1b9b6aSSam Leffler } 1918a1b9b6aSSam Leffler if (ic->ic_tim_bitmap != NULL) { 1928a1b9b6aSSam Leffler FREE(ic->ic_tim_bitmap, M_DEVBUF); 1938a1b9b6aSSam Leffler ic->ic_tim_bitmap = NULL; 1948a1b9b6aSSam Leffler } 1958a1b9b6aSSam Leffler } 1968a1b9b6aSSam Leffler 1978a1b9b6aSSam Leffler /* 1988a1b9b6aSSam Leffler * Port authorize/unauthorize interfaces for use by an authenticator. 1998a1b9b6aSSam Leffler */ 2008a1b9b6aSSam Leffler 2018a1b9b6aSSam Leffler void 202e4918ecdSSam Leffler ieee80211_node_authorize(struct ieee80211_node *ni) 2038a1b9b6aSSam Leffler { 204e4918ecdSSam Leffler struct ieee80211com *ic = ni->ni_ic; 205e4918ecdSSam Leffler 2068a1b9b6aSSam Leffler ni->ni_flags |= IEEE80211_NODE_AUTH; 2072045f699SSam Leffler ni->ni_inact_reload = ic->ic_inact_run; 2088a1b9b6aSSam Leffler } 2098a1b9b6aSSam Leffler 2108a1b9b6aSSam Leffler void 211e4918ecdSSam Leffler ieee80211_node_unauthorize(struct ieee80211_node *ni) 2128a1b9b6aSSam Leffler { 2138a1b9b6aSSam Leffler ni->ni_flags &= ~IEEE80211_NODE_AUTH; 2148a1b9b6aSSam Leffler } 2158a1b9b6aSSam Leffler 2168a1b9b6aSSam Leffler /* 2178a1b9b6aSSam Leffler * Set/change the channel. The rate set is also updated as 2188a1b9b6aSSam Leffler * to insure a consistent view by drivers. 2198a1b9b6aSSam Leffler */ 2208a1b9b6aSSam Leffler static __inline void 2218a1b9b6aSSam Leffler ieee80211_set_chan(struct ieee80211com *ic, 2228a1b9b6aSSam Leffler struct ieee80211_node *ni, struct ieee80211_channel *chan) 2238a1b9b6aSSam Leffler { 2248a1b9b6aSSam Leffler ni->ni_chan = chan; 2258a1b9b6aSSam Leffler ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2mode(ic, chan)]; 2261a1e1d21SSam Leffler } 2271a1e1d21SSam Leffler 2281a1e1d21SSam Leffler /* 2291a1e1d21SSam Leffler * AP scanning support. 2301a1e1d21SSam Leffler */ 2311a1e1d21SSam Leffler 2328a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG 2338a1b9b6aSSam Leffler static void 2348a1b9b6aSSam Leffler dump_chanlist(const u_char chans[]) 2358a1b9b6aSSam Leffler { 2368a1b9b6aSSam Leffler const char *sep; 2378a1b9b6aSSam Leffler int i; 2388a1b9b6aSSam Leffler 2398a1b9b6aSSam Leffler sep = " "; 2408a1b9b6aSSam Leffler for (i = 0; i < IEEE80211_CHAN_MAX; i++) 2418a1b9b6aSSam Leffler if (isset(chans, i)) { 2428a1b9b6aSSam Leffler printf("%s%u", sep, i); 2438a1b9b6aSSam Leffler sep = ", "; 2448a1b9b6aSSam Leffler } 2458a1b9b6aSSam Leffler } 2468a1b9b6aSSam Leffler #endif /* IEEE80211_DEBUG */ 2478a1b9b6aSSam Leffler 2481a1e1d21SSam Leffler /* 2498a1b9b6aSSam Leffler * Initialize the channel set to scan based on the 2501a1e1d21SSam Leffler * of available channels and the current PHY mode. 2511a1e1d21SSam Leffler */ 252a11c9a5cSSam Leffler static void 2538a1b9b6aSSam Leffler ieee80211_reset_scan(struct ieee80211com *ic) 2541a1e1d21SSam Leffler { 2551a1e1d21SSam Leffler 2568a1b9b6aSSam Leffler /* XXX ic_des_chan should be handled with ic_chan_active */ 2578a1b9b6aSSam Leffler if (ic->ic_des_chan != IEEE80211_CHAN_ANYC) { 2588a1b9b6aSSam Leffler memset(ic->ic_chan_scan, 0, sizeof(ic->ic_chan_scan)); 2598a1b9b6aSSam Leffler setbit(ic->ic_chan_scan, 2608a1b9b6aSSam Leffler ieee80211_chan2ieee(ic, ic->ic_des_chan)); 2618a1b9b6aSSam Leffler } else 2621a1e1d21SSam Leffler memcpy(ic->ic_chan_scan, ic->ic_chan_active, 2631a1e1d21SSam Leffler sizeof(ic->ic_chan_active)); 264a11c9a5cSSam Leffler /* NB: hack, setup so next_scan starts with the first channel */ 265a11c9a5cSSam Leffler if (ic->ic_bss->ni_chan == IEEE80211_CHAN_ANYC) 2668a1b9b6aSSam Leffler ieee80211_set_chan(ic, ic->ic_bss, 2678a1b9b6aSSam Leffler &ic->ic_channels[IEEE80211_CHAN_MAX]); 2688a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG 2698a1b9b6aSSam Leffler if (ieee80211_msg_scan(ic)) { 2708a1b9b6aSSam Leffler printf("%s: scan set:", __func__); 2718a1b9b6aSSam Leffler dump_chanlist(ic->ic_chan_scan); 2728a1b9b6aSSam Leffler printf(" start chan %u\n", 2738a1b9b6aSSam Leffler ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan)); 2748a1b9b6aSSam Leffler } 2758a1b9b6aSSam Leffler #endif /* IEEE80211_DEBUG */ 2761a1e1d21SSam Leffler } 2771a1e1d21SSam Leffler 2781a1e1d21SSam Leffler /* 2791a1e1d21SSam Leffler * Begin an active scan. 2801a1e1d21SSam Leffler */ 2811a1e1d21SSam Leffler void 2828a1b9b6aSSam Leffler ieee80211_begin_scan(struct ieee80211com *ic, int reset) 2831a1e1d21SSam Leffler { 2841a1e1d21SSam Leffler 2858a1b9b6aSSam Leffler ic->ic_scan.nt_scangen++; 286a11c9a5cSSam Leffler /* 287a11c9a5cSSam Leffler * In all but hostap mode scanning starts off in 288a11c9a5cSSam Leffler * an active mode before switching to passive. 289a11c9a5cSSam Leffler */ 2901be50176SSam Leffler if (ic->ic_opmode != IEEE80211_M_HOSTAP) { 291a11c9a5cSSam Leffler ic->ic_flags |= IEEE80211_F_ASCAN; 2921be50176SSam Leffler ic->ic_stats.is_scan_active++; 2931be50176SSam Leffler } else 2941be50176SSam Leffler ic->ic_stats.is_scan_passive++; 2953ea67c54SSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, 2963ea67c54SSam Leffler "begin %s scan in %s mode, scangen %u\n", 2978a1b9b6aSSam Leffler (ic->ic_flags & IEEE80211_F_ASCAN) ? "active" : "passive", 2983ea67c54SSam Leffler ieee80211_phymode_name[ic->ic_curmode], ic->ic_scan.nt_scangen); 2991a1e1d21SSam Leffler /* 3008a1b9b6aSSam Leffler * Clear scan state and flush any previously seen AP's. 3011a1e1d21SSam Leffler */ 3028a1b9b6aSSam Leffler ieee80211_reset_scan(ic); 3038a1b9b6aSSam Leffler if (reset) 3048a1b9b6aSSam Leffler ieee80211_free_allnodes(&ic->ic_scan); 3058a1b9b6aSSam Leffler 3068a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_SCAN; 3071a1e1d21SSam Leffler 308a11c9a5cSSam Leffler /* Scan the next channel. */ 3098a1b9b6aSSam Leffler ieee80211_next_scan(ic); 3101a1e1d21SSam Leffler } 3111a1e1d21SSam Leffler 3121a1e1d21SSam Leffler /* 3131a1e1d21SSam Leffler * Switch to the next channel marked for scanning. 3141a1e1d21SSam Leffler */ 3158a1b9b6aSSam Leffler int 3168a1b9b6aSSam Leffler ieee80211_next_scan(struct ieee80211com *ic) 3171a1e1d21SSam Leffler { 3181a1e1d21SSam Leffler struct ieee80211_channel *chan; 3191a1e1d21SSam Leffler 3208a1b9b6aSSam Leffler /* 3218a1b9b6aSSam Leffler * Insure any previous mgt frame timeouts don't fire. 3228a1b9b6aSSam Leffler * This assumes the driver does the right thing in 3238a1b9b6aSSam Leffler * flushing anything queued in the driver and below. 3248a1b9b6aSSam Leffler */ 3258a1b9b6aSSam Leffler ic->ic_mgt_timer = 0; 3268a1b9b6aSSam Leffler 3271a1e1d21SSam Leffler chan = ic->ic_bss->ni_chan; 3288a1b9b6aSSam Leffler do { 3291a1e1d21SSam Leffler if (++chan > &ic->ic_channels[IEEE80211_CHAN_MAX]) 3301a1e1d21SSam Leffler chan = &ic->ic_channels[0]; 3311a1e1d21SSam Leffler if (isset(ic->ic_chan_scan, ieee80211_chan2ieee(ic, chan))) { 3321a1e1d21SSam Leffler clrbit(ic->ic_chan_scan, ieee80211_chan2ieee(ic, chan)); 3338a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, 3348a1b9b6aSSam Leffler "%s: chan %d->%d\n", __func__, 3351a1e1d21SSam Leffler ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan), 3368a1b9b6aSSam Leffler ieee80211_chan2ieee(ic, chan)); 3378a1b9b6aSSam Leffler ieee80211_set_chan(ic, ic->ic_bss, chan); 338a11c9a5cSSam Leffler ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 3398a1b9b6aSSam Leffler return 1; 3408a1b9b6aSSam Leffler } 3418a1b9b6aSSam Leffler } while (chan != ic->ic_bss->ni_chan); 3428a1b9b6aSSam Leffler ieee80211_end_scan(ic); 3438a1b9b6aSSam Leffler return 0; 3441a1e1d21SSam Leffler } 3451a1e1d21SSam Leffler 346f9cd9174SSam Leffler static __inline void 347f9cd9174SSam Leffler copy_bss(struct ieee80211_node *nbss, const struct ieee80211_node *obss) 348f9cd9174SSam Leffler { 349f9cd9174SSam Leffler /* propagate useful state */ 350f9cd9174SSam Leffler nbss->ni_authmode = obss->ni_authmode; 351f9cd9174SSam Leffler nbss->ni_txpower = obss->ni_txpower; 352f9cd9174SSam Leffler nbss->ni_vlan = obss->ni_vlan; 353f9cd9174SSam Leffler nbss->ni_rsn = obss->ni_rsn; 354f9cd9174SSam Leffler /* XXX statistics? */ 355f9cd9174SSam Leffler } 356f9cd9174SSam Leffler 3571a1e1d21SSam Leffler void 3581a1e1d21SSam Leffler ieee80211_create_ibss(struct ieee80211com* ic, struct ieee80211_channel *chan) 3591a1e1d21SSam Leffler { 360acc4f7f5SSam Leffler struct ieee80211_node_table *nt; 3611a1e1d21SSam Leffler struct ieee80211_node *ni; 3628a1b9b6aSSam Leffler 3638a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, 3648a1b9b6aSSam Leffler "%s: creating ibss\n", __func__); 3658a1b9b6aSSam Leffler 3668a1b9b6aSSam Leffler /* 3678a1b9b6aSSam Leffler * Create the station/neighbor table. Note that for adhoc 3688a1b9b6aSSam Leffler * mode we make the initial inactivity timer longer since 3698a1b9b6aSSam Leffler * we create nodes only through discovery and they typically 3708a1b9b6aSSam Leffler * are long-lived associations. 3718a1b9b6aSSam Leffler */ 372acc4f7f5SSam Leffler nt = &ic->ic_sta; 373acc4f7f5SSam Leffler IEEE80211_NODE_LOCK(nt); 374acc4f7f5SSam Leffler if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 375acc4f7f5SSam Leffler nt->nt_name = "station"; 376acc4f7f5SSam Leffler nt->nt_inact_init = ic->ic_inact_init; 377acc4f7f5SSam Leffler } else { 378acc4f7f5SSam Leffler nt->nt_name = "neighbor"; 379acc4f7f5SSam Leffler nt->nt_inact_init = ic->ic_inact_run; 380acc4f7f5SSam Leffler } 381acc4f7f5SSam Leffler IEEE80211_NODE_UNLOCK(nt); 382acc4f7f5SSam Leffler 383acc4f7f5SSam Leffler ni = ieee80211_alloc_node(nt, ic->ic_myaddr); 384acc4f7f5SSam Leffler if (ni == NULL) { 385acc4f7f5SSam Leffler /* XXX recovery? */ 3868a1b9b6aSSam Leffler return; 3878a1b9b6aSSam Leffler } 3881a1e1d21SSam Leffler IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_myaddr); 3891a1e1d21SSam Leffler ni->ni_esslen = ic->ic_des_esslen; 3901a1e1d21SSam Leffler memcpy(ni->ni_essid, ic->ic_des_essid, ni->ni_esslen); 391f9cd9174SSam Leffler copy_bss(ni, ic->ic_bss); 3921a1e1d21SSam Leffler ni->ni_intval = ic->ic_lintval; 3938a1b9b6aSSam Leffler if (ic->ic_flags & IEEE80211_F_PRIVACY) 3941a1e1d21SSam Leffler ni->ni_capinfo |= IEEE80211_CAPINFO_PRIVACY; 3951a1e1d21SSam Leffler if (ic->ic_phytype == IEEE80211_T_FH) { 3961a1e1d21SSam Leffler ni->ni_fhdwell = 200; /* XXX */ 3971a1e1d21SSam Leffler ni->ni_fhindex = 1; 3981a1e1d21SSam Leffler } 3998a1b9b6aSSam Leffler if (ic->ic_opmode == IEEE80211_M_IBSS) { 4008a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_SIBSS; 4018a1b9b6aSSam Leffler ni->ni_capinfo |= IEEE80211_CAPINFO_IBSS; /* XXX */ 40248b0a5beSSam Leffler if (ic->ic_flags & IEEE80211_F_DESBSSID) 40348b0a5beSSam Leffler IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_des_bssid); 40448b0a5beSSam Leffler else 4058a1b9b6aSSam Leffler ni->ni_bssid[0] |= 0x02; /* local bit for IBSS */ 4068a1b9b6aSSam Leffler } 4078a1b9b6aSSam Leffler /* 4088a1b9b6aSSam Leffler * Fix the channel and related attributes. 4098a1b9b6aSSam Leffler */ 4108a1b9b6aSSam Leffler ieee80211_set_chan(ic, ni, chan); 4118a1b9b6aSSam Leffler ic->ic_curmode = ieee80211_chan2mode(ic, chan); 4128a1b9b6aSSam Leffler /* 4138a1b9b6aSSam Leffler * Do mode-specific rate setup. 4148a1b9b6aSSam Leffler */ 4158a1b9b6aSSam Leffler if (ic->ic_curmode == IEEE80211_MODE_11G) { 4168a1b9b6aSSam Leffler /* 4178a1b9b6aSSam Leffler * Use a mixed 11b/11g rate set. 4188a1b9b6aSSam Leffler */ 4198a1b9b6aSSam Leffler ieee80211_set11gbasicrates(&ni->ni_rates, IEEE80211_MODE_11G); 4208a1b9b6aSSam Leffler } else if (ic->ic_curmode == IEEE80211_MODE_11B) { 4218a1b9b6aSSam Leffler /* 4228a1b9b6aSSam Leffler * Force pure 11b rate set. 4238a1b9b6aSSam Leffler */ 4248a1b9b6aSSam Leffler ieee80211_set11gbasicrates(&ni->ni_rates, IEEE80211_MODE_11B); 4258a1b9b6aSSam Leffler } 4268a1b9b6aSSam Leffler 427acc4f7f5SSam Leffler (void) ieee80211_sta_join(ic, ieee80211_ref_node(ni)); 4281a1e1d21SSam Leffler } 4291a1e1d21SSam Leffler 4308a1b9b6aSSam Leffler void 4318a1b9b6aSSam Leffler ieee80211_reset_bss(struct ieee80211com *ic) 432b4c5a90fSSam Leffler { 4338a1b9b6aSSam Leffler struct ieee80211_node *ni, *obss; 4348a1b9b6aSSam Leffler 4358a1b9b6aSSam Leffler ieee80211_node_table_reset(&ic->ic_scan); 436acc4f7f5SSam Leffler ieee80211_node_table_reset(&ic->ic_sta); 437acc4f7f5SSam Leffler 4388a1b9b6aSSam Leffler ni = ieee80211_alloc_node(&ic->ic_scan, ic->ic_myaddr); 4398a1b9b6aSSam Leffler KASSERT(ni != NULL, ("unable to setup inital BSS node")); 4408a1b9b6aSSam Leffler obss = ic->ic_bss; 4418a1b9b6aSSam Leffler ic->ic_bss = ieee80211_ref_node(ni); 442f9cd9174SSam Leffler if (obss != NULL) { 443f9cd9174SSam Leffler copy_bss(ni, obss); 444f9cd9174SSam Leffler ni->ni_intval = ic->ic_lintval; 4458a1b9b6aSSam Leffler ieee80211_free_node(obss); 4468a1b9b6aSSam Leffler } 447f9cd9174SSam Leffler } 4488a1b9b6aSSam Leffler 4498a1b9b6aSSam Leffler static int 4508a1b9b6aSSam Leffler ieee80211_match_bss(struct ieee80211com *ic, struct ieee80211_node *ni) 4518a1b9b6aSSam Leffler { 452b4c5a90fSSam Leffler u_int8_t rate; 453b4c5a90fSSam Leffler int fail; 454b4c5a90fSSam Leffler 455b4c5a90fSSam Leffler fail = 0; 456b4c5a90fSSam Leffler if (isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ni->ni_chan))) 457b4c5a90fSSam Leffler fail |= 0x01; 458b4c5a90fSSam Leffler if (ic->ic_des_chan != IEEE80211_CHAN_ANYC && 459b4c5a90fSSam Leffler ni->ni_chan != ic->ic_des_chan) 460b4c5a90fSSam Leffler fail |= 0x01; 461b4c5a90fSSam Leffler if (ic->ic_opmode == IEEE80211_M_IBSS) { 462b4c5a90fSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) == 0) 463b4c5a90fSSam Leffler fail |= 0x02; 464b4c5a90fSSam Leffler } else { 465b4c5a90fSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_ESS) == 0) 466b4c5a90fSSam Leffler fail |= 0x02; 467b4c5a90fSSam Leffler } 4688a1b9b6aSSam Leffler if (ic->ic_flags & IEEE80211_F_PRIVACY) { 469b4c5a90fSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) == 0) 470b4c5a90fSSam Leffler fail |= 0x04; 471b4c5a90fSSam Leffler } else { 472b4c5a90fSSam Leffler /* XXX does this mean privacy is supported or required? */ 473b4c5a90fSSam Leffler if (ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) 474b4c5a90fSSam Leffler fail |= 0x04; 475b4c5a90fSSam Leffler } 4767d77cd53SSam Leffler rate = ieee80211_fix_rate(ni, IEEE80211_F_DONEGO | IEEE80211_F_DOFRATE); 477b4c5a90fSSam Leffler if (rate & IEEE80211_RATE_BASIC) 478b4c5a90fSSam Leffler fail |= 0x08; 479b4c5a90fSSam Leffler if (ic->ic_des_esslen != 0 && 480b4c5a90fSSam Leffler (ni->ni_esslen != ic->ic_des_esslen || 481b4c5a90fSSam Leffler memcmp(ni->ni_essid, ic->ic_des_essid, ic->ic_des_esslen) != 0)) 482b4c5a90fSSam Leffler fail |= 0x10; 483b4c5a90fSSam Leffler if ((ic->ic_flags & IEEE80211_F_DESBSSID) && 484b4c5a90fSSam Leffler !IEEE80211_ADDR_EQ(ic->ic_des_bssid, ni->ni_bssid)) 485b4c5a90fSSam Leffler fail |= 0x20; 486b4c5a90fSSam Leffler #ifdef IEEE80211_DEBUG 4878a1b9b6aSSam Leffler if (ieee80211_msg_scan(ic)) { 488b4c5a90fSSam Leffler printf(" %c %s", fail ? '-' : '+', 489b4c5a90fSSam Leffler ether_sprintf(ni->ni_macaddr)); 490b4c5a90fSSam Leffler printf(" %s%c", ether_sprintf(ni->ni_bssid), 491b4c5a90fSSam Leffler fail & 0x20 ? '!' : ' '); 492b4c5a90fSSam Leffler printf(" %3d%c", ieee80211_chan2ieee(ic, ni->ni_chan), 493b4c5a90fSSam Leffler fail & 0x01 ? '!' : ' '); 494b4c5a90fSSam Leffler printf(" %+4d", ni->ni_rssi); 495b4c5a90fSSam Leffler printf(" %2dM%c", (rate & IEEE80211_RATE_VAL) / 2, 496b4c5a90fSSam Leffler fail & 0x08 ? '!' : ' '); 497b4c5a90fSSam Leffler printf(" %4s%c", 498b4c5a90fSSam Leffler (ni->ni_capinfo & IEEE80211_CAPINFO_ESS) ? "ess" : 499b4c5a90fSSam Leffler (ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) ? "ibss" : 500b4c5a90fSSam Leffler "????", 501b4c5a90fSSam Leffler fail & 0x02 ? '!' : ' '); 502b4c5a90fSSam Leffler printf(" %3s%c ", 503b4c5a90fSSam Leffler (ni->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) ? 504b4c5a90fSSam Leffler "wep" : "no", 505b4c5a90fSSam Leffler fail & 0x04 ? '!' : ' '); 506b4c5a90fSSam Leffler ieee80211_print_essid(ni->ni_essid, ni->ni_esslen); 507b4c5a90fSSam Leffler printf("%s\n", fail & 0x10 ? "!" : ""); 508b4c5a90fSSam Leffler } 509b4c5a90fSSam Leffler #endif 510b4c5a90fSSam Leffler return fail; 511b4c5a90fSSam Leffler } 512b4c5a90fSSam Leffler 5138a1b9b6aSSam Leffler static __inline u_int8_t 5148a1b9b6aSSam Leffler maxrate(const struct ieee80211_node *ni) 5158a1b9b6aSSam Leffler { 5168a1b9b6aSSam Leffler const struct ieee80211_rateset *rs = &ni->ni_rates; 5178a1b9b6aSSam Leffler /* NB: assumes rate set is sorted (happens on frame receive) */ 5188a1b9b6aSSam Leffler return rs->rs_rates[rs->rs_nrates-1] & IEEE80211_RATE_VAL; 5198a1b9b6aSSam Leffler } 5208a1b9b6aSSam Leffler 5218a1b9b6aSSam Leffler /* 5228a1b9b6aSSam Leffler * Compare the capabilities of two nodes and decide which is 5238a1b9b6aSSam Leffler * more desirable (return >0 if a is considered better). Note 5248a1b9b6aSSam Leffler * that we assume compatibility/usability has already been checked 5258a1b9b6aSSam Leffler * so we don't need to (e.g. validate whether privacy is supported). 5268a1b9b6aSSam Leffler * Used to select the best scan candidate for association in a BSS. 5278a1b9b6aSSam Leffler */ 5288a1b9b6aSSam Leffler static int 5298a1b9b6aSSam Leffler ieee80211_node_compare(struct ieee80211com *ic, 5308a1b9b6aSSam Leffler const struct ieee80211_node *a, 5318a1b9b6aSSam Leffler const struct ieee80211_node *b) 5328a1b9b6aSSam Leffler { 5338a1b9b6aSSam Leffler u_int8_t maxa, maxb; 5348a1b9b6aSSam Leffler u_int8_t rssia, rssib; 5358a1b9b6aSSam Leffler 5368a1b9b6aSSam Leffler /* privacy support preferred */ 5378a1b9b6aSSam Leffler if ((a->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) && 5388a1b9b6aSSam Leffler (b->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) == 0) 5398a1b9b6aSSam Leffler return 1; 5408a1b9b6aSSam Leffler if ((a->ni_capinfo & IEEE80211_CAPINFO_PRIVACY) == 0 && 5418a1b9b6aSSam Leffler (b->ni_capinfo & IEEE80211_CAPINFO_PRIVACY)) 5428a1b9b6aSSam Leffler return -1; 5438a1b9b6aSSam Leffler 544ef92bcdcSSam Leffler rssia = ic->ic_node_getrssi(a); 545ef92bcdcSSam Leffler rssib = ic->ic_node_getrssi(b); 546ef92bcdcSSam Leffler if (abs(rssib - rssia) < 5) { 5478a1b9b6aSSam Leffler /* best/max rate preferred if signal level close enough XXX */ 5488a1b9b6aSSam Leffler maxa = maxrate(a); 5498a1b9b6aSSam Leffler maxb = maxrate(b); 550ef92bcdcSSam Leffler if (maxa != maxb) 5518a1b9b6aSSam Leffler return maxa - maxb; 5528a1b9b6aSSam Leffler /* XXX use freq for channel preference */ 5538a1b9b6aSSam Leffler /* for now just prefer 5Ghz band to all other bands */ 5548a1b9b6aSSam Leffler if (IEEE80211_IS_CHAN_5GHZ(a->ni_chan) && 5558a1b9b6aSSam Leffler !IEEE80211_IS_CHAN_5GHZ(b->ni_chan)) 5568a1b9b6aSSam Leffler return 1; 5578a1b9b6aSSam Leffler if (!IEEE80211_IS_CHAN_5GHZ(a->ni_chan) && 5588a1b9b6aSSam Leffler IEEE80211_IS_CHAN_5GHZ(b->ni_chan)) 5598a1b9b6aSSam Leffler return -1; 560ef92bcdcSSam Leffler } 5618a1b9b6aSSam Leffler /* all things being equal, use signal level */ 5628a1b9b6aSSam Leffler return rssia - rssib; 5638a1b9b6aSSam Leffler } 5648a1b9b6aSSam Leffler 5651a1e1d21SSam Leffler /* 566c75ac469SSam Leffler * Mark an ongoing scan stopped. 567c75ac469SSam Leffler */ 568c75ac469SSam Leffler void 569c75ac469SSam Leffler ieee80211_cancel_scan(struct ieee80211com *ic) 570c75ac469SSam Leffler { 571c75ac469SSam Leffler 572c75ac469SSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, "%s: end %s scan\n", 573c75ac469SSam Leffler __func__, 574c75ac469SSam Leffler (ic->ic_flags & IEEE80211_F_ASCAN) ? "active" : "passive"); 575c75ac469SSam Leffler 576c75ac469SSam Leffler ic->ic_flags &= ~(IEEE80211_F_SCAN | IEEE80211_F_ASCAN); 577c75ac469SSam Leffler } 578c75ac469SSam Leffler 579c75ac469SSam Leffler /* 5801a1e1d21SSam Leffler * Complete a scan of potential channels. 5811a1e1d21SSam Leffler */ 5821a1e1d21SSam Leffler void 5838a1b9b6aSSam Leffler ieee80211_end_scan(struct ieee80211com *ic) 5841a1e1d21SSam Leffler { 5853fcfbbfaSSam Leffler struct ieee80211_node_table *nt = &ic->ic_scan; 5863fcfbbfaSSam Leffler struct ieee80211_node *ni, *selbs; 5871a1e1d21SSam Leffler 588c75ac469SSam Leffler ieee80211_cancel_scan(ic); 589c75ac469SSam Leffler ieee80211_notify_scan_done(ic); 5908a1b9b6aSSam Leffler 5911a1e1d21SSam Leffler if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 5928a1b9b6aSSam Leffler u_int8_t maxrssi[IEEE80211_CHAN_MAX]; /* XXX off stack? */ 5938a1b9b6aSSam Leffler int i, bestchan; 5948a1b9b6aSSam Leffler u_int8_t rssi; 5958a1b9b6aSSam Leffler 5961a1e1d21SSam Leffler /* 5971a1e1d21SSam Leffler * The passive scan to look for existing AP's completed, 5981a1e1d21SSam Leffler * select a channel to camp on. Identify the channels 5991a1e1d21SSam Leffler * that already have one or more AP's and try to locate 600acc4f7f5SSam Leffler * an unoccupied one. If that fails, pick a channel that 6018a1b9b6aSSam Leffler * looks to be quietest. 6021a1e1d21SSam Leffler */ 6038a1b9b6aSSam Leffler memset(maxrssi, 0, sizeof(maxrssi)); 6043fcfbbfaSSam Leffler IEEE80211_NODE_LOCK(nt); 6053fcfbbfaSSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 6068a1b9b6aSSam Leffler rssi = ic->ic_node_getrssi(ni); 6078a1b9b6aSSam Leffler i = ieee80211_chan2ieee(ic, ni->ni_chan); 6088a1b9b6aSSam Leffler if (rssi > maxrssi[i]) 6098a1b9b6aSSam Leffler maxrssi[i] = rssi; 6101a1e1d21SSam Leffler } 6113fcfbbfaSSam Leffler IEEE80211_NODE_UNLOCK(nt); 6128a1b9b6aSSam Leffler /* XXX select channel more intelligently */ 6138a1b9b6aSSam Leffler bestchan = -1; 6141a1e1d21SSam Leffler for (i = 0; i < IEEE80211_CHAN_MAX; i++) 6158a1b9b6aSSam Leffler if (isset(ic->ic_chan_active, i)) { 6168a1b9b6aSSam Leffler /* 6178a1b9b6aSSam Leffler * If the channel is unoccupied the max rssi 6188a1b9b6aSSam Leffler * should be zero; just take it. Otherwise 6198a1b9b6aSSam Leffler * track the channel with the lowest rssi and 6208a1b9b6aSSam Leffler * use that when all channels appear occupied. 6218a1b9b6aSSam Leffler */ 6228a1b9b6aSSam Leffler if (maxrssi[i] == 0) { 6238a1b9b6aSSam Leffler bestchan = i; 6241a1e1d21SSam Leffler break; 6251a1e1d21SSam Leffler } 6266edf09a6SSam Leffler if (bestchan == -1 || 6276edf09a6SSam Leffler maxrssi[i] < maxrssi[bestchan]) 6288a1b9b6aSSam Leffler bestchan = i; 6298a1b9b6aSSam Leffler } 6308a1b9b6aSSam Leffler if (bestchan != -1) { 6318a1b9b6aSSam Leffler ieee80211_create_ibss(ic, &ic->ic_channels[bestchan]); 6321a1e1d21SSam Leffler return; 6331a1e1d21SSam Leffler } 6348a1b9b6aSSam Leffler /* no suitable channel, should not happen */ 6358a1b9b6aSSam Leffler } 6368a1b9b6aSSam Leffler 6378a1b9b6aSSam Leffler /* 6388a1b9b6aSSam Leffler * When manually sequencing the state machine; scan just once 6398a1b9b6aSSam Leffler * regardless of whether we have a candidate or not. The 6408a1b9b6aSSam Leffler * controlling application is expected to setup state and 6418a1b9b6aSSam Leffler * initiate an association. 6428a1b9b6aSSam Leffler */ 6438a1b9b6aSSam Leffler if (ic->ic_roaming == IEEE80211_ROAMING_MANUAL) 6448a1b9b6aSSam Leffler return; 6458a1b9b6aSSam Leffler /* 6468a1b9b6aSSam Leffler * Automatic sequencing; look for a candidate and 6478a1b9b6aSSam Leffler * if found join the network. 6488a1b9b6aSSam Leffler */ 6493fcfbbfaSSam Leffler /* NB: unlocked read should be ok */ 6503fcfbbfaSSam Leffler if (TAILQ_FIRST(&nt->nt_node) == NULL) { 6518a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, 6528a1b9b6aSSam Leffler "%s: no scan candidate\n", __func__); 6531a1e1d21SSam Leffler notfound: 6541a1e1d21SSam Leffler if (ic->ic_opmode == IEEE80211_M_IBSS && 6551a1e1d21SSam Leffler (ic->ic_flags & IEEE80211_F_IBSSON) && 6561a1e1d21SSam Leffler ic->ic_des_esslen != 0) { 6571a1e1d21SSam Leffler ieee80211_create_ibss(ic, ic->ic_ibss_chan); 6581a1e1d21SSam Leffler return; 6591a1e1d21SSam Leffler } 6601a1e1d21SSam Leffler /* 6611a1e1d21SSam Leffler * Reset the list of channels to scan and start again. 6621a1e1d21SSam Leffler */ 6638a1b9b6aSSam Leffler ieee80211_reset_scan(ic); 6648a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_SCAN; 6658a1b9b6aSSam Leffler ieee80211_next_scan(ic); 6661a1e1d21SSam Leffler return; 6671a1e1d21SSam Leffler } 6681a1e1d21SSam Leffler selbs = NULL; 6698a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, "\t%s\n", 6708a1b9b6aSSam Leffler "macaddr bssid chan rssi rate flag wep essid"); 6713fcfbbfaSSam Leffler IEEE80211_NODE_LOCK(nt); 6723fcfbbfaSSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 6731a1e1d21SSam Leffler if (ni->ni_fails) { 6741a1e1d21SSam Leffler /* 6751a1e1d21SSam Leffler * The configuration of the access points may change 6761a1e1d21SSam Leffler * during my scan. So delete the entry for the AP 6771a1e1d21SSam Leffler * and retry to associate if there is another beacon. 6781a1e1d21SSam Leffler */ 6798a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, 6808a1b9b6aSSam Leffler "%s: skip scan candidate %s, fails %u\n", 6818a1b9b6aSSam Leffler __func__, ether_sprintf(ni->ni_macaddr), 6828a1b9b6aSSam Leffler ni->ni_fails); 6833fcfbbfaSSam Leffler ni->ni_fails++; 6843fcfbbfaSSam Leffler #if 0 6851a1e1d21SSam Leffler if (ni->ni_fails++ > 2) 6868a1b9b6aSSam Leffler ieee80211_free_node(ni); 6873fcfbbfaSSam Leffler #endif 6881a1e1d21SSam Leffler continue; 6891a1e1d21SSam Leffler } 6908a1b9b6aSSam Leffler if (ieee80211_match_bss(ic, ni) == 0) { 6911a1e1d21SSam Leffler if (selbs == NULL) 6921a1e1d21SSam Leffler selbs = ni; 6933fcfbbfaSSam Leffler else if (ieee80211_node_compare(ic, ni, selbs) > 0) 6941a1e1d21SSam Leffler selbs = ni; 6951a1e1d21SSam Leffler } 6961a1e1d21SSam Leffler } 6973fcfbbfaSSam Leffler if (selbs != NULL) /* NB: grab ref while dropping lock */ 6983fcfbbfaSSam Leffler (void) ieee80211_ref_node(selbs); 6993fcfbbfaSSam Leffler IEEE80211_NODE_UNLOCK(nt); 7001a1e1d21SSam Leffler if (selbs == NULL) 7011a1e1d21SSam Leffler goto notfound; 7028a1b9b6aSSam Leffler if (!ieee80211_sta_join(ic, selbs)) { 7033fcfbbfaSSam Leffler ieee80211_free_node(selbs); 7041a1e1d21SSam Leffler goto notfound; 7051a1e1d21SSam Leffler } 7068a1b9b6aSSam Leffler } 7078a1b9b6aSSam Leffler 708750d6d0cSSam Leffler /* 7098a1b9b6aSSam Leffler * Handle 802.11 ad hoc network merge. The 7108a1b9b6aSSam Leffler * convention, set by the Wireless Ethernet Compatibility Alliance 7118a1b9b6aSSam Leffler * (WECA), is that an 802.11 station will change its BSSID to match 7128a1b9b6aSSam Leffler * the "oldest" 802.11 ad hoc network, on the same channel, that 7138a1b9b6aSSam Leffler * has the station's desired SSID. The "oldest" 802.11 network 7148a1b9b6aSSam Leffler * sends beacons with the greatest TSF timestamp. 7158a1b9b6aSSam Leffler * 7168a1b9b6aSSam Leffler * The caller is assumed to validate TSF's before attempting a merge. 7178a1b9b6aSSam Leffler * 7188a1b9b6aSSam Leffler * Return !0 if the BSSID changed, 0 otherwise. 719750d6d0cSSam Leffler */ 7208a1b9b6aSSam Leffler int 721641b4d0bSSam Leffler ieee80211_ibss_merge(struct ieee80211_node *ni) 7228a1b9b6aSSam Leffler { 723641b4d0bSSam Leffler struct ieee80211com *ic = ni->ni_ic; 7248a1b9b6aSSam Leffler 72596acc1b6SSam Leffler if (ni == ic->ic_bss || 72696acc1b6SSam Leffler IEEE80211_ADDR_EQ(ni->ni_bssid, ic->ic_bss->ni_bssid)) { 7278a1b9b6aSSam Leffler /* unchanged, nothing to do */ 7288a1b9b6aSSam Leffler return 0; 7298a1b9b6aSSam Leffler } 7308a1b9b6aSSam Leffler if (ieee80211_match_bss(ic, ni) != 0) { /* capabilities mismatch */ 7318a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 7328a1b9b6aSSam Leffler "%s: merge failed, capabilities mismatch\n", __func__); 7338a1b9b6aSSam Leffler ic->ic_stats.is_ibss_capmismatch++; 7348a1b9b6aSSam Leffler return 0; 7358a1b9b6aSSam Leffler } 7368a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 7378a1b9b6aSSam Leffler "%s: new bssid %s: %s preamble, %s slot time%s\n", __func__, 7388a1b9b6aSSam Leffler ether_sprintf(ni->ni_bssid), 7398a1b9b6aSSam Leffler ic->ic_flags&IEEE80211_F_SHPREAMBLE ? "short" : "long", 7408a1b9b6aSSam Leffler ic->ic_flags&IEEE80211_F_SHSLOT ? "short" : "long", 7418a1b9b6aSSam Leffler ic->ic_flags&IEEE80211_F_USEPROT ? ", protection" : "" 7428a1b9b6aSSam Leffler ); 743acc4f7f5SSam Leffler return ieee80211_sta_join(ic, ieee80211_ref_node(ni)); 7448a1b9b6aSSam Leffler } 7458a1b9b6aSSam Leffler 7468a1b9b6aSSam Leffler /* 7478a1b9b6aSSam Leffler * Join the specified IBSS/BSS network. The node is assumed to 7488a1b9b6aSSam Leffler * be passed in with a held reference. 7498a1b9b6aSSam Leffler */ 7508a1b9b6aSSam Leffler int 7518a1b9b6aSSam Leffler ieee80211_sta_join(struct ieee80211com *ic, struct ieee80211_node *selbs) 7528a1b9b6aSSam Leffler { 7538a1b9b6aSSam Leffler struct ieee80211_node *obss; 7548a1b9b6aSSam Leffler 7558a1b9b6aSSam Leffler if (ic->ic_opmode == IEEE80211_M_IBSS) { 756acc4f7f5SSam Leffler struct ieee80211_node_table *nt; 7578a1b9b6aSSam Leffler /* 75898ff6263SSam Leffler * Delete unusable rates; we've already checked 75998ff6263SSam Leffler * that the negotiated rate set is acceptable. 7608a1b9b6aSSam Leffler */ 7617d77cd53SSam Leffler ieee80211_fix_rate(selbs, IEEE80211_F_DODEL); 7628a1b9b6aSSam Leffler /* 763acc4f7f5SSam Leffler * Fillin the neighbor table; it will already 7643d073929SSam Leffler * exist if we are simply switching mastership. 765acc4f7f5SSam Leffler * XXX ic_sta always setup so this is unnecessary? 7668a1b9b6aSSam Leffler */ 767acc4f7f5SSam Leffler nt = &ic->ic_sta; 768acc4f7f5SSam Leffler IEEE80211_NODE_LOCK(nt); 769acc4f7f5SSam Leffler nt->nt_name = "neighbor"; 770acc4f7f5SSam Leffler nt->nt_inact_init = ic->ic_inact_run; 771acc4f7f5SSam Leffler IEEE80211_NODE_UNLOCK(nt); 7723d073929SSam Leffler } 7731a1e1d21SSam Leffler 7748a1b9b6aSSam Leffler /* 7758a1b9b6aSSam Leffler * Committed to selbs, setup state. 7768a1b9b6aSSam Leffler */ 7778a1b9b6aSSam Leffler obss = ic->ic_bss; 778acc4f7f5SSam Leffler ic->ic_bss = selbs; /* NB: caller assumed to bump refcnt */ 7798a1b9b6aSSam Leffler if (obss != NULL) 7808a1b9b6aSSam Leffler ieee80211_free_node(obss); 7818a1b9b6aSSam Leffler /* 7828a1b9b6aSSam Leffler * Set the erp state (mostly the slot time) to deal with 7838a1b9b6aSSam Leffler * the auto-select case; this should be redundant if the 7848a1b9b6aSSam Leffler * mode is locked. 7858a1b9b6aSSam Leffler */ 7868a1b9b6aSSam Leffler ic->ic_curmode = ieee80211_chan2mode(ic, selbs->ni_chan); 7878a1b9b6aSSam Leffler ieee80211_reset_erp(ic); 7888a1b9b6aSSam Leffler ieee80211_wme_initparams(ic); 789acc4f7f5SSam Leffler 790acc4f7f5SSam Leffler if (ic->ic_opmode == IEEE80211_M_STA) 7918a1b9b6aSSam Leffler ieee80211_new_state(ic, IEEE80211_S_AUTH, -1); 792acc4f7f5SSam Leffler else 793acc4f7f5SSam Leffler ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 7948a1b9b6aSSam Leffler return 1; 7958a1b9b6aSSam Leffler } 7968a1b9b6aSSam Leffler 7978a1b9b6aSSam Leffler /* 7988a1b9b6aSSam Leffler * Leave the specified IBSS/BSS network. The node is assumed to 7998a1b9b6aSSam Leffler * be passed in with a held reference. 8008a1b9b6aSSam Leffler */ 8018a1b9b6aSSam Leffler void 8028a1b9b6aSSam Leffler ieee80211_sta_leave(struct ieee80211com *ic, struct ieee80211_node *ni) 8038a1b9b6aSSam Leffler { 8048a1b9b6aSSam Leffler ic->ic_node_cleanup(ni); 8058a1b9b6aSSam Leffler ieee80211_notify_node_leave(ic, ni); 8068a1b9b6aSSam Leffler } 8078a1b9b6aSSam Leffler 8081a1e1d21SSam Leffler static struct ieee80211_node * 8098a1b9b6aSSam Leffler node_alloc(struct ieee80211_node_table *nt) 8101a1e1d21SSam Leffler { 811410ca74bSSam Leffler struct ieee80211_node *ni; 8128a1b9b6aSSam Leffler 813410ca74bSSam Leffler MALLOC(ni, struct ieee80211_node *, sizeof(struct ieee80211_node), 814410ca74bSSam Leffler M_80211_NODE, M_NOWAIT | M_ZERO); 815410ca74bSSam Leffler return ni; 8161a1e1d21SSam Leffler } 8171a1e1d21SSam Leffler 8188a1b9b6aSSam Leffler /* 8198a1b9b6aSSam Leffler * Reclaim any resources in a node and reset any critical 8208a1b9b6aSSam Leffler * state. Typically nodes are free'd immediately after, 8218a1b9b6aSSam Leffler * but in some cases the storage may be reused so we need 8228a1b9b6aSSam Leffler * to insure consistent state (should probably fix that). 8238a1b9b6aSSam Leffler */ 8241a1e1d21SSam Leffler static void 8258a1b9b6aSSam Leffler node_cleanup(struct ieee80211_node *ni) 8261a1e1d21SSam Leffler { 8278a1b9b6aSSam Leffler #define N(a) (sizeof(a)/sizeof(a[0])) 8288a1b9b6aSSam Leffler struct ieee80211com *ic = ni->ni_ic; 8298a1b9b6aSSam Leffler int i, qlen; 8308a1b9b6aSSam Leffler 8318a1b9b6aSSam Leffler /* NB: preserve ni_table */ 8328a1b9b6aSSam Leffler if (ni->ni_flags & IEEE80211_NODE_PWR_MGT) { 8338a1b9b6aSSam Leffler ic->ic_ps_sta--; 8348a1b9b6aSSam Leffler ni->ni_flags &= ~IEEE80211_NODE_PWR_MGT; 8358a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER, 8368a1b9b6aSSam Leffler "[%s] power save mode off, %u sta's in ps mode\n", 8378a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ic->ic_ps_sta); 8388a1b9b6aSSam Leffler } 839ebdda46cSSam Leffler /* 840ebdda46cSSam Leffler * Clear AREF flag that marks the authorization refcnt bump 841ebdda46cSSam Leffler * has happened. This is probably not needed as the node 842ebdda46cSSam Leffler * should always be removed from the table so not found but 843ebdda46cSSam Leffler * do it just in case. 844ebdda46cSSam Leffler */ 845ebdda46cSSam Leffler ni->ni_flags &= ~IEEE80211_NODE_AREF; 8468a1b9b6aSSam Leffler 8478a1b9b6aSSam Leffler /* 8488a1b9b6aSSam Leffler * Drain power save queue and, if needed, clear TIM. 8498a1b9b6aSSam Leffler */ 8508a1b9b6aSSam Leffler IEEE80211_NODE_SAVEQ_DRAIN(ni, qlen); 8518a1b9b6aSSam Leffler if (qlen != 0 && ic->ic_set_tim != NULL) 852edfa57d0SSam Leffler ic->ic_set_tim(ni, 0); 8538a1b9b6aSSam Leffler 8548a1b9b6aSSam Leffler ni->ni_associd = 0; 8558a1b9b6aSSam Leffler if (ni->ni_challenge != NULL) { 8568a1b9b6aSSam Leffler FREE(ni->ni_challenge, M_DEVBUF); 8578a1b9b6aSSam Leffler ni->ni_challenge = NULL; 8588a1b9b6aSSam Leffler } 8598a1b9b6aSSam Leffler /* 8608a1b9b6aSSam Leffler * Preserve SSID, WPA, and WME ie's so the bss node is 8618a1b9b6aSSam Leffler * reusable during a re-auth/re-assoc state transition. 8628a1b9b6aSSam Leffler * If we remove these data they will not be recreated 8638a1b9b6aSSam Leffler * because they come from a probe-response or beacon frame 8648a1b9b6aSSam Leffler * which cannot be expected prior to the association-response. 8658a1b9b6aSSam Leffler * This should not be an issue when operating in other modes 8668a1b9b6aSSam Leffler * as stations leaving always go through a full state transition 8678a1b9b6aSSam Leffler * which will rebuild this state. 8688a1b9b6aSSam Leffler * 8698a1b9b6aSSam Leffler * XXX does this leave us open to inheriting old state? 8708a1b9b6aSSam Leffler */ 8718a1b9b6aSSam Leffler for (i = 0; i < N(ni->ni_rxfrag); i++) 8728a1b9b6aSSam Leffler if (ni->ni_rxfrag[i] != NULL) { 8738a1b9b6aSSam Leffler m_freem(ni->ni_rxfrag[i]); 8748a1b9b6aSSam Leffler ni->ni_rxfrag[i] = NULL; 8758a1b9b6aSSam Leffler } 8768a1b9b6aSSam Leffler ieee80211_crypto_delkey(ic, &ni->ni_ucastkey); 8778a1b9b6aSSam Leffler #undef N 8788a1b9b6aSSam Leffler } 8798a1b9b6aSSam Leffler 8808a1b9b6aSSam Leffler static void 8818a1b9b6aSSam Leffler node_free(struct ieee80211_node *ni) 8828a1b9b6aSSam Leffler { 8838a1b9b6aSSam Leffler struct ieee80211com *ic = ni->ni_ic; 8848a1b9b6aSSam Leffler 8858a1b9b6aSSam Leffler ic->ic_node_cleanup(ni); 8868a1b9b6aSSam Leffler if (ni->ni_wpa_ie != NULL) 8878a1b9b6aSSam Leffler FREE(ni->ni_wpa_ie, M_DEVBUF); 8888a1b9b6aSSam Leffler if (ni->ni_wme_ie != NULL) 8898a1b9b6aSSam Leffler FREE(ni->ni_wme_ie, M_DEVBUF); 8908a1b9b6aSSam Leffler IEEE80211_NODE_SAVEQ_DESTROY(ni); 891410ca74bSSam Leffler FREE(ni, M_80211_NODE); 8921a1e1d21SSam Leffler } 8931a1e1d21SSam Leffler 894d1e61976SSam Leffler static u_int8_t 8958a1b9b6aSSam Leffler node_getrssi(const struct ieee80211_node *ni) 896d1e61976SSam Leffler { 897d1e61976SSam Leffler return ni->ni_rssi; 898d1e61976SSam Leffler } 899d1e61976SSam Leffler 9001a1e1d21SSam Leffler static void 9018a1b9b6aSSam Leffler ieee80211_setup_node(struct ieee80211_node_table *nt, 9028a1b9b6aSSam Leffler struct ieee80211_node *ni, const u_int8_t *macaddr) 9031a1e1d21SSam Leffler { 9048a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 9051a1e1d21SSam Leffler int hash; 9061a1e1d21SSam Leffler 9078a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 90849a15236SSam Leffler "%s %p<%s> in %s table\n", __func__, ni, 9098a1b9b6aSSam Leffler ether_sprintf(macaddr), nt->nt_name); 9108a1b9b6aSSam Leffler 9111a1e1d21SSam Leffler IEEE80211_ADDR_COPY(ni->ni_macaddr, macaddr); 9121a1e1d21SSam Leffler hash = IEEE80211_NODE_HASH(macaddr); 9138a1b9b6aSSam Leffler ieee80211_node_initref(ni); /* mark referenced */ 9148a1b9b6aSSam Leffler ni->ni_chan = IEEE80211_CHAN_ANYC; 9158a1b9b6aSSam Leffler ni->ni_authmode = IEEE80211_AUTH_OPEN; 9168a1b9b6aSSam Leffler ni->ni_txpower = ic->ic_txpowlimit; /* max power */ 9178a1b9b6aSSam Leffler ieee80211_crypto_resetkey(ic, &ni->ni_ucastkey, IEEE80211_KEYIX_NONE); 9182045f699SSam Leffler ni->ni_inact_reload = nt->nt_inact_init; 9192045f699SSam Leffler ni->ni_inact = ni->ni_inact_reload; 9208a1b9b6aSSam Leffler IEEE80211_NODE_SAVEQ_INIT(ni, "unknown"); 9218a1b9b6aSSam Leffler 9228a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 9238a1b9b6aSSam Leffler TAILQ_INSERT_TAIL(&nt->nt_node, ni, ni_list); 9248a1b9b6aSSam Leffler LIST_INSERT_HEAD(&nt->nt_hash[hash], ni, ni_hash); 9258a1b9b6aSSam Leffler ni->ni_table = nt; 9268a1b9b6aSSam Leffler ni->ni_ic = ic; 9278a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 9281a1e1d21SSam Leffler } 9291a1e1d21SSam Leffler 9301a1e1d21SSam Leffler struct ieee80211_node * 9318a1b9b6aSSam Leffler ieee80211_alloc_node(struct ieee80211_node_table *nt, const u_int8_t *macaddr) 9321a1e1d21SSam Leffler { 9338a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 9348a1b9b6aSSam Leffler struct ieee80211_node *ni; 9358a1b9b6aSSam Leffler 9368a1b9b6aSSam Leffler ni = ic->ic_node_alloc(nt); 9371a1e1d21SSam Leffler if (ni != NULL) 9388a1b9b6aSSam Leffler ieee80211_setup_node(nt, ni, macaddr); 939c64bfa0fSSam Leffler else 940c64bfa0fSSam Leffler ic->ic_stats.is_rx_nodealloc++; 9411a1e1d21SSam Leffler return ni; 9421a1e1d21SSam Leffler } 9431a1e1d21SSam Leffler 9441a1e1d21SSam Leffler struct ieee80211_node * 9458a1b9b6aSSam Leffler ieee80211_dup_bss(struct ieee80211_node_table *nt, const u_int8_t *macaddr) 9461a1e1d21SSam Leffler { 9478a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 9488a1b9b6aSSam Leffler struct ieee80211_node *ni; 9498a1b9b6aSSam Leffler 9508a1b9b6aSSam Leffler ni = ic->ic_node_alloc(nt); 9511a1e1d21SSam Leffler if (ni != NULL) { 9528a1b9b6aSSam Leffler ieee80211_setup_node(nt, ni, macaddr); 953694dca64SSam Leffler /* 954694dca64SSam Leffler * Inherit from ic_bss. 955694dca64SSam Leffler */ 9568a1b9b6aSSam Leffler ni->ni_authmode = ic->ic_bss->ni_authmode; 9578a1b9b6aSSam Leffler ni->ni_txpower = ic->ic_bss->ni_txpower; 9588a1b9b6aSSam Leffler ni->ni_vlan = ic->ic_bss->ni_vlan; /* XXX?? */ 959694dca64SSam Leffler IEEE80211_ADDR_COPY(ni->ni_bssid, ic->ic_bss->ni_bssid); 9608a1b9b6aSSam Leffler ieee80211_set_chan(ic, ni, ic->ic_bss->ni_chan); 9618a1b9b6aSSam Leffler ni->ni_rsn = ic->ic_bss->ni_rsn; 962694dca64SSam Leffler } else 963694dca64SSam Leffler ic->ic_stats.is_rx_nodealloc++; 9641a1e1d21SSam Leffler return ni; 9651a1e1d21SSam Leffler } 9661a1e1d21SSam Leffler 967750d6d0cSSam Leffler static struct ieee80211_node * 9688a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 9698a1b9b6aSSam Leffler _ieee80211_find_node_debug(struct ieee80211_node_table *nt, 9708a1b9b6aSSam Leffler const u_int8_t *macaddr, const char *func, int line) 9718a1b9b6aSSam Leffler #else 9728a1b9b6aSSam Leffler _ieee80211_find_node(struct ieee80211_node_table *nt, 9738a1b9b6aSSam Leffler const u_int8_t *macaddr) 9748a1b9b6aSSam Leffler #endif 9751a1e1d21SSam Leffler { 9761a1e1d21SSam Leffler struct ieee80211_node *ni; 9771a1e1d21SSam Leffler int hash; 9781a1e1d21SSam Leffler 9798a1b9b6aSSam Leffler IEEE80211_NODE_LOCK_ASSERT(nt); 980750d6d0cSSam Leffler 9811a1e1d21SSam Leffler hash = IEEE80211_NODE_HASH(macaddr); 9828a1b9b6aSSam Leffler LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) { 9831a1e1d21SSam Leffler if (IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr)) { 9848a1b9b6aSSam Leffler ieee80211_ref_node(ni); /* mark referenced */ 9858a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 9868a1b9b6aSSam Leffler IEEE80211_DPRINTF(nt->nt_ic, IEEE80211_MSG_NODE, 98749a15236SSam Leffler "%s (%s:%u) %p<%s> refcnt %d\n", __func__, 98849a15236SSam Leffler func, line, 98949a15236SSam Leffler ni, ether_sprintf(ni->ni_macaddr), 9908a1b9b6aSSam Leffler ieee80211_node_refcnt(ni)); 9918a1b9b6aSSam Leffler #endif 992750d6d0cSSam Leffler return ni; 9931a1e1d21SSam Leffler } 9941a1e1d21SSam Leffler } 995750d6d0cSSam Leffler return NULL; 996750d6d0cSSam Leffler } 9978a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 9988a1b9b6aSSam Leffler #define _ieee80211_find_node(nt, mac) \ 9998a1b9b6aSSam Leffler _ieee80211_find_node_debug(nt, mac, func, line) 10008a1b9b6aSSam Leffler #endif 1001750d6d0cSSam Leffler 1002750d6d0cSSam Leffler struct ieee80211_node * 10038a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 10048a1b9b6aSSam Leffler ieee80211_find_node_debug(struct ieee80211_node_table *nt, 10058a1b9b6aSSam Leffler const u_int8_t *macaddr, const char *func, int line) 10068a1b9b6aSSam Leffler #else 10078a1b9b6aSSam Leffler ieee80211_find_node(struct ieee80211_node_table *nt, const u_int8_t *macaddr) 10088a1b9b6aSSam Leffler #endif 1009750d6d0cSSam Leffler { 1010750d6d0cSSam Leffler struct ieee80211_node *ni; 1011750d6d0cSSam Leffler 10128a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 10138a1b9b6aSSam Leffler ni = _ieee80211_find_node(nt, macaddr); 10148a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 10151a1e1d21SSam Leffler return ni; 10161a1e1d21SSam Leffler } 10171a1e1d21SSam Leffler 10181a1e1d21SSam Leffler /* 10198a1b9b6aSSam Leffler * Fake up a node; this handles node discovery in adhoc mode. 10208a1b9b6aSSam Leffler * Note that for the driver's benefit we we treat this like 10218a1b9b6aSSam Leffler * an association so the driver has an opportunity to setup 10228a1b9b6aSSam Leffler * it's private state. 10238a1b9b6aSSam Leffler */ 10248a1b9b6aSSam Leffler struct ieee80211_node * 10258a1b9b6aSSam Leffler ieee80211_fakeup_adhoc_node(struct ieee80211_node_table *nt, 10268a1b9b6aSSam Leffler const u_int8_t macaddr[IEEE80211_ADDR_LEN]) 10278a1b9b6aSSam Leffler { 10288a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 10298a1b9b6aSSam Leffler struct ieee80211_node *ni; 10308a1b9b6aSSam Leffler 10318a1b9b6aSSam Leffler ni = ieee80211_dup_bss(nt, macaddr); 10328a1b9b6aSSam Leffler if (ni != NULL) { 10338a1b9b6aSSam Leffler /* XXX no rate negotiation; just dup */ 10348a1b9b6aSSam Leffler ni->ni_rates = ic->ic_bss->ni_rates; 1035736b3dc3SSam Leffler if (ic->ic_newassoc != NULL) 1036e9962332SSam Leffler ic->ic_newassoc(ni, 1); 10378a1b9b6aSSam Leffler /* XXX not right for 802.1x/WPA */ 1038e4918ecdSSam Leffler ieee80211_node_authorize(ni); 10398a1b9b6aSSam Leffler } 10408a1b9b6aSSam Leffler return ni; 10418a1b9b6aSSam Leffler } 10428a1b9b6aSSam Leffler 10438a1b9b6aSSam Leffler /* 10448a1b9b6aSSam Leffler * Locate the node for sender, track state, and then pass the 10458a1b9b6aSSam Leffler * (referenced) node up to the 802.11 layer for its use. We 10468a1b9b6aSSam Leffler * are required to pass some node so we fall back to ic_bss 10478a1b9b6aSSam Leffler * when this frame is from an unknown sender. The 802.11 layer 10488a1b9b6aSSam Leffler * knows this means the sender wasn't in the node table and 10498a1b9b6aSSam Leffler * acts accordingly. 10508a1b9b6aSSam Leffler */ 10518a1b9b6aSSam Leffler struct ieee80211_node * 10528a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 10538a1b9b6aSSam Leffler ieee80211_find_rxnode_debug(struct ieee80211com *ic, 10548a1b9b6aSSam Leffler const struct ieee80211_frame_min *wh, const char *func, int line) 10558a1b9b6aSSam Leffler #else 10568a1b9b6aSSam Leffler ieee80211_find_rxnode(struct ieee80211com *ic, 10578a1b9b6aSSam Leffler const struct ieee80211_frame_min *wh) 10588a1b9b6aSSam Leffler #endif 10598a1b9b6aSSam Leffler { 10608a1b9b6aSSam Leffler #define IS_CTL(wh) \ 10618a1b9b6aSSam Leffler ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_CTL) 10628a1b9b6aSSam Leffler #define IS_PSPOLL(wh) \ 10638a1b9b6aSSam Leffler ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) == IEEE80211_FC0_SUBTYPE_PS_POLL) 10648a1b9b6aSSam Leffler struct ieee80211_node_table *nt; 10658a1b9b6aSSam Leffler struct ieee80211_node *ni; 10668a1b9b6aSSam Leffler 10678a1b9b6aSSam Leffler /* XXX may want scanned nodes in the neighbor table for adhoc */ 10688a1b9b6aSSam Leffler if (ic->ic_opmode == IEEE80211_M_STA || 10698a1b9b6aSSam Leffler ic->ic_opmode == IEEE80211_M_MONITOR || 10708a1b9b6aSSam Leffler (ic->ic_flags & IEEE80211_F_SCAN)) 10718a1b9b6aSSam Leffler nt = &ic->ic_scan; 10728a1b9b6aSSam Leffler else 1073acc4f7f5SSam Leffler nt = &ic->ic_sta; 10748a1b9b6aSSam Leffler /* XXX check ic_bss first in station mode */ 10758a1b9b6aSSam Leffler /* XXX 4-address frames? */ 10768a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 10778a1b9b6aSSam Leffler if (IS_CTL(wh) && !IS_PSPOLL(wh) /*&& !IS_RTS(ah)*/) 10788a1b9b6aSSam Leffler ni = _ieee80211_find_node(nt, wh->i_addr1); 10798a1b9b6aSSam Leffler else 10808a1b9b6aSSam Leffler ni = _ieee80211_find_node(nt, wh->i_addr2); 10818a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 10828a1b9b6aSSam Leffler 10838a1b9b6aSSam Leffler return (ni != NULL ? ni : ieee80211_ref_node(ic->ic_bss)); 10848a1b9b6aSSam Leffler #undef IS_PSPOLL 10858a1b9b6aSSam Leffler #undef IS_CTL 10868a1b9b6aSSam Leffler } 10878a1b9b6aSSam Leffler 10888a1b9b6aSSam Leffler /* 1089750d6d0cSSam Leffler * Return a reference to the appropriate node for sending 1090750d6d0cSSam Leffler * a data frame. This handles node discovery in adhoc networks. 1091750d6d0cSSam Leffler */ 1092750d6d0cSSam Leffler struct ieee80211_node * 10938a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 10948a1b9b6aSSam Leffler ieee80211_find_txnode_debug(struct ieee80211com *ic, const u_int8_t *macaddr, 10958a1b9b6aSSam Leffler const char *func, int line) 10968a1b9b6aSSam Leffler #else 10978a1b9b6aSSam Leffler ieee80211_find_txnode(struct ieee80211com *ic, const u_int8_t *macaddr) 10988a1b9b6aSSam Leffler #endif 1099750d6d0cSSam Leffler { 1100acc4f7f5SSam Leffler struct ieee80211_node_table *nt = &ic->ic_sta; 1101750d6d0cSSam Leffler struct ieee80211_node *ni; 1102750d6d0cSSam Leffler 1103750d6d0cSSam Leffler /* 1104750d6d0cSSam Leffler * The destination address should be in the node table 1105750d6d0cSSam Leffler * unless we are operating in station mode or this is a 1106750d6d0cSSam Leffler * multicast/broadcast frame. 1107750d6d0cSSam Leffler */ 1108acc4f7f5SSam Leffler if (ic->ic_opmode == IEEE80211_M_STA || IEEE80211_IS_MULTICAST(macaddr)) 11098a1b9b6aSSam Leffler return ieee80211_ref_node(ic->ic_bss); 1110750d6d0cSSam Leffler 1111750d6d0cSSam Leffler /* XXX can't hold lock across dup_bss 'cuz of recursive locking */ 11128a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 11138a1b9b6aSSam Leffler ni = _ieee80211_find_node(nt, macaddr); 11148a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 11158a1b9b6aSSam Leffler 11168a1b9b6aSSam Leffler if (ni == NULL) { 11178a1b9b6aSSam Leffler if (ic->ic_opmode == IEEE80211_M_IBSS || 111890d0d036SSam Leffler ic->ic_opmode == IEEE80211_M_AHDEMO) { 111990d0d036SSam Leffler /* 112090d0d036SSam Leffler * In adhoc mode cons up a node for the destination. 112190d0d036SSam Leffler * Note that we need an additional reference for the 112290d0d036SSam Leffler * caller to be consistent with _ieee80211_find_node. 112390d0d036SSam Leffler */ 11248a1b9b6aSSam Leffler ni = ieee80211_fakeup_adhoc_node(nt, macaddr); 112590d0d036SSam Leffler if (ni != NULL) 112690d0d036SSam Leffler (void) ieee80211_ref_node(ni); 112790d0d036SSam Leffler } else { 11288a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_OUTPUT, 11298a1b9b6aSSam Leffler "[%s] no node, discard frame (%s)\n", 11308a1b9b6aSSam Leffler ether_sprintf(macaddr), __func__); 11318a1b9b6aSSam Leffler ic->ic_stats.is_tx_nonode++; 1132750d6d0cSSam Leffler } 1133750d6d0cSSam Leffler } 1134750d6d0cSSam Leffler return ni; 1135750d6d0cSSam Leffler } 1136750d6d0cSSam Leffler 1137750d6d0cSSam Leffler /* 11381a1e1d21SSam Leffler * Like find but search based on the channel too. 11391a1e1d21SSam Leffler */ 11401a1e1d21SSam Leffler struct ieee80211_node * 11418a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 11428a1b9b6aSSam Leffler ieee80211_find_node_with_channel_debug(struct ieee80211_node_table *nt, 11438a1b9b6aSSam Leffler const u_int8_t *macaddr, struct ieee80211_channel *chan, 11448a1b9b6aSSam Leffler const char *func, int line) 11458a1b9b6aSSam Leffler #else 11468a1b9b6aSSam Leffler ieee80211_find_node_with_channel(struct ieee80211_node_table *nt, 11478a1b9b6aSSam Leffler const u_int8_t *macaddr, struct ieee80211_channel *chan) 11488a1b9b6aSSam Leffler #endif 11491a1e1d21SSam Leffler { 11501a1e1d21SSam Leffler struct ieee80211_node *ni; 11511a1e1d21SSam Leffler int hash; 11521a1e1d21SSam Leffler 11531a1e1d21SSam Leffler hash = IEEE80211_NODE_HASH(macaddr); 11548a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 11558a1b9b6aSSam Leffler LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) { 1156750d6d0cSSam Leffler if (IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr) && 1157750d6d0cSSam Leffler ni->ni_chan == chan) { 11588a1b9b6aSSam Leffler ieee80211_ref_node(ni); /* mark referenced */ 11598a1b9b6aSSam Leffler IEEE80211_DPRINTF(nt->nt_ic, IEEE80211_MSG_NODE, 11608a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 116149a15236SSam Leffler "%s (%s:%u) %p<%s> refcnt %d\n", __func__, 116249a15236SSam Leffler func, line, 11638a1b9b6aSSam Leffler #else 116449a15236SSam Leffler "%s %p<%s> refcnt %d\n", __func__, 11658a1b9b6aSSam Leffler #endif 116649a15236SSam Leffler ni, ether_sprintf(ni->ni_macaddr), 11678a1b9b6aSSam Leffler ieee80211_node_refcnt(ni)); 11681a1e1d21SSam Leffler break; 11691a1e1d21SSam Leffler } 11701a1e1d21SSam Leffler } 11718a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 11721a1e1d21SSam Leffler return ni; 11731a1e1d21SSam Leffler } 11741a1e1d21SSam Leffler 11758a1b9b6aSSam Leffler /* 11768a1b9b6aSSam Leffler * Like find but search based on the ssid too. 11778a1b9b6aSSam Leffler */ 11788a1b9b6aSSam Leffler struct ieee80211_node * 11798a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 11808a1b9b6aSSam Leffler ieee80211_find_node_with_ssid_debug(struct ieee80211_node_table *nt, 11818a1b9b6aSSam Leffler const u_int8_t *macaddr, u_int ssidlen, const u_int8_t *ssid, 11828a1b9b6aSSam Leffler const char *func, int line) 11838a1b9b6aSSam Leffler #else 11848a1b9b6aSSam Leffler ieee80211_find_node_with_ssid(struct ieee80211_node_table *nt, 11858a1b9b6aSSam Leffler const u_int8_t *macaddr, u_int ssidlen, const u_int8_t *ssid) 11868a1b9b6aSSam Leffler #endif 11871a1e1d21SSam Leffler { 1188f02a0bd2SSam Leffler #define MATCH_SSID(ni, ssid, ssidlen) \ 1189f02a0bd2SSam Leffler (ni->ni_esslen == ssidlen && memcmp(ni->ni_essid, ssid, ssidlen) == 0) 1190f02a0bd2SSam Leffler static const u_int8_t zeromac[IEEE80211_ADDR_LEN]; 11918a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 11921a1e1d21SSam Leffler struct ieee80211_node *ni; 11938a1b9b6aSSam Leffler int hash; 11941a1e1d21SSam Leffler 11958a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 1196f02a0bd2SSam Leffler /* 1197f02a0bd2SSam Leffler * A mac address that is all zero means match only the ssid; 1198f02a0bd2SSam Leffler * otherwise we must match both. 1199f02a0bd2SSam Leffler */ 1200f02a0bd2SSam Leffler if (IEEE80211_ADDR_EQ(macaddr, zeromac)) { 1201f02a0bd2SSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 1202f02a0bd2SSam Leffler if (MATCH_SSID(ni, ssid, ssidlen)) 1203f02a0bd2SSam Leffler break; 1204f02a0bd2SSam Leffler } 1205f02a0bd2SSam Leffler } else { 1206f02a0bd2SSam Leffler hash = IEEE80211_NODE_HASH(macaddr); 12078a1b9b6aSSam Leffler LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) { 12088a1b9b6aSSam Leffler if (IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr) && 1209f02a0bd2SSam Leffler MATCH_SSID(ni, ssid, ssidlen)) 1210f02a0bd2SSam Leffler break; 1211f02a0bd2SSam Leffler } 1212f02a0bd2SSam Leffler } 1213f02a0bd2SSam Leffler if (ni != NULL) { 12148a1b9b6aSSam Leffler ieee80211_ref_node(ni); /* mark referenced */ 12158a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 12168a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 121749a15236SSam Leffler "%s (%s:%u) %p<%s> refcnt %d\n", __func__, 121849a15236SSam Leffler func, line, 12198a1b9b6aSSam Leffler #else 122049a15236SSam Leffler "%s %p<%s> refcnt %d\n", __func__, 12218a1b9b6aSSam Leffler #endif 122249a15236SSam Leffler ni, ether_sprintf(ni->ni_macaddr), 12238a1b9b6aSSam Leffler ieee80211_node_refcnt(ni)); 12248a1b9b6aSSam Leffler } 12258a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 12268a1b9b6aSSam Leffler return ni; 1227f02a0bd2SSam Leffler #undef MATCH_SSID 12288a1b9b6aSSam Leffler } 12298a1b9b6aSSam Leffler 12308a1b9b6aSSam Leffler static void 12318a1b9b6aSSam Leffler _ieee80211_free_node(struct ieee80211_node *ni) 12328a1b9b6aSSam Leffler { 12338a1b9b6aSSam Leffler struct ieee80211com *ic = ni->ni_ic; 12348a1b9b6aSSam Leffler struct ieee80211_node_table *nt = ni->ni_table; 12358a1b9b6aSSam Leffler 12368a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 123749a15236SSam Leffler "%s %p<%s> in %s table\n", __func__, ni, 123849a15236SSam Leffler ether_sprintf(ni->ni_macaddr), 12398a1b9b6aSSam Leffler nt != NULL ? nt->nt_name : "<gone>"); 12408a1b9b6aSSam Leffler 12418a1b9b6aSSam Leffler IEEE80211_AID_CLR(ni->ni_associd, ic->ic_aid_bitmap); 12428a1b9b6aSSam Leffler if (nt != NULL) { 12438a1b9b6aSSam Leffler TAILQ_REMOVE(&nt->nt_node, ni, ni_list); 12448a1b9b6aSSam Leffler LIST_REMOVE(ni, ni_hash); 12458a1b9b6aSSam Leffler } 12468a1b9b6aSSam Leffler ic->ic_node_free(ni); 12478a1b9b6aSSam Leffler } 12488a1b9b6aSSam Leffler 12498a1b9b6aSSam Leffler void 12508a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 12518a1b9b6aSSam Leffler ieee80211_free_node_debug(struct ieee80211_node *ni, const char *func, int line) 12528a1b9b6aSSam Leffler #else 12538a1b9b6aSSam Leffler ieee80211_free_node(struct ieee80211_node *ni) 12548a1b9b6aSSam Leffler #endif 12558a1b9b6aSSam Leffler { 12568a1b9b6aSSam Leffler struct ieee80211_node_table *nt = ni->ni_table; 12578a1b9b6aSSam Leffler 12588a1b9b6aSSam Leffler #ifdef IEEE80211_DEBUG_REFCNT 125929d368a7SSam Leffler IEEE80211_DPRINTF(ni->ni_ic, IEEE80211_MSG_NODE, 126049a15236SSam Leffler "%s (%s:%u) %p<%s> refcnt %d\n", __func__, func, line, ni, 12618a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni)-1); 12628a1b9b6aSSam Leffler #endif 12638a1b9b6aSSam Leffler if (ieee80211_node_dectestref(ni)) { 12648a1b9b6aSSam Leffler /* 12658a1b9b6aSSam Leffler * Beware; if the node is marked gone then it's already 12668a1b9b6aSSam Leffler * been removed from the table and we cannot assume the 12678a1b9b6aSSam Leffler * table still exists. Regardless, there's no need to lock 12688a1b9b6aSSam Leffler * the table. 12698a1b9b6aSSam Leffler */ 12708a1b9b6aSSam Leffler if (ni->ni_table != NULL) { 12718a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 12728a1b9b6aSSam Leffler _ieee80211_free_node(ni); 12738a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 12748a1b9b6aSSam Leffler } else 12758a1b9b6aSSam Leffler _ieee80211_free_node(ni); 12768a1b9b6aSSam Leffler } 12771a1e1d21SSam Leffler } 12781a1e1d21SSam Leffler 1279303ebc3cSSam Leffler /* 12808a1b9b6aSSam Leffler * Reclaim a node. If this is the last reference count then 12818a1b9b6aSSam Leffler * do the normal free work. Otherwise remove it from the node 12828a1b9b6aSSam Leffler * table and mark it gone by clearing the back-reference. 12838a1b9b6aSSam Leffler */ 12848a1b9b6aSSam Leffler static void 12858a1b9b6aSSam Leffler node_reclaim(struct ieee80211_node_table *nt, struct ieee80211_node *ni) 12868a1b9b6aSSam Leffler { 12878a1b9b6aSSam Leffler 128849a15236SSam Leffler IEEE80211_DPRINTF(ni->ni_ic, IEEE80211_MSG_NODE, 128949a15236SSam Leffler "%s: remove %p<%s> from %s table, refcnt %d\n", 129049a15236SSam Leffler __func__, ni, ether_sprintf(ni->ni_macaddr), 129149a15236SSam Leffler nt->nt_name, ieee80211_node_refcnt(ni)-1); 12928a1b9b6aSSam Leffler if (!ieee80211_node_dectestref(ni)) { 12938a1b9b6aSSam Leffler /* 12948a1b9b6aSSam Leffler * Other references are present, just remove the 12958a1b9b6aSSam Leffler * node from the table so it cannot be found. When 12968a1b9b6aSSam Leffler * the references are dropped storage will be 1297acc4f7f5SSam Leffler * reclaimed. 12988a1b9b6aSSam Leffler */ 12998a1b9b6aSSam Leffler TAILQ_REMOVE(&nt->nt_node, ni, ni_list); 13008a1b9b6aSSam Leffler LIST_REMOVE(ni, ni_hash); 13018a1b9b6aSSam Leffler ni->ni_table = NULL; /* clear reference */ 13028a1b9b6aSSam Leffler } else 13038a1b9b6aSSam Leffler _ieee80211_free_node(ni); 13048a1b9b6aSSam Leffler } 13058a1b9b6aSSam Leffler 13068a1b9b6aSSam Leffler static void 13078a1b9b6aSSam Leffler ieee80211_free_allnodes_locked(struct ieee80211_node_table *nt) 13088a1b9b6aSSam Leffler { 13098a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 13108a1b9b6aSSam Leffler struct ieee80211_node *ni; 13118a1b9b6aSSam Leffler 13128a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 13138a1b9b6aSSam Leffler "%s: free all nodes in %s table\n", __func__, nt->nt_name); 13148a1b9b6aSSam Leffler 13158a1b9b6aSSam Leffler while ((ni = TAILQ_FIRST(&nt->nt_node)) != NULL) { 13168a1b9b6aSSam Leffler if (ni->ni_associd != 0) { 13178a1b9b6aSSam Leffler if (ic->ic_auth->ia_node_leave != NULL) 13188a1b9b6aSSam Leffler ic->ic_auth->ia_node_leave(ic, ni); 13198a1b9b6aSSam Leffler IEEE80211_AID_CLR(ni->ni_associd, ic->ic_aid_bitmap); 13208a1b9b6aSSam Leffler } 13218a1b9b6aSSam Leffler node_reclaim(nt, ni); 13228a1b9b6aSSam Leffler } 13238a1b9b6aSSam Leffler ieee80211_reset_erp(ic); 13248a1b9b6aSSam Leffler } 13258a1b9b6aSSam Leffler 13268a1b9b6aSSam Leffler static void 13278a1b9b6aSSam Leffler ieee80211_free_allnodes(struct ieee80211_node_table *nt) 13288a1b9b6aSSam Leffler { 13298a1b9b6aSSam Leffler 13308a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 13318a1b9b6aSSam Leffler ieee80211_free_allnodes_locked(nt); 13328a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 13338a1b9b6aSSam Leffler } 13348a1b9b6aSSam Leffler 13358a1b9b6aSSam Leffler /* 13368a1b9b6aSSam Leffler * Timeout entries in the scan cache. 13378a1b9b6aSSam Leffler */ 13388a1b9b6aSSam Leffler static void 13398a1b9b6aSSam Leffler ieee80211_timeout_scan_candidates(struct ieee80211_node_table *nt) 13408a1b9b6aSSam Leffler { 13418a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 13428a1b9b6aSSam Leffler struct ieee80211_node *ni, *tni; 13438a1b9b6aSSam Leffler 13448a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 13458a1b9b6aSSam Leffler ni = ic->ic_bss; 13468a1b9b6aSSam Leffler /* XXX belongs elsewhere */ 13478a1b9b6aSSam Leffler if (ni->ni_rxfrag[0] != NULL && ticks > ni->ni_rxfragstamp + hz) { 13488a1b9b6aSSam Leffler m_freem(ni->ni_rxfrag[0]); 13498a1b9b6aSSam Leffler ni->ni_rxfrag[0] = NULL; 13508a1b9b6aSSam Leffler } 13518a1b9b6aSSam Leffler TAILQ_FOREACH_SAFE(ni, &nt->nt_node, ni_list, tni) { 13528a1b9b6aSSam Leffler if (ni->ni_inact && --ni->ni_inact == 0) { 13538a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 13548a1b9b6aSSam Leffler "[%s] scan candidate purged from cache " 13558a1b9b6aSSam Leffler "(refcnt %u)\n", ether_sprintf(ni->ni_macaddr), 135649a15236SSam Leffler ieee80211_node_refcnt(ni)); 13578a1b9b6aSSam Leffler node_reclaim(nt, ni); 13588a1b9b6aSSam Leffler } 13598a1b9b6aSSam Leffler } 13608a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 13618a1b9b6aSSam Leffler 13628a1b9b6aSSam Leffler nt->nt_inact_timer = IEEE80211_INACT_WAIT; 13638a1b9b6aSSam Leffler } 13648a1b9b6aSSam Leffler 13658a1b9b6aSSam Leffler /* 13668a1b9b6aSSam Leffler * Timeout inactive stations and do related housekeeping. 13678a1b9b6aSSam Leffler * Note that we cannot hold the node lock while sending a 13688a1b9b6aSSam Leffler * frame as this would lead to a LOR. Instead we use a 13698a1b9b6aSSam Leffler * generation number to mark nodes that we've scanned and 13708a1b9b6aSSam Leffler * drop the lock and restart a scan if we have to time out 13718a1b9b6aSSam Leffler * a node. Since we are single-threaded by virtue of 1372303ebc3cSSam Leffler * controlling the inactivity timer we can be sure this will 1373303ebc3cSSam Leffler * process each node only once. 1374303ebc3cSSam Leffler */ 13758a1b9b6aSSam Leffler static void 13768a1b9b6aSSam Leffler ieee80211_timeout_stations(struct ieee80211_node_table *nt) 13771a1e1d21SSam Leffler { 13788a1b9b6aSSam Leffler struct ieee80211com *ic = nt->nt_ic; 1379303ebc3cSSam Leffler struct ieee80211_node *ni; 13808a1b9b6aSSam Leffler u_int gen; 1381f66d97f6SSam Leffler int isadhoc; 13821a1e1d21SSam Leffler 1383f66d97f6SSam Leffler isadhoc = (ic->ic_opmode == IEEE80211_M_IBSS || 1384f66d97f6SSam Leffler ic->ic_opmode == IEEE80211_M_AHDEMO); 13858a1b9b6aSSam Leffler IEEE80211_SCAN_LOCK(nt); 13868a1b9b6aSSam Leffler gen = nt->nt_scangen++; 13878a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 138849a15236SSam Leffler "%s: %s scangen %u\n", __func__, nt->nt_name, gen); 1389303ebc3cSSam Leffler restart: 13908a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 13918a1b9b6aSSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 1392303ebc3cSSam Leffler if (ni->ni_scangen == gen) /* previously handled */ 1393303ebc3cSSam Leffler continue; 1394303ebc3cSSam Leffler ni->ni_scangen = gen; 13950a915fadSSam Leffler /* 1396ebdda46cSSam Leffler * Ignore entries for which have yet to receive an 1397ebdda46cSSam Leffler * authentication frame. These are transient and 1398ebdda46cSSam Leffler * will be reclaimed when the last reference to them 1399ebdda46cSSam Leffler * goes away (when frame xmits complete). 1400ebdda46cSSam Leffler */ 140144b666cdSSam Leffler if (ic->ic_opmode == IEEE80211_M_HOSTAP && 140244b666cdSSam Leffler (ni->ni_flags & IEEE80211_NODE_AREF) == 0) 1403ebdda46cSSam Leffler continue; 1404ebdda46cSSam Leffler /* 14058a1b9b6aSSam Leffler * Free fragment if not needed anymore 14068a1b9b6aSSam Leffler * (last fragment older than 1s). 14078a1b9b6aSSam Leffler * XXX doesn't belong here 14080a915fadSSam Leffler */ 14098a1b9b6aSSam Leffler if (ni->ni_rxfrag[0] != NULL && 14108a1b9b6aSSam Leffler ticks > ni->ni_rxfragstamp + hz) { 14118a1b9b6aSSam Leffler m_freem(ni->ni_rxfrag[0]); 14128a1b9b6aSSam Leffler ni->ni_rxfrag[0] = NULL; 14138a1b9b6aSSam Leffler } 1414ce647032SSam Leffler /* 1415ce647032SSam Leffler * Special case ourself; we may be idle for extended periods 1416ce647032SSam Leffler * of time and regardless reclaiming our state is wrong. 1417ce647032SSam Leffler */ 1418ce647032SSam Leffler if (ni == ic->ic_bss) 1419ce647032SSam Leffler continue; 14208a1b9b6aSSam Leffler ni->ni_inact--; 1421f66d97f6SSam Leffler if (ni->ni_associd != 0 || isadhoc) { 14228a1b9b6aSSam Leffler /* 14238a1b9b6aSSam Leffler * Age frames on the power save queue. The 14248a1b9b6aSSam Leffler * aging interval is 4 times the listen 14258a1b9b6aSSam Leffler * interval specified by the station. This 14268a1b9b6aSSam Leffler * number is factored into the age calculations 14278a1b9b6aSSam Leffler * when the frame is placed on the queue. We 14288a1b9b6aSSam Leffler * store ages as time differences we can check 14298a1b9b6aSSam Leffler * and/or adjust only the head of the list. 14308a1b9b6aSSam Leffler */ 14318a1b9b6aSSam Leffler if (IEEE80211_NODE_SAVEQ_QLEN(ni) != 0) { 14328a1b9b6aSSam Leffler struct mbuf *m; 14338a1b9b6aSSam Leffler int discard = 0; 14348a1b9b6aSSam Leffler 14358a1b9b6aSSam Leffler IEEE80211_NODE_SAVEQ_LOCK(ni); 14368a1b9b6aSSam Leffler while (IF_POLL(&ni->ni_savedq, m) != NULL && 14378a1b9b6aSSam Leffler M_AGE_GET(m) < IEEE80211_INACT_WAIT) { 14388a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER, "[%s] discard frame, age %u\n", ether_sprintf(ni->ni_macaddr), M_AGE_GET(m));/*XXX*/ 14398a1b9b6aSSam Leffler _IEEE80211_NODE_SAVEQ_DEQUEUE_HEAD(ni, m); 14408a1b9b6aSSam Leffler m_freem(m); 14418a1b9b6aSSam Leffler discard++; 14428a1b9b6aSSam Leffler } 14438a1b9b6aSSam Leffler if (m != NULL) 14448a1b9b6aSSam Leffler M_AGE_SUB(m, IEEE80211_INACT_WAIT); 14458a1b9b6aSSam Leffler IEEE80211_NODE_SAVEQ_UNLOCK(ni); 14468a1b9b6aSSam Leffler 14478a1b9b6aSSam Leffler if (discard != 0) { 14488a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, 14498a1b9b6aSSam Leffler IEEE80211_MSG_POWER, 14508a1b9b6aSSam Leffler "[%s] discard %u frames for age\n", 14518a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), 14528a1b9b6aSSam Leffler discard); 14538a1b9b6aSSam Leffler IEEE80211_NODE_STAT_ADD(ni, 14548a1b9b6aSSam Leffler ps_discard, discard); 14558a1b9b6aSSam Leffler if (IEEE80211_NODE_SAVEQ_QLEN(ni) == 0) 1456edfa57d0SSam Leffler ic->ic_set_tim(ni, 0); 14578a1b9b6aSSam Leffler } 14588a1b9b6aSSam Leffler } 14598a1b9b6aSSam Leffler /* 14608a1b9b6aSSam Leffler * Probe the station before time it out. We 14618a1b9b6aSSam Leffler * send a null data frame which may not be 14628a1b9b6aSSam Leffler * universally supported by drivers (need it 14638a1b9b6aSSam Leffler * for ps-poll support so it should be...). 14648a1b9b6aSSam Leffler */ 14652045f699SSam Leffler if (0 < ni->ni_inact && 14662045f699SSam Leffler ni->ni_inact <= ic->ic_inact_probe) { 1467f66d97f6SSam Leffler IEEE80211_NOTE(ic, 1468f66d97f6SSam Leffler IEEE80211_MSG_INACT | IEEE80211_MSG_NODE, 1469f66d97f6SSam Leffler ni, "%s", 1470f66d97f6SSam Leffler "probe station due to inactivity"); 14718a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 1472f62121ceSSam Leffler ieee80211_send_nulldata(ni); 14738a1b9b6aSSam Leffler /* XXX stat? */ 14748a1b9b6aSSam Leffler goto restart; 14758a1b9b6aSSam Leffler } 14768a1b9b6aSSam Leffler } 14778a1b9b6aSSam Leffler if (ni->ni_inact <= 0) { 1478f66d97f6SSam Leffler IEEE80211_NOTE(ic, 1479f66d97f6SSam Leffler IEEE80211_MSG_INACT | IEEE80211_MSG_NODE, ni, 1480f66d97f6SSam Leffler "station timed out due to inactivity " 1481f66d97f6SSam Leffler "(refcnt %u)", ieee80211_node_refcnt(ni)); 14828a1b9b6aSSam Leffler /* 14838a1b9b6aSSam Leffler * Send a deauthenticate frame and drop the station. 14848a1b9b6aSSam Leffler * This is somewhat complicated due to reference counts 14858a1b9b6aSSam Leffler * and locking. At this point a station will typically 14868a1b9b6aSSam Leffler * have a reference count of 1. ieee80211_node_leave 14878a1b9b6aSSam Leffler * will do a "free" of the node which will drop the 14888a1b9b6aSSam Leffler * reference count. But in the meantime a reference 14898a1b9b6aSSam Leffler * wil be held by the deauth frame. The actual reclaim 14908a1b9b6aSSam Leffler * of the node will happen either after the tx is 14918a1b9b6aSSam Leffler * completed or by ieee80211_node_leave. 14928a1b9b6aSSam Leffler * 14938a1b9b6aSSam Leffler * Separately we must drop the node lock before sending 14948a1b9b6aSSam Leffler * in case the driver takes a lock, as this will result 14958a1b9b6aSSam Leffler * in LOR between the node lock and the driver lock. 14968a1b9b6aSSam Leffler */ 14978a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 14988a1b9b6aSSam Leffler if (ni->ni_associd != 0) { 14991a1e1d21SSam Leffler IEEE80211_SEND_MGMT(ic, ni, 15001a1e1d21SSam Leffler IEEE80211_FC0_SUBTYPE_DEAUTH, 15011a1e1d21SSam Leffler IEEE80211_REASON_AUTH_EXPIRE); 15028a1b9b6aSSam Leffler } 15038a1b9b6aSSam Leffler ieee80211_node_leave(ic, ni); 15041be50176SSam Leffler ic->ic_stats.is_node_timeout++; 1505303ebc3cSSam Leffler goto restart; 1506303ebc3cSSam Leffler } 15071a1e1d21SSam Leffler } 15088a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 15098a1b9b6aSSam Leffler 15108a1b9b6aSSam Leffler IEEE80211_SCAN_UNLOCK(nt); 15118a1b9b6aSSam Leffler 15128a1b9b6aSSam Leffler nt->nt_inact_timer = IEEE80211_INACT_WAIT; 15131a1e1d21SSam Leffler } 15141a1e1d21SSam Leffler 15151a1e1d21SSam Leffler void 15168a1b9b6aSSam Leffler ieee80211_iterate_nodes(struct ieee80211_node_table *nt, ieee80211_iter_func *f, void *arg) 15171a1e1d21SSam Leffler { 15181a1e1d21SSam Leffler struct ieee80211_node *ni; 15198a1b9b6aSSam Leffler u_int gen; 15201a1e1d21SSam Leffler 15218a1b9b6aSSam Leffler IEEE80211_SCAN_LOCK(nt); 15228a1b9b6aSSam Leffler gen = nt->nt_scangen++; 15238a1b9b6aSSam Leffler restart: 15248a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 15258a1b9b6aSSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 15268a1b9b6aSSam Leffler if (ni->ni_scangen != gen) { 15278a1b9b6aSSam Leffler ni->ni_scangen = gen; 15288a1b9b6aSSam Leffler (void) ieee80211_ref_node(ni); 15298a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 15301a1e1d21SSam Leffler (*f)(arg, ni); 15318a1b9b6aSSam Leffler ieee80211_free_node(ni); 15328a1b9b6aSSam Leffler goto restart; 15338a1b9b6aSSam Leffler } 15348a1b9b6aSSam Leffler } 15358a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 15368a1b9b6aSSam Leffler 15378a1b9b6aSSam Leffler IEEE80211_SCAN_UNLOCK(nt); 15388a1b9b6aSSam Leffler } 15398a1b9b6aSSam Leffler 15408a1b9b6aSSam Leffler void 15418a1b9b6aSSam Leffler ieee80211_dump_node(struct ieee80211_node_table *nt, struct ieee80211_node *ni) 15428a1b9b6aSSam Leffler { 15438a1b9b6aSSam Leffler printf("0x%p: mac %s refcnt %d\n", ni, 15448a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni)); 15458a1b9b6aSSam Leffler printf("\tscangen %u authmode %u flags 0x%x\n", 15468a1b9b6aSSam Leffler ni->ni_scangen, ni->ni_authmode, ni->ni_flags); 15478a1b9b6aSSam Leffler printf("\tassocid 0x%x txpower %u vlan %u\n", 15488a1b9b6aSSam Leffler ni->ni_associd, ni->ni_txpower, ni->ni_vlan); 15498a1b9b6aSSam Leffler printf("\ttxseq %u rxseq %u fragno %u rxfragstamp %u\n", 15508a1b9b6aSSam Leffler ni->ni_txseqs[0], 15518a1b9b6aSSam Leffler ni->ni_rxseqs[0] >> IEEE80211_SEQ_SEQ_SHIFT, 15528a1b9b6aSSam Leffler ni->ni_rxseqs[0] & IEEE80211_SEQ_FRAG_MASK, 15538a1b9b6aSSam Leffler ni->ni_rxfragstamp); 15548a1b9b6aSSam Leffler printf("\trstamp %u rssi %u intval %u capinfo 0x%x\n", 15558a1b9b6aSSam Leffler ni->ni_rstamp, ni->ni_rssi, ni->ni_intval, ni->ni_capinfo); 15568a1b9b6aSSam Leffler printf("\tbssid %s essid \"%.*s\" channel %u:0x%x\n", 15578a1b9b6aSSam Leffler ether_sprintf(ni->ni_bssid), 15588a1b9b6aSSam Leffler ni->ni_esslen, ni->ni_essid, 15598a1b9b6aSSam Leffler ni->ni_chan->ic_freq, ni->ni_chan->ic_flags); 15608a1b9b6aSSam Leffler printf("\tfails %u inact %u txrate %u\n", 15618a1b9b6aSSam Leffler ni->ni_fails, ni->ni_inact, ni->ni_txrate); 15628a1b9b6aSSam Leffler } 15638a1b9b6aSSam Leffler 15648a1b9b6aSSam Leffler void 15658a1b9b6aSSam Leffler ieee80211_dump_nodes(struct ieee80211_node_table *nt) 15668a1b9b6aSSam Leffler { 15678a1b9b6aSSam Leffler ieee80211_iterate_nodes(nt, 15688a1b9b6aSSam Leffler (ieee80211_iter_func *) ieee80211_dump_node, nt); 15698a1b9b6aSSam Leffler } 15708a1b9b6aSSam Leffler 15718a1b9b6aSSam Leffler /* 15728a1b9b6aSSam Leffler * Handle a station joining an 11g network. 15738a1b9b6aSSam Leffler */ 15748a1b9b6aSSam Leffler static void 15758a1b9b6aSSam Leffler ieee80211_node_join_11g(struct ieee80211com *ic, struct ieee80211_node *ni) 15768a1b9b6aSSam Leffler { 15778a1b9b6aSSam Leffler 15788a1b9b6aSSam Leffler /* 15798a1b9b6aSSam Leffler * Station isn't capable of short slot time. Bump 15808a1b9b6aSSam Leffler * the count of long slot time stations and disable 15818a1b9b6aSSam Leffler * use of short slot time. Note that the actual switch 15828a1b9b6aSSam Leffler * over to long slot time use may not occur until the 15838a1b9b6aSSam Leffler * next beacon transmission (per sec. 7.3.1.4 of 11g). 15848a1b9b6aSSam Leffler */ 15858a1b9b6aSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) == 0) { 15868a1b9b6aSSam Leffler ic->ic_longslotsta++; 15878a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 15888a1b9b6aSSam Leffler "[%s] station needs long slot time, count %d\n", 15898a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ic->ic_longslotsta); 15908a1b9b6aSSam Leffler /* XXX vap's w/ conflicting needs won't work */ 15918a1b9b6aSSam Leffler ieee80211_set_shortslottime(ic, 0); 15928a1b9b6aSSam Leffler } 15938a1b9b6aSSam Leffler /* 15948a1b9b6aSSam Leffler * If the new station is not an ERP station 15958a1b9b6aSSam Leffler * then bump the counter and enable protection 15968a1b9b6aSSam Leffler * if configured. 15978a1b9b6aSSam Leffler */ 15988a1b9b6aSSam Leffler if (!ieee80211_iserp_rateset(ic, &ni->ni_rates)) { 15998a1b9b6aSSam Leffler ic->ic_nonerpsta++; 16008a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 16018a1b9b6aSSam Leffler "[%s] station is !ERP, %d non-ERP stations associated\n", 16028a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ic->ic_nonerpsta); 16038a1b9b6aSSam Leffler /* 16048a1b9b6aSSam Leffler * If protection is configured, enable it. 16058a1b9b6aSSam Leffler */ 16068a1b9b6aSSam Leffler if (ic->ic_protmode != IEEE80211_PROT_NONE) { 16078a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 16088a1b9b6aSSam Leffler "%s: enable use of protection\n", __func__); 16098a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_USEPROT; 16108a1b9b6aSSam Leffler } 16118a1b9b6aSSam Leffler /* 16128a1b9b6aSSam Leffler * If station does not support short preamble 16138a1b9b6aSSam Leffler * then we must enable use of Barker preamble. 16148a1b9b6aSSam Leffler */ 16158a1b9b6aSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE) == 0) { 16168a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 16178a1b9b6aSSam Leffler "[%s] station needs long preamble\n", 16188a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr)); 16198a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_USEBARKER; 16208a1b9b6aSSam Leffler ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE; 16218a1b9b6aSSam Leffler } 16228a1b9b6aSSam Leffler } else 16238a1b9b6aSSam Leffler ni->ni_flags |= IEEE80211_NODE_ERP; 16248a1b9b6aSSam Leffler } 16258a1b9b6aSSam Leffler 16268a1b9b6aSSam Leffler void 16278a1b9b6aSSam Leffler ieee80211_node_join(struct ieee80211com *ic, struct ieee80211_node *ni, int resp) 16288a1b9b6aSSam Leffler { 16298a1b9b6aSSam Leffler int newassoc; 16308a1b9b6aSSam Leffler 16318a1b9b6aSSam Leffler if (ni->ni_associd == 0) { 16328a1b9b6aSSam Leffler u_int16_t aid; 16338a1b9b6aSSam Leffler 16348a1b9b6aSSam Leffler /* 16358a1b9b6aSSam Leffler * It would be good to search the bitmap 16368a1b9b6aSSam Leffler * more efficiently, but this will do for now. 16378a1b9b6aSSam Leffler */ 16388a1b9b6aSSam Leffler for (aid = 1; aid < ic->ic_max_aid; aid++) { 16398a1b9b6aSSam Leffler if (!IEEE80211_AID_ISSET(aid, 16408a1b9b6aSSam Leffler ic->ic_aid_bitmap)) 16418a1b9b6aSSam Leffler break; 16428a1b9b6aSSam Leffler } 16438a1b9b6aSSam Leffler if (aid >= ic->ic_max_aid) { 16448a1b9b6aSSam Leffler IEEE80211_SEND_MGMT(ic, ni, resp, 16458a1b9b6aSSam Leffler IEEE80211_REASON_ASSOC_TOOMANY); 16468a1b9b6aSSam Leffler ieee80211_node_leave(ic, ni); 16478a1b9b6aSSam Leffler return; 16488a1b9b6aSSam Leffler } 16498a1b9b6aSSam Leffler ni->ni_associd = aid | 0xc000; 16508a1b9b6aSSam Leffler IEEE80211_AID_SET(ni->ni_associd, ic->ic_aid_bitmap); 16518a1b9b6aSSam Leffler ic->ic_sta_assoc++; 16528a1b9b6aSSam Leffler newassoc = 1; 1653624a1bdbSSam Leffler if (ic->ic_curmode == IEEE80211_MODE_11G || 1654624a1bdbSSam Leffler ic->ic_curmode == IEEE80211_MODE_TURBO_G) 16558a1b9b6aSSam Leffler ieee80211_node_join_11g(ic, ni); 16568a1b9b6aSSam Leffler } else 16578a1b9b6aSSam Leffler newassoc = 0; 16588a1b9b6aSSam Leffler 16598a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC | IEEE80211_MSG_DEBUG, 1660b8fcf546SSam Leffler "[%s] station %sassociated at aid %d: %s preamble, %s slot time%s%s\n", 1661b8fcf546SSam Leffler ether_sprintf(ni->ni_macaddr), newassoc ? "" : "re", 1662b8fcf546SSam Leffler IEEE80211_NODE_AID(ni), 1663b8fcf546SSam Leffler ic->ic_flags & IEEE80211_F_SHPREAMBLE ? "short" : "long", 1664b8fcf546SSam Leffler ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long", 1665b8fcf546SSam Leffler ic->ic_flags & IEEE80211_F_USEPROT ? ", protection" : "", 1666b8fcf546SSam Leffler ni->ni_flags & IEEE80211_NODE_QOS ? ", QoS" : "" 1667b8fcf546SSam Leffler ); 16688a1b9b6aSSam Leffler 16698a1b9b6aSSam Leffler /* give driver a chance to setup state like ni_txrate */ 1670736b3dc3SSam Leffler if (ic->ic_newassoc != NULL) 1671e9962332SSam Leffler ic->ic_newassoc(ni, newassoc); 16722045f699SSam Leffler ni->ni_inact_reload = ic->ic_inact_auth; 16732045f699SSam Leffler ni->ni_inact = ni->ni_inact_reload; 16748a1b9b6aSSam Leffler IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_SUCCESS); 16758a1b9b6aSSam Leffler /* tell the authenticator about new station */ 16768a1b9b6aSSam Leffler if (ic->ic_auth->ia_node_join != NULL) 16778a1b9b6aSSam Leffler ic->ic_auth->ia_node_join(ic, ni); 16788a1b9b6aSSam Leffler ieee80211_notify_node_join(ic, ni, newassoc); 16798a1b9b6aSSam Leffler } 16808a1b9b6aSSam Leffler 16818a1b9b6aSSam Leffler /* 16828a1b9b6aSSam Leffler * Handle a station leaving an 11g network. 16838a1b9b6aSSam Leffler */ 16848a1b9b6aSSam Leffler static void 16858a1b9b6aSSam Leffler ieee80211_node_leave_11g(struct ieee80211com *ic, struct ieee80211_node *ni) 16868a1b9b6aSSam Leffler { 16878a1b9b6aSSam Leffler 1688624a1bdbSSam Leffler KASSERT(ic->ic_curmode == IEEE80211_MODE_11G || 1689624a1bdbSSam Leffler ic->ic_curmode == IEEE80211_MODE_TURBO_G, 16908a1b9b6aSSam Leffler ("not in 11g, curmode %x", ic->ic_curmode)); 16918a1b9b6aSSam Leffler 16928a1b9b6aSSam Leffler /* 16938a1b9b6aSSam Leffler * If a long slot station do the slot time bookkeeping. 16948a1b9b6aSSam Leffler */ 16958a1b9b6aSSam Leffler if ((ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) == 0) { 16968a1b9b6aSSam Leffler KASSERT(ic->ic_longslotsta > 0, 16978a1b9b6aSSam Leffler ("bogus long slot station count %d", ic->ic_longslotsta)); 16988a1b9b6aSSam Leffler ic->ic_longslotsta--; 16998a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 17008a1b9b6aSSam Leffler "[%s] long slot time station leaves, count now %d\n", 17018a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ic->ic_longslotsta); 17028a1b9b6aSSam Leffler if (ic->ic_longslotsta == 0) { 17038a1b9b6aSSam Leffler /* 17048a1b9b6aSSam Leffler * Re-enable use of short slot time if supported 17058a1b9b6aSSam Leffler * and not operating in IBSS mode (per spec). 17068a1b9b6aSSam Leffler */ 17078a1b9b6aSSam Leffler if ((ic->ic_caps & IEEE80211_C_SHSLOT) && 17088a1b9b6aSSam Leffler ic->ic_opmode != IEEE80211_M_IBSS) { 17098a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 17108a1b9b6aSSam Leffler "%s: re-enable use of short slot time\n", 17118a1b9b6aSSam Leffler __func__); 17128a1b9b6aSSam Leffler ieee80211_set_shortslottime(ic, 1); 17138a1b9b6aSSam Leffler } 17148a1b9b6aSSam Leffler } 17158a1b9b6aSSam Leffler } 17168a1b9b6aSSam Leffler /* 17178a1b9b6aSSam Leffler * If a non-ERP station do the protection-related bookkeeping. 17188a1b9b6aSSam Leffler */ 17198a1b9b6aSSam Leffler if ((ni->ni_flags & IEEE80211_NODE_ERP) == 0) { 17208a1b9b6aSSam Leffler KASSERT(ic->ic_nonerpsta > 0, 17218a1b9b6aSSam Leffler ("bogus non-ERP station count %d", ic->ic_nonerpsta)); 17228a1b9b6aSSam Leffler ic->ic_nonerpsta--; 17238a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 17248a1b9b6aSSam Leffler "[%s] non-ERP station leaves, count now %d\n", 17258a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), ic->ic_nonerpsta); 17268a1b9b6aSSam Leffler if (ic->ic_nonerpsta == 0) { 17278a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 17288a1b9b6aSSam Leffler "%s: disable use of protection\n", __func__); 17298a1b9b6aSSam Leffler ic->ic_flags &= ~IEEE80211_F_USEPROT; 17308a1b9b6aSSam Leffler /* XXX verify mode? */ 17318a1b9b6aSSam Leffler if (ic->ic_caps & IEEE80211_C_SHPREAMBLE) { 17328a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC, 17338a1b9b6aSSam Leffler "%s: re-enable use of short preamble\n", 17348a1b9b6aSSam Leffler __func__); 17358a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_SHPREAMBLE; 17368a1b9b6aSSam Leffler ic->ic_flags &= ~IEEE80211_F_USEBARKER; 17378a1b9b6aSSam Leffler } 17388a1b9b6aSSam Leffler } 17398a1b9b6aSSam Leffler } 17408a1b9b6aSSam Leffler } 17418a1b9b6aSSam Leffler 17428a1b9b6aSSam Leffler /* 17438a1b9b6aSSam Leffler * Handle bookkeeping for station deauthentication/disassociation 17448a1b9b6aSSam Leffler * when operating as an ap. 17458a1b9b6aSSam Leffler */ 17468a1b9b6aSSam Leffler void 17478a1b9b6aSSam Leffler ieee80211_node_leave(struct ieee80211com *ic, struct ieee80211_node *ni) 17488a1b9b6aSSam Leffler { 174944acc00dSSam Leffler struct ieee80211_node_table *nt = ni->ni_table; 17508a1b9b6aSSam Leffler 17518a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC | IEEE80211_MSG_DEBUG, 17528a1b9b6aSSam Leffler "[%s] station with aid %d leaves\n", 17538a1b9b6aSSam Leffler ether_sprintf(ni->ni_macaddr), IEEE80211_NODE_AID(ni)); 17548a1b9b6aSSam Leffler 17558a1b9b6aSSam Leffler KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP || 17568a1b9b6aSSam Leffler ic->ic_opmode == IEEE80211_M_IBSS || 17578a1b9b6aSSam Leffler ic->ic_opmode == IEEE80211_M_AHDEMO, 17588a1b9b6aSSam Leffler ("unexpected operating mode %u", ic->ic_opmode)); 17598a1b9b6aSSam Leffler /* 17608a1b9b6aSSam Leffler * If node wasn't previously associated all 17618a1b9b6aSSam Leffler * we need to do is reclaim the reference. 17628a1b9b6aSSam Leffler */ 17638a1b9b6aSSam Leffler /* XXX ibss mode bypasses 11g and notification */ 17648a1b9b6aSSam Leffler if (ni->ni_associd == 0) 17658a1b9b6aSSam Leffler goto done; 17668a1b9b6aSSam Leffler /* 17678a1b9b6aSSam Leffler * Tell the authenticator the station is leaving. 17688a1b9b6aSSam Leffler * Note that we must do this before yanking the 17698a1b9b6aSSam Leffler * association id as the authenticator uses the 17708a1b9b6aSSam Leffler * associd to locate it's state block. 17718a1b9b6aSSam Leffler */ 17728a1b9b6aSSam Leffler if (ic->ic_auth->ia_node_leave != NULL) 17738a1b9b6aSSam Leffler ic->ic_auth->ia_node_leave(ic, ni); 17748a1b9b6aSSam Leffler IEEE80211_AID_CLR(ni->ni_associd, ic->ic_aid_bitmap); 17758a1b9b6aSSam Leffler ni->ni_associd = 0; 17768a1b9b6aSSam Leffler ic->ic_sta_assoc--; 17778a1b9b6aSSam Leffler 1778624a1bdbSSam Leffler if (ic->ic_curmode == IEEE80211_MODE_11G || 1779624a1bdbSSam Leffler ic->ic_curmode == IEEE80211_MODE_TURBO_G) 17808a1b9b6aSSam Leffler ieee80211_node_leave_11g(ic, ni); 17818a1b9b6aSSam Leffler /* 17828a1b9b6aSSam Leffler * Cleanup station state. In particular clear various 17838a1b9b6aSSam Leffler * state that might otherwise be reused if the node 17848a1b9b6aSSam Leffler * is reused before the reference count goes to zero 17858a1b9b6aSSam Leffler * (and memory is reclaimed). 17868a1b9b6aSSam Leffler */ 17878a1b9b6aSSam Leffler ieee80211_sta_leave(ic, ni); 17888a1b9b6aSSam Leffler done: 178944acc00dSSam Leffler /* 179044acc00dSSam Leffler * Remove the node from any table it's recorded in and 179144acc00dSSam Leffler * drop the caller's reference. Removal from the table 179244acc00dSSam Leffler * is important to insure the node is not reprocessed 179344acc00dSSam Leffler * for inactivity. 179444acc00dSSam Leffler */ 179544acc00dSSam Leffler if (nt != NULL) { 179644acc00dSSam Leffler IEEE80211_NODE_LOCK(nt); 179744acc00dSSam Leffler node_reclaim(nt, ni); 179844acc00dSSam Leffler IEEE80211_NODE_UNLOCK(nt); 179944acc00dSSam Leffler } else 18008a1b9b6aSSam Leffler ieee80211_free_node(ni); 18018a1b9b6aSSam Leffler } 18028a1b9b6aSSam Leffler 18038a1b9b6aSSam Leffler u_int8_t 18048a1b9b6aSSam Leffler ieee80211_getrssi(struct ieee80211com *ic) 18058a1b9b6aSSam Leffler { 18068a1b9b6aSSam Leffler #define NZ(x) ((x) == 0 ? 1 : (x)) 1807acc4f7f5SSam Leffler struct ieee80211_node_table *nt = &ic->ic_sta; 18088a1b9b6aSSam Leffler u_int32_t rssi_samples, rssi_total; 18098a1b9b6aSSam Leffler struct ieee80211_node *ni; 18108a1b9b6aSSam Leffler 18118a1b9b6aSSam Leffler rssi_total = 0; 18128a1b9b6aSSam Leffler rssi_samples = 0; 18138a1b9b6aSSam Leffler switch (ic->ic_opmode) { 18148a1b9b6aSSam Leffler case IEEE80211_M_IBSS: /* average of all ibss neighbors */ 18158a1b9b6aSSam Leffler /* XXX locking */ 1816acc4f7f5SSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) 18178a1b9b6aSSam Leffler if (ni->ni_capinfo & IEEE80211_CAPINFO_IBSS) { 18188a1b9b6aSSam Leffler rssi_samples++; 18198a1b9b6aSSam Leffler rssi_total += ic->ic_node_getrssi(ni); 18208a1b9b6aSSam Leffler } 18218a1b9b6aSSam Leffler break; 18228a1b9b6aSSam Leffler case IEEE80211_M_AHDEMO: /* average of all neighbors */ 18238a1b9b6aSSam Leffler /* XXX locking */ 1824acc4f7f5SSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 18258a1b9b6aSSam Leffler rssi_samples++; 18268a1b9b6aSSam Leffler rssi_total += ic->ic_node_getrssi(ni); 18278a1b9b6aSSam Leffler } 18288a1b9b6aSSam Leffler break; 18298a1b9b6aSSam Leffler case IEEE80211_M_HOSTAP: /* average of all associated stations */ 18308a1b9b6aSSam Leffler /* XXX locking */ 1831acc4f7f5SSam Leffler TAILQ_FOREACH(ni, &nt->nt_node, ni_list) 18328a1b9b6aSSam Leffler if (IEEE80211_AID(ni->ni_associd) != 0) { 18338a1b9b6aSSam Leffler rssi_samples++; 18348a1b9b6aSSam Leffler rssi_total += ic->ic_node_getrssi(ni); 18358a1b9b6aSSam Leffler } 18368a1b9b6aSSam Leffler break; 18378a1b9b6aSSam Leffler case IEEE80211_M_MONITOR: /* XXX */ 18388a1b9b6aSSam Leffler case IEEE80211_M_STA: /* use stats from associated ap */ 18398a1b9b6aSSam Leffler default: 18408a1b9b6aSSam Leffler if (ic->ic_bss != NULL) 18418a1b9b6aSSam Leffler rssi_total = ic->ic_node_getrssi(ic->ic_bss); 18428a1b9b6aSSam Leffler rssi_samples = 1; 18438a1b9b6aSSam Leffler break; 18448a1b9b6aSSam Leffler } 18458a1b9b6aSSam Leffler return rssi_total / NZ(rssi_samples); 18468a1b9b6aSSam Leffler #undef NZ 18478a1b9b6aSSam Leffler } 18488a1b9b6aSSam Leffler 18498a1b9b6aSSam Leffler /* 18508a1b9b6aSSam Leffler * Indicate whether there are frames queued for a station in power-save mode. 18518a1b9b6aSSam Leffler */ 18528a1b9b6aSSam Leffler static void 1853edfa57d0SSam Leffler ieee80211_set_tim(struct ieee80211_node *ni, int set) 18548a1b9b6aSSam Leffler { 1855edfa57d0SSam Leffler struct ieee80211com *ic = ni->ni_ic; 18568a1b9b6aSSam Leffler u_int16_t aid; 18578a1b9b6aSSam Leffler 18588a1b9b6aSSam Leffler KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP || 18598a1b9b6aSSam Leffler ic->ic_opmode == IEEE80211_M_IBSS, 18608a1b9b6aSSam Leffler ("operating mode %u", ic->ic_opmode)); 18618a1b9b6aSSam Leffler 18628a1b9b6aSSam Leffler aid = IEEE80211_AID(ni->ni_associd); 18638a1b9b6aSSam Leffler KASSERT(aid < ic->ic_max_aid, 18648a1b9b6aSSam Leffler ("bogus aid %u, max %u", aid, ic->ic_max_aid)); 18658a1b9b6aSSam Leffler 18668a1b9b6aSSam Leffler IEEE80211_BEACON_LOCK(ic); 18678a1b9b6aSSam Leffler if (set != (isset(ic->ic_tim_bitmap, aid) != 0)) { 18688a1b9b6aSSam Leffler if (set) { 18698a1b9b6aSSam Leffler setbit(ic->ic_tim_bitmap, aid); 18708a1b9b6aSSam Leffler ic->ic_ps_pending++; 18718a1b9b6aSSam Leffler } else { 18728a1b9b6aSSam Leffler clrbit(ic->ic_tim_bitmap, aid); 18738a1b9b6aSSam Leffler ic->ic_ps_pending--; 18748a1b9b6aSSam Leffler } 18758a1b9b6aSSam Leffler ic->ic_flags |= IEEE80211_F_TIMUPDATE; 18768a1b9b6aSSam Leffler } 18778a1b9b6aSSam Leffler IEEE80211_BEACON_UNLOCK(ic); 18788a1b9b6aSSam Leffler } 18798a1b9b6aSSam Leffler 18808a1b9b6aSSam Leffler /* 18818a1b9b6aSSam Leffler * Node table support. 18828a1b9b6aSSam Leffler */ 18838a1b9b6aSSam Leffler 18848a1b9b6aSSam Leffler static void 18858a1b9b6aSSam Leffler ieee80211_node_table_init(struct ieee80211com *ic, 18868a1b9b6aSSam Leffler struct ieee80211_node_table *nt, 18878a1b9b6aSSam Leffler const char *name, int inact, 18888a1b9b6aSSam Leffler void (*timeout)(struct ieee80211_node_table *)) 18898a1b9b6aSSam Leffler { 18908a1b9b6aSSam Leffler 18918a1b9b6aSSam Leffler IEEE80211_DPRINTF(ic, IEEE80211_MSG_NODE, 18928a1b9b6aSSam Leffler "%s %s table, inact %u\n", __func__, name, inact); 18938a1b9b6aSSam Leffler 18948a1b9b6aSSam Leffler nt->nt_ic = ic; 18958a1b9b6aSSam Leffler /* XXX need unit */ 18968a1b9b6aSSam Leffler IEEE80211_NODE_LOCK_INIT(nt, ic->ic_ifp->if_xname); 18978a1b9b6aSSam Leffler IEEE80211_SCAN_LOCK_INIT(nt, ic->ic_ifp->if_xname); 18988a1b9b6aSSam Leffler TAILQ_INIT(&nt->nt_node); 18998a1b9b6aSSam Leffler nt->nt_name = name; 19008a1b9b6aSSam Leffler nt->nt_scangen = 1; 19018a1b9b6aSSam Leffler nt->nt_inact_init = inact; 19028a1b9b6aSSam Leffler nt->nt_timeout = timeout; 19038a1b9b6aSSam Leffler } 19048a1b9b6aSSam Leffler 19058a1b9b6aSSam Leffler void 19068a1b9b6aSSam Leffler ieee80211_node_table_reset(struct ieee80211_node_table *nt) 19078a1b9b6aSSam Leffler { 19088a1b9b6aSSam Leffler 19098a1b9b6aSSam Leffler IEEE80211_DPRINTF(nt->nt_ic, IEEE80211_MSG_NODE, 19108a1b9b6aSSam Leffler "%s %s table\n", __func__, nt->nt_name); 19118a1b9b6aSSam Leffler 19128a1b9b6aSSam Leffler IEEE80211_NODE_LOCK(nt); 19138a1b9b6aSSam Leffler nt->nt_inact_timer = 0; 19148a1b9b6aSSam Leffler ieee80211_free_allnodes_locked(nt); 19158a1b9b6aSSam Leffler IEEE80211_NODE_UNLOCK(nt); 19168a1b9b6aSSam Leffler } 19178a1b9b6aSSam Leffler 19188a1b9b6aSSam Leffler static void 19198a1b9b6aSSam Leffler ieee80211_node_table_cleanup(struct ieee80211_node_table *nt) 19208a1b9b6aSSam Leffler { 19218a1b9b6aSSam Leffler 19228a1b9b6aSSam Leffler IEEE80211_DPRINTF(nt->nt_ic, IEEE80211_MSG_NODE, 19238a1b9b6aSSam Leffler "%s %s table\n", __func__, nt->nt_name); 19248a1b9b6aSSam Leffler 19258a1b9b6aSSam Leffler ieee80211_free_allnodes_locked(nt); 19268a1b9b6aSSam Leffler IEEE80211_SCAN_LOCK_DESTROY(nt); 19278a1b9b6aSSam Leffler IEEE80211_NODE_LOCK_DESTROY(nt); 19288a1b9b6aSSam Leffler } 1929