ieee80211_freebsd.c revision 173273
138494Sobrien/*- 2174294Sobrien * Copyright (c) 2003-2007 Sam Leffler, Errno Consulting 338494Sobrien * All rights reserved. 438494Sobrien * 538494Sobrien * Redistribution and use in source and binary forms, with or without 638494Sobrien * modification, are permitted provided that the following conditions 738494Sobrien * are met: 838494Sobrien * 1. Redistributions of source code must retain the above copyright 938494Sobrien * notice, this list of conditions and the following disclaimer. 1038494Sobrien * 2. Redistributions in binary form must reproduce the above copyright 1138494Sobrien * notice, this list of conditions and the following disclaimer in the 1238494Sobrien * documentation and/or other materials provided with the distribution. 1338494Sobrien * 1438494Sobrien * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 1538494Sobrien * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 1638494Sobrien * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 1738494Sobrien * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 1838494Sobrien * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 1938494Sobrien * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2042629Sobrien * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2138494Sobrien * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2238494Sobrien * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 2338494Sobrien * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2438494Sobrien */ 2538494Sobrien 2638494Sobrien#include <sys/cdefs.h> 2738494Sobrien__FBSDID("$FreeBSD: head/sys/net80211/ieee80211_freebsd.c 173273 2007-11-02 05:22:25Z sam $"); 2838494Sobrien 2938494Sobrien/* 3038494Sobrien * IEEE 802.11 support (FreeBSD-specific code) 3138494Sobrien */ 3238494Sobrien#include <sys/param.h> 3338494Sobrien#include <sys/kernel.h> 3438494Sobrien#include <sys/systm.h> 3538494Sobrien#include <sys/linker.h> 3638494Sobrien#include <sys/mbuf.h> 3738494Sobrien#include <sys/module.h> 3838494Sobrien#include <sys/proc.h> 3938494Sobrien#include <sys/sysctl.h> 40174294Sobrien 4138494Sobrien#include <sys/socket.h> 4238494Sobrien 4338494Sobrien#include <net/if.h> 4438494Sobrien#include <net/if_media.h> 4538494Sobrien#include <net/ethernet.h> 4638494Sobrien#include <net/route.h> 4738494Sobrien 4838494Sobrien#include <net80211/ieee80211_var.h> 4938494Sobrien 5038494SobrienSYSCTL_NODE(_net, OID_AUTO, wlan, CTLFLAG_RD, 0, "IEEE 80211 parameters"); 5138494Sobrien 5238494Sobrien#ifdef IEEE80211_DEBUG 5338494Sobrienint ieee80211_debug = 0; 5438494SobrienSYSCTL_INT(_net_wlan, OID_AUTO, debug, CTLFLAG_RW, &ieee80211_debug, 5538494Sobrien 0, "debugging printfs"); 5638494Sobrien#endif 5738494Sobrienextern int ieee80211_recv_bar_ena; 5838494SobrienSYSCTL_INT(_net_wlan, OID_AUTO, recv_bar, CTLFLAG_RW, &ieee80211_recv_bar_ena, 5938494Sobrien 0, "BAR frame processing (ena/dis)"); 6038494Sobrien 6138494Sobrien#ifdef IEEE80211_AMPDU_AGE 6238494Sobrienstatic int 6338494Sobrienieee80211_sysctl_ampdu_age(SYSCTL_HANDLER_ARGS) 6438494Sobrien{ 6538494Sobrien extern int ieee80211_ampdu_age; 6638494Sobrien int ampdu_age = ticks_to_msecs(ieee80211_ampdu_age); 6738494Sobrien int error; 6838494Sobrien 6938494Sobrien error = sysctl_handle_int(oidp, &du_age, 0, req); 7038494Sobrien if (error || !req->newptr) 7138494Sobrien return error; 7238494Sobrien ieee80211_ampdu_age = msecs_to_ticks(ampdu_age); 7338494Sobrien return 0; 7438494Sobrien} 7538494SobrienSYSCTL_PROC(_net_wlan, OID_AUTO, "ampdu_age", CTLFLAG_RW, NULL, 0, 7638494Sobrien ieee80211_sysctl_ampdu_age, "A", "AMPDU max reorder age (ms)"); 7738494Sobrien#endif 7838494Sobrien 7938494Sobrienstatic int 8038494Sobrienieee80211_sysctl_inact(SYSCTL_HANDLER_ARGS) 8138494Sobrien{ 8238494Sobrien int inact = (*(int *)arg1) * IEEE80211_INACT_WAIT; 8338494Sobrien int error; 8438494Sobrien 8538494Sobrien error = sysctl_handle_int(oidp, &inact, 0, req); 8638494Sobrien if (error || !req->newptr) 8738494Sobrien return error; 8838494Sobrien *(int *)arg1 = inact / IEEE80211_INACT_WAIT; 8938494Sobrien return 0; 9038494Sobrien} 9138494Sobrien 9238494Sobrienstatic int 9338494Sobrienieee80211_sysctl_parent(SYSCTL_HANDLER_ARGS) 9438494Sobrien{ 9538494Sobrien struct ieee80211com *ic = arg1; 9638494Sobrien const char *name = ic->ic_ifp->if_xname; 9738494Sobrien 9838494Sobrien return SYSCTL_OUT(req, name, strlen(name)); 9938494Sobrien} 10038494Sobrien 10138494Sobrienvoid 10238494Sobrienieee80211_sysctl_attach(struct ieee80211com *ic) 10338494Sobrien{ 10438494Sobrien struct sysctl_ctx_list *ctx; 10538494Sobrien struct sysctl_oid *oid; 10638494Sobrien char num[14]; /* sufficient for 32 bits */ 10738494Sobrien 10838494Sobrien MALLOC(ctx, struct sysctl_ctx_list *, sizeof(struct sysctl_ctx_list), 10938494Sobrien M_DEVBUF, M_NOWAIT | M_ZERO); 11038494Sobrien if (ctx == NULL) { 11138494Sobrien if_printf(ic->ic_ifp, "%s: cannot allocate sysctl context!\n", 11238494Sobrien __func__); 11338494Sobrien return; 11438494Sobrien } 11538494Sobrien sysctl_ctx_init(ctx); 11638494Sobrien snprintf(num, sizeof(num), "%u", ic->ic_vap); 11738494Sobrien oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan), 11838494Sobrien OID_AUTO, num, CTLFLAG_RD, NULL, ""); 11938494Sobrien SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 12038494Sobrien "%parent", CTLFLAG_RD, ic, 0, ieee80211_sysctl_parent, "A", 12138494Sobrien "parent device"); 12238494Sobrien#ifdef IEEE80211_DEBUG 12338494Sobrien ic->ic_debug = ieee80211_debug; 12438494Sobrien SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 12538494Sobrien "debug", CTLFLAG_RW, &ic->ic_debug, 0, 12638494Sobrien "control debugging printfs"); 12738494Sobrien#endif 12838494Sobrien /* XXX inherit from tunables */ 12938494Sobrien SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 13038494Sobrien "inact_run", CTLTYPE_INT | CTLFLAG_RW, &ic->ic_inact_run, 0, 13138494Sobrien ieee80211_sysctl_inact, "I", 13238494Sobrien "station inactivity timeout (sec)"); 13338494Sobrien SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 13438494Sobrien "inact_probe", CTLTYPE_INT | CTLFLAG_RW, &ic->ic_inact_probe, 0, 13538494Sobrien ieee80211_sysctl_inact, "I", 13638494Sobrien "station inactivity probe timeout (sec)"); 13738494Sobrien SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 138 "inact_auth", CTLTYPE_INT | CTLFLAG_RW, &ic->ic_inact_auth, 0, 139 ieee80211_sysctl_inact, "I", 140 "station authentication timeout (sec)"); 141 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 142 "inact_init", CTLTYPE_INT | CTLFLAG_RW, &ic->ic_inact_init, 0, 143 ieee80211_sysctl_inact, "I", 144 "station initial state timeout (sec)"); 145 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 146 "driver_caps", CTLFLAG_RW, &ic->ic_caps, 0, 147 "driver capabilities"); 148 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 149 "bmiss_max", CTLFLAG_RW, &ic->ic_bmiss_max, 0, 150 "consecutive beacon misses before scanning"); 151 ic->ic_sysctl = ctx; 152} 153 154void 155ieee80211_sysctl_detach(struct ieee80211com *ic) 156{ 157 158 if (ic->ic_sysctl != NULL) { 159 sysctl_ctx_free(ic->ic_sysctl); 160 FREE(ic->ic_sysctl, M_DEVBUF); 161 ic->ic_sysctl = NULL; 162 } 163} 164 165int 166ieee80211_node_dectestref(struct ieee80211_node *ni) 167{ 168 /* XXX need equivalent of atomic_dec_and_test */ 169 atomic_subtract_int(&ni->ni_refcnt, 1); 170 return atomic_cmpset_int(&ni->ni_refcnt, 0, 1); 171} 172 173void 174ieee80211_drain_ifq(struct ifqueue *ifq) 175{ 176 struct ieee80211_node *ni; 177 struct mbuf *m; 178 179 for (;;) { 180 IF_DEQUEUE(ifq, m); 181 if (m == NULL) 182 break; 183 184 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 185 KASSERT(ni != NULL, ("frame w/o node")); 186 ieee80211_free_node(ni); 187 m->m_pkthdr.rcvif = NULL; 188 189 m_freem(m); 190 } 191} 192 193/* 194 * As above, for mbufs allocated with m_gethdr/MGETHDR 195 * or initialized by M_COPY_PKTHDR. 196 */ 197#define MC_ALIGN(m, len) \ 198do { \ 199 (m)->m_data += (MCLBYTES - (len)) &~ (sizeof(long) - 1); \ 200} while (/* CONSTCOND */ 0) 201 202/* 203 * Allocate and setup a management frame of the specified 204 * size. We return the mbuf and a pointer to the start 205 * of the contiguous data area that's been reserved based 206 * on the packet length. The data area is forced to 32-bit 207 * alignment and the buffer length to a multiple of 4 bytes. 208 * This is done mainly so beacon frames (that require this) 209 * can use this interface too. 210 */ 211struct mbuf * 212ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen) 213{ 214 struct mbuf *m; 215 u_int len; 216 217 /* 218 * NB: we know the mbuf routines will align the data area 219 * so we don't need to do anything special. 220 */ 221 len = roundup2(headroom + pktlen, 4); 222 KASSERT(len <= MCLBYTES, ("802.11 mgt frame too large: %u", len)); 223 if (len < MINCLSIZE) { 224 m = m_gethdr(M_NOWAIT, MT_DATA); 225 /* 226 * Align the data in case additional headers are added. 227 * This should only happen when a WEP header is added 228 * which only happens for shared key authentication mgt 229 * frames which all fit in MHLEN. 230 */ 231 if (m != NULL) 232 MH_ALIGN(m, len); 233 } else { 234 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 235 if (m != NULL) 236 MC_ALIGN(m, len); 237 } 238 if (m != NULL) { 239 m->m_data += headroom; 240 *frm = m->m_data; 241 } 242 return m; 243} 244 245int 246ieee80211_add_callback(struct mbuf *m, 247 void (*func)(struct ieee80211_node *, void *, int), void *arg) 248{ 249 struct m_tag *mtag; 250 struct ieee80211_cb *cb; 251 252 mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, 253 sizeof(struct ieee80211_cb), M_NOWAIT); 254 if (mtag == NULL) 255 return 0; 256 257 cb = (struct ieee80211_cb *)(mtag+1); 258 cb->func = func; 259 cb->arg = arg; 260 m_tag_prepend(m, mtag); 261 m->m_flags |= M_TXCB; 262 return 1; 263} 264 265void 266ieee80211_process_callback(struct ieee80211_node *ni, 267 struct mbuf *m, int status) 268{ 269 struct m_tag *mtag; 270 271 mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, NULL); 272 if (mtag != NULL) { 273 struct ieee80211_cb *cb = (struct ieee80211_cb *)(mtag+1); 274 cb->func(ni, cb->arg, status); 275 } 276} 277 278#include <sys/libkern.h> 279 280void 281get_random_bytes(void *p, size_t n) 282{ 283 uint8_t *dp = p; 284 285 while (n > 0) { 286 uint32_t v = arc4random(); 287 size_t nb = n > sizeof(uint32_t) ? sizeof(uint32_t) : n; 288 bcopy(&v, dp, n > sizeof(uint32_t) ? sizeof(uint32_t) : n); 289 dp += sizeof(uint32_t), n -= nb; 290 } 291} 292 293void 294ieee80211_notify_node_join(struct ieee80211com *ic, struct ieee80211_node *ni, int newassoc) 295{ 296 struct ifnet *ifp = ic->ic_ifp; 297 struct ieee80211_join_event iev; 298 299 memset(&iev, 0, sizeof(iev)); 300 if (ni == ic->ic_bss) { 301 IEEE80211_ADDR_COPY(iev.iev_addr, ni->ni_bssid); 302 rt_ieee80211msg(ifp, newassoc ? 303 RTM_IEEE80211_ASSOC : RTM_IEEE80211_REASSOC, 304 &iev, sizeof(iev)); 305 if_link_state_change(ifp, LINK_STATE_UP); 306 } else { 307 IEEE80211_ADDR_COPY(iev.iev_addr, ni->ni_macaddr); 308 rt_ieee80211msg(ifp, newassoc ? 309 RTM_IEEE80211_JOIN : RTM_IEEE80211_REJOIN, 310 &iev, sizeof(iev)); 311 } 312} 313 314void 315ieee80211_notify_node_leave(struct ieee80211com *ic, struct ieee80211_node *ni) 316{ 317 struct ifnet *ifp = ic->ic_ifp; 318 struct ieee80211_leave_event iev; 319 320 if (ni == ic->ic_bss) { 321 rt_ieee80211msg(ifp, RTM_IEEE80211_DISASSOC, NULL, 0); 322 if_link_state_change(ifp, LINK_STATE_DOWN); 323 } else { 324 /* fire off wireless event station leaving */ 325 memset(&iev, 0, sizeof(iev)); 326 IEEE80211_ADDR_COPY(iev.iev_addr, ni->ni_macaddr); 327 rt_ieee80211msg(ifp, RTM_IEEE80211_LEAVE, &iev, sizeof(iev)); 328 } 329} 330 331void 332ieee80211_notify_scan_done(struct ieee80211com *ic) 333{ 334 struct ifnet *ifp = ic->ic_ifp; 335 336 IEEE80211_DPRINTF(ic, IEEE80211_MSG_SCAN, "%s\n", "notify scan done"); 337 338 /* dispatch wireless event indicating scan completed */ 339 rt_ieee80211msg(ifp, RTM_IEEE80211_SCAN, NULL, 0); 340} 341 342void 343ieee80211_notify_replay_failure(struct ieee80211com *ic, 344 const struct ieee80211_frame *wh, const struct ieee80211_key *k, 345 u_int64_t rsc) 346{ 347 struct ifnet *ifp = ic->ic_ifp; 348 349 IEEE80211_DPRINTF(ic, IEEE80211_MSG_CRYPTO, 350 "[%s] %s replay detected <rsc %ju, csc %ju, keyix %u rxkeyix %u>\n", 351 ether_sprintf(wh->i_addr2), k->wk_cipher->ic_name, 352 (intmax_t) rsc, (intmax_t) k->wk_keyrsc, 353 k->wk_keyix, k->wk_rxkeyix); 354 355 if (ifp != NULL) { /* NB: for cipher test modules */ 356 struct ieee80211_replay_event iev; 357 358 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1); 359 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2); 360 iev.iev_cipher = k->wk_cipher->ic_cipher; 361 if (k->wk_rxkeyix != IEEE80211_KEYIX_NONE) 362 iev.iev_keyix = k->wk_rxkeyix; 363 else 364 iev.iev_keyix = k->wk_keyix; 365 iev.iev_keyrsc = k->wk_keyrsc; 366 iev.iev_rsc = rsc; 367 rt_ieee80211msg(ifp, RTM_IEEE80211_REPLAY, &iev, sizeof(iev)); 368 } 369} 370 371void 372ieee80211_notify_michael_failure(struct ieee80211com *ic, 373 const struct ieee80211_frame *wh, u_int keyix) 374{ 375 struct ifnet *ifp = ic->ic_ifp; 376 377 IEEE80211_DPRINTF(ic, IEEE80211_MSG_CRYPTO, 378 "[%s] michael MIC verification failed <keyix %u>\n", 379 ether_sprintf(wh->i_addr2), keyix); 380 ic->ic_stats.is_rx_tkipmic++; 381 382 if (ifp != NULL) { /* NB: for cipher test modules */ 383 struct ieee80211_michael_event iev; 384 385 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1); 386 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2); 387 iev.iev_cipher = IEEE80211_CIPHER_TKIP; 388 iev.iev_keyix = keyix; 389 rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev)); 390 } 391} 392 393void 394ieee80211_load_module(const char *modname) 395{ 396 397#ifdef notyet 398 (void)kern_kldload(curthread, modname, NULL); 399#else 400 printf("%s: load the %s module by hand for now.\n", __func__, modname); 401#endif 402} 403 404/* 405 * Module glue. 406 * 407 * NB: the module name is "wlan" for compatibility with NetBSD. 408 */ 409static int 410wlan_modevent(module_t mod, int type, void *unused) 411{ 412 switch (type) { 413 case MOD_LOAD: 414 if (bootverbose) 415 printf("wlan: <802.11 Link Layer>\n"); 416 return 0; 417 case MOD_UNLOAD: 418 return 0; 419 } 420 return EINVAL; 421} 422 423static moduledata_t wlan_mod = { 424 "wlan", 425 wlan_modevent, 426 0 427}; 428DECLARE_MODULE(wlan, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 429MODULE_VERSION(wlan, 1); 430MODULE_DEPEND(wlan, ether, 1, 1, 1); 431