wlan: Remove unused ieee80211_drain_ifq
[dragonfly.git] / sys / netproto / 802_11 / wlan / ieee80211_dragonfly.c
CommitLineData
32176cfd
RP
1/*-
2 * Copyright (c) 2003-2009 Sam Leffler, Errno Consulting
841ab66c
SZ
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
841ab66c
SZ
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
32176cfd 25 * $FreeBSD: head/sys/net80211/ieee80211_freebsd.c 202612 2010-01-19 05:00:57Z thompsa $
841ab66c
SZ
26 */
27
28/*
29 * IEEE 802.11 support (DragonFlyBSD-specific code)
30 */
32176cfd
RP
31#include "opt_wlan.h"
32
841ab66c
SZ
33#include <sys/param.h>
34#include <sys/kernel.h>
35#include <sys/systm.h>
36#include <sys/linker.h>
37#include <sys/mbuf.h>
38#include <sys/module.h>
39#include <sys/proc.h>
40#include <sys/sysctl.h>
41
42#include <sys/socket.h>
43
32176cfd 44#include <net/bpf.h>
841ab66c 45#include <net/if.h>
32176cfd
RP
46#include <net/if_dl.h>
47#include <net/if_clone.h>
841ab66c 48#include <net/if_media.h>
32176cfd 49#include <net/if_types.h>
841ab66c
SZ
50#include <net/ethernet.h>
51#include <net/route.h>
fcaa651d 52#include <net/ifq_var.h>
841ab66c
SZ
53
54#include <netproto/802_11/ieee80211_var.h>
32176cfd 55#include <netproto/802_11/ieee80211_input.h>
841ab66c 56
841ab66c
SZ
57SYSCTL_NODE(_net, OID_AUTO, wlan, CTLFLAG_RD, 0, "IEEE 80211 parameters");
58
59#ifdef IEEE80211_DEBUG
60int ieee80211_debug = 0;
61SYSCTL_INT(_net_wlan, OID_AUTO, debug, CTLFLAG_RW, &ieee80211_debug,
32176cfd 62 0, "debugging printfs");
e5b94a62
SW
63#endif
64
65int ieee80211_force_swcrypto = 0;
1b196a0c
MD
66SYSCTL_INT(_net_wlan, OID_AUTO, force_swcrypto, CTLFLAG_RW,
67 &ieee80211_force_swcrypto, 0, "force software crypto");
841ab66c 68
32176cfd
RP
69MALLOC_DEFINE(M_80211_COM, "80211com", "802.11 com state");
70
ea86af0d 71
a7e9152e 72static int wlan_clone_destroy(struct ifnet *);
ea86af0d
RP
73static int wlan_clone_create(struct if_clone *, int, caddr_t);
74
75static struct if_clone wlan_cloner =
76 IF_CLONE_INITIALIZER("wlan", wlan_clone_create, wlan_clone_destroy,
77 0, IF_MAXUNIT);
78
26c6f223 79struct lwkt_serialize wlan_global_serializer = LWKT_SERIALIZE_INITIALIZER;
ea86af0d 80
32176cfd
RP
81/*
82 * Allocate/free com structure in conjunction with ifnet;
83 * these routines are registered with if_register_com_alloc
84 * below and are called automatically by the ifnet code
85 * when the ifnet of the parent device is created.
86 */
87static void *
88wlan_alloc(u_char type, struct ifnet *ifp)
89{
90 struct ieee80211com *ic;
91
92 ic = kmalloc(sizeof(struct ieee80211com), M_80211_COM, M_WAITOK|M_ZERO);
93 ic->ic_ifp = ifp;
94
95 return (ic);
96}
97
98static void
99wlan_free(void *ic, u_char type)
100{
101 kfree(ic, M_80211_COM);
102}
103
104static int
105wlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
106{
107 struct ieee80211_clone_params cp;
108 struct ieee80211vap *vap;
109 struct ieee80211com *ic;
110 struct ifnet *ifp;
111 int error;
112
113 error = copyin(params, &cp, sizeof(cp));
114 if (error)
115 return error;
116 ifp = ifunit(cp.icp_parent);
117 if (ifp == NULL)
118 return ENXIO;
119 /* XXX move printfs to DIAGNOSTIC before release */
120 if (ifp->if_type != IFT_IEEE80211) {
121 if_printf(ifp, "%s: reject, not an 802.11 device\n", __func__);
122 return ENXIO;
123 }
124 if (cp.icp_opmode >= IEEE80211_OPMODE_MAX) {
125 if_printf(ifp, "%s: invalid opmode %d\n",
126 __func__, cp.icp_opmode);
127 return EINVAL;
128 }
129 ic = ifp->if_l2com;
130 if ((ic->ic_caps & ieee80211_opcap[cp.icp_opmode]) == 0) {
131 if_printf(ifp, "%s mode not supported\n",
132 ieee80211_opmode_name[cp.icp_opmode]);
133 return EOPNOTSUPP;
134 }
135 if ((cp.icp_flags & IEEE80211_CLONE_TDMA) &&
136#ifdef IEEE80211_SUPPORT_TDMA
137 (ic->ic_caps & IEEE80211_C_TDMA) == 0
138#else
139 (1)
140#endif
141 ) {
142 if_printf(ifp, "TDMA not supported\n");
143 return EOPNOTSUPP;
144 }
145 vap = ic->ic_vap_create(ic, ifc->ifc_name, unit,
146 cp.icp_opmode, cp.icp_flags, cp.icp_bssid,
147 cp.icp_flags & IEEE80211_CLONE_MACADDR ?
148 cp.icp_macaddr : (const uint8_t *)IF_LLADDR(ifp));
149 return (vap == NULL ? EIO : 0);
150}
151
a7e9152e 152static int
32176cfd
RP
153wlan_clone_destroy(struct ifnet *ifp)
154{
155 struct ieee80211vap *vap = ifp->if_softc;
156 struct ieee80211com *ic = vap->iv_ic;
157
22a4b172 158 wlan_serialize_enter(); /* WARNING must be global serializer */
32176cfd 159 ic->ic_vap_delete(vap);
22a4b172 160 wlan_serialize_exit();
a7e9152e
SZ
161
162 return 0;
32176cfd 163}
32176cfd 164
51237956
MD
165const char *wlan_last_enter_func;
166const char *wlan_last_exit_func;
26c6f223
MD
167/*
168 * These serializer functions are used by wlan and all drivers.
169 */
170void
51237956 171_wlan_serialize_enter(const char *funcname)
26c6f223
MD
172{
173 lwkt_serialize_enter(&wlan_global_serializer);
51237956 174 wlan_last_enter_func = funcname;
26c6f223
MD
175}
176
177void
51237956 178_wlan_serialize_exit(const char *funcname)
26c6f223
MD
179{
180 lwkt_serialize_exit(&wlan_global_serializer);
51237956 181 wlan_last_exit_func = funcname;
26c6f223
MD
182}
183
184int
185wlan_serialize_sleep(void *ident, int flags, const char *wmesg, int timo)
186{
187 return(zsleep(ident, &wlan_global_serializer, flags, wmesg, timo));
188}
189
190/*
191 * condition-var functions which interlock the ic lock (which is now
192 * just wlan_global_serializer)
193 */
194void
195wlan_cv_init(struct cv *cv, const char *desc)
196{
197 cv->cv_desc = desc;
198 cv->cv_waiters = 0;
199}
200
201int
202wlan_cv_timedwait(struct cv *cv, int ticks)
203{
204 int error;
205
206 ++cv->cv_waiters;
207 error = wlan_serialize_sleep(cv, 0, cv->cv_desc, ticks);
208 return (error);
209}
210
211void
212wlan_cv_wait(struct cv *cv)
213{
214 ++cv->cv_waiters;
215 wlan_serialize_sleep(cv, 0, cv->cv_desc, 0);
216}
217
218void
219wlan_cv_signal(struct cv *cv, int broadcast)
220{
221 if (cv->cv_waiters) {
222 if (broadcast) {
223 cv->cv_waiters = 0;
224 wakeup(cv);
225 } else {
226 --cv->cv_waiters;
227 wakeup_one(cv);
228 }
229 }
230}
231
232/*
233 * Misc
234 */
32176cfd
RP
235void
236ieee80211_vap_destroy(struct ieee80211vap *vap)
237{
1f714e29
MD
238 wlan_assert_serialized();
239 wlan_serialize_exit();
5fe801af 240 if_clone_destroy(vap->iv_ifp->if_xname);
1f714e29 241 wlan_serialize_enter();
32176cfd
RP
242}
243
47156d48
MD
244/*
245 * NOTE: This handler is used generally to convert milliseconds
246 * to ticks for various simple sysctl variables and does not
247 * need to be serialized.
248 */
32176cfd
RP
249int
250ieee80211_sysctl_msecs_ticks(SYSCTL_HANDLER_ARGS)
251{
252 int msecs = ticks_to_msecs(*(int *)arg1);
253 int error, t;
254
255 error = sysctl_handle_int(oidp, &msecs, 0, req);
47156d48
MD
256 if (error == 0 && req->newptr) {
257 t = msecs_to_ticks(msecs);
258 *(int *)arg1 = (t < 1) ? 1 : t;
259 }
260
261 return error;
32176cfd
RP
262}
263
841ab66c
SZ
264static int
265ieee80211_sysctl_inact(SYSCTL_HANDLER_ARGS)
266{
267 int inact = (*(int *)arg1) * IEEE80211_INACT_WAIT;
268 int error;
269
270 error = sysctl_handle_int(oidp, &inact, 0, req);
47156d48
MD
271 wlan_serialize_enter();
272 if (error == 0 && req->newptr)
273 *(int *)arg1 = inact / IEEE80211_INACT_WAIT;
274 wlan_serialize_exit();
275
276 return error;
841ab66c
SZ
277}
278
279static int
280ieee80211_sysctl_parent(SYSCTL_HANDLER_ARGS)
281{
282 struct ieee80211com *ic = arg1;
283 const char *name = ic->ic_ifp->if_xname;
284
285 return SYSCTL_OUT(req, name, strlen(name));
286}
287
32176cfd
RP
288static int
289ieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS)
290{
291 struct ieee80211com *ic = arg1;
292 int t = 0, error;
293
294 error = sysctl_handle_int(oidp, &t, 0, req);
47156d48
MD
295 wlan_serialize_enter();
296 if (error == 0 && req->newptr)
297 ieee80211_dfs_notify_radar(ic, ic->ic_curchan);
298 wlan_serialize_exit();
299
300 return error;
32176cfd
RP
301}
302
841ab66c
SZ
303void
304ieee80211_sysctl_attach(struct ieee80211com *ic)
305{
32176cfd
RP
306}
307
308void
309ieee80211_sysctl_detach(struct ieee80211com *ic)
310{
311}
312
313void
314ieee80211_sysctl_vattach(struct ieee80211vap *vap)
315{
316 struct ifnet *ifp = vap->iv_ifp;
841ab66c
SZ
317 struct sysctl_ctx_list *ctx;
318 struct sysctl_oid *oid;
319 char num[14]; /* sufficient for 32 bits */
320
f4385629 321 ctx = (struct sysctl_ctx_list *) kmalloc(sizeof(struct sysctl_ctx_list),
fcaa651d 322 M_DEVBUF, M_INTWAIT | M_ZERO);
32176cfd
RP
323 if (ctx == NULL) {
324 if_printf(ifp, "%s: cannot allocate sysctl context!\n",
325 __func__);
326 return;
327 }
841ab66c 328 sysctl_ctx_init(ctx);
32176cfd 329 ksnprintf(num, sizeof(num), "%u", ifp->if_dunit);
841ab66c
SZ
330 oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
331 OID_AUTO, num, CTLFLAG_RD, NULL, "");
841ab66c 332 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd
RP
333 "%parent", CTLFLAG_RD, vap->iv_ic, 0,
334 ieee80211_sysctl_parent, "A", "parent device");
335 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
336 "driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
337 "driver capabilities");
841ab66c 338#ifdef IEEE80211_DEBUG
32176cfd 339 vap->iv_debug = ieee80211_debug;
841ab66c 340 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd
RP
341 "debug", CTLFLAG_RW, &vap->iv_debug, 0,
342 "control debugging printfs");
841ab66c 343#endif
32176cfd
RP
344 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
345 "bmiss_max", CTLFLAG_RW, &vap->iv_bmiss_max, 0,
346 "consecutive beacon misses before scanning");
841ab66c
SZ
347 /* XXX inherit from tunables */
348 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd 349 "inact_run", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_run, 0,
841ab66c
SZ
350 ieee80211_sysctl_inact, "I",
351 "station inactivity timeout (sec)");
352 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd 353 "inact_probe", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_probe, 0,
841ab66c
SZ
354 ieee80211_sysctl_inact, "I",
355 "station inactivity probe timeout (sec)");
356 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd 357 "inact_auth", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_auth, 0,
841ab66c
SZ
358 ieee80211_sysctl_inact, "I",
359 "station authentication timeout (sec)");
360 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
32176cfd 361 "inact_init", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_init, 0,
841ab66c
SZ
362 ieee80211_sysctl_inact, "I",
363 "station initial state timeout (sec)");
32176cfd
RP
364 if (vap->iv_htcaps & IEEE80211_HTC_HT) {
365 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
366 "ampdu_mintraffic_bk", CTLFLAG_RW,
367 &vap->iv_ampdu_mintraffic[WME_AC_BK], 0,
368 "BK traffic tx aggr threshold (pps)");
369 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
370 "ampdu_mintraffic_be", CTLFLAG_RW,
371 &vap->iv_ampdu_mintraffic[WME_AC_BE], 0,
372 "BE traffic tx aggr threshold (pps)");
373 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
374 "ampdu_mintraffic_vo", CTLFLAG_RW,
375 &vap->iv_ampdu_mintraffic[WME_AC_VO], 0,
376 "VO traffic tx aggr threshold (pps)");
377 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
378 "ampdu_mintraffic_vi", CTLFLAG_RW,
379 &vap->iv_ampdu_mintraffic[WME_AC_VI], 0,
380 "VI traffic tx aggr threshold (pps)");
381 }
382 if (vap->iv_caps & IEEE80211_C_DFS) {
383 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
384 "radar", CTLTYPE_INT | CTLFLAG_RW, vap->iv_ic, 0,
385 ieee80211_sysctl_radar, "I", "simulate radar event");
386 }
387 vap->iv_sysctl = ctx;
388 vap->iv_oid = oid;
841ab66c
SZ
389}
390
391void
32176cfd 392ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
841ab66c 393{
32176cfd
RP
394
395 if (vap->iv_sysctl != NULL) {
396 sysctl_ctx_free(vap->iv_sysctl);
f4385629 397 kfree(vap->iv_sysctl, M_DEVBUF);
32176cfd 398 vap->iv_sysctl = NULL;
841ab66c
SZ
399 }
400}
401
402int
403ieee80211_node_dectestref(struct ieee80211_node *ni)
404{
405 /* XXX need equivalent of atomic_dec_and_test */
406 atomic_subtract_int(&ni->ni_refcnt, 1);
407 return atomic_cmpset_int(&ni->ni_refcnt, 0, 1);
408}
409
32176cfd 410void
32176cfd
RP
411ieee80211_flush_ifq(struct ifqueue *ifq, struct ieee80211vap *vap)
412{
413 struct ieee80211_node *ni;
414 struct mbuf *m, **mprev;
415
26c6f223 416 wlan_assert_serialized();
32176cfd
RP
417 mprev = &ifq->ifq_head;
418 while ((m = *mprev) != NULL) {
419 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
420 if (ni != NULL && ni->ni_vap == vap) {
421 *mprev = m->m_nextpkt; /* remove from list */
422 ifq->ifq_len--;
423
424 m_freem(m);
425 ieee80211_free_node(ni); /* reclaim ref */
426 } else
427 mprev = &m->m_nextpkt;
428 }
429 /* recalculate tail ptr */
430 m = ifq->ifq_head;
431 for (; m != NULL && m->m_nextpkt != NULL; m = m->m_nextpkt)
432 ;
433 ifq->ifq_tail = m;
32176cfd
RP
434}
435
436/*
437 * As above, for mbufs allocated with m_gethdr/MGETHDR
438 * or initialized by M_COPY_PKTHDR.
439 */
440#define MC_ALIGN(m, len) \
441do { \
442 (m)->m_data += (MCLBYTES - (len)) &~ (sizeof(long) - 1); \
443} while (/* CONSTCOND */ 0)
444
841ab66c
SZ
445/*
446 * Allocate and setup a management frame of the specified
447 * size. We return the mbuf and a pointer to the start
448 * of the contiguous data area that's been reserved based
449 * on the packet length. The data area is forced to 32-bit
450 * alignment and the buffer length to a multiple of 4 bytes.
451 * This is done mainly so beacon frames (that require this)
452 * can use this interface too.
453 */
454struct mbuf *
32176cfd 455ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen)
841ab66c
SZ
456{
457 struct mbuf *m;
458 u_int len;
459
460 /*
461 * NB: we know the mbuf routines will align the data area
462 * so we don't need to do anything special.
463 */
32176cfd 464 len = roundup2(headroom + pktlen, 4);
841ab66c
SZ
465 KASSERT(len <= MCLBYTES, ("802.11 mgt frame too large: %u", len));
466 if (len < MINCLSIZE) {
543d1dec 467 m = m_gethdr(MB_DONTWAIT, MT_DATA);
841ab66c
SZ
468 /*
469 * Align the data in case additional headers are added.
470 * This should only happen when a WEP header is added
471 * which only happens for shared key authentication mgt
472 * frames which all fit in MHLEN.
473 */
474 if (m != NULL)
475 MH_ALIGN(m, len);
32176cfd 476 } else {
543d1dec 477 m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
32176cfd
RP
478 if (m != NULL)
479 MC_ALIGN(m, len);
480 }
841ab66c 481 if (m != NULL) {
4ac84526 482 m->m_data += headroom;
32176cfd 483 *frm = m->m_data;
841ab66c
SZ
484 }
485 return m;
486}
487
32176cfd
RP
488/*
489 * Re-align the payload in the mbuf. This is mainly used (right now)
490 * to handle IP header alignment requirements on certain architectures.
491 */
492struct mbuf *
493ieee80211_realign(struct ieee80211vap *vap, struct mbuf *m, size_t align)
494{
495 int pktlen, space;
ea86af0d 496 struct mbuf *n = NULL;
32176cfd
RP
497
498 pktlen = m->m_pkthdr.len;
499 space = pktlen + align;
500 if (space < MINCLSIZE)
f4385629 501 n = m_gethdr(MB_DONTWAIT, MT_DATA);
22603758 502#ifdef notyet
32176cfd 503 else {
f4385629 504 n = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR,
32176cfd
RP
505 space <= MCLBYTES ? MCLBYTES :
506#if MJUMPAGESIZE != MCLBYTES
507 space <= MJUMPAGESIZE ? MJUMPAGESIZE :
508#endif
509 space <= MJUM9BYTES ? MJUM9BYTES : MJUM16BYTES);
510 }
22603758 511#endif
32176cfd
RP
512 if (__predict_true(n != NULL)) {
513 m_move_pkthdr(n, m);
514 n->m_data = (caddr_t)(ALIGN(n->m_data + align) - align);
515 m_copydata(m, 0, pktlen, mtod(n, caddr_t));
516 n->m_len = pktlen;
517 } else {
518 IEEE80211_DISCARD(vap, IEEE80211_MSG_ANY,
519 mtod(m, const struct ieee80211_frame *), NULL,
520 "%s", "no mbuf to realign");
521 vap->iv_stats.is_rx_badalign++;
522 }
523 m_freem(m);
524 return n;
525}
526
527int
528ieee80211_add_callback(struct mbuf *m,
529 void (*func)(struct ieee80211_node *, void *, int), void *arg)
530{
531 struct m_tag *mtag;
532 struct ieee80211_cb *cb;
533
534 mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_CALLBACK,
fcaa651d 535 sizeof(struct ieee80211_cb), M_INTWAIT);
32176cfd
RP
536 if (mtag == NULL)
537 return 0;
538
539 cb = (struct ieee80211_cb *)(mtag+1);
540 cb->func = func;
541 cb->arg = arg;
542 m_tag_prepend(m, mtag);
543 m->m_flags |= M_TXCB;
544 return 1;
545}
546
547void
548ieee80211_process_callback(struct ieee80211_node *ni,
549 struct mbuf *m, int status)
550{
551 struct m_tag *mtag;
552
553 mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, NULL);
554 if (mtag != NULL) {
555 struct ieee80211_cb *cb = (struct ieee80211_cb *)(mtag+1);
556 cb->func(ni, cb->arg, status);
557 }
558}
559
841ab66c
SZ
560#include <sys/libkern.h>
561
562void
563get_random_bytes(void *p, size_t n)
564{
565 uint8_t *dp = p;
566
567 while (n > 0) {
0ced1954 568 uint32_t v = karc4random();
841ab66c 569 size_t nb = n > sizeof(uint32_t) ? sizeof(uint32_t) : n;
841ab66c
SZ
570 bcopy(&v, dp, n > sizeof(uint32_t) ? sizeof(uint32_t) : n);
571 dp += sizeof(uint32_t), n -= nb;
572 }
573}
574
32176cfd
RP
575/*
576 * Helper function for events that pass just a single mac address.
577 */
578static void
579notify_macaddr(struct ifnet *ifp, int op, const uint8_t mac[IEEE80211_ADDR_LEN])
841ab66c 580{
841ab66c
SZ
581 struct ieee80211_join_event iev;
582
583 memset(&iev, 0, sizeof(iev));
32176cfd
RP
584 IEEE80211_ADDR_COPY(iev.iev_addr, mac);
585 rt_ieee80211msg(ifp, op, &iev, sizeof(iev));
32176cfd
RP
586}
587
588void
589ieee80211_notify_node_join(struct ieee80211_node *ni, int newassoc)
590{
591 struct ieee80211vap *vap = ni->ni_vap;
592 struct ifnet *ifp = vap->iv_ifp;
593
32176cfd
RP
594 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode join",
595 (ni == vap->iv_bss) ? "bss " : "");
596
597 if (ni == vap->iv_bss) {
598 notify_macaddr(ifp, newassoc ?
599 RTM_IEEE80211_ASSOC : RTM_IEEE80211_REASSOC, ni->ni_bssid);
f4385629 600 if_link_state_change(ifp);
841ab66c 601 } else {
32176cfd
RP
602 notify_macaddr(ifp, newassoc ?
603 RTM_IEEE80211_JOIN : RTM_IEEE80211_REJOIN, ni->ni_macaddr);
841ab66c
SZ
604 }
605}
606
607void
32176cfd 608ieee80211_notify_node_leave(struct ieee80211_node *ni)
841ab66c 609{
32176cfd
RP
610 struct ieee80211vap *vap = ni->ni_vap;
611 struct ifnet *ifp = vap->iv_ifp;
612
32176cfd
RP
613 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode leave",
614 (ni == vap->iv_bss) ? "bss " : "");
841ab66c 615
32176cfd 616 if (ni == vap->iv_bss) {
841ab66c 617 rt_ieee80211msg(ifp, RTM_IEEE80211_DISASSOC, NULL, 0);
f4385629 618 if_link_state_change(ifp);
841ab66c
SZ
619 } else {
620 /* fire off wireless event station leaving */
32176cfd 621 notify_macaddr(ifp, RTM_IEEE80211_LEAVE, ni->ni_macaddr);
841ab66c
SZ
622 }
623}
624
625void
32176cfd 626ieee80211_notify_scan_done(struct ieee80211vap *vap)
841ab66c 627{
32176cfd 628 struct ifnet *ifp = vap->iv_ifp;
841ab66c 629
32176cfd 630 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s\n", "notify scan done");
841ab66c
SZ
631
632 /* dispatch wireless event indicating scan completed */
633 rt_ieee80211msg(ifp, RTM_IEEE80211_SCAN, NULL, 0);
634}
635
636void
32176cfd 637ieee80211_notify_replay_failure(struct ieee80211vap *vap,
841ab66c 638 const struct ieee80211_frame *wh, const struct ieee80211_key *k,
32176cfd 639 u_int64_t rsc, int tid)
841ab66c 640{
32176cfd 641 struct ifnet *ifp = vap->iv_ifp;
841ab66c 642
32176cfd
RP
643 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
644 "%s replay detected <rsc %ju, csc %ju, keyix %u rxkeyix %u>",
645 k->wk_cipher->ic_name, (intmax_t) rsc,
646 (intmax_t) k->wk_keyrsc[tid],
841ab66c
SZ
647 k->wk_keyix, k->wk_rxkeyix);
648
649 if (ifp != NULL) { /* NB: for cipher test modules */
650 struct ieee80211_replay_event iev;
651
652 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
653 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
654 iev.iev_cipher = k->wk_cipher->ic_cipher;
655 if (k->wk_rxkeyix != IEEE80211_KEYIX_NONE)
656 iev.iev_keyix = k->wk_rxkeyix;
657 else
658 iev.iev_keyix = k->wk_keyix;
32176cfd 659 iev.iev_keyrsc = k->wk_keyrsc[tid];
841ab66c
SZ
660 iev.iev_rsc = rsc;
661 rt_ieee80211msg(ifp, RTM_IEEE80211_REPLAY, &iev, sizeof(iev));
662 }
663}
664
665void
32176cfd 666ieee80211_notify_michael_failure(struct ieee80211vap *vap,
841ab66c
SZ
667 const struct ieee80211_frame *wh, u_int keyix)
668{
32176cfd 669 struct ifnet *ifp = vap->iv_ifp;
841ab66c 670
32176cfd
RP
671 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
672 "michael MIC verification failed <keyix %u>", keyix);
673 vap->iv_stats.is_rx_tkipmic++;
841ab66c
SZ
674
675 if (ifp != NULL) { /* NB: for cipher test modules */
676 struct ieee80211_michael_event iev;
677
678 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
679 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
680 iev.iev_cipher = IEEE80211_CIPHER_TKIP;
681 iev.iev_keyix = keyix;
682 rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev));
683 }
684}
685
686void
32176cfd 687ieee80211_notify_wds_discover(struct ieee80211_node *ni)
841ab66c 688{
32176cfd
RP
689 struct ieee80211vap *vap = ni->ni_vap;
690 struct ifnet *ifp = vap->iv_ifp;
841ab66c 691
32176cfd 692 notify_macaddr(ifp, RTM_IEEE80211_WDS, ni->ni_macaddr);
841ab66c
SZ
693}
694
32176cfd
RP
695void
696ieee80211_notify_csa(struct ieee80211com *ic,
697 const struct ieee80211_channel *c, int mode, int count)
841ab66c 698{
32176cfd
RP
699 struct ifnet *ifp = ic->ic_ifp;
700 struct ieee80211_csa_event iev;
841ab66c 701
32176cfd
RP
702 memset(&iev, 0, sizeof(iev));
703 iev.iev_flags = c->ic_flags;
704 iev.iev_freq = c->ic_freq;
705 iev.iev_ieee = c->ic_ieee;
706 iev.iev_mode = mode;
707 iev.iev_count = count;
708 rt_ieee80211msg(ifp, RTM_IEEE80211_CSA, &iev, sizeof(iev));
841ab66c
SZ
709}
710
32176cfd
RP
711void
712ieee80211_notify_radar(struct ieee80211com *ic,
713 const struct ieee80211_channel *c)
841ab66c 714{
32176cfd
RP
715 struct ifnet *ifp = ic->ic_ifp;
716 struct ieee80211_radar_event iev;
841ab66c 717
32176cfd
RP
718 memset(&iev, 0, sizeof(iev));
719 iev.iev_flags = c->ic_flags;
720 iev.iev_freq = c->ic_freq;
721 iev.iev_ieee = c->ic_ieee;
722 rt_ieee80211msg(ifp, RTM_IEEE80211_RADAR, &iev, sizeof(iev));
723}
841ab66c 724
32176cfd
RP
725void
726ieee80211_notify_cac(struct ieee80211com *ic,
727 const struct ieee80211_channel *c, enum ieee80211_notify_cac_event type)
728{
729 struct ifnet *ifp = ic->ic_ifp;
730 struct ieee80211_cac_event iev;
841ab66c 731
32176cfd
RP
732 memset(&iev, 0, sizeof(iev));
733 iev.iev_flags = c->ic_flags;
734 iev.iev_freq = c->ic_freq;
735 iev.iev_ieee = c->ic_ieee;
736 iev.iev_type = type;
737 rt_ieee80211msg(ifp, RTM_IEEE80211_CAC, &iev, sizeof(iev));
738}
739
740void
741ieee80211_notify_node_deauth(struct ieee80211_node *ni)
742{
743 struct ieee80211vap *vap = ni->ni_vap;
744 struct ifnet *ifp = vap->iv_ifp;
745
746 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node deauth");
747
748 notify_macaddr(ifp, RTM_IEEE80211_DEAUTH, ni->ni_macaddr);
749}
750
751void
752ieee80211_notify_node_auth(struct ieee80211_node *ni)
753{
754 struct ieee80211vap *vap = ni->ni_vap;
755 struct ifnet *ifp = vap->iv_ifp;
756
757 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node auth");
758
759 notify_macaddr(ifp, RTM_IEEE80211_AUTH, ni->ni_macaddr);
760}
761
762void
763ieee80211_notify_country(struct ieee80211vap *vap,
764 const uint8_t bssid[IEEE80211_ADDR_LEN], const uint8_t cc[2])
765{
766 struct ifnet *ifp = vap->iv_ifp;
767 struct ieee80211_country_event iev;
768
769 memset(&iev, 0, sizeof(iev));
770 IEEE80211_ADDR_COPY(iev.iev_addr, bssid);
771 iev.iev_cc[0] = cc[0];
772 iev.iev_cc[1] = cc[1];
773 rt_ieee80211msg(ifp, RTM_IEEE80211_COUNTRY, &iev, sizeof(iev));
774}
775
776void
777ieee80211_notify_radio(struct ieee80211com *ic, int state)
778{
779 struct ifnet *ifp = ic->ic_ifp;
780 struct ieee80211_radio_event iev;
781
782 memset(&iev, 0, sizeof(iev));
783 iev.iev_state = state;
784 rt_ieee80211msg(ifp, RTM_IEEE80211_RADIO, &iev, sizeof(iev));
785}
786
fcaa651d
RP
787int
788ieee80211_handoff(struct ifnet *dst_ifp, struct mbuf *m)
789{
790 struct mbuf *m0;
791
792 /* We may be sending a fragment so traverse the mbuf */
22a4b172
MD
793 wlan_assert_serialized();
794 wlan_serialize_exit();
fcaa651d
RP
795 for (; m; m = m0) {
796 struct altq_pktattr pktattr;
797
798 m0 = m->m_nextpkt;
799 m->m_nextpkt = NULL;
800
801 if (ifq_is_enabled(&dst_ifp->if_snd))
802 altq_etherclassify(&dst_ifp->if_snd, m, &pktattr);
803
804 ifq_dispatch(dst_ifp, m, &pktattr);
805 }
22a4b172 806 wlan_serialize_enter();
fcaa651d
RP
807
808 return (0);
809}
810
a13825b3
RP
811/* IEEE Std 802.11a-1999, page 9, table 79 */
812#define IEEE80211_OFDM_SYM_TIME 4
813#define IEEE80211_OFDM_PREAMBLE_TIME 16
814#define IEEE80211_OFDM_SIGNAL_TIME 4
815/* IEEE Std 802.11g-2003, page 44 */
816#define IEEE80211_OFDM_SIGNAL_EXT_TIME 6
817
818/* IEEE Std 802.11a-1999, page 7, figure 107 */
819#define IEEE80211_OFDM_PLCP_SERVICE_NBITS 16
820#define IEEE80211_OFDM_TAIL_NBITS 6
821
822#define IEEE80211_OFDM_NBITS(frmlen) \
823 (IEEE80211_OFDM_PLCP_SERVICE_NBITS + \
824 ((frmlen) * NBBY) + \
825 IEEE80211_OFDM_TAIL_NBITS)
826
827#define IEEE80211_OFDM_NBITS_PER_SYM(kbps) \
828 (((kbps) * IEEE80211_OFDM_SYM_TIME) / 1000)
829
830#define IEEE80211_OFDM_NSYMS(kbps, frmlen) \
831 howmany(IEEE80211_OFDM_NBITS((frmlen)), \
832 IEEE80211_OFDM_NBITS_PER_SYM((kbps)))
833
834#define IEEE80211_OFDM_TXTIME(kbps, frmlen) \
835 (IEEE80211_OFDM_PREAMBLE_TIME + \
836 IEEE80211_OFDM_SIGNAL_TIME + \
837 (IEEE80211_OFDM_NSYMS((kbps), (frmlen)) * IEEE80211_OFDM_SYM_TIME))
838
839/* IEEE Std 802.11b-1999, page 28, subclause 18.3.4 */
840#define IEEE80211_CCK_PREAMBLE_LEN 144
841#define IEEE80211_CCK_PLCP_HDR_TIME 48
842#define IEEE80211_CCK_SHPREAMBLE_LEN 72
843#define IEEE80211_CCK_SHPLCP_HDR_TIME 24
844
845#define IEEE80211_CCK_NBITS(frmlen) ((frmlen) * NBBY)
846#define IEEE80211_CCK_TXTIME(kbps, frmlen) \
847 (((IEEE80211_CCK_NBITS((frmlen)) * 1000) + (kbps) - 1) / (kbps))
848
849uint16_t
850ieee80211_txtime(struct ieee80211_node *ni, u_int len, uint8_t rs_rate,
851 uint32_t flags)
852{
853 struct ieee80211vap *vap = ni->ni_vap;
854 uint16_t txtime;
855 int rate;
856
857 rs_rate &= IEEE80211_RATE_VAL;
858 rate = rs_rate * 500; /* ieee80211 rate -> kbps */
859
860 if (vap->iv_ic->ic_phytype == IEEE80211_T_OFDM) {
861 /*
862 * IEEE Std 802.11a-1999, page 37, equation (29)
863 * IEEE Std 802.11g-2003, page 44, equation (42)
864 */
865 txtime = IEEE80211_OFDM_TXTIME(rate, len);
866 if (vap->iv_ic->ic_curmode == IEEE80211_MODE_11G)
867 txtime += IEEE80211_OFDM_SIGNAL_EXT_TIME;
868 } else {
869 /*
870 * IEEE Std 802.11b-1999, page 28, subclause 18.3.4
871 * IEEE Std 802.11g-2003, page 45, equation (43)
872 */
873 if (vap->iv_ic->ic_phytype == IEEE80211_T_OFDM_QUARTER+1)
874 ++len;
875 txtime = IEEE80211_CCK_TXTIME(rate, len);
876
877 /*
878 * Short preamble is not applicable for DS 1Mbits/s
879 */
880 if (rs_rate != 2 && (flags & IEEE80211_F_SHPREAMBLE)) {
881 txtime += IEEE80211_CCK_SHPREAMBLE_LEN +
882 IEEE80211_CCK_SHPLCP_HDR_TIME;
883 } else {
884 txtime += IEEE80211_CCK_PREAMBLE_LEN +
885 IEEE80211_CCK_PLCP_HDR_TIME;
886 }
887 }
888 return txtime;
889}
890
32176cfd
RP
891void
892ieee80211_load_module(const char *modname)
893{
894
895#ifdef notyet
896 (void)kern_kldload(curthread, modname, NULL);
897#else
898 kprintf("%s: load the %s module by hand for now.\n", __func__, modname);
899#endif
900}
901
902static eventhandler_tag wlan_bpfevent;
903static eventhandler_tag wlan_ifllevent;
904
905static void
51237956 906bpf_track_event(void *arg, struct ifnet *ifp, int dlt, int attach)
32176cfd
RP
907{
908 /* NB: identify vap's by if_start */
47156d48
MD
909
910 wlan_serialize_enter();
32176cfd
RP
911 if (dlt == DLT_IEEE802_11_RADIO && ifp->if_start == ieee80211_start) {
912 struct ieee80211vap *vap = ifp->if_softc;
841ab66c 913 /*
32176cfd
RP
914 * Track bpf radiotap listener state. We mark the vap
915 * to indicate if any listener is present and the com
916 * to indicate if any listener exists on any associated
917 * vap. This flag is used by drivers to prepare radiotap
918 * state only when needed.
841ab66c 919 */
32176cfd
RP
920 if (attach) {
921 ieee80211_syncflag_ext(vap, IEEE80211_FEXT_BPF);
922 if (vap->iv_opmode == IEEE80211_M_MONITOR)
923 atomic_add_int(&vap->iv_ic->ic_montaps, 1);
19f10c78 924 } else if (!vap->iv_rawbpf) {
32176cfd
RP
925 ieee80211_syncflag_ext(vap, -IEEE80211_FEXT_BPF);
926 if (vap->iv_opmode == IEEE80211_M_MONITOR)
927 atomic_subtract_int(&vap->iv_ic->ic_montaps, 1);
841ab66c 928 }
841ab66c 929 }
47156d48 930 wlan_serialize_exit();
841ab66c
SZ
931}
932
32176cfd 933static void
51237956 934wlan_iflladdr_event(void *arg __unused, struct ifnet *ifp)
31358101 935{
32176cfd
RP
936 struct ieee80211com *ic = ifp->if_l2com;
937 struct ieee80211vap *vap, *next;
31358101 938
47156d48
MD
939 wlan_serialize_enter();
940 if (ifp->if_type != IFT_IEEE80211 || ic == NULL) {
941 wlan_serialize_exit();
32176cfd 942 return;
47156d48 943 }
31358101 944
f4385629 945 TAILQ_FOREACH_MUTABLE(vap, &ic->ic_vaps, iv_next, next) {
32176cfd
RP
946 /*
947 * If the MAC address has changed on the parent and it was
948 * copied to the vap on creation then re-sync.
949 */
950 if (vap->iv_ic == ic &&
951 (vap->iv_flags_ext & IEEE80211_FEXT_UNIQMAC) == 0) {
952 IEEE80211_ADDR_COPY(vap->iv_myaddr, IF_LLADDR(ifp));
26c6f223 953 wlan_serialize_exit();
32176cfd 954 if_setlladdr(vap->iv_ifp, IF_LLADDR(ifp),
26c6f223
MD
955 IEEE80211_ADDR_LEN);
956 wlan_serialize_enter();
32176cfd 957 }
31358101 958 }
47156d48 959 wlan_serialize_exit();
31358101
SW
960}
961
841ab66c
SZ
962/*
963 * Module glue.
964 *
965 * NB: the module name is "wlan" for compatibility with NetBSD.
966 */
967static int
968wlan_modevent(module_t mod, int type, void *unused)
969{
47156d48
MD
970 int error;
971
972 wlan_serialize_enter();
973
841ab66c
SZ
974 switch (type) {
975 case MOD_LOAD:
976 if (bootverbose)
a6ec04bc 977 kprintf("wlan: <802.11 Link Layer>\n");
32176cfd 978 wlan_bpfevent = EVENTHANDLER_REGISTER(bpf_track,
51237956 979 bpf_track_event, 0,
47156d48
MD
980 EVENTHANDLER_PRI_ANY);
981 if (wlan_bpfevent == NULL) {
982 error = ENOMEM;
983 break;
984 }
32176cfd 985 wlan_ifllevent = EVENTHANDLER_REGISTER(iflladdr_event,
51237956 986 wlan_iflladdr_event, NULL,
47156d48 987 EVENTHANDLER_PRI_ANY);
32176cfd
RP
988 if (wlan_ifllevent == NULL) {
989 EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent);
47156d48
MD
990 error = ENOMEM;
991 break;
32176cfd
RP
992 }
993 if_clone_attach(&wlan_cloner);
cf719b06 994 if_register_com_alloc(IFT_IEEE80211, wlan_alloc, wlan_free);
47156d48
MD
995 error = 0;
996 break;
841ab66c 997 case MOD_UNLOAD:
32176cfd
RP
998 if_deregister_com_alloc(IFT_IEEE80211);
999 if_clone_detach(&wlan_cloner);
1000 EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent);
1001 EVENTHANDLER_DEREGISTER(iflladdr_event, wlan_ifllevent);
47156d48
MD
1002 error = 0;
1003 break;
1004 default:
1005 error = EINVAL;
1006 break;
841ab66c 1007 }
47156d48
MD
1008 wlan_serialize_exit();
1009
1010 return error;
841ab66c
SZ
1011}
1012
1013static moduledata_t wlan_mod = {
1014 "wlan",
1015 wlan_modevent,
1016 0
1017};
1018DECLARE_MODULE(wlan, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
1019MODULE_VERSION(wlan, 1);
32176cfd 1020MODULE_DEPEND(wlan, ether, 1, 1, 1);