1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009 Sam Leffler, Errno Consulting
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30
31 /*
32 * IEEE 802.11 radiotap support.
33 */
34 #include "opt_wlan.h"
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/mbuf.h>
39 #include <sys/malloc.h>
40 #include <sys/endian.h>
41 #include <sys/kernel.h>
42
43 #include <sys/socket.h>
44
45 #include <net/bpf.h>
46 #include <net/if.h>
47 #include <net/if_var.h>
48 #include <net/if_media.h>
49 #include <net/ethernet.h>
50
51 #include <net80211/ieee80211_var.h>
52
53 static int radiotap_offset(struct ieee80211_radiotap_header *, int, int);
54
55 void
56 ieee80211_radiotap_attach(struct ieee80211com *ic,
57 struct ieee80211_radiotap_header *th, int tlen, uint32_t tx_radiotap,
58 struct ieee80211_radiotap_header *rh, int rlen, uint32_t rx_radiotap)
59 {
60 ieee80211_radiotap_attachv(ic, th, tlen, 0, tx_radiotap,
61 rh, rlen, 0, rx_radiotap);
62 }
63
64 void
65 ieee80211_radiotap_attachv(struct ieee80211com *ic,
66 struct ieee80211_radiotap_header *th,
67 int tlen, int n_tx_v, uint32_t tx_radiotap,
68 struct ieee80211_radiotap_header *rh,
69 int rlen, int n_rx_v, uint32_t rx_radiotap)
70 {
71 #define B(_v) (1<<(_v))
72 int off;
73
74 th->it_len = htole16(roundup2(tlen, sizeof(uint32_t)));
75 th->it_present = htole32(tx_radiotap);
76 ic->ic_th = th;
77 /* calculate offset to channel data */
78 off = -1;
79 if (tx_radiotap & B(IEEE80211_RADIOTAP_CHANNEL))
80 off = radiotap_offset(th, n_tx_v, IEEE80211_RADIOTAP_CHANNEL);
81 else if (tx_radiotap & B(IEEE80211_RADIOTAP_XCHANNEL))
82 off = radiotap_offset(th, n_tx_v, IEEE80211_RADIOTAP_XCHANNEL);
83 if (off == -1) {
84 ic_printf(ic, "%s: no tx channel, radiotap 0x%x\n", __func__,
85 tx_radiotap);
86 /* NB: we handle this case but data will have no chan spec */
87 } else
88 ic->ic_txchan = ((uint8_t *) th) + off;
89
90 rh->it_len = htole16(roundup2(rlen, sizeof(uint32_t)));
91 rh->it_present = htole32(rx_radiotap);
92 ic->ic_rh = rh;
93 /* calculate offset to channel data */
94 off = -1;
95 if (rx_radiotap & B(IEEE80211_RADIOTAP_CHANNEL))
96 off = radiotap_offset(rh, n_rx_v, IEEE80211_RADIOTAP_CHANNEL);
97 else if (rx_radiotap & B(IEEE80211_RADIOTAP_XCHANNEL))
98 off = radiotap_offset(rh, n_rx_v, IEEE80211_RADIOTAP_XCHANNEL);
99 if (off == -1) {
100 ic_printf(ic, "%s: no rx channel, radiotap 0x%x\n", __func__,
101 rx_radiotap);
102 /* NB: we handle this case but data will have no chan spec */
103 } else
104 ic->ic_rxchan = ((uint8_t *) rh) + off;
105 #undef B
106 }
107
108 void
109 ieee80211_radiotap_detach(struct ieee80211com *ic)
110 {
111 }
112
113 void
114 ieee80211_radiotap_vattach(struct ieee80211vap *vap)
115 {
116 struct ieee80211com *ic = vap->iv_ic;
117 struct ieee80211_radiotap_header *th = ic->ic_th;
118
119 if (th != NULL && ic->ic_rh != NULL) {
120 /* radiotap DLT for raw 802.11 frames */
121 bpfattach2(vap->iv_ifp, DLT_IEEE802_11_RADIO,
122 sizeof(struct ieee80211_frame) + le16toh(th->it_len),
123 &vap->iv_rawbpf);
124 }
125 }
126
127 void
128 ieee80211_radiotap_vdetach(struct ieee80211vap *vap)
129 {
130 /* NB: bpfattach is called by ether_ifdetach and claims all taps */
131 }
132
133 static void
134 set_channel(void *p, const struct ieee80211_channel *c)
135 {
136 struct {
137 uint16_t freq;
138 uint16_t flags;
139 } *rc = p;
140
141 rc->freq = htole16(c->ic_freq);
142 rc->flags = htole16(c->ic_flags);
143 }
144
145 static void
146 set_xchannel(void *p, const struct ieee80211_channel *c)
147 {
148 struct {
149 uint32_t flags;
150 uint16_t freq;
151 uint8_t ieee;
152 uint8_t maxpow;
153 } *rc = p;
154
155 rc->flags = htole32(c->ic_flags);
156 rc->freq = htole16(c->ic_freq);
157 rc->ieee = c->ic_ieee;
158 rc->maxpow = c->ic_maxregpower;
159 }
160
161 /*
162 * Update radiotap state on channel change.
163 */
164 void
165 ieee80211_radiotap_chan_change(struct ieee80211com *ic)
166 {
167 if (ic->ic_rxchan != NULL) {
168 struct ieee80211_radiotap_header *rh = ic->ic_rh;
169
170 if (rh->it_present & htole32(1<<IEEE80211_RADIOTAP_XCHANNEL))
171 set_xchannel(ic->ic_rxchan, ic->ic_curchan);
172 else if (rh->it_present & htole32(1<<IEEE80211_RADIOTAP_CHANNEL))
173 set_channel(ic->ic_rxchan, ic->ic_curchan);
174 }
175 if (ic->ic_txchan != NULL) {
176 struct ieee80211_radiotap_header *th = ic->ic_th;
177
178 if (th->it_present & htole32(1<<IEEE80211_RADIOTAP_XCHANNEL))
179 set_xchannel(ic->ic_txchan, ic->ic_curchan);
180 else if (th->it_present & htole32(1<<IEEE80211_RADIOTAP_CHANNEL))
181 set_channel(ic->ic_txchan, ic->ic_curchan);
182 }
183 }
184
185 /*
186 * Distribute radiotap data (+packet) to all monitor mode
187 * vaps with an active tap other than vap0.
188 */
189 static void
190 spam_vaps(struct ieee80211vap *vap0, struct mbuf *m,
191 struct ieee80211_radiotap_header *rh, int len)
192 {
193 struct ieee80211com *ic = vap0->iv_ic;
194 struct ieee80211vap *vap;
195
196 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
197 if (vap != vap0 &&
198 vap->iv_opmode == IEEE80211_M_MONITOR &&
199 (vap->iv_flags_ext & IEEE80211_FEXT_BPF) &&
200 vap->iv_state != IEEE80211_S_INIT)
201 bpf_mtap2(vap->iv_rawbpf, rh, len, m);
202 }
203 }
204
205 /*
206 * Dispatch radiotap data for transmitted packet.
207 */
208 void
209 ieee80211_radiotap_tx(struct ieee80211vap *vap0, struct mbuf *m)
210 {
211 struct ieee80211com *ic = vap0->iv_ic;
212 struct ieee80211_radiotap_header *th = ic->ic_th;
213 int len;
214
215 KASSERT(th != NULL, ("no tx radiotap header"));
216 len = le16toh(th->it_len);
217
218 if (vap0->iv_flags_ext & IEEE80211_FEXT_BPF)
219 bpf_mtap2(vap0->iv_rawbpf, th, len, m);
220 /*
221 * Spam monitor mode vaps.
222 */
223 if (ic->ic_montaps != 0)
224 spam_vaps(vap0, m, th, len);
225 }
226
227 /*
228 * Dispatch radiotap data for received packet.
229 */
230 void
231 ieee80211_radiotap_rx(struct ieee80211vap *vap0, struct mbuf *m)
232 {
233 struct ieee80211com *ic = vap0->iv_ic;
234 struct ieee80211_radiotap_header *rh = ic->ic_rh;
235 int len;
236
237 KASSERT(rh != NULL, ("no rx radiotap header"));
238 len = le16toh(rh->it_len);
239
240 if (vap0->iv_flags_ext & IEEE80211_FEXT_BPF)
241 bpf_mtap2(vap0->iv_rawbpf, rh, len, m);
242 /*
243 * Spam monitor mode vaps with unicast frames. Multicast
244 * frames are handled by passing through ieee80211_input_all
245 * which distributes copies to the monitor mode vaps.
246 */
247 if (ic->ic_montaps != 0 && (m->m_flags & M_BCAST) == 0)
248 spam_vaps(vap0, m, rh, len);
249 }
250
251 /*
252 * Dispatch radiotap data for a packet received outside the normal
253 * rx processing path; this is used, for example, to handle frames
254 * received with errors that would otherwise be dropped.
255 */
256 void
257 ieee80211_radiotap_rx_all(struct ieee80211com *ic, struct mbuf *m)
258 {
259 struct ieee80211_radiotap_header *rh = ic->ic_rh;
260 int len = le16toh(rh->it_len);
261 struct ieee80211vap *vap;
262
263 /* XXX locking? */
264 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
265 if (ieee80211_radiotap_active_vap(vap) &&
266 vap->iv_state != IEEE80211_S_INIT)
267 bpf_mtap2(vap->iv_rawbpf, rh, len, m);
268 }
269 }
270
271 /*
272 * Return the offset of the specified item in the radiotap
273 * header description. If the item is not present or is not
274 * known -1 is returned.
275 */
276 static int
277 radiotap_offset(struct ieee80211_radiotap_header *rh,
278 int n_vendor_attributes, int item)
279 {
280 static const struct {
281 size_t align, width;
282 } items[] = {
283 [IEEE80211_RADIOTAP_TSFT] = {
284 .align = sizeof(uint64_t),
285 .width = sizeof(uint64_t),
286 },
287 [IEEE80211_RADIOTAP_FLAGS] = {
288 .align = sizeof(uint8_t),
289 .width = sizeof(uint8_t),
290 },
291 [IEEE80211_RADIOTAP_RATE] = {
292 .align = sizeof(uint8_t),
293 .width = sizeof(uint8_t),
294 },
295 [IEEE80211_RADIOTAP_CHANNEL] = {
296 .align = sizeof(uint16_t),
297 .width = 2*sizeof(uint16_t),
298 },
299 [IEEE80211_RADIOTAP_FHSS] = {
300 .align = sizeof(uint16_t),
301 .width = sizeof(uint16_t),
302 },
303 [IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = {
304 .align = sizeof(uint8_t),
305 .width = sizeof(uint8_t),
306 },
307 [IEEE80211_RADIOTAP_DBM_ANTNOISE] = {
308 .align = sizeof(uint8_t),
309 .width = sizeof(uint8_t),
310 },
311 [IEEE80211_RADIOTAP_LOCK_QUALITY] = {
312 .align = sizeof(uint16_t),
313 .width = sizeof(uint16_t),
314 },
315 [IEEE80211_RADIOTAP_TX_ATTENUATION] = {
316 .align = sizeof(uint16_t),
317 .width = sizeof(uint16_t),
318 },
319 [IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = {
320 .align = sizeof(uint16_t),
321 .width = sizeof(uint16_t),
322 },
323 [IEEE80211_RADIOTAP_DBM_TX_POWER] = {
324 .align = sizeof(uint8_t),
325 .width = sizeof(uint8_t),
326 },
327 [IEEE80211_RADIOTAP_ANTENNA] = {
328 .align = sizeof(uint8_t),
329 .width = sizeof(uint8_t),
330 },
331 [IEEE80211_RADIOTAP_DB_ANTSIGNAL] = {
332 .align = sizeof(uint8_t),
333 .width = sizeof(uint8_t),
334 },
335 [IEEE80211_RADIOTAP_DB_ANTNOISE] = {
336 .align = sizeof(uint8_t),
337 .width = sizeof(uint8_t),
338 },
339 [IEEE80211_RADIOTAP_XCHANNEL] = {
340 .align = sizeof(uint32_t),
341 .width = 2*sizeof(uint32_t),
342 },
343 [IEEE80211_RADIOTAP_MCS] = {
344 .align = sizeof(uint8_t),
345 .width = 3*sizeof(uint8_t),
346 },
347 };
348 uint32_t present = le32toh(rh->it_present);
349 int off, i;
350
351 off = sizeof(struct ieee80211_radiotap_header);
352 off += n_vendor_attributes * (sizeof(uint32_t));
353
354 for (i = 0; i < IEEE80211_RADIOTAP_EXT; i++) {
355 if ((present & (1<<i)) == 0)
356 continue;
357 if (items[i].align == 0) {
358 /* NB: unidentified element, don't guess */
359 printf("%s: unknown item %d\n", __func__, i);
360 return -1;
361 }
362 off = roundup2(off, items[i].align);
363 if (i == item) {
364 if (off + items[i].width > le16toh(rh->it_len)) {
365 /* NB: item does not fit in header data */
366 printf("%s: item %d not in header data, "
367 "off %d width %zu len %d\n", __func__, i,
368 off, items[i].width, le16toh(rh->it_len));
369 return -1;
370 }
371 return off;
372 }
373 off += items[i].width;
374 }
375 return -1;
376 }
Cache object: 77e8dea47191c17bf2a4101c78cab7bc
|