1/*-
2 * Copyright (c) 2003-2009 Sam Leffler, Errno Consulting
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.
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 */
25
26#include <sys/cdefs.h>
| 1/*-
2 * Copyright (c) 2003-2009 Sam Leffler, Errno Consulting
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.
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 */
25
26#include <sys/cdefs.h>
|
27__FBSDID("$FreeBSD: head/sys/net80211/ieee80211_freebsd.c 193541 2009-06-05 23:10:30Z sam $");
| 27__FBSDID("$FreeBSD: head/sys/net80211/ieee80211_freebsd.c 195757 2009-07-18 20:19:53Z sam $");
|
28
29/*
30 * IEEE 802.11 support (FreeBSD-specific code)
31 */
32#include "opt_wlan.h"
33
34#include <sys/param.h>
35#include <sys/kernel.h>
36#include <sys/systm.h>
37#include <sys/linker.h>
38#include <sys/mbuf.h>
39#include <sys/module.h>
40#include <sys/proc.h>
41#include <sys/sysctl.h>
42
43#include <sys/socket.h>
44#include <sys/vimage.h>
45
46#include <net/bpf.h>
47#include <net/if.h>
48#include <net/if_dl.h>
49#include <net/if_clone.h>
50#include <net/if_media.h>
51#include <net/if_types.h>
52#include <net/ethernet.h>
53#include <net/route.h>
54
55#include <net80211/ieee80211_var.h>
| 28
29/*
30 * IEEE 802.11 support (FreeBSD-specific code)
31 */
32#include "opt_wlan.h"
33
34#include <sys/param.h>
35#include <sys/kernel.h>
36#include <sys/systm.h>
37#include <sys/linker.h>
38#include <sys/mbuf.h>
39#include <sys/module.h>
40#include <sys/proc.h>
41#include <sys/sysctl.h>
42
43#include <sys/socket.h>
44#include <sys/vimage.h>
45
46#include <net/bpf.h>
47#include <net/if.h>
48#include <net/if_dl.h>
49#include <net/if_clone.h>
50#include <net/if_media.h>
51#include <net/if_types.h>
52#include <net/ethernet.h>
53#include <net/route.h>
54
55#include <net80211/ieee80211_var.h>
|
| 56#include <net80211/ieee80211_input.h>
|
56
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,
62 0, "debugging printfs");
63#endif
64
65MALLOC_DEFINE(M_80211_COM, "80211com", "802.11 com state");
66
67/*
68 * Allocate/free com structure in conjunction with ifnet;
69 * these routines are registered with if_register_com_alloc
70 * below and are called automatically by the ifnet code
71 * when the ifnet of the parent device is created.
72 */
73static void *
74wlan_alloc(u_char type, struct ifnet *ifp)
75{
76 struct ieee80211com *ic;
77
78 ic = malloc(sizeof(struct ieee80211com), M_80211_COM, M_WAITOK|M_ZERO);
79 ic->ic_ifp = ifp;
80
81 return (ic);
82}
83
84static void
85wlan_free(void *ic, u_char type)
86{
87 free(ic, M_80211_COM);
88}
89
90static int
91wlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
92{
93 struct ieee80211_clone_params cp;
94 struct ieee80211vap *vap;
95 struct ieee80211com *ic;
96 struct ifnet *ifp;
97 int error;
98
99 error = copyin(params, &cp, sizeof(cp));
100 if (error)
101 return error;
102 ifp = ifunit(cp.icp_parent);
103 if (ifp == NULL)
104 return ENXIO;
105 /* XXX move printfs to DIAGNOSTIC before release */
106 if (ifp->if_type != IFT_IEEE80211) {
107 if_printf(ifp, "%s: reject, not an 802.11 device\n", __func__);
108 return ENXIO;
109 }
110 if (cp.icp_opmode >= IEEE80211_OPMODE_MAX) {
111 if_printf(ifp, "%s: invalid opmode %d\n",
112 __func__, cp.icp_opmode);
113 return EINVAL;
114 }
115 ic = ifp->if_l2com;
116 if ((ic->ic_caps & ieee80211_opcap[cp.icp_opmode]) == 0) {
117 if_printf(ifp, "%s mode not supported\n",
118 ieee80211_opmode_name[cp.icp_opmode]);
119 return EOPNOTSUPP;
120 }
121 if ((cp.icp_flags & IEEE80211_CLONE_TDMA) &&
122#ifdef IEEE80211_SUPPORT_TDMA
123 (ic->ic_caps & IEEE80211_C_TDMA) == 0
124#else
125 (1)
126#endif
127 ) {
128 if_printf(ifp, "TDMA not supported\n");
129 return EOPNOTSUPP;
130 }
131 vap = ic->ic_vap_create(ic, ifc->ifc_name, unit,
132 cp.icp_opmode, cp.icp_flags, cp.icp_bssid,
133 cp.icp_flags & IEEE80211_CLONE_MACADDR ?
134 cp.icp_macaddr : (const uint8_t *)IF_LLADDR(ifp));
135 return (vap == NULL ? EIO : 0);
136}
137
138static void
139wlan_clone_destroy(struct ifnet *ifp)
140{
141 struct ieee80211vap *vap = ifp->if_softc;
142 struct ieee80211com *ic = vap->iv_ic;
143
144 ic->ic_vap_delete(vap);
145}
146IFC_SIMPLE_DECLARE(wlan, 0);
147
148void
149ieee80211_vap_destroy(struct ieee80211vap *vap)
150{
151 if_clone_destroyif(&wlan_cloner, vap->iv_ifp);
152}
153
154int
155ieee80211_sysctl_msecs_ticks(SYSCTL_HANDLER_ARGS)
156{
157 int msecs = ticks_to_msecs(*(int *)arg1);
158 int error, t;
159
160 error = sysctl_handle_int(oidp, &msecs, 0, req);
161 if (error || !req->newptr)
162 return error;
163 t = msecs_to_ticks(msecs);
164 *(int *)arg1 = (t < 1) ? 1 : t;
165 return 0;
166}
167
168static int
169ieee80211_sysctl_inact(SYSCTL_HANDLER_ARGS)
170{
171 int inact = (*(int *)arg1) * IEEE80211_INACT_WAIT;
172 int error;
173
174 error = sysctl_handle_int(oidp, &inact, 0, req);
175 if (error || !req->newptr)
176 return error;
177 *(int *)arg1 = inact / IEEE80211_INACT_WAIT;
178 return 0;
179}
180
181static int
182ieee80211_sysctl_parent(SYSCTL_HANDLER_ARGS)
183{
184 struct ieee80211com *ic = arg1;
185 const char *name = ic->ic_ifp->if_xname;
186
187 return SYSCTL_OUT(req, name, strlen(name));
188}
189
190static int
191ieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS)
192{
193 struct ieee80211com *ic = arg1;
194 int t = 0, error;
195
196 error = sysctl_handle_int(oidp, &t, 0, req);
197 if (error || !req->newptr)
198 return error;
199 IEEE80211_LOCK(ic);
200 ieee80211_dfs_notify_radar(ic, ic->ic_curchan);
201 IEEE80211_UNLOCK(ic);
202 return 0;
203}
204
205void
206ieee80211_sysctl_attach(struct ieee80211com *ic)
207{
208}
209
210void
211ieee80211_sysctl_detach(struct ieee80211com *ic)
212{
213}
214
215void
216ieee80211_sysctl_vattach(struct ieee80211vap *vap)
217{
218 struct ifnet *ifp = vap->iv_ifp;
219 struct sysctl_ctx_list *ctx;
220 struct sysctl_oid *oid;
221 char num[14]; /* sufficient for 32 bits */
222
223 ctx = (struct sysctl_ctx_list *) malloc(sizeof(struct sysctl_ctx_list),
224 M_DEVBUF, M_NOWAIT | M_ZERO);
225 if (ctx == NULL) {
226 if_printf(ifp, "%s: cannot allocate sysctl context!\n",
227 __func__);
228 return;
229 }
230 sysctl_ctx_init(ctx);
231 snprintf(num, sizeof(num), "%u", ifp->if_dunit);
232 oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
233 OID_AUTO, num, CTLFLAG_RD, NULL, "");
234 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
235 "%parent", CTLFLAG_RD, vap->iv_ic, 0,
236 ieee80211_sysctl_parent, "A", "parent device");
237 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
238 "driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
239 "driver capabilities");
240#ifdef IEEE80211_DEBUG
241 vap->iv_debug = ieee80211_debug;
242 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
243 "debug", CTLFLAG_RW, &vap->iv_debug, 0,
244 "control debugging printfs");
245#endif
246 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
247 "bmiss_max", CTLFLAG_RW, &vap->iv_bmiss_max, 0,
248 "consecutive beacon misses before scanning");
249 /* XXX inherit from tunables */
250 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
251 "inact_run", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_run, 0,
252 ieee80211_sysctl_inact, "I",
253 "station inactivity timeout (sec)");
254 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
255 "inact_probe", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_probe, 0,
256 ieee80211_sysctl_inact, "I",
257 "station inactivity probe timeout (sec)");
258 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
259 "inact_auth", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_auth, 0,
260 ieee80211_sysctl_inact, "I",
261 "station authentication timeout (sec)");
262 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
263 "inact_init", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_init, 0,
264 ieee80211_sysctl_inact, "I",
265 "station initial state timeout (sec)");
266 if (vap->iv_htcaps & IEEE80211_HTC_HT) {
267 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
268 "ampdu_mintraffic_bk", CTLFLAG_RW,
269 &vap->iv_ampdu_mintraffic[WME_AC_BK], 0,
270 "BK traffic tx aggr threshold (pps)");
271 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
272 "ampdu_mintraffic_be", CTLFLAG_RW,
273 &vap->iv_ampdu_mintraffic[WME_AC_BE], 0,
274 "BE traffic tx aggr threshold (pps)");
275 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
276 "ampdu_mintraffic_vo", CTLFLAG_RW,
277 &vap->iv_ampdu_mintraffic[WME_AC_VO], 0,
278 "VO traffic tx aggr threshold (pps)");
279 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
280 "ampdu_mintraffic_vi", CTLFLAG_RW,
281 &vap->iv_ampdu_mintraffic[WME_AC_VI], 0,
282 "VI traffic tx aggr threshold (pps)");
283 }
284 if (vap->iv_caps & IEEE80211_C_DFS) {
285 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
286 "radar", CTLTYPE_INT | CTLFLAG_RW, vap->iv_ic, 0,
287 ieee80211_sysctl_radar, "I", "simulate radar event");
288 }
289 vap->iv_sysctl = ctx;
290 vap->iv_oid = oid;
291}
292
293void
294ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
295{
296
297 if (vap->iv_sysctl != NULL) {
298 sysctl_ctx_free(vap->iv_sysctl);
299 free(vap->iv_sysctl, M_DEVBUF);
300 vap->iv_sysctl = NULL;
301 }
302}
303
304int
305ieee80211_node_dectestref(struct ieee80211_node *ni)
306{
307 /* XXX need equivalent of atomic_dec_and_test */
308 atomic_subtract_int(&ni->ni_refcnt, 1);
309 return atomic_cmpset_int(&ni->ni_refcnt, 0, 1);
310}
311
312void
313ieee80211_drain_ifq(struct ifqueue *ifq)
314{
315 struct ieee80211_node *ni;
316 struct mbuf *m;
317
318 for (;;) {
319 IF_DEQUEUE(ifq, m);
320 if (m == NULL)
321 break;
322
323 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
324 KASSERT(ni != NULL, ("frame w/o node"));
325 ieee80211_free_node(ni);
326 m->m_pkthdr.rcvif = NULL;
327
328 m_freem(m);
329 }
330}
331
332void
333ieee80211_flush_ifq(struct ifqueue *ifq, struct ieee80211vap *vap)
334{
335 struct ieee80211_node *ni;
336 struct mbuf *m, **mprev;
337
338 IF_LOCK(ifq);
339 mprev = &ifq->ifq_head;
340 while ((m = *mprev) != NULL) {
341 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
342 if (ni != NULL && ni->ni_vap == vap) {
343 *mprev = m->m_nextpkt; /* remove from list */
344 ifq->ifq_len--;
345
346 m_freem(m);
347 ieee80211_free_node(ni); /* reclaim ref */
348 } else
349 mprev = &m->m_nextpkt;
350 }
351 /* recalculate tail ptr */
352 m = ifq->ifq_head;
353 for (; m != NULL && m->m_nextpkt != NULL; m = m->m_nextpkt)
354 ;
355 ifq->ifq_tail = m;
356 IF_UNLOCK(ifq);
357}
358
359/*
360 * As above, for mbufs allocated with m_gethdr/MGETHDR
361 * or initialized by M_COPY_PKTHDR.
362 */
363#define MC_ALIGN(m, len) \
364do { \
365 (m)->m_data += (MCLBYTES - (len)) &~ (sizeof(long) - 1); \
366} while (/* CONSTCOND */ 0)
367
368/*
369 * Allocate and setup a management frame of the specified
370 * size. We return the mbuf and a pointer to the start
371 * of the contiguous data area that's been reserved based
372 * on the packet length. The data area is forced to 32-bit
373 * alignment and the buffer length to a multiple of 4 bytes.
374 * This is done mainly so beacon frames (that require this)
375 * can use this interface too.
376 */
377struct mbuf *
378ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen)
379{
380 struct mbuf *m;
381 u_int len;
382
383 /*
384 * NB: we know the mbuf routines will align the data area
385 * so we don't need to do anything special.
386 */
387 len = roundup2(headroom + pktlen, 4);
388 KASSERT(len <= MCLBYTES, ("802.11 mgt frame too large: %u", len));
389 if (len < MINCLSIZE) {
390 m = m_gethdr(M_NOWAIT, MT_DATA);
391 /*
392 * Align the data in case additional headers are added.
393 * This should only happen when a WEP header is added
394 * which only happens for shared key authentication mgt
395 * frames which all fit in MHLEN.
396 */
397 if (m != NULL)
398 MH_ALIGN(m, len);
399 } else {
400 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
401 if (m != NULL)
402 MC_ALIGN(m, len);
403 }
404 if (m != NULL) {
405 m->m_data += headroom;
406 *frm = m->m_data;
407 }
408 return m;
409}
410
| 57
58SYSCTL_NODE(_net, OID_AUTO, wlan, CTLFLAG_RD, 0, "IEEE 80211 parameters");
59
60#ifdef IEEE80211_DEBUG
61int ieee80211_debug = 0;
62SYSCTL_INT(_net_wlan, OID_AUTO, debug, CTLFLAG_RW, &ieee80211_debug,
63 0, "debugging printfs");
64#endif
65
66MALLOC_DEFINE(M_80211_COM, "80211com", "802.11 com state");
67
68/*
69 * Allocate/free com structure in conjunction with ifnet;
70 * these routines are registered with if_register_com_alloc
71 * below and are called automatically by the ifnet code
72 * when the ifnet of the parent device is created.
73 */
74static void *
75wlan_alloc(u_char type, struct ifnet *ifp)
76{
77 struct ieee80211com *ic;
78
79 ic = malloc(sizeof(struct ieee80211com), M_80211_COM, M_WAITOK|M_ZERO);
80 ic->ic_ifp = ifp;
81
82 return (ic);
83}
84
85static void
86wlan_free(void *ic, u_char type)
87{
88 free(ic, M_80211_COM);
89}
90
91static int
92wlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
93{
94 struct ieee80211_clone_params cp;
95 struct ieee80211vap *vap;
96 struct ieee80211com *ic;
97 struct ifnet *ifp;
98 int error;
99
100 error = copyin(params, &cp, sizeof(cp));
101 if (error)
102 return error;
103 ifp = ifunit(cp.icp_parent);
104 if (ifp == NULL)
105 return ENXIO;
106 /* XXX move printfs to DIAGNOSTIC before release */
107 if (ifp->if_type != IFT_IEEE80211) {
108 if_printf(ifp, "%s: reject, not an 802.11 device\n", __func__);
109 return ENXIO;
110 }
111 if (cp.icp_opmode >= IEEE80211_OPMODE_MAX) {
112 if_printf(ifp, "%s: invalid opmode %d\n",
113 __func__, cp.icp_opmode);
114 return EINVAL;
115 }
116 ic = ifp->if_l2com;
117 if ((ic->ic_caps & ieee80211_opcap[cp.icp_opmode]) == 0) {
118 if_printf(ifp, "%s mode not supported\n",
119 ieee80211_opmode_name[cp.icp_opmode]);
120 return EOPNOTSUPP;
121 }
122 if ((cp.icp_flags & IEEE80211_CLONE_TDMA) &&
123#ifdef IEEE80211_SUPPORT_TDMA
124 (ic->ic_caps & IEEE80211_C_TDMA) == 0
125#else
126 (1)
127#endif
128 ) {
129 if_printf(ifp, "TDMA not supported\n");
130 return EOPNOTSUPP;
131 }
132 vap = ic->ic_vap_create(ic, ifc->ifc_name, unit,
133 cp.icp_opmode, cp.icp_flags, cp.icp_bssid,
134 cp.icp_flags & IEEE80211_CLONE_MACADDR ?
135 cp.icp_macaddr : (const uint8_t *)IF_LLADDR(ifp));
136 return (vap == NULL ? EIO : 0);
137}
138
139static void
140wlan_clone_destroy(struct ifnet *ifp)
141{
142 struct ieee80211vap *vap = ifp->if_softc;
143 struct ieee80211com *ic = vap->iv_ic;
144
145 ic->ic_vap_delete(vap);
146}
147IFC_SIMPLE_DECLARE(wlan, 0);
148
149void
150ieee80211_vap_destroy(struct ieee80211vap *vap)
151{
152 if_clone_destroyif(&wlan_cloner, vap->iv_ifp);
153}
154
155int
156ieee80211_sysctl_msecs_ticks(SYSCTL_HANDLER_ARGS)
157{
158 int msecs = ticks_to_msecs(*(int *)arg1);
159 int error, t;
160
161 error = sysctl_handle_int(oidp, &msecs, 0, req);
162 if (error || !req->newptr)
163 return error;
164 t = msecs_to_ticks(msecs);
165 *(int *)arg1 = (t < 1) ? 1 : t;
166 return 0;
167}
168
169static int
170ieee80211_sysctl_inact(SYSCTL_HANDLER_ARGS)
171{
172 int inact = (*(int *)arg1) * IEEE80211_INACT_WAIT;
173 int error;
174
175 error = sysctl_handle_int(oidp, &inact, 0, req);
176 if (error || !req->newptr)
177 return error;
178 *(int *)arg1 = inact / IEEE80211_INACT_WAIT;
179 return 0;
180}
181
182static int
183ieee80211_sysctl_parent(SYSCTL_HANDLER_ARGS)
184{
185 struct ieee80211com *ic = arg1;
186 const char *name = ic->ic_ifp->if_xname;
187
188 return SYSCTL_OUT(req, name, strlen(name));
189}
190
191static int
192ieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS)
193{
194 struct ieee80211com *ic = arg1;
195 int t = 0, error;
196
197 error = sysctl_handle_int(oidp, &t, 0, req);
198 if (error || !req->newptr)
199 return error;
200 IEEE80211_LOCK(ic);
201 ieee80211_dfs_notify_radar(ic, ic->ic_curchan);
202 IEEE80211_UNLOCK(ic);
203 return 0;
204}
205
206void
207ieee80211_sysctl_attach(struct ieee80211com *ic)
208{
209}
210
211void
212ieee80211_sysctl_detach(struct ieee80211com *ic)
213{
214}
215
216void
217ieee80211_sysctl_vattach(struct ieee80211vap *vap)
218{
219 struct ifnet *ifp = vap->iv_ifp;
220 struct sysctl_ctx_list *ctx;
221 struct sysctl_oid *oid;
222 char num[14]; /* sufficient for 32 bits */
223
224 ctx = (struct sysctl_ctx_list *) malloc(sizeof(struct sysctl_ctx_list),
225 M_DEVBUF, M_NOWAIT | M_ZERO);
226 if (ctx == NULL) {
227 if_printf(ifp, "%s: cannot allocate sysctl context!\n",
228 __func__);
229 return;
230 }
231 sysctl_ctx_init(ctx);
232 snprintf(num, sizeof(num), "%u", ifp->if_dunit);
233 oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
234 OID_AUTO, num, CTLFLAG_RD, NULL, "");
235 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
236 "%parent", CTLFLAG_RD, vap->iv_ic, 0,
237 ieee80211_sysctl_parent, "A", "parent device");
238 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
239 "driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
240 "driver capabilities");
241#ifdef IEEE80211_DEBUG
242 vap->iv_debug = ieee80211_debug;
243 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
244 "debug", CTLFLAG_RW, &vap->iv_debug, 0,
245 "control debugging printfs");
246#endif
247 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
248 "bmiss_max", CTLFLAG_RW, &vap->iv_bmiss_max, 0,
249 "consecutive beacon misses before scanning");
250 /* XXX inherit from tunables */
251 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
252 "inact_run", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_run, 0,
253 ieee80211_sysctl_inact, "I",
254 "station inactivity timeout (sec)");
255 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
256 "inact_probe", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_probe, 0,
257 ieee80211_sysctl_inact, "I",
258 "station inactivity probe timeout (sec)");
259 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
260 "inact_auth", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_auth, 0,
261 ieee80211_sysctl_inact, "I",
262 "station authentication timeout (sec)");
263 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
264 "inact_init", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_init, 0,
265 ieee80211_sysctl_inact, "I",
266 "station initial state timeout (sec)");
267 if (vap->iv_htcaps & IEEE80211_HTC_HT) {
268 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
269 "ampdu_mintraffic_bk", CTLFLAG_RW,
270 &vap->iv_ampdu_mintraffic[WME_AC_BK], 0,
271 "BK traffic tx aggr threshold (pps)");
272 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
273 "ampdu_mintraffic_be", CTLFLAG_RW,
274 &vap->iv_ampdu_mintraffic[WME_AC_BE], 0,
275 "BE traffic tx aggr threshold (pps)");
276 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
277 "ampdu_mintraffic_vo", CTLFLAG_RW,
278 &vap->iv_ampdu_mintraffic[WME_AC_VO], 0,
279 "VO traffic tx aggr threshold (pps)");
280 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
281 "ampdu_mintraffic_vi", CTLFLAG_RW,
282 &vap->iv_ampdu_mintraffic[WME_AC_VI], 0,
283 "VI traffic tx aggr threshold (pps)");
284 }
285 if (vap->iv_caps & IEEE80211_C_DFS) {
286 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
287 "radar", CTLTYPE_INT | CTLFLAG_RW, vap->iv_ic, 0,
288 ieee80211_sysctl_radar, "I", "simulate radar event");
289 }
290 vap->iv_sysctl = ctx;
291 vap->iv_oid = oid;
292}
293
294void
295ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
296{
297
298 if (vap->iv_sysctl != NULL) {
299 sysctl_ctx_free(vap->iv_sysctl);
300 free(vap->iv_sysctl, M_DEVBUF);
301 vap->iv_sysctl = NULL;
302 }
303}
304
305int
306ieee80211_node_dectestref(struct ieee80211_node *ni)
307{
308 /* XXX need equivalent of atomic_dec_and_test */
309 atomic_subtract_int(&ni->ni_refcnt, 1);
310 return atomic_cmpset_int(&ni->ni_refcnt, 0, 1);
311}
312
313void
314ieee80211_drain_ifq(struct ifqueue *ifq)
315{
316 struct ieee80211_node *ni;
317 struct mbuf *m;
318
319 for (;;) {
320 IF_DEQUEUE(ifq, m);
321 if (m == NULL)
322 break;
323
324 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
325 KASSERT(ni != NULL, ("frame w/o node"));
326 ieee80211_free_node(ni);
327 m->m_pkthdr.rcvif = NULL;
328
329 m_freem(m);
330 }
331}
332
333void
334ieee80211_flush_ifq(struct ifqueue *ifq, struct ieee80211vap *vap)
335{
336 struct ieee80211_node *ni;
337 struct mbuf *m, **mprev;
338
339 IF_LOCK(ifq);
340 mprev = &ifq->ifq_head;
341 while ((m = *mprev) != NULL) {
342 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
343 if (ni != NULL && ni->ni_vap == vap) {
344 *mprev = m->m_nextpkt; /* remove from list */
345 ifq->ifq_len--;
346
347 m_freem(m);
348 ieee80211_free_node(ni); /* reclaim ref */
349 } else
350 mprev = &m->m_nextpkt;
351 }
352 /* recalculate tail ptr */
353 m = ifq->ifq_head;
354 for (; m != NULL && m->m_nextpkt != NULL; m = m->m_nextpkt)
355 ;
356 ifq->ifq_tail = m;
357 IF_UNLOCK(ifq);
358}
359
360/*
361 * As above, for mbufs allocated with m_gethdr/MGETHDR
362 * or initialized by M_COPY_PKTHDR.
363 */
364#define MC_ALIGN(m, len) \
365do { \
366 (m)->m_data += (MCLBYTES - (len)) &~ (sizeof(long) - 1); \
367} while (/* CONSTCOND */ 0)
368
369/*
370 * Allocate and setup a management frame of the specified
371 * size. We return the mbuf and a pointer to the start
372 * of the contiguous data area that's been reserved based
373 * on the packet length. The data area is forced to 32-bit
374 * alignment and the buffer length to a multiple of 4 bytes.
375 * This is done mainly so beacon frames (that require this)
376 * can use this interface too.
377 */
378struct mbuf *
379ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen)
380{
381 struct mbuf *m;
382 u_int len;
383
384 /*
385 * NB: we know the mbuf routines will align the data area
386 * so we don't need to do anything special.
387 */
388 len = roundup2(headroom + pktlen, 4);
389 KASSERT(len <= MCLBYTES, ("802.11 mgt frame too large: %u", len));
390 if (len < MINCLSIZE) {
391 m = m_gethdr(M_NOWAIT, MT_DATA);
392 /*
393 * Align the data in case additional headers are added.
394 * This should only happen when a WEP header is added
395 * which only happens for shared key authentication mgt
396 * frames which all fit in MHLEN.
397 */
398 if (m != NULL)
399 MH_ALIGN(m, len);
400 } else {
401 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
402 if (m != NULL)
403 MC_ALIGN(m, len);
404 }
405 if (m != NULL) {
406 m->m_data += headroom;
407 *frm = m->m_data;
408 }
409 return m;
410}
411
|
| 412/*
413 * Re-align the payload in the mbuf. This is mainly used (right now)
414 * to handle IP header alignment requirements on certain architectures.
415 */
416struct mbuf *
417ieee80211_realign(struct ieee80211vap *vap, struct mbuf *m, size_t align)
418{
419 int pktlen, space;
420 struct mbuf *n;
421
422 pktlen = m->m_pkthdr.len;
423 space = pktlen + align;
424 if (space < MINCLSIZE)
425 n = m_gethdr(M_DONTWAIT, MT_DATA);
426 else {
427 n = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR,
428 space <= MCLBYTES ? MCLBYTES :
429#if MJUMPAGESIZE != MCLBYTES
430 space <= MJUMPAGESIZE ? MJUMPAGESIZE :
431#endif
432 space <= MJUM9BYTES ? MJUM9BYTES : MJUM16BYTES);
433 }
434 if (__predict_true(n != NULL)) {
435 m_move_pkthdr(n, m);
436 n->m_data = (caddr_t)(ALIGN(n->m_data + align) - align);
437 m_copydata(m, 0, pktlen, mtod(n, caddr_t));
438 n->m_len = pktlen;
439 } else {
440 IEEE80211_DISCARD(vap, IEEE80211_MSG_ANY,
441 mtod(m, const struct ieee80211_frame *), NULL,
442 "%s", "no mbuf to realign");
443 vap->iv_stats.is_rx_badalign++;
444 }
445 m_freem(m);
446 return n;
447}
448
|
411int
412ieee80211_add_callback(struct mbuf *m,
413 void (*func)(struct ieee80211_node *, void *, int), void *arg)
414{
415 struct m_tag *mtag;
416 struct ieee80211_cb *cb;
417
418 mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_CALLBACK,
419 sizeof(struct ieee80211_cb), M_NOWAIT);
420 if (mtag == NULL)
421 return 0;
422
423 cb = (struct ieee80211_cb *)(mtag+1);
424 cb->func = func;
425 cb->arg = arg;
426 m_tag_prepend(m, mtag);
427 m->m_flags |= M_TXCB;
428 return 1;
429}
430
431void
432ieee80211_process_callback(struct ieee80211_node *ni,
433 struct mbuf *m, int status)
434{
435 struct m_tag *mtag;
436
437 mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, NULL);
438 if (mtag != NULL) {
439 struct ieee80211_cb *cb = (struct ieee80211_cb *)(mtag+1);
440 cb->func(ni, cb->arg, status);
441 }
442}
443
444#include <sys/libkern.h>
445
446void
447get_random_bytes(void *p, size_t n)
448{
449 uint8_t *dp = p;
450
451 while (n > 0) {
452 uint32_t v = arc4random();
453 size_t nb = n > sizeof(uint32_t) ? sizeof(uint32_t) : n;
454 bcopy(&v, dp, n > sizeof(uint32_t) ? sizeof(uint32_t) : n);
455 dp += sizeof(uint32_t), n -= nb;
456 }
457}
458
459/*
460 * Helper function for events that pass just a single mac address.
461 */
462static void
463notify_macaddr(struct ifnet *ifp, int op, const uint8_t mac[IEEE80211_ADDR_LEN])
464{
465 struct ieee80211_join_event iev;
466
467 CURVNET_SET(ifp->if_vnet);
468 memset(&iev, 0, sizeof(iev));
469 IEEE80211_ADDR_COPY(iev.iev_addr, mac);
470 rt_ieee80211msg(ifp, op, &iev, sizeof(iev));
471 CURVNET_RESTORE();
472}
473
474void
475ieee80211_notify_node_join(struct ieee80211_node *ni, int newassoc)
476{
477 struct ieee80211vap *vap = ni->ni_vap;
478 struct ifnet *ifp = vap->iv_ifp;
479
480 CURVNET_SET_QUIET(ifp->if_vnet);
481 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode join",
482 (ni == vap->iv_bss) ? "bss " : "");
483
484 if (ni == vap->iv_bss) {
485 notify_macaddr(ifp, newassoc ?
486 RTM_IEEE80211_ASSOC : RTM_IEEE80211_REASSOC, ni->ni_bssid);
487 if_link_state_change(ifp, LINK_STATE_UP);
488 } else {
489 notify_macaddr(ifp, newassoc ?
490 RTM_IEEE80211_JOIN : RTM_IEEE80211_REJOIN, ni->ni_macaddr);
491 }
492 CURVNET_RESTORE();
493}
494
495void
496ieee80211_notify_node_leave(struct ieee80211_node *ni)
497{
498 struct ieee80211vap *vap = ni->ni_vap;
499 struct ifnet *ifp = vap->iv_ifp;
500
501 CURVNET_SET_QUIET(ifp->if_vnet);
502 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode leave",
503 (ni == vap->iv_bss) ? "bss " : "");
504
505 if (ni == vap->iv_bss) {
506 rt_ieee80211msg(ifp, RTM_IEEE80211_DISASSOC, NULL, 0);
507 if_link_state_change(ifp, LINK_STATE_DOWN);
508 } else {
509 /* fire off wireless event station leaving */
510 notify_macaddr(ifp, RTM_IEEE80211_LEAVE, ni->ni_macaddr);
511 }
512 CURVNET_RESTORE();
513}
514
515void
516ieee80211_notify_scan_done(struct ieee80211vap *vap)
517{
518 struct ifnet *ifp = vap->iv_ifp;
519
520 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s\n", "notify scan done");
521
522 /* dispatch wireless event indicating scan completed */
523 CURVNET_SET(ifp->if_vnet);
524 rt_ieee80211msg(ifp, RTM_IEEE80211_SCAN, NULL, 0);
525 CURVNET_RESTORE();
526}
527
528void
529ieee80211_notify_replay_failure(struct ieee80211vap *vap,
530 const struct ieee80211_frame *wh, const struct ieee80211_key *k,
531 u_int64_t rsc, int tid)
532{
533 struct ifnet *ifp = vap->iv_ifp;
534
535 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
536 "%s replay detected <rsc %ju, csc %ju, keyix %u rxkeyix %u>",
537 k->wk_cipher->ic_name, (intmax_t) rsc,
538 (intmax_t) k->wk_keyrsc[tid],
539 k->wk_keyix, k->wk_rxkeyix);
540
541 if (ifp != NULL) { /* NB: for cipher test modules */
542 struct ieee80211_replay_event iev;
543
544 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
545 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
546 iev.iev_cipher = k->wk_cipher->ic_cipher;
547 if (k->wk_rxkeyix != IEEE80211_KEYIX_NONE)
548 iev.iev_keyix = k->wk_rxkeyix;
549 else
550 iev.iev_keyix = k->wk_keyix;
551 iev.iev_keyrsc = k->wk_keyrsc[tid];
552 iev.iev_rsc = rsc;
553 CURVNET_SET(ifp->if_vnet);
554 rt_ieee80211msg(ifp, RTM_IEEE80211_REPLAY, &iev, sizeof(iev));
555 CURVNET_RESTORE();
556 }
557}
558
559void
560ieee80211_notify_michael_failure(struct ieee80211vap *vap,
561 const struct ieee80211_frame *wh, u_int keyix)
562{
563 struct ifnet *ifp = vap->iv_ifp;
564
565 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
566 "michael MIC verification failed <keyix %u>", keyix);
567 vap->iv_stats.is_rx_tkipmic++;
568
569 if (ifp != NULL) { /* NB: for cipher test modules */
570 struct ieee80211_michael_event iev;
571
572 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
573 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
574 iev.iev_cipher = IEEE80211_CIPHER_TKIP;
575 iev.iev_keyix = keyix;
576 CURVNET_SET(ifp->if_vnet);
577 rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev));
578 CURVNET_RESTORE();
579 }
580}
581
582void
583ieee80211_notify_wds_discover(struct ieee80211_node *ni)
584{
585 struct ieee80211vap *vap = ni->ni_vap;
586 struct ifnet *ifp = vap->iv_ifp;
587
588 notify_macaddr(ifp, RTM_IEEE80211_WDS, ni->ni_macaddr);
589}
590
591void
592ieee80211_notify_csa(struct ieee80211com *ic,
593 const struct ieee80211_channel *c, int mode, int count)
594{
595 struct ifnet *ifp = ic->ic_ifp;
596 struct ieee80211_csa_event iev;
597
598 memset(&iev, 0, sizeof(iev));
599 iev.iev_flags = c->ic_flags;
600 iev.iev_freq = c->ic_freq;
601 iev.iev_ieee = c->ic_ieee;
602 iev.iev_mode = mode;
603 iev.iev_count = count;
604 rt_ieee80211msg(ifp, RTM_IEEE80211_CSA, &iev, sizeof(iev));
605}
606
607void
608ieee80211_notify_radar(struct ieee80211com *ic,
609 const struct ieee80211_channel *c)
610{
611 struct ifnet *ifp = ic->ic_ifp;
612 struct ieee80211_radar_event iev;
613
614 memset(&iev, 0, sizeof(iev));
615 iev.iev_flags = c->ic_flags;
616 iev.iev_freq = c->ic_freq;
617 iev.iev_ieee = c->ic_ieee;
618 rt_ieee80211msg(ifp, RTM_IEEE80211_RADAR, &iev, sizeof(iev));
619}
620
621void
622ieee80211_notify_cac(struct ieee80211com *ic,
623 const struct ieee80211_channel *c, enum ieee80211_notify_cac_event type)
624{
625 struct ifnet *ifp = ic->ic_ifp;
626 struct ieee80211_cac_event iev;
627
628 memset(&iev, 0, sizeof(iev));
629 iev.iev_flags = c->ic_flags;
630 iev.iev_freq = c->ic_freq;
631 iev.iev_ieee = c->ic_ieee;
632 iev.iev_type = type;
633 rt_ieee80211msg(ifp, RTM_IEEE80211_CAC, &iev, sizeof(iev));
634}
635
636void
637ieee80211_notify_node_deauth(struct ieee80211_node *ni)
638{
639 struct ieee80211vap *vap = ni->ni_vap;
640 struct ifnet *ifp = vap->iv_ifp;
641
642 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node deauth");
643
644 notify_macaddr(ifp, RTM_IEEE80211_DEAUTH, ni->ni_macaddr);
645}
646
647void
648ieee80211_notify_node_auth(struct ieee80211_node *ni)
649{
650 struct ieee80211vap *vap = ni->ni_vap;
651 struct ifnet *ifp = vap->iv_ifp;
652
653 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node auth");
654
655 notify_macaddr(ifp, RTM_IEEE80211_AUTH, ni->ni_macaddr);
656}
657
658void
659ieee80211_notify_country(struct ieee80211vap *vap,
660 const uint8_t bssid[IEEE80211_ADDR_LEN], const uint8_t cc[2])
661{
662 struct ifnet *ifp = vap->iv_ifp;
663 struct ieee80211_country_event iev;
664
665 memset(&iev, 0, sizeof(iev));
666 IEEE80211_ADDR_COPY(iev.iev_addr, bssid);
667 iev.iev_cc[0] = cc[0];
668 iev.iev_cc[1] = cc[1];
669 rt_ieee80211msg(ifp, RTM_IEEE80211_COUNTRY, &iev, sizeof(iev));
670}
671
672void
673ieee80211_notify_radio(struct ieee80211com *ic, int state)
674{
675 struct ifnet *ifp = ic->ic_ifp;
676 struct ieee80211_radio_event iev;
677
678 memset(&iev, 0, sizeof(iev));
679 iev.iev_state = state;
680 rt_ieee80211msg(ifp, RTM_IEEE80211_RADIO, &iev, sizeof(iev));
681}
682
683void
684ieee80211_load_module(const char *modname)
685{
686
687#ifdef notyet
688 (void)kern_kldload(curthread, modname, NULL);
689#else
690 printf("%s: load the %s module by hand for now.\n", __func__, modname);
691#endif
692}
693
694static eventhandler_tag wlan_bpfevent;
695
696static void
697bpf_track(void *arg, struct ifnet *ifp, int dlt, int attach)
698{
699 /* NB: identify vap's by if_start */
700 if (dlt == DLT_IEEE802_11_RADIO && ifp->if_start == ieee80211_start) {
701 struct ieee80211vap *vap = ifp->if_softc;
702 /*
703 * Track bpf radiotap listener state. We mark the vap
704 * to indicate if any listener is present and the com
705 * to indicate if any listener exists on any associated
706 * vap. This flag is used by drivers to prepare radiotap
707 * state only when needed.
708 */
709 if (attach) {
710 ieee80211_syncflag_ext(vap, IEEE80211_FEXT_BPF);
711 if (vap->iv_opmode == IEEE80211_M_MONITOR)
712 atomic_add_int(&vap->iv_ic->ic_montaps, 1);
713 } else if (!bpf_peers_present(vap->iv_rawbpf)) {
714 ieee80211_syncflag_ext(vap, -IEEE80211_FEXT_BPF);
715 if (vap->iv_opmode == IEEE80211_M_MONITOR)
716 atomic_subtract_int(&vap->iv_ic->ic_montaps, 1);
717 }
718 }
719}
720
721/*
722 * Module glue.
723 *
724 * NB: the module name is "wlan" for compatibility with NetBSD.
725 */
726static int
727wlan_modevent(module_t mod, int type, void *unused)
728{
729 switch (type) {
730 case MOD_LOAD:
731 if (bootverbose)
732 printf("wlan: <802.11 Link Layer>\n");
733 wlan_bpfevent = EVENTHANDLER_REGISTER(bpf_track,
734 bpf_track, 0, EVENTHANDLER_PRI_ANY);
735 if (wlan_bpfevent == NULL)
736 return ENOMEM;
737 if_clone_attach(&wlan_cloner);
738 if_register_com_alloc(IFT_IEEE80211, wlan_alloc, wlan_free);
739 return 0;
740 case MOD_UNLOAD:
741 if_deregister_com_alloc(IFT_IEEE80211);
742 if_clone_detach(&wlan_cloner);
743 EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent);
744 return 0;
745 }
746 return EINVAL;
747}
748
749static moduledata_t wlan_mod = {
750 "wlan",
751 wlan_modevent,
752 0
753};
754DECLARE_MODULE(wlan, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
755MODULE_VERSION(wlan, 1);
756MODULE_DEPEND(wlan, ether, 1, 1, 1);
| 449int
450ieee80211_add_callback(struct mbuf *m,
451 void (*func)(struct ieee80211_node *, void *, int), void *arg)
452{
453 struct m_tag *mtag;
454 struct ieee80211_cb *cb;
455
456 mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_CALLBACK,
457 sizeof(struct ieee80211_cb), M_NOWAIT);
458 if (mtag == NULL)
459 return 0;
460
461 cb = (struct ieee80211_cb *)(mtag+1);
462 cb->func = func;
463 cb->arg = arg;
464 m_tag_prepend(m, mtag);
465 m->m_flags |= M_TXCB;
466 return 1;
467}
468
469void
470ieee80211_process_callback(struct ieee80211_node *ni,
471 struct mbuf *m, int status)
472{
473 struct m_tag *mtag;
474
475 mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, NULL);
476 if (mtag != NULL) {
477 struct ieee80211_cb *cb = (struct ieee80211_cb *)(mtag+1);
478 cb->func(ni, cb->arg, status);
479 }
480}
481
482#include <sys/libkern.h>
483
484void
485get_random_bytes(void *p, size_t n)
486{
487 uint8_t *dp = p;
488
489 while (n > 0) {
490 uint32_t v = arc4random();
491 size_t nb = n > sizeof(uint32_t) ? sizeof(uint32_t) : n;
492 bcopy(&v, dp, n > sizeof(uint32_t) ? sizeof(uint32_t) : n);
493 dp += sizeof(uint32_t), n -= nb;
494 }
495}
496
497/*
498 * Helper function for events that pass just a single mac address.
499 */
500static void
501notify_macaddr(struct ifnet *ifp, int op, const uint8_t mac[IEEE80211_ADDR_LEN])
502{
503 struct ieee80211_join_event iev;
504
505 CURVNET_SET(ifp->if_vnet);
506 memset(&iev, 0, sizeof(iev));
507 IEEE80211_ADDR_COPY(iev.iev_addr, mac);
508 rt_ieee80211msg(ifp, op, &iev, sizeof(iev));
509 CURVNET_RESTORE();
510}
511
512void
513ieee80211_notify_node_join(struct ieee80211_node *ni, int newassoc)
514{
515 struct ieee80211vap *vap = ni->ni_vap;
516 struct ifnet *ifp = vap->iv_ifp;
517
518 CURVNET_SET_QUIET(ifp->if_vnet);
519 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode join",
520 (ni == vap->iv_bss) ? "bss " : "");
521
522 if (ni == vap->iv_bss) {
523 notify_macaddr(ifp, newassoc ?
524 RTM_IEEE80211_ASSOC : RTM_IEEE80211_REASSOC, ni->ni_bssid);
525 if_link_state_change(ifp, LINK_STATE_UP);
526 } else {
527 notify_macaddr(ifp, newassoc ?
528 RTM_IEEE80211_JOIN : RTM_IEEE80211_REJOIN, ni->ni_macaddr);
529 }
530 CURVNET_RESTORE();
531}
532
533void
534ieee80211_notify_node_leave(struct ieee80211_node *ni)
535{
536 struct ieee80211vap *vap = ni->ni_vap;
537 struct ifnet *ifp = vap->iv_ifp;
538
539 CURVNET_SET_QUIET(ifp->if_vnet);
540 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode leave",
541 (ni == vap->iv_bss) ? "bss " : "");
542
543 if (ni == vap->iv_bss) {
544 rt_ieee80211msg(ifp, RTM_IEEE80211_DISASSOC, NULL, 0);
545 if_link_state_change(ifp, LINK_STATE_DOWN);
546 } else {
547 /* fire off wireless event station leaving */
548 notify_macaddr(ifp, RTM_IEEE80211_LEAVE, ni->ni_macaddr);
549 }
550 CURVNET_RESTORE();
551}
552
553void
554ieee80211_notify_scan_done(struct ieee80211vap *vap)
555{
556 struct ifnet *ifp = vap->iv_ifp;
557
558 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s\n", "notify scan done");
559
560 /* dispatch wireless event indicating scan completed */
561 CURVNET_SET(ifp->if_vnet);
562 rt_ieee80211msg(ifp, RTM_IEEE80211_SCAN, NULL, 0);
563 CURVNET_RESTORE();
564}
565
566void
567ieee80211_notify_replay_failure(struct ieee80211vap *vap,
568 const struct ieee80211_frame *wh, const struct ieee80211_key *k,
569 u_int64_t rsc, int tid)
570{
571 struct ifnet *ifp = vap->iv_ifp;
572
573 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
574 "%s replay detected <rsc %ju, csc %ju, keyix %u rxkeyix %u>",
575 k->wk_cipher->ic_name, (intmax_t) rsc,
576 (intmax_t) k->wk_keyrsc[tid],
577 k->wk_keyix, k->wk_rxkeyix);
578
579 if (ifp != NULL) { /* NB: for cipher test modules */
580 struct ieee80211_replay_event iev;
581
582 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
583 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
584 iev.iev_cipher = k->wk_cipher->ic_cipher;
585 if (k->wk_rxkeyix != IEEE80211_KEYIX_NONE)
586 iev.iev_keyix = k->wk_rxkeyix;
587 else
588 iev.iev_keyix = k->wk_keyix;
589 iev.iev_keyrsc = k->wk_keyrsc[tid];
590 iev.iev_rsc = rsc;
591 CURVNET_SET(ifp->if_vnet);
592 rt_ieee80211msg(ifp, RTM_IEEE80211_REPLAY, &iev, sizeof(iev));
593 CURVNET_RESTORE();
594 }
595}
596
597void
598ieee80211_notify_michael_failure(struct ieee80211vap *vap,
599 const struct ieee80211_frame *wh, u_int keyix)
600{
601 struct ifnet *ifp = vap->iv_ifp;
602
603 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
604 "michael MIC verification failed <keyix %u>", keyix);
605 vap->iv_stats.is_rx_tkipmic++;
606
607 if (ifp != NULL) { /* NB: for cipher test modules */
608 struct ieee80211_michael_event iev;
609
610 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
611 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
612 iev.iev_cipher = IEEE80211_CIPHER_TKIP;
613 iev.iev_keyix = keyix;
614 CURVNET_SET(ifp->if_vnet);
615 rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev));
616 CURVNET_RESTORE();
617 }
618}
619
620void
621ieee80211_notify_wds_discover(struct ieee80211_node *ni)
622{
623 struct ieee80211vap *vap = ni->ni_vap;
624 struct ifnet *ifp = vap->iv_ifp;
625
626 notify_macaddr(ifp, RTM_IEEE80211_WDS, ni->ni_macaddr);
627}
628
629void
630ieee80211_notify_csa(struct ieee80211com *ic,
631 const struct ieee80211_channel *c, int mode, int count)
632{
633 struct ifnet *ifp = ic->ic_ifp;
634 struct ieee80211_csa_event iev;
635
636 memset(&iev, 0, sizeof(iev));
637 iev.iev_flags = c->ic_flags;
638 iev.iev_freq = c->ic_freq;
639 iev.iev_ieee = c->ic_ieee;
640 iev.iev_mode = mode;
641 iev.iev_count = count;
642 rt_ieee80211msg(ifp, RTM_IEEE80211_CSA, &iev, sizeof(iev));
643}
644
645void
646ieee80211_notify_radar(struct ieee80211com *ic,
647 const struct ieee80211_channel *c)
648{
649 struct ifnet *ifp = ic->ic_ifp;
650 struct ieee80211_radar_event iev;
651
652 memset(&iev, 0, sizeof(iev));
653 iev.iev_flags = c->ic_flags;
654 iev.iev_freq = c->ic_freq;
655 iev.iev_ieee = c->ic_ieee;
656 rt_ieee80211msg(ifp, RTM_IEEE80211_RADAR, &iev, sizeof(iev));
657}
658
659void
660ieee80211_notify_cac(struct ieee80211com *ic,
661 const struct ieee80211_channel *c, enum ieee80211_notify_cac_event type)
662{
663 struct ifnet *ifp = ic->ic_ifp;
664 struct ieee80211_cac_event iev;
665
666 memset(&iev, 0, sizeof(iev));
667 iev.iev_flags = c->ic_flags;
668 iev.iev_freq = c->ic_freq;
669 iev.iev_ieee = c->ic_ieee;
670 iev.iev_type = type;
671 rt_ieee80211msg(ifp, RTM_IEEE80211_CAC, &iev, sizeof(iev));
672}
673
674void
675ieee80211_notify_node_deauth(struct ieee80211_node *ni)
676{
677 struct ieee80211vap *vap = ni->ni_vap;
678 struct ifnet *ifp = vap->iv_ifp;
679
680 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node deauth");
681
682 notify_macaddr(ifp, RTM_IEEE80211_DEAUTH, ni->ni_macaddr);
683}
684
685void
686ieee80211_notify_node_auth(struct ieee80211_node *ni)
687{
688 struct ieee80211vap *vap = ni->ni_vap;
689 struct ifnet *ifp = vap->iv_ifp;
690
691 IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node auth");
692
693 notify_macaddr(ifp, RTM_IEEE80211_AUTH, ni->ni_macaddr);
694}
695
696void
697ieee80211_notify_country(struct ieee80211vap *vap,
698 const uint8_t bssid[IEEE80211_ADDR_LEN], const uint8_t cc[2])
699{
700 struct ifnet *ifp = vap->iv_ifp;
701 struct ieee80211_country_event iev;
702
703 memset(&iev, 0, sizeof(iev));
704 IEEE80211_ADDR_COPY(iev.iev_addr, bssid);
705 iev.iev_cc[0] = cc[0];
706 iev.iev_cc[1] = cc[1];
707 rt_ieee80211msg(ifp, RTM_IEEE80211_COUNTRY, &iev, sizeof(iev));
708}
709
710void
711ieee80211_notify_radio(struct ieee80211com *ic, int state)
712{
713 struct ifnet *ifp = ic->ic_ifp;
714 struct ieee80211_radio_event iev;
715
716 memset(&iev, 0, sizeof(iev));
717 iev.iev_state = state;
718 rt_ieee80211msg(ifp, RTM_IEEE80211_RADIO, &iev, sizeof(iev));
719}
720
721void
722ieee80211_load_module(const char *modname)
723{
724
725#ifdef notyet
726 (void)kern_kldload(curthread, modname, NULL);
727#else
728 printf("%s: load the %s module by hand for now.\n", __func__, modname);
729#endif
730}
731
732static eventhandler_tag wlan_bpfevent;
733
734static void
735bpf_track(void *arg, struct ifnet *ifp, int dlt, int attach)
736{
737 /* NB: identify vap's by if_start */
738 if (dlt == DLT_IEEE802_11_RADIO && ifp->if_start == ieee80211_start) {
739 struct ieee80211vap *vap = ifp->if_softc;
740 /*
741 * Track bpf radiotap listener state. We mark the vap
742 * to indicate if any listener is present and the com
743 * to indicate if any listener exists on any associated
744 * vap. This flag is used by drivers to prepare radiotap
745 * state only when needed.
746 */
747 if (attach) {
748 ieee80211_syncflag_ext(vap, IEEE80211_FEXT_BPF);
749 if (vap->iv_opmode == IEEE80211_M_MONITOR)
750 atomic_add_int(&vap->iv_ic->ic_montaps, 1);
751 } else if (!bpf_peers_present(vap->iv_rawbpf)) {
752 ieee80211_syncflag_ext(vap, -IEEE80211_FEXT_BPF);
753 if (vap->iv_opmode == IEEE80211_M_MONITOR)
754 atomic_subtract_int(&vap->iv_ic->ic_montaps, 1);
755 }
756 }
757}
758
759/*
760 * Module glue.
761 *
762 * NB: the module name is "wlan" for compatibility with NetBSD.
763 */
764static int
765wlan_modevent(module_t mod, int type, void *unused)
766{
767 switch (type) {
768 case MOD_LOAD:
769 if (bootverbose)
770 printf("wlan: <802.11 Link Layer>\n");
771 wlan_bpfevent = EVENTHANDLER_REGISTER(bpf_track,
772 bpf_track, 0, EVENTHANDLER_PRI_ANY);
773 if (wlan_bpfevent == NULL)
774 return ENOMEM;
775 if_clone_attach(&wlan_cloner);
776 if_register_com_alloc(IFT_IEEE80211, wlan_alloc, wlan_free);
777 return 0;
778 case MOD_UNLOAD:
779 if_deregister_com_alloc(IFT_IEEE80211);
780 if_clone_detach(&wlan_cloner);
781 EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent);
782 return 0;
783 }
784 return EINVAL;
785}
786
787static moduledata_t wlan_mod = {
788 "wlan",
789 wlan_modevent,
790 0
791};
792DECLARE_MODULE(wlan, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
793MODULE_VERSION(wlan, 1);
794MODULE_DEPEND(wlan, ether, 1, 1, 1);
|