]> The Tcpdump Group git mirrors - tcpdump/blob - print-802_11.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Handle very large -f files by rejecting them.
[tcpdump] / print-802_11.c
1 /*
2 * Copyright (c) 2001
3 * Fortress Technologies, Inc. All rights reserved.
4 * Charlie Lenahan (clenahan@fortresstech.com)
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that: (1) source code distributions
8 * retain the above copyright notice and this paragraph in its entirety, (2)
9 * distributions including binary code include the above copyright notice and
10 * this paragraph in its entirety in the documentation or other materials
11 * provided with the distribution, and (3) all advertising materials mentioning
12 * features or use of this software display the following acknowledgement:
13 * ``This product includes software developed by the University of California,
14 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
15 * the University nor the names of its contributors may be used to endorse
16 * or promote products derived from this software without specific prior
17 * written permission.
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 */
22
23 /* \summary: IEEE 802.11 printer */
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <netdissect-stdinc.h>
30
31 #include <string.h>
32
33 #include "netdissect.h"
34 #include "addrtoname.h"
35
36 #include "extract.h"
37
38 #include "cpack.h"
39
40
41 /* Lengths of 802.11 header components. */
42 #define IEEE802_11_FC_LEN 2
43 #define IEEE802_11_DUR_LEN 2
44 #define IEEE802_11_DA_LEN 6
45 #define IEEE802_11_SA_LEN 6
46 #define IEEE802_11_BSSID_LEN 6
47 #define IEEE802_11_RA_LEN 6
48 #define IEEE802_11_TA_LEN 6
49 #define IEEE802_11_ADDR1_LEN 6
50 #define IEEE802_11_SEQ_LEN 2
51 #define IEEE802_11_CTL_LEN 2
52 #define IEEE802_11_CARRIED_FC_LEN 2
53 #define IEEE802_11_HT_CONTROL_LEN 4
54 #define IEEE802_11_IV_LEN 3
55 #define IEEE802_11_KID_LEN 1
56
57 /* Frame check sequence length. */
58 #define IEEE802_11_FCS_LEN 4
59
60 /* Lengths of beacon components. */
61 #define IEEE802_11_TSTAMP_LEN 8
62 #define IEEE802_11_BCNINT_LEN 2
63 #define IEEE802_11_CAPINFO_LEN 2
64 #define IEEE802_11_LISTENINT_LEN 2
65
66 #define IEEE802_11_AID_LEN 2
67 #define IEEE802_11_STATUS_LEN 2
68 #define IEEE802_11_REASON_LEN 2
69
70 /* Length of previous AP in reassocation frame */
71 #define IEEE802_11_AP_LEN 6
72
73 #define T_MGMT 0x0 /* management */
74 #define T_CTRL 0x1 /* control */
75 #define T_DATA 0x2 /* data */
76 #define T_RESV 0x3 /* reserved */
77
78 #define ST_ASSOC_REQUEST 0x0
79 #define ST_ASSOC_RESPONSE 0x1
80 #define ST_REASSOC_REQUEST 0x2
81 #define ST_REASSOC_RESPONSE 0x3
82 #define ST_PROBE_REQUEST 0x4
83 #define ST_PROBE_RESPONSE 0x5
84 /* RESERVED 0x6 */
85 /* RESERVED 0x7 */
86 #define ST_BEACON 0x8
87 #define ST_ATIM 0x9
88 #define ST_DISASSOC 0xA
89 #define ST_AUTH 0xB
90 #define ST_DEAUTH 0xC
91 #define ST_ACTION 0xD
92 /* RESERVED 0xE */
93 /* RESERVED 0xF */
94
95 static const struct tok st_str[] = {
96 { ST_ASSOC_REQUEST, "Assoc Request" },
97 { ST_ASSOC_RESPONSE, "Assoc Response" },
98 { ST_REASSOC_REQUEST, "ReAssoc Request" },
99 { ST_REASSOC_RESPONSE, "ReAssoc Response" },
100 { ST_PROBE_REQUEST, "Probe Request" },
101 { ST_PROBE_RESPONSE, "Probe Response" },
102 { ST_BEACON, "Beacon" },
103 { ST_ATIM, "ATIM" },
104 { ST_DISASSOC, "Disassociation" },
105 { ST_AUTH, "Authentication" },
106 { ST_DEAUTH, "DeAuthentication" },
107 { ST_ACTION, "Action" },
108 { 0, NULL }
109 };
110
111 #define CTRL_CONTROL_WRAPPER 0x7
112 #define CTRL_BAR 0x8
113 #define CTRL_BA 0x9
114 #define CTRL_PS_POLL 0xA
115 #define CTRL_RTS 0xB
116 #define CTRL_CTS 0xC
117 #define CTRL_ACK 0xD
118 #define CTRL_CF_END 0xE
119 #define CTRL_END_ACK 0xF
120
121 static const struct tok ctrl_str[] = {
122 { CTRL_CONTROL_WRAPPER, "Control Wrapper" },
123 { CTRL_BAR, "BAR" },
124 { CTRL_BA, "BA" },
125 { CTRL_PS_POLL, "Power Save-Poll" },
126 { CTRL_RTS, "Request-To-Send" },
127 { CTRL_CTS, "Clear-To-Send" },
128 { CTRL_ACK, "Acknowledgment" },
129 { CTRL_CF_END, "CF-End" },
130 { CTRL_END_ACK, "CF-End+CF-Ack" },
131 { 0, NULL }
132 };
133
134 #define DATA_DATA 0x0
135 #define DATA_DATA_CF_ACK 0x1
136 #define DATA_DATA_CF_POLL 0x2
137 #define DATA_DATA_CF_ACK_POLL 0x3
138 #define DATA_NODATA 0x4
139 #define DATA_NODATA_CF_ACK 0x5
140 #define DATA_NODATA_CF_POLL 0x6
141 #define DATA_NODATA_CF_ACK_POLL 0x7
142
143 #define DATA_QOS_DATA 0x8
144 #define DATA_QOS_DATA_CF_ACK 0x9
145 #define DATA_QOS_DATA_CF_POLL 0xA
146 #define DATA_QOS_DATA_CF_ACK_POLL 0xB
147 #define DATA_QOS_NODATA 0xC
148 #define DATA_QOS_CF_POLL_NODATA 0xE
149 #define DATA_QOS_CF_ACK_POLL_NODATA 0xF
150
151 /*
152 * The subtype field of a data frame is, in effect, composed of 4 flag
153 * bits - CF-Ack, CF-Poll, Null (means the frame doesn't actually have
154 * any data), and QoS.
155 */
156 #define DATA_FRAME_IS_CF_ACK(x) ((x) & 0x01)
157 #define DATA_FRAME_IS_CF_POLL(x) ((x) & 0x02)
158 #define DATA_FRAME_IS_NULL(x) ((x) & 0x04)
159 #define DATA_FRAME_IS_QOS(x) ((x) & 0x08)
160
161 /*
162 * Bits in the frame control field.
163 */
164 #define FC_VERSION(fc) ((fc) & 0x3)
165 #define FC_TYPE(fc) (((fc) >> 2) & 0x3)
166 #define FC_SUBTYPE(fc) (((fc) >> 4) & 0xF)
167 #define FC_TO_DS(fc) ((fc) & 0x0100)
168 #define FC_FROM_DS(fc) ((fc) & 0x0200)
169 #define FC_MORE_FLAG(fc) ((fc) & 0x0400)
170 #define FC_RETRY(fc) ((fc) & 0x0800)
171 #define FC_POWER_MGMT(fc) ((fc) & 0x1000)
172 #define FC_MORE_DATA(fc) ((fc) & 0x2000)
173 #define FC_PROTECTED(fc) ((fc) & 0x4000)
174 #define FC_ORDER(fc) ((fc) & 0x8000)
175
176 struct mgmt_header_t {
177 uint16_t fc;
178 uint16_t duration;
179 uint8_t da[IEEE802_11_DA_LEN];
180 uint8_t sa[IEEE802_11_SA_LEN];
181 uint8_t bssid[IEEE802_11_BSSID_LEN];
182 uint16_t seq_ctrl;
183 };
184
185 #define MGMT_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
186 IEEE802_11_DA_LEN+IEEE802_11_SA_LEN+\
187 IEEE802_11_BSSID_LEN+IEEE802_11_SEQ_LEN)
188
189 #define CAPABILITY_ESS(cap) ((cap) & 0x0001)
190 #define CAPABILITY_IBSS(cap) ((cap) & 0x0002)
191 #define CAPABILITY_CFP(cap) ((cap) & 0x0004)
192 #define CAPABILITY_CFP_REQ(cap) ((cap) & 0x0008)
193 #define CAPABILITY_PRIVACY(cap) ((cap) & 0x0010)
194
195 struct ssid_t {
196 uint8_t element_id;
197 uint8_t length;
198 u_char ssid[33]; /* 32 + 1 for null */
199 };
200
201 struct rates_t {
202 uint8_t element_id;
203 uint8_t length;
204 uint8_t rate[16];
205 };
206
207 struct challenge_t {
208 uint8_t element_id;
209 uint8_t length;
210 uint8_t text[254]; /* 1-253 + 1 for null */
211 };
212
213 struct fh_t {
214 uint8_t element_id;
215 uint8_t length;
216 uint16_t dwell_time;
217 uint8_t hop_set;
218 uint8_t hop_pattern;
219 uint8_t hop_index;
220 };
221
222 struct ds_t {
223 uint8_t element_id;
224 uint8_t length;
225 uint8_t channel;
226 };
227
228 struct cf_t {
229 uint8_t element_id;
230 uint8_t length;
231 uint8_t count;
232 uint8_t period;
233 uint16_t max_duration;
234 uint16_t dur_remaing;
235 };
236
237 struct tim_t {
238 uint8_t element_id;
239 uint8_t length;
240 uint8_t count;
241 uint8_t period;
242 uint8_t bitmap_control;
243 uint8_t bitmap[251];
244 };
245
246 #define E_SSID 0
247 #define E_RATES 1
248 #define E_FH 2
249 #define E_DS 3
250 #define E_CF 4
251 #define E_TIM 5
252 #define E_IBSS 6
253 /* reserved 7 */
254 /* reserved 8 */
255 /* reserved 9 */
256 /* reserved 10 */
257 /* reserved 11 */
258 /* reserved 12 */
259 /* reserved 13 */
260 /* reserved 14 */
261 /* reserved 15 */
262 /* reserved 16 */
263
264 #define E_CHALLENGE 16
265 /* reserved 17 */
266 /* reserved 18 */
267 /* reserved 19 */
268 /* reserved 16 */
269 /* reserved 16 */
270
271
272 struct mgmt_body_t {
273 uint8_t timestamp[IEEE802_11_TSTAMP_LEN];
274 uint16_t beacon_interval;
275 uint16_t listen_interval;
276 uint16_t status_code;
277 uint16_t aid;
278 u_char ap[IEEE802_11_AP_LEN];
279 uint16_t reason_code;
280 uint16_t auth_alg;
281 uint16_t auth_trans_seq_num;
282 int challenge_present;
283 struct challenge_t challenge;
284 uint16_t capability_info;
285 int ssid_present;
286 struct ssid_t ssid;
287 int rates_present;
288 struct rates_t rates;
289 int ds_present;
290 struct ds_t ds;
291 int cf_present;
292 struct cf_t cf;
293 int fh_present;
294 struct fh_t fh;
295 int tim_present;
296 struct tim_t tim;
297 };
298
299 struct ctrl_control_wrapper_hdr_t {
300 uint16_t fc;
301 uint16_t duration;
302 uint8_t addr1[IEEE802_11_ADDR1_LEN];
303 uint16_t carried_fc[IEEE802_11_CARRIED_FC_LEN];
304 uint16_t ht_control[IEEE802_11_HT_CONTROL_LEN];
305 };
306
307 #define CTRL_CONTROL_WRAPPER_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
308 IEEE802_11_ADDR1_LEN+\
309 IEEE802_11_CARRIED_FC_LEN+\
310 IEEE802_11_HT_CONTROL_LEN)
311
312 struct ctrl_rts_hdr_t {
313 uint16_t fc;
314 uint16_t duration;
315 uint8_t ra[IEEE802_11_RA_LEN];
316 uint8_t ta[IEEE802_11_TA_LEN];
317 };
318
319 #define CTRL_RTS_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
320 IEEE802_11_RA_LEN+IEEE802_11_TA_LEN)
321
322 struct ctrl_cts_hdr_t {
323 uint16_t fc;
324 uint16_t duration;
325 uint8_t ra[IEEE802_11_RA_LEN];
326 };
327
328 #define CTRL_CTS_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+IEEE802_11_RA_LEN)
329
330 struct ctrl_ack_hdr_t {
331 uint16_t fc;
332 uint16_t duration;
333 uint8_t ra[IEEE802_11_RA_LEN];
334 };
335
336 #define CTRL_ACK_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+IEEE802_11_RA_LEN)
337
338 struct ctrl_ps_poll_hdr_t {
339 uint16_t fc;
340 uint16_t aid;
341 uint8_t bssid[IEEE802_11_BSSID_LEN];
342 uint8_t ta[IEEE802_11_TA_LEN];
343 };
344
345 #define CTRL_PS_POLL_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_AID_LEN+\
346 IEEE802_11_BSSID_LEN+IEEE802_11_TA_LEN)
347
348 struct ctrl_end_hdr_t {
349 uint16_t fc;
350 uint16_t duration;
351 uint8_t ra[IEEE802_11_RA_LEN];
352 uint8_t bssid[IEEE802_11_BSSID_LEN];
353 };
354
355 #define CTRL_END_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
356 IEEE802_11_RA_LEN+IEEE802_11_BSSID_LEN)
357
358 struct ctrl_end_ack_hdr_t {
359 uint16_t fc;
360 uint16_t duration;
361 uint8_t ra[IEEE802_11_RA_LEN];
362 uint8_t bssid[IEEE802_11_BSSID_LEN];
363 };
364
365 #define CTRL_END_ACK_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
366 IEEE802_11_RA_LEN+IEEE802_11_BSSID_LEN)
367
368 struct ctrl_ba_hdr_t {
369 uint16_t fc;
370 uint16_t duration;
371 uint8_t ra[IEEE802_11_RA_LEN];
372 };
373
374 #define CTRL_BA_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+IEEE802_11_RA_LEN)
375
376 struct ctrl_bar_hdr_t {
377 uint16_t fc;
378 uint16_t dur;
379 uint8_t ra[IEEE802_11_RA_LEN];
380 uint8_t ta[IEEE802_11_TA_LEN];
381 uint16_t ctl;
382 uint16_t seq;
383 };
384
385 #define CTRL_BAR_HDRLEN (IEEE802_11_FC_LEN+IEEE802_11_DUR_LEN+\
386 IEEE802_11_RA_LEN+IEEE802_11_TA_LEN+\
387 IEEE802_11_CTL_LEN+IEEE802_11_SEQ_LEN)
388
389 struct meshcntl_t {
390 uint8_t flags;
391 uint8_t ttl;
392 uint8_t seq[4];
393 uint8_t addr4[6];
394 uint8_t addr5[6];
395 uint8_t addr6[6];
396 };
397
398 #define IV_IV(iv) ((iv) & 0xFFFFFF)
399 #define IV_PAD(iv) (((iv) >> 24) & 0x3F)
400 #define IV_KEYID(iv) (((iv) >> 30) & 0x03)
401
402 #define PRINT_SSID(p) \
403 if (p.ssid_present) { \
404 ND_PRINT((ndo, " (")); \
405 fn_print(ndo, p.ssid.ssid, NULL); \
406 ND_PRINT((ndo, ")")); \
407 }
408
409 #define PRINT_RATE(_sep, _r, _suf) \
410 ND_PRINT((ndo, "%s%2.1f%s", _sep, (.5 * ((_r) & 0x7f)), _suf))
411 #define PRINT_RATES(p) \
412 if (p.rates_present) { \
413 int z; \
414 const char *sep = " ["; \
415 for (z = 0; z < p.rates.length ; z++) { \
416 PRINT_RATE(sep, p.rates.rate[z], \
417 (p.rates.rate[z] & 0x80 ? "*" : "")); \
418 sep = " "; \
419 } \
420 if (p.rates.length != 0) \
421 ND_PRINT((ndo, " Mbit]")); \
422 }
423
424 #define PRINT_DS_CHANNEL(p) \
425 if (p.ds_present) \
426 ND_PRINT((ndo, " CH: %u", p.ds.channel)); \
427 ND_PRINT((ndo, "%s", \
428 CAPABILITY_PRIVACY(p.capability_info) ? ", PRIVACY" : ""));
429
430 #define MAX_MCS_INDEX 76
431
432 /*
433 * Indices are:
434 *
435 * the MCS index (0-76);
436 *
437 * 0 for 20 MHz, 1 for 40 MHz;
438 *
439 * 0 for a long guard interval, 1 for a short guard interval.
440 */
441 static const float ieee80211_float_htrates[MAX_MCS_INDEX+1][2][2] = {
442 /* MCS 0 */
443 { /* 20 Mhz */ { 6.5, /* SGI */ 7.2, },
444 /* 40 Mhz */ { 13.5, /* SGI */ 15.0, },
445 },
446
447 /* MCS 1 */
448 { /* 20 Mhz */ { 13.0, /* SGI */ 14.4, },
449 /* 40 Mhz */ { 27.0, /* SGI */ 30.0, },
450 },
451
452 /* MCS 2 */
453 { /* 20 Mhz */ { 19.5, /* SGI */ 21.7, },
454 /* 40 Mhz */ { 40.5, /* SGI */ 45.0, },
455 },
456
457 /* MCS 3 */
458 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
459 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
460 },
461
462 /* MCS 4 */
463 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
464 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
465 },
466
467 /* MCS 5 */
468 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
469 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
470 },
471
472 /* MCS 6 */
473 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
474 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
475 },
476
477 /* MCS 7 */
478 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
479 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
480 },
481
482 /* MCS 8 */
483 { /* 20 Mhz */ { 13.0, /* SGI */ 14.4, },
484 /* 40 Mhz */ { 27.0, /* SGI */ 30.0, },
485 },
486
487 /* MCS 9 */
488 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
489 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
490 },
491
492 /* MCS 10 */
493 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
494 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
495 },
496
497 /* MCS 11 */
498 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
499 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
500 },
501
502 /* MCS 12 */
503 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
504 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
505 },
506
507 /* MCS 13 */
508 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
509 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
510 },
511
512 /* MCS 14 */
513 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
514 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
515 },
516
517 /* MCS 15 */
518 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
519 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
520 },
521
522 /* MCS 16 */
523 { /* 20 Mhz */ { 19.5, /* SGI */ 21.7, },
524 /* 40 Mhz */ { 40.5, /* SGI */ 45.0, },
525 },
526
527 /* MCS 17 */
528 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
529 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
530 },
531
532 /* MCS 18 */
533 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
534 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
535 },
536
537 /* MCS 19 */
538 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
539 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
540 },
541
542 /* MCS 20 */
543 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
544 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
545 },
546
547 /* MCS 21 */
548 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
549 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
550 },
551
552 /* MCS 22 */
553 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
554 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
555 },
556
557 /* MCS 23 */
558 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
559 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
560 },
561
562 /* MCS 24 */
563 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
564 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
565 },
566
567 /* MCS 25 */
568 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
569 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
570 },
571
572 /* MCS 26 */
573 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
574 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
575 },
576
577 /* MCS 27 */
578 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
579 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
580 },
581
582 /* MCS 28 */
583 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
584 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
585 },
586
587 /* MCS 29 */
588 { /* 20 Mhz */ { 208.0, /* SGI */ 231.1, },
589 /* 40 Mhz */ { 432.0, /* SGI */ 480.0, },
590 },
591
592 /* MCS 30 */
593 { /* 20 Mhz */ { 234.0, /* SGI */ 260.0, },
594 /* 40 Mhz */ { 486.0, /* SGI */ 540.0, },
595 },
596
597 /* MCS 31 */
598 { /* 20 Mhz */ { 260.0, /* SGI */ 288.9, },
599 /* 40 Mhz */ { 540.0, /* SGI */ 600.0, },
600 },
601
602 /* MCS 32 */
603 { /* 20 Mhz */ { 0.0, /* SGI */ 0.0, }, /* not valid */
604 /* 40 Mhz */ { 6.0, /* SGI */ 6.7, },
605 },
606
607 /* MCS 33 */
608 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
609 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
610 },
611
612 /* MCS 34 */
613 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
614 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
615 },
616
617 /* MCS 35 */
618 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
619 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
620 },
621
622 /* MCS 36 */
623 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
624 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
625 },
626
627 /* MCS 37 */
628 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
629 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
630 },
631
632 /* MCS 38 */
633 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
634 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
635 },
636
637 /* MCS 39 */
638 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
639 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
640 },
641
642 /* MCS 40 */
643 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
644 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
645 },
646
647 /* MCS 41 */
648 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
649 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
650 },
651
652 /* MCS 42 */
653 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
654 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
655 },
656
657 /* MCS 43 */
658 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
659 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
660 },
661
662 /* MCS 44 */
663 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
664 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
665 },
666
667 /* MCS 45 */
668 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
669 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
670 },
671
672 /* MCS 46 */
673 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
674 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
675 },
676
677 /* MCS 47 */
678 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
679 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
680 },
681
682 /* MCS 48 */
683 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
684 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
685 },
686
687 /* MCS 49 */
688 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
689 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
690 },
691
692 /* MCS 50 */
693 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
694 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
695 },
696
697 /* MCS 51 */
698 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
699 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
700 },
701
702 /* MCS 52 */
703 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
704 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
705 },
706
707 /* MCS 53 */
708 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
709 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
710 },
711
712 /* MCS 54 */
713 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
714 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
715 },
716
717 /* MCS 55 */
718 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
719 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
720 },
721
722 /* MCS 56 */
723 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
724 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
725 },
726
727 /* MCS 57 */
728 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
729 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
730 },
731
732 /* MCS 58 */
733 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
734 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
735 },
736
737 /* MCS 59 */
738 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
739 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
740 },
741
742 /* MCS 60 */
743 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
744 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
745 },
746
747 /* MCS 61 */
748 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
749 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
750 },
751
752 /* MCS 62 */
753 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
754 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
755 },
756
757 /* MCS 63 */
758 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
759 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
760 },
761
762 /* MCS 64 */
763 { /* 20 Mhz */ { 143.0, /* SGI */ 158.9, },
764 /* 40 Mhz */ { 297.0, /* SGI */ 330.0, },
765 },
766
767 /* MCS 65 */
768 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
769 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
770 },
771
772 /* MCS 66 */
773 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
774 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
775 },
776
777 /* MCS 67 */
778 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
779 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
780 },
781
782 /* MCS 68 */
783 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
784 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
785 },
786
787 /* MCS 69 */
788 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
789 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
790 },
791
792 /* MCS 70 */
793 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
794 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
795 },
796
797 /* MCS 71 */
798 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
799 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
800 },
801
802 /* MCS 72 */
803 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
804 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
805 },
806
807 /* MCS 73 */
808 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
809 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
810 },
811
812 /* MCS 74 */
813 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
814 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
815 },
816
817 /* MCS 75 */
818 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
819 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
820 },
821
822 /* MCS 76 */
823 { /* 20 Mhz */ { 214.5, /* SGI */ 238.3, },
824 /* 40 Mhz */ { 445.5, /* SGI */ 495.0, },
825 },
826 };
827
828 static const char *auth_alg_text[]={"Open System","Shared Key","EAP"};
829 #define NUM_AUTH_ALGS (sizeof auth_alg_text / sizeof auth_alg_text[0])
830
831 static const char *status_text[] = {
832 "Successful", /* 0 */
833 "Unspecified failure", /* 1 */
834 "Reserved", /* 2 */
835 "Reserved", /* 3 */
836 "Reserved", /* 4 */
837 "Reserved", /* 5 */
838 "Reserved", /* 6 */
839 "Reserved", /* 7 */
840 "Reserved", /* 8 */
841 "Reserved", /* 9 */
842 "Cannot Support all requested capabilities in the Capability "
843 "Information field", /* 10 */
844 "Reassociation denied due to inability to confirm that association "
845 "exists", /* 11 */
846 "Association denied due to reason outside the scope of the "
847 "standard", /* 12 */
848 "Responding station does not support the specified authentication "
849 "algorithm ", /* 13 */
850 "Received an Authentication frame with authentication transaction "
851 "sequence number out of expected sequence", /* 14 */
852 "Authentication rejected because of challenge failure", /* 15 */
853 "Authentication rejected due to timeout waiting for next frame in "
854 "sequence", /* 16 */
855 "Association denied because AP is unable to handle additional"
856 "associated stations", /* 17 */
857 "Association denied due to requesting station not supporting all of "
858 "the data rates in BSSBasicRateSet parameter", /* 18 */
859 "Association denied due to requesting station not supporting "
860 "short preamble operation", /* 19 */
861 "Association denied due to requesting station not supporting "
862 "PBCC encoding", /* 20 */
863 "Association denied due to requesting station not supporting "
864 "channel agility", /* 21 */
865 "Association request rejected because Spectrum Management "
866 "capability is required", /* 22 */
867 "Association request rejected because the information in the "
868 "Power Capability element is unacceptable", /* 23 */
869 "Association request rejected because the information in the "
870 "Supported Channels element is unacceptable", /* 24 */
871 "Association denied due to requesting station not supporting "
872 "short slot operation", /* 25 */
873 "Association denied due to requesting station not supporting "
874 "DSSS-OFDM operation", /* 26 */
875 "Association denied because the requested STA does not support HT "
876 "features", /* 27 */
877 "Reserved", /* 28 */
878 "Association denied because the requested STA does not support "
879 "the PCO transition time required by the AP", /* 29 */
880 "Reserved", /* 30 */
881 "Reserved", /* 31 */
882 "Unspecified, QoS-related failure", /* 32 */
883 "Association denied due to QAP having insufficient bandwidth "
884 "to handle another QSTA", /* 33 */
885 "Association denied due to excessive frame loss rates and/or "
886 "poor conditions on current operating channel", /* 34 */
887 "Association (with QBSS) denied due to requesting station not "
888 "supporting the QoS facility", /* 35 */
889 "Association denied due to requesting station not supporting "
890 "Block Ack", /* 36 */
891 "The request has been declined", /* 37 */
892 "The request has not been successful as one or more parameters "
893 "have invalid values", /* 38 */
894 "The TS has not been created because the request cannot be honored. "
895 "Try again with the suggested changes to the TSPEC", /* 39 */
896 "Invalid Information Element", /* 40 */
897 "Group Cipher is not valid", /* 41 */
898 "Pairwise Cipher is not valid", /* 42 */
899 "AKMP is not valid", /* 43 */
900 "Unsupported RSN IE version", /* 44 */
901 "Invalid RSN IE Capabilities", /* 45 */
902 "Cipher suite is rejected per security policy", /* 46 */
903 "The TS has not been created. However, the HC may be capable of "
904 "creating a TS, in response to a request, after the time indicated "
905 "in the TS Delay element", /* 47 */
906 "Direct Link is not allowed in the BSS by policy", /* 48 */
907 "Destination STA is not present within this QBSS.", /* 49 */
908 "The Destination STA is not a QSTA.", /* 50 */
909
910 };
911 #define NUM_STATUSES (sizeof status_text / sizeof status_text[0])
912
913 static const char *reason_text[] = {
914 "Reserved", /* 0 */
915 "Unspecified reason", /* 1 */
916 "Previous authentication no longer valid", /* 2 */
917 "Deauthenticated because sending station is leaving (or has left) "
918 "IBSS or ESS", /* 3 */
919 "Disassociated due to inactivity", /* 4 */
920 "Disassociated because AP is unable to handle all currently "
921 " associated stations", /* 5 */
922 "Class 2 frame received from nonauthenticated station", /* 6 */
923 "Class 3 frame received from nonassociated station", /* 7 */
924 "Disassociated because sending station is leaving "
925 "(or has left) BSS", /* 8 */
926 "Station requesting (re)association is not authenticated with "
927 "responding station", /* 9 */
928 "Disassociated because the information in the Power Capability "
929 "element is unacceptable", /* 10 */
930 "Disassociated because the information in the SupportedChannels "
931 "element is unacceptable", /* 11 */
932 "Invalid Information Element", /* 12 */
933 "Reserved", /* 13 */
934 "Michael MIC failure", /* 14 */
935 "4-Way Handshake timeout", /* 15 */
936 "Group key update timeout", /* 16 */
937 "Information element in 4-Way Handshake different from (Re)Association"
938 "Request/Probe Response/Beacon", /* 17 */
939 "Group Cipher is not valid", /* 18 */
940 "AKMP is not valid", /* 20 */
941 "Unsupported RSN IE version", /* 21 */
942 "Invalid RSN IE Capabilities", /* 22 */
943 "IEEE 802.1X Authentication failed", /* 23 */
944 "Cipher suite is rejected per security policy", /* 24 */
945 "Reserved", /* 25 */
946 "Reserved", /* 26 */
947 "Reserved", /* 27 */
948 "Reserved", /* 28 */
949 "Reserved", /* 29 */
950 "Reserved", /* 30 */
951 "TS deleted because QoS AP lacks sufficient bandwidth for this "
952 "QoS STA due to a change in BSS service characteristics or "
953 "operational mode (e.g. an HT BSS change from 40 MHz channel "
954 "to 20 MHz channel)", /* 31 */
955 "Disassociated for unspecified, QoS-related reason", /* 32 */
956 "Disassociated because QoS AP lacks sufficient bandwidth for this "
957 "QoS STA", /* 33 */
958 "Disassociated because of excessive number of frames that need to be "
959 "acknowledged, but are not acknowledged for AP transmissions "
960 "and/or poor channel conditions", /* 34 */
961 "Disassociated because STA is transmitting outside the limits "
962 "of its TXOPs", /* 35 */
963 "Requested from peer STA as the STA is leaving the BSS "
964 "(or resetting)", /* 36 */
965 "Requested from peer STA as it does not want to use the "
966 "mechanism", /* 37 */
967 "Requested from peer STA as the STA received frames using the "
968 "mechanism for which a set up is required", /* 38 */
969 "Requested from peer STA due to time out", /* 39 */
970 "Reserved", /* 40 */
971 "Reserved", /* 41 */
972 "Reserved", /* 42 */
973 "Reserved", /* 43 */
974 "Reserved", /* 44 */
975 "Peer STA does not support the requested cipher suite", /* 45 */
976 "Association denied due to requesting STA not supporting HT "
977 "features", /* 46 */
978 };
979 #define NUM_REASONS (sizeof reason_text / sizeof reason_text[0])
980
981 static int
982 wep_print(netdissect_options *ndo,
983 const u_char *p)
984 {
985 uint32_t iv;
986
987 if (!ND_TTEST2(*p, IEEE802_11_IV_LEN + IEEE802_11_KID_LEN))
988 return 0;
989 iv = EXTRACT_LE_32BITS(p);
990
991 ND_PRINT((ndo, " IV:%3x Pad %x KeyID %x", IV_IV(iv), IV_PAD(iv),
992 IV_KEYID(iv)));
993
994 return 1;
995 }
996
997 static int
998 parse_elements(netdissect_options *ndo,
999 struct mgmt_body_t *pbody, const u_char *p, int offset,
1000 u_int length)
1001 {
1002 u_int elementlen;
1003 struct ssid_t ssid;
1004 struct challenge_t challenge;
1005 struct rates_t rates;
1006 struct ds_t ds;
1007 struct cf_t cf;
1008 struct tim_t tim;
1009
1010 /*
1011 * We haven't seen any elements yet.
1012 */
1013 pbody->challenge_present = 0;
1014 pbody->ssid_present = 0;
1015 pbody->rates_present = 0;
1016 pbody->ds_present = 0;
1017 pbody->cf_present = 0;
1018 pbody->tim_present = 0;
1019
1020 while (length != 0) {
1021 /* Make sure we at least have the element ID and length. */
1022 if (!ND_TTEST2(*(p + offset), 2))
1023 return 0;
1024 if (length < 2)
1025 return 0;
1026 elementlen = *(p + offset + 1);
1027
1028 /* Make sure we have the entire element. */
1029 if (!ND_TTEST2(*(p + offset + 2), elementlen))
1030 return 0;
1031 if (length < elementlen + 2)
1032 return 0;
1033
1034 switch (*(p + offset)) {
1035 case E_SSID:
1036 memcpy(&ssid, p + offset, 2);
1037 offset += 2;
1038 length -= 2;
1039 if (ssid.length != 0) {
1040 if (ssid.length > sizeof(ssid.ssid) - 1)
1041 return 0;
1042 memcpy(&ssid.ssid, p + offset, ssid.length);
1043 offset += ssid.length;
1044 length -= ssid.length;
1045 }
1046 ssid.ssid[ssid.length] = '\0';
1047 /*
1048 * Present and not truncated.
1049 *
1050 * If we haven't already seen an SSID IE,
1051 * copy this one, otherwise ignore this one,
1052 * so we later report the first one we saw.
1053 */
1054 if (!pbody->ssid_present) {
1055 pbody->ssid = ssid;
1056 pbody->ssid_present = 1;
1057 }
1058 break;
1059 case E_CHALLENGE:
1060 memcpy(&challenge, p + offset, 2);
1061 offset += 2;
1062 length -= 2;
1063 if (challenge.length != 0) {
1064 if (challenge.length >
1065 sizeof(challenge.text) - 1)
1066 return 0;
1067 memcpy(&challenge.text, p + offset,
1068 challenge.length);
1069 offset += challenge.length;
1070 length -= challenge.length;
1071 }
1072 challenge.text[challenge.length] = '\0';
1073 /*
1074 * Present and not truncated.
1075 *
1076 * If we haven't already seen a challenge IE,
1077 * copy this one, otherwise ignore this one,
1078 * so we later report the first one we saw.
1079 */
1080 if (!pbody->challenge_present) {
1081 pbody->challenge = challenge;
1082 pbody->challenge_present = 1;
1083 }
1084 break;
1085 case E_RATES:
1086 memcpy(&rates, p + offset, 2);
1087 offset += 2;
1088 length -= 2;
1089 if (rates.length != 0) {
1090 if (rates.length > sizeof rates.rate)
1091 return 0;
1092 memcpy(&rates.rate, p + offset, rates.length);
1093 offset += rates.length;
1094 length -= rates.length;
1095 }
1096 /*
1097 * Present and not truncated.
1098 *
1099 * If we haven't already seen a rates IE,
1100 * copy this one if it's not zero-length,
1101 * otherwise ignore this one, so we later
1102 * report the first one we saw.
1103 *
1104 * We ignore zero-length rates IEs as some
1105 * devices seem to put a zero-length rates
1106 * IE, followed by an SSID IE, followed by
1107 * a non-zero-length rates IE into frames,
1108 * even though IEEE Std 802.11-2007 doesn't
1109 * seem to indicate that a zero-length rates
1110 * IE is valid.
1111 */
1112 if (!pbody->rates_present && rates.length != 0) {
1113 pbody->rates = rates;
1114 pbody->rates_present = 1;
1115 }
1116 break;
1117 case E_DS:
1118 memcpy(&ds, p + offset, 2);
1119 offset += 2;
1120 length -= 2;
1121 if (ds.length != 1) {
1122 offset += ds.length;
1123 length -= ds.length;
1124 break;
1125 }
1126 ds.channel = *(p + offset);
1127 offset += 1;
1128 length -= 1;
1129 /*
1130 * Present and not truncated.
1131 *
1132 * If we haven't already seen a DS IE,
1133 * copy this one, otherwise ignore this one,
1134 * so we later report the first one we saw.
1135 */
1136 if (!pbody->ds_present) {
1137 pbody->ds = ds;
1138 pbody->ds_present = 1;
1139 }
1140 break;
1141 case E_CF:
1142 memcpy(&cf, p + offset, 2);
1143 offset += 2;
1144 length -= 2;
1145 if (cf.length != 6) {
1146 offset += cf.length;
1147 length -= cf.length;
1148 break;
1149 }
1150 memcpy(&cf.count, p + offset, 6);
1151 offset += 6;
1152 length -= 6;
1153 /*
1154 * Present and not truncated.
1155 *
1156 * If we haven't already seen a CF IE,
1157 * copy this one, otherwise ignore this one,
1158 * so we later report the first one we saw.
1159 */
1160 if (!pbody->cf_present) {
1161 pbody->cf = cf;
1162 pbody->cf_present = 1;
1163 }
1164 break;
1165 case E_TIM:
1166 memcpy(&tim, p + offset, 2);
1167 offset += 2;
1168 length -= 2;
1169 if (tim.length <= 3) {
1170 offset += tim.length;
1171 length -= tim.length;
1172 break;
1173 }
1174 if (tim.length - 3 > (int)sizeof tim.bitmap)
1175 return 0;
1176 memcpy(&tim.count, p + offset, 3);
1177 offset += 3;
1178 length -= 3;
1179
1180 memcpy(tim.bitmap, p + offset, tim.length - 3);
1181 offset += tim.length - 3;
1182 length -= tim.length - 3;
1183 /*
1184 * Present and not truncated.
1185 *
1186 * If we haven't already seen a TIM IE,
1187 * copy this one, otherwise ignore this one,
1188 * so we later report the first one we saw.
1189 */
1190 if (!pbody->tim_present) {
1191 pbody->tim = tim;
1192 pbody->tim_present = 1;
1193 }
1194 break;
1195 default:
1196 #if 0
1197 ND_PRINT((ndo, "(1) unhandled element_id (%d) ",
1198 *(p + offset)));
1199 #endif
1200 offset += 2 + elementlen;
1201 length -= 2 + elementlen;
1202 break;
1203 }
1204 }
1205
1206 /* No problems found. */
1207 return 1;
1208 }
1209
1210 /*********************************************************************************
1211 * Print Handle functions for the management frame types
1212 *********************************************************************************/
1213
1214 static int
1215 handle_beacon(netdissect_options *ndo,
1216 const u_char *p, u_int length)
1217 {
1218 struct mgmt_body_t pbody;
1219 int offset = 0;
1220 int ret;
1221
1222 memset(&pbody, 0, sizeof(pbody));
1223
1224 if (!ND_TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1225 IEEE802_11_CAPINFO_LEN))
1226 return 0;
1227 if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1228 IEEE802_11_CAPINFO_LEN)
1229 return 0;
1230 memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
1231 offset += IEEE802_11_TSTAMP_LEN;
1232 length -= IEEE802_11_TSTAMP_LEN;
1233 pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
1234 offset += IEEE802_11_BCNINT_LEN;
1235 length -= IEEE802_11_BCNINT_LEN;
1236 pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
1237 offset += IEEE802_11_CAPINFO_LEN;
1238 length -= IEEE802_11_CAPINFO_LEN;
1239
1240 ret = parse_elements(ndo, &pbody, p, offset, length);
1241
1242 PRINT_SSID(pbody);
1243 PRINT_RATES(pbody);
1244 ND_PRINT((ndo, " %s",
1245 CAPABILITY_ESS(pbody.capability_info) ? "ESS" : "IBSS"));
1246 PRINT_DS_CHANNEL(pbody);
1247
1248 return ret;
1249 }
1250
1251 static int
1252 handle_assoc_request(netdissect_options *ndo,
1253 const u_char *p, u_int length)
1254 {
1255 struct mgmt_body_t pbody;
1256 int offset = 0;
1257 int ret;
1258
1259 memset(&pbody, 0, sizeof(pbody));
1260
1261 if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN))
1262 return 0;
1263 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN)
1264 return 0;
1265 pbody.capability_info = EXTRACT_LE_16BITS(p);
1266 offset += IEEE802_11_CAPINFO_LEN;
1267 length -= IEEE802_11_CAPINFO_LEN;
1268 pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
1269 offset += IEEE802_11_LISTENINT_LEN;
1270 length -= IEEE802_11_LISTENINT_LEN;
1271
1272 ret = parse_elements(ndo, &pbody, p, offset, length);
1273
1274 PRINT_SSID(pbody);
1275 PRINT_RATES(pbody);
1276 return ret;
1277 }
1278
1279 static int
1280 handle_assoc_response(netdissect_options *ndo,
1281 const u_char *p, u_int length)
1282 {
1283 struct mgmt_body_t pbody;
1284 int offset = 0;
1285 int ret;
1286
1287 memset(&pbody, 0, sizeof(pbody));
1288
1289 if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
1290 IEEE802_11_AID_LEN))
1291 return 0;
1292 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
1293 IEEE802_11_AID_LEN)
1294 return 0;
1295 pbody.capability_info = EXTRACT_LE_16BITS(p);
1296 offset += IEEE802_11_CAPINFO_LEN;
1297 length -= IEEE802_11_CAPINFO_LEN;
1298 pbody.status_code = EXTRACT_LE_16BITS(p+offset);
1299 offset += IEEE802_11_STATUS_LEN;
1300 length -= IEEE802_11_STATUS_LEN;
1301 pbody.aid = EXTRACT_LE_16BITS(p+offset);
1302 offset += IEEE802_11_AID_LEN;
1303 length -= IEEE802_11_AID_LEN;
1304
1305 ret = parse_elements(ndo, &pbody, p, offset, length);
1306
1307 ND_PRINT((ndo, " AID(%x) :%s: %s", ((uint16_t)(pbody.aid << 2 )) >> 2 ,
1308 CAPABILITY_PRIVACY(pbody.capability_info) ? " PRIVACY " : "",
1309 (pbody.status_code < NUM_STATUSES
1310 ? status_text[pbody.status_code]
1311 : "n/a")));
1312
1313 return ret;
1314 }
1315
1316 static int
1317 handle_reassoc_request(netdissect_options *ndo,
1318 const u_char *p, u_int length)
1319 {
1320 struct mgmt_body_t pbody;
1321 int offset = 0;
1322 int ret;
1323
1324 memset(&pbody, 0, sizeof(pbody));
1325
1326 if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1327 IEEE802_11_AP_LEN))
1328 return 0;
1329 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1330 IEEE802_11_AP_LEN)
1331 return 0;
1332 pbody.capability_info = EXTRACT_LE_16BITS(p);
1333 offset += IEEE802_11_CAPINFO_LEN;
1334 length -= IEEE802_11_CAPINFO_LEN;
1335 pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
1336 offset += IEEE802_11_LISTENINT_LEN;
1337 length -= IEEE802_11_LISTENINT_LEN;
1338 memcpy(&pbody.ap, p+offset, IEEE802_11_AP_LEN);
1339 offset += IEEE802_11_AP_LEN;
1340 length -= IEEE802_11_AP_LEN;
1341
1342 ret = parse_elements(ndo, &pbody, p, offset, length);
1343
1344 PRINT_SSID(pbody);
1345 ND_PRINT((ndo, " AP : %s", etheraddr_string(ndo, pbody.ap )));
1346
1347 return ret;
1348 }
1349
1350 static int
1351 handle_reassoc_response(netdissect_options *ndo,
1352 const u_char *p, u_int length)
1353 {
1354 /* Same as a Association Reponse */
1355 return handle_assoc_response(ndo, p, length);
1356 }
1357
1358 static int
1359 handle_probe_request(netdissect_options *ndo,
1360 const u_char *p, u_int length)
1361 {
1362 struct mgmt_body_t pbody;
1363 int offset = 0;
1364 int ret;
1365
1366 memset(&pbody, 0, sizeof(pbody));
1367
1368 ret = parse_elements(ndo, &pbody, p, offset, length);
1369
1370 PRINT_SSID(pbody);
1371 PRINT_RATES(pbody);
1372
1373 return ret;
1374 }
1375
1376 static int
1377 handle_probe_response(netdissect_options *ndo,
1378 const u_char *p, u_int length)
1379 {
1380 struct mgmt_body_t pbody;
1381 int offset = 0;
1382 int ret;
1383
1384 memset(&pbody, 0, sizeof(pbody));
1385
1386 if (!ND_TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1387 IEEE802_11_CAPINFO_LEN))
1388 return 0;
1389 if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1390 IEEE802_11_CAPINFO_LEN)
1391 return 0;
1392 memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
1393 offset += IEEE802_11_TSTAMP_LEN;
1394 length -= IEEE802_11_TSTAMP_LEN;
1395 pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
1396 offset += IEEE802_11_BCNINT_LEN;
1397 length -= IEEE802_11_BCNINT_LEN;
1398 pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
1399 offset += IEEE802_11_CAPINFO_LEN;
1400 length -= IEEE802_11_CAPINFO_LEN;
1401
1402 ret = parse_elements(ndo, &pbody, p, offset, length);
1403
1404 PRINT_SSID(pbody);
1405 PRINT_RATES(pbody);
1406 PRINT_DS_CHANNEL(pbody);
1407
1408 return ret;
1409 }
1410
1411 static int
1412 handle_atim(void)
1413 {
1414 /* the frame body for ATIM is null. */
1415 return 1;
1416 }
1417
1418 static int
1419 handle_disassoc(netdissect_options *ndo,
1420 const u_char *p, u_int length)
1421 {
1422 struct mgmt_body_t pbody;
1423
1424 memset(&pbody, 0, sizeof(pbody));
1425
1426 if (!ND_TTEST2(*p, IEEE802_11_REASON_LEN))
1427 return 0;
1428 if (length < IEEE802_11_REASON_LEN)
1429 return 0;
1430 pbody.reason_code = EXTRACT_LE_16BITS(p);
1431
1432 ND_PRINT((ndo, ": %s",
1433 (pbody.reason_code < NUM_REASONS)
1434 ? reason_text[pbody.reason_code]
1435 : "Reserved"));
1436
1437 return 1;
1438 }
1439
1440 static int
1441 handle_auth(netdissect_options *ndo,
1442 const u_char *p, u_int length)
1443 {
1444 struct mgmt_body_t pbody;
1445 int offset = 0;
1446 int ret;
1447
1448 memset(&pbody, 0, sizeof(pbody));
1449
1450 if (!ND_TTEST2(*p, 6))
1451 return 0;
1452 if (length < 6)
1453 return 0;
1454 pbody.auth_alg = EXTRACT_LE_16BITS(p);
1455 offset += 2;
1456 length -= 2;
1457 pbody.auth_trans_seq_num = EXTRACT_LE_16BITS(p + offset);
1458 offset += 2;
1459 length -= 2;
1460 pbody.status_code = EXTRACT_LE_16BITS(p + offset);
1461 offset += 2;
1462 length -= 2;
1463
1464 ret = parse_elements(ndo, &pbody, p, offset, length);
1465
1466 if ((pbody.auth_alg == 1) &&
1467 ((pbody.auth_trans_seq_num == 2) ||
1468 (pbody.auth_trans_seq_num == 3))) {
1469 ND_PRINT((ndo, " (%s)-%x [Challenge Text] %s",
1470 (pbody.auth_alg < NUM_AUTH_ALGS)
1471 ? auth_alg_text[pbody.auth_alg]
1472 : "Reserved",
1473 pbody.auth_trans_seq_num,
1474 ((pbody.auth_trans_seq_num % 2)
1475 ? ((pbody.status_code < NUM_STATUSES)
1476 ? status_text[pbody.status_code]
1477 : "n/a") : "")));
1478 return ret;
1479 }
1480 ND_PRINT((ndo, " (%s)-%x: %s",
1481 (pbody.auth_alg < NUM_AUTH_ALGS)
1482 ? auth_alg_text[pbody.auth_alg]
1483 : "Reserved",
1484 pbody.auth_trans_seq_num,
1485 (pbody.auth_trans_seq_num % 2)
1486 ? ((pbody.status_code < NUM_STATUSES)
1487 ? status_text[pbody.status_code]
1488 : "n/a")
1489 : ""));
1490
1491 return ret;
1492 }
1493
1494 static int
1495 handle_deauth(netdissect_options *ndo,
1496 const uint8_t *src, const u_char *p, u_int length)
1497 {
1498 struct mgmt_body_t pbody;
1499 const char *reason = NULL;
1500
1501 memset(&pbody, 0, sizeof(pbody));
1502
1503 if (!ND_TTEST2(*p, IEEE802_11_REASON_LEN))
1504 return 0;
1505 if (length < IEEE802_11_REASON_LEN)
1506 return 0;
1507 pbody.reason_code = EXTRACT_LE_16BITS(p);
1508
1509 reason = (pbody.reason_code < NUM_REASONS)
1510 ? reason_text[pbody.reason_code]
1511 : "Reserved";
1512
1513 if (ndo->ndo_eflag) {
1514 ND_PRINT((ndo, ": %s", reason));
1515 } else {
1516 ND_PRINT((ndo, " (%s): %s", etheraddr_string(ndo, src), reason));
1517 }
1518 return 1;
1519 }
1520
1521 #define PRINT_HT_ACTION(v) (\
1522 (v) == 0 ? ND_PRINT((ndo, "TxChWidth")) : \
1523 (v) == 1 ? ND_PRINT((ndo, "MIMOPwrSave")) : \
1524 ND_PRINT((ndo, "Act#%d", (v))) \
1525 )
1526 #define PRINT_BA_ACTION(v) (\
1527 (v) == 0 ? ND_PRINT((ndo, "ADDBA Request")) : \
1528 (v) == 1 ? ND_PRINT((ndo, "ADDBA Response")) : \
1529 (v) == 2 ? ND_PRINT((ndo, "DELBA")) : \
1530 ND_PRINT((ndo, "Act#%d", (v))) \
1531 )
1532 #define PRINT_MESHLINK_ACTION(v) (\
1533 (v) == 0 ? ND_PRINT((ndo, "Request")) : \
1534 (v) == 1 ? ND_PRINT((ndo, "Report")) : \
1535 ND_PRINT((ndo, "Act#%d", (v))) \
1536 )
1537 #define PRINT_MESHPEERING_ACTION(v) (\
1538 (v) == 0 ? ND_PRINT((ndo, "Open")) : \
1539 (v) == 1 ? ND_PRINT((ndo, "Confirm")) : \
1540 (v) == 2 ? ND_PRINT((ndo, "Close")) : \
1541 ND_PRINT((ndo, "Act#%d", (v))) \
1542 )
1543 #define PRINT_MESHPATH_ACTION(v) (\
1544 (v) == 0 ? ND_PRINT((ndo, "Request")) : \
1545 (v) == 1 ? ND_PRINT((ndo, "Report")) : \
1546 (v) == 2 ? ND_PRINT((ndo, "Error")) : \
1547 (v) == 3 ? ND_PRINT((ndo, "RootAnnouncement")) : \
1548 ND_PRINT((ndo, "Act#%d", (v))) \
1549 )
1550
1551 #define PRINT_MESH_ACTION(v) (\
1552 (v) == 0 ? ND_PRINT((ndo, "MeshLink")) : \
1553 (v) == 1 ? ND_PRINT((ndo, "HWMP")) : \
1554 (v) == 2 ? ND_PRINT((ndo, "Gate Announcement")) : \
1555 (v) == 3 ? ND_PRINT((ndo, "Congestion Control")) : \
1556 (v) == 4 ? ND_PRINT((ndo, "MCCA Setup Request")) : \
1557 (v) == 5 ? ND_PRINT((ndo, "MCCA Setup Reply")) : \
1558 (v) == 6 ? ND_PRINT((ndo, "MCCA Advertisement Request")) : \
1559 (v) == 7 ? ND_PRINT((ndo, "MCCA Advertisement")) : \
1560 (v) == 8 ? ND_PRINT((ndo, "MCCA Teardown")) : \
1561 (v) == 9 ? ND_PRINT((ndo, "TBTT Adjustment Request")) : \
1562 (v) == 10 ? ND_PRINT((ndo, "TBTT Adjustment Response")) : \
1563 ND_PRINT((ndo, "Act#%d", (v))) \
1564 )
1565 #define PRINT_MULTIHOP_ACTION(v) (\
1566 (v) == 0 ? ND_PRINT((ndo, "Proxy Update")) : \
1567 (v) == 1 ? ND_PRINT((ndo, "Proxy Update Confirmation")) : \
1568 ND_PRINT((ndo, "Act#%d", (v))) \
1569 )
1570 #define PRINT_SELFPROT_ACTION(v) (\
1571 (v) == 1 ? ND_PRINT((ndo, "Peering Open")) : \
1572 (v) == 2 ? ND_PRINT((ndo, "Peering Confirm")) : \
1573 (v) == 3 ? ND_PRINT((ndo, "Peering Close")) : \
1574 (v) == 4 ? ND_PRINT((ndo, "Group Key Inform")) : \
1575 (v) == 5 ? ND_PRINT((ndo, "Group Key Acknowledge")) : \
1576 ND_PRINT((ndo, "Act#%d", (v))) \
1577 )
1578
1579 static int
1580 handle_action(netdissect_options *ndo,
1581 const uint8_t *src, const u_char *p, u_int length)
1582 {
1583 if (!ND_TTEST2(*p, 2))
1584 return 0;
1585 if (length < 2)
1586 return 0;
1587 if (ndo->ndo_eflag) {
1588 ND_PRINT((ndo, ": "));
1589 } else {
1590 ND_PRINT((ndo, " (%s): ", etheraddr_string(ndo, src)));
1591 }
1592 switch (p[0]) {
1593 case 0: ND_PRINT((ndo, "Spectrum Management Act#%d", p[1])); break;
1594 case 1: ND_PRINT((ndo, "QoS Act#%d", p[1])); break;
1595 case 2: ND_PRINT((ndo, "DLS Act#%d", p[1])); break;
1596 case 3: ND_PRINT((ndo, "BA ")); PRINT_BA_ACTION(p[1]); break;
1597 case 7: ND_PRINT((ndo, "HT ")); PRINT_HT_ACTION(p[1]); break;
1598 case 13: ND_PRINT((ndo, "MeshAction ")); PRINT_MESH_ACTION(p[1]); break;
1599 case 14:
1600 ND_PRINT((ndo, "MultiohopAction "));
1601 PRINT_MULTIHOP_ACTION(p[1]); break;
1602 case 15:
1603 ND_PRINT((ndo, "SelfprotectAction "));
1604 PRINT_SELFPROT_ACTION(p[1]); break;
1605 case 127: ND_PRINT((ndo, "Vendor Act#%d", p[1])); break;
1606 default:
1607 ND_PRINT((ndo, "Reserved(%d) Act#%d", p[0], p[1]));
1608 break;
1609 }
1610 return 1;
1611 }
1612
1613
1614 /*********************************************************************************
1615 * Print Body funcs
1616 *********************************************************************************/
1617
1618
1619 static int
1620 mgmt_body_print(netdissect_options *ndo,
1621 uint16_t fc, const uint8_t *src, const u_char *p, u_int length)
1622 {
1623 ND_PRINT((ndo, "%s", tok2str(st_str, "Unhandled Management subtype(%x)", FC_SUBTYPE(fc))));
1624
1625 /* There may be a problem w/ AP not having this bit set */
1626 if (FC_PROTECTED(fc))
1627 return wep_print(ndo, p);
1628 switch (FC_SUBTYPE(fc)) {
1629 case ST_ASSOC_REQUEST:
1630 return handle_assoc_request(ndo, p, length);
1631 case ST_ASSOC_RESPONSE:
1632 return handle_assoc_response(ndo, p, length);
1633 case ST_REASSOC_REQUEST:
1634 return handle_reassoc_request(ndo, p, length);
1635 case ST_REASSOC_RESPONSE:
1636 return handle_reassoc_response(ndo, p, length);
1637 case ST_PROBE_REQUEST:
1638 return handle_probe_request(ndo, p, length);
1639 case ST_PROBE_RESPONSE:
1640 return handle_probe_response(ndo, p, length);
1641 case ST_BEACON:
1642 return handle_beacon(ndo, p, length);
1643 case ST_ATIM:
1644 return handle_atim();
1645 case ST_DISASSOC:
1646 return handle_disassoc(ndo, p, length);
1647 case ST_AUTH:
1648 return handle_auth(ndo, p, length);
1649 case ST_DEAUTH:
1650 return handle_deauth(ndo, src, p, length);
1651 case ST_ACTION:
1652 return handle_action(ndo, src, p, length);
1653 default:
1654 return 1;
1655 }
1656 }
1657
1658
1659 /*********************************************************************************
1660 * Handles printing all the control frame types
1661 *********************************************************************************/
1662
1663 static int
1664 ctrl_body_print(netdissect_options *ndo,
1665 uint16_t fc, const u_char *p)
1666 {
1667 ND_PRINT((ndo, "%s", tok2str(ctrl_str, "Unknown Ctrl Subtype", FC_SUBTYPE(fc))));
1668 switch (FC_SUBTYPE(fc)) {
1669 case CTRL_CONTROL_WRAPPER:
1670 /* XXX - requires special handling */
1671 break;
1672 case CTRL_BAR:
1673 if (!ND_TTEST2(*p, CTRL_BAR_HDRLEN))
1674 return 0;
1675 if (!ndo->ndo_eflag)
1676 ND_PRINT((ndo, " RA:%s TA:%s CTL(%x) SEQ(%u) ",
1677 etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
1678 etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
1679 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->ctl)),
1680 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->seq))));
1681 break;
1682 case CTRL_BA:
1683 if (!ND_TTEST2(*p, CTRL_BA_HDRLEN))
1684 return 0;
1685 if (!ndo->ndo_eflag)
1686 ND_PRINT((ndo, " RA:%s ",
1687 etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra)));
1688 break;
1689 case CTRL_PS_POLL:
1690 if (!ND_TTEST2(*p, CTRL_PS_POLL_HDRLEN))
1691 return 0;
1692 ND_PRINT((ndo, " AID(%x)",
1693 EXTRACT_LE_16BITS(&(((const struct ctrl_ps_poll_hdr_t *)p)->aid))));
1694 break;
1695 case CTRL_RTS:
1696 if (!ND_TTEST2(*p, CTRL_RTS_HDRLEN))
1697 return 0;
1698 if (!ndo->ndo_eflag)
1699 ND_PRINT((ndo, " TA:%s ",
1700 etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta)));
1701 break;
1702 case CTRL_CTS:
1703 if (!ND_TTEST2(*p, CTRL_CTS_HDRLEN))
1704 return 0;
1705 if (!ndo->ndo_eflag)
1706 ND_PRINT((ndo, " RA:%s ",
1707 etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra)));
1708 break;
1709 case CTRL_ACK:
1710 if (!ND_TTEST2(*p, CTRL_ACK_HDRLEN))
1711 return 0;
1712 if (!ndo->ndo_eflag)
1713 ND_PRINT((ndo, " RA:%s ",
1714 etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra)));
1715 break;
1716 case CTRL_CF_END:
1717 if (!ND_TTEST2(*p, CTRL_END_HDRLEN))
1718 return 0;
1719 if (!ndo->ndo_eflag)
1720 ND_PRINT((ndo, " RA:%s ",
1721 etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra)));
1722 break;
1723 case CTRL_END_ACK:
1724 if (!ND_TTEST2(*p, CTRL_END_ACK_HDRLEN))
1725 return 0;
1726 if (!ndo->ndo_eflag)
1727 ND_PRINT((ndo, " RA:%s ",
1728 etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra)));
1729 break;
1730 }
1731 return 1;
1732 }
1733
1734 /*
1735 * Data Frame - Address field contents
1736 *
1737 * To Ds | From DS | Addr 1 | Addr 2 | Addr 3 | Addr 4
1738 * 0 | 0 | DA | SA | BSSID | n/a
1739 * 0 | 1 | DA | BSSID | SA | n/a
1740 * 1 | 0 | BSSID | SA | DA | n/a
1741 * 1 | 1 | RA | TA | DA | SA
1742 */
1743
1744 /*
1745 * Function to get source and destination MAC addresses for a data frame.
1746 */
1747 static void
1748 get_data_src_dst_mac(uint16_t fc, const u_char *p, const uint8_t **srcp,
1749 const uint8_t **dstp)
1750 {
1751 #define ADDR1 (p + 4)
1752 #define ADDR2 (p + 10)
1753 #define ADDR3 (p + 16)
1754 #define ADDR4 (p + 24)
1755
1756 if (!FC_TO_DS(fc)) {
1757 if (!FC_FROM_DS(fc)) {
1758 /* not To DS and not From DS */
1759 *srcp = ADDR2;
1760 *dstp = ADDR1;
1761 } else {
1762 /* not To DS and From DS */
1763 *srcp = ADDR3;
1764 *dstp = ADDR1;
1765 }
1766 } else {
1767 if (!FC_FROM_DS(fc)) {
1768 /* From DS and not To DS */
1769 *srcp = ADDR2;
1770 *dstp = ADDR3;
1771 } else {
1772 /* To DS and From DS */
1773 *srcp = ADDR4;
1774 *dstp = ADDR3;
1775 }
1776 }
1777
1778 #undef ADDR1
1779 #undef ADDR2
1780 #undef ADDR3
1781 #undef ADDR4
1782 }
1783
1784 static void
1785 get_mgmt_src_dst_mac(const u_char *p, const uint8_t **srcp, const uint8_t **dstp)
1786 {
1787 const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
1788
1789 if (srcp != NULL)
1790 *srcp = hp->sa;
1791 if (dstp != NULL)
1792 *dstp = hp->da;
1793 }
1794
1795 /*
1796 * Print Header funcs
1797 */
1798
1799 static void
1800 data_header_print(netdissect_options *ndo, uint16_t fc, const u_char *p)
1801 {
1802 u_int subtype = FC_SUBTYPE(fc);
1803
1804 if (DATA_FRAME_IS_CF_ACK(subtype) || DATA_FRAME_IS_CF_POLL(subtype) ||
1805 DATA_FRAME_IS_QOS(subtype)) {
1806 ND_PRINT((ndo, "CF "));
1807 if (DATA_FRAME_IS_CF_ACK(subtype)) {
1808 if (DATA_FRAME_IS_CF_POLL(subtype))
1809 ND_PRINT((ndo, "Ack/Poll"));
1810 else
1811 ND_PRINT((ndo, "Ack"));
1812 } else {
1813 if (DATA_FRAME_IS_CF_POLL(subtype))
1814 ND_PRINT((ndo, "Poll"));
1815 }
1816 if (DATA_FRAME_IS_QOS(subtype))
1817 ND_PRINT((ndo, "+QoS"));
1818 ND_PRINT((ndo, " "));
1819 }
1820
1821 #define ADDR1 (p + 4)
1822 #define ADDR2 (p + 10)
1823 #define ADDR3 (p + 16)
1824 #define ADDR4 (p + 24)
1825
1826 if (!FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1827 ND_PRINT((ndo, "DA:%s SA:%s BSSID:%s ",
1828 etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1829 etheraddr_string(ndo, ADDR3)));
1830 } else if (!FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1831 ND_PRINT((ndo, "DA:%s BSSID:%s SA:%s ",
1832 etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1833 etheraddr_string(ndo, ADDR3)));
1834 } else if (FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1835 ND_PRINT((ndo, "BSSID:%s SA:%s DA:%s ",
1836 etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1837 etheraddr_string(ndo, ADDR3)));
1838 } else if (FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1839 ND_PRINT((ndo, "RA:%s TA:%s DA:%s SA:%s ",
1840 etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1841 etheraddr_string(ndo, ADDR3), etheraddr_string(ndo, ADDR4)));
1842 }
1843
1844 #undef ADDR1
1845 #undef ADDR2
1846 #undef ADDR3
1847 #undef ADDR4
1848 }
1849
1850 static void
1851 mgmt_header_print(netdissect_options *ndo, const u_char *p)
1852 {
1853 const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
1854
1855 ND_PRINT((ndo, "BSSID:%s DA:%s SA:%s ",
1856 etheraddr_string(ndo, (hp)->bssid), etheraddr_string(ndo, (hp)->da),
1857 etheraddr_string(ndo, (hp)->sa)));
1858 }
1859
1860 static void
1861 ctrl_header_print(netdissect_options *ndo, uint16_t fc, const u_char *p)
1862 {
1863 switch (FC_SUBTYPE(fc)) {
1864 case CTRL_BAR:
1865 ND_PRINT((ndo, " RA:%s TA:%s CTL(%x) SEQ(%u) ",
1866 etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
1867 etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
1868 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->ctl)),
1869 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->seq))));
1870 break;
1871 case CTRL_BA:
1872 ND_PRINT((ndo, "RA:%s ",
1873 etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra)));
1874 break;
1875 case CTRL_PS_POLL:
1876 ND_PRINT((ndo, "BSSID:%s TA:%s ",
1877 etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->bssid),
1878 etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->ta)));
1879 break;
1880 case CTRL_RTS:
1881 ND_PRINT((ndo, "RA:%s TA:%s ",
1882 etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ra),
1883 etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta)));
1884 break;
1885 case CTRL_CTS:
1886 ND_PRINT((ndo, "RA:%s ",
1887 etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra)));
1888 break;
1889 case CTRL_ACK:
1890 ND_PRINT((ndo, "RA:%s ",
1891 etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra)));
1892 break;
1893 case CTRL_CF_END:
1894 ND_PRINT((ndo, "RA:%s BSSID:%s ",
1895 etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra),
1896 etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->bssid)));
1897 break;
1898 case CTRL_END_ACK:
1899 ND_PRINT((ndo, "RA:%s BSSID:%s ",
1900 etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra),
1901 etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->bssid)));
1902 break;
1903 default:
1904 /* We shouldn't get here - we should already have quit */
1905 break;
1906 }
1907 }
1908
1909 static int
1910 extract_header_length(netdissect_options *ndo,
1911 uint16_t fc)
1912 {
1913 int len;
1914
1915 switch (FC_TYPE(fc)) {
1916 case T_MGMT:
1917 return MGMT_HDRLEN;
1918 case T_CTRL:
1919 switch (FC_SUBTYPE(fc)) {
1920 case CTRL_CONTROL_WRAPPER:
1921 return CTRL_CONTROL_WRAPPER_HDRLEN;
1922 case CTRL_BAR:
1923 return CTRL_BAR_HDRLEN;
1924 case CTRL_BA:
1925 return CTRL_BA_HDRLEN;
1926 case CTRL_PS_POLL:
1927 return CTRL_PS_POLL_HDRLEN;
1928 case CTRL_RTS:
1929 return CTRL_RTS_HDRLEN;
1930 case CTRL_CTS:
1931 return CTRL_CTS_HDRLEN;
1932 case CTRL_ACK:
1933 return CTRL_ACK_HDRLEN;
1934 case CTRL_CF_END:
1935 return CTRL_END_HDRLEN;
1936 case CTRL_END_ACK:
1937 return CTRL_END_ACK_HDRLEN;
1938 default:
1939 ND_PRINT((ndo, "unknown 802.11 ctrl frame subtype (%d)", FC_SUBTYPE(fc)));
1940 return 0;
1941 }
1942 case T_DATA:
1943 len = (FC_TO_DS(fc) && FC_FROM_DS(fc)) ? 30 : 24;
1944 if (DATA_FRAME_IS_QOS(FC_SUBTYPE(fc)))
1945 len += 2;
1946 return len;
1947 default:
1948 ND_PRINT((ndo, "unknown 802.11 frame type (%d)", FC_TYPE(fc)));
1949 return 0;
1950 }
1951 }
1952
1953 static int
1954 extract_mesh_header_length(const u_char *p)
1955 {
1956 return (p[0] &~ 3) ? 0 : 6*(1 + (p[0] & 3));
1957 }
1958
1959 /*
1960 * Print the 802.11 MAC header.
1961 */
1962 static void
1963 ieee_802_11_hdr_print(netdissect_options *ndo,
1964 uint16_t fc, const u_char *p, u_int hdrlen,
1965 u_int meshdrlen)
1966 {
1967 if (ndo->ndo_vflag) {
1968 if (FC_MORE_DATA(fc))
1969 ND_PRINT((ndo, "More Data "));
1970 if (FC_MORE_FLAG(fc))
1971 ND_PRINT((ndo, "More Fragments "));
1972 if (FC_POWER_MGMT(fc))
1973 ND_PRINT((ndo, "Pwr Mgmt "));
1974 if (FC_RETRY(fc))
1975 ND_PRINT((ndo, "Retry "));
1976 if (FC_ORDER(fc))
1977 ND_PRINT((ndo, "Strictly Ordered "));
1978 if (FC_PROTECTED(fc))
1979 ND_PRINT((ndo, "Protected "));
1980 if (FC_TYPE(fc) != T_CTRL || FC_SUBTYPE(fc) != CTRL_PS_POLL)
1981 ND_PRINT((ndo, "%dus ",
1982 EXTRACT_LE_16BITS(
1983 &((const struct mgmt_header_t *)p)->duration)));
1984 }
1985 if (meshdrlen != 0) {
1986 const struct meshcntl_t *mc =
1987 (const struct meshcntl_t *)&p[hdrlen - meshdrlen];
1988 int ae = mc->flags & 3;
1989
1990 ND_PRINT((ndo, "MeshData (AE %d TTL %u seq %u", ae, mc->ttl,
1991 EXTRACT_LE_32BITS(mc->seq)));
1992 if (ae > 0)
1993 ND_PRINT((ndo, " A4:%s", etheraddr_string(ndo, mc->addr4)));
1994 if (ae > 1)
1995 ND_PRINT((ndo, " A5:%s", etheraddr_string(ndo, mc->addr5)));
1996 if (ae > 2)
1997 ND_PRINT((ndo, " A6:%s", etheraddr_string(ndo, mc->addr6)));
1998 ND_PRINT((ndo, ") "));
1999 }
2000
2001 switch (FC_TYPE(fc)) {
2002 case T_MGMT:
2003 mgmt_header_print(ndo, p);
2004 break;
2005 case T_CTRL:
2006 ctrl_header_print(ndo, fc, p);
2007 break;
2008 case T_DATA:
2009 data_header_print(ndo, fc, p);
2010 break;
2011 default:
2012 break;
2013 }
2014 }
2015
2016 #ifndef roundup2
2017 #define roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
2018 #endif
2019
2020 static const char tstr[] = "[|802.11]";
2021
2022 static u_int
2023 ieee802_11_print(netdissect_options *ndo,
2024 const u_char *p, u_int length, u_int orig_caplen, int pad,
2025 u_int fcslen)
2026 {
2027 uint16_t fc;
2028 u_int caplen, hdrlen, meshdrlen;
2029 struct lladdr_info src, dst;
2030 int llc_hdrlen;
2031
2032 caplen = orig_caplen;
2033 /* Remove FCS, if present */
2034 if (length < fcslen) {
2035 ND_PRINT((ndo, "%s", tstr));
2036 return caplen;
2037 }
2038 length -= fcslen;
2039 if (caplen > length) {
2040 /* Amount of FCS in actual packet data, if any */
2041 fcslen = caplen - length;
2042 caplen -= fcslen;
2043 ndo->ndo_snapend -= fcslen;
2044 }
2045
2046 if (caplen < IEEE802_11_FC_LEN) {
2047 ND_PRINT((ndo, "%s", tstr));
2048 return orig_caplen;
2049 }
2050
2051 fc = EXTRACT_LE_16BITS(p);
2052 hdrlen = extract_header_length(ndo, fc);
2053 if (hdrlen == 0) {
2054 /* Unknown frame type or control frame subtype; quit. */
2055 return (0);
2056 }
2057 if (pad)
2058 hdrlen = roundup2(hdrlen, 4);
2059 if (ndo->ndo_Hflag && FC_TYPE(fc) == T_DATA &&
2060 DATA_FRAME_IS_QOS(FC_SUBTYPE(fc))) {
2061 if (caplen < hdrlen + 1) {
2062 ND_PRINT((ndo, "%s", tstr));
2063 return hdrlen;
2064 }
2065 meshdrlen = extract_mesh_header_length(p+hdrlen);
2066 hdrlen += meshdrlen;
2067 } else
2068 meshdrlen = 0;
2069
2070 if (caplen < hdrlen) {
2071 ND_PRINT((ndo, "%s", tstr));
2072 return hdrlen;
2073 }
2074
2075 if (ndo->ndo_eflag)
2076 ieee_802_11_hdr_print(ndo, fc, p, hdrlen, meshdrlen);
2077
2078 /*
2079 * Go past the 802.11 header.
2080 */
2081 length -= hdrlen;
2082 caplen -= hdrlen;
2083 p += hdrlen;
2084
2085 src.addr_string = etheraddr_string;
2086 dst.addr_string = etheraddr_string;
2087 switch (FC_TYPE(fc)) {
2088 case T_MGMT:
2089 get_mgmt_src_dst_mac(p - hdrlen, &src.addr, &dst.addr);
2090 if (!mgmt_body_print(ndo, fc, src.addr, p, length)) {
2091 ND_PRINT((ndo, "%s", tstr));
2092 return hdrlen;
2093 }
2094 break;
2095 case T_CTRL:
2096 if (!ctrl_body_print(ndo, fc, p - hdrlen)) {
2097 ND_PRINT((ndo, "%s", tstr));
2098 return hdrlen;
2099 }
2100 break;
2101 case T_DATA:
2102 if (DATA_FRAME_IS_NULL(FC_SUBTYPE(fc)))
2103 return hdrlen; /* no-data frame */
2104 /* There may be a problem w/ AP not having this bit set */
2105 if (FC_PROTECTED(fc)) {
2106 ND_PRINT((ndo, "Data"));
2107 if (!wep_print(ndo, p)) {
2108 ND_PRINT((ndo, "%s", tstr));
2109 return hdrlen;
2110 }
2111 } else {
2112 get_data_src_dst_mac(fc, p - hdrlen, &src.addr, &dst.addr);
2113 llc_hdrlen = llc_print(ndo, p, length, caplen, &src, &dst);
2114 if (llc_hdrlen < 0) {
2115 /*
2116 * Some kinds of LLC packet we cannot
2117 * handle intelligently
2118 */
2119 if (!ndo->ndo_suppress_default_print)
2120 ND_DEFAULTPRINT(p, caplen);
2121 llc_hdrlen = -llc_hdrlen;
2122 }
2123 hdrlen += llc_hdrlen;
2124 }
2125 break;
2126 default:
2127 /* We shouldn't get here - we should already have quit */
2128 break;
2129 }
2130
2131 return hdrlen;
2132 }
2133
2134 /*
2135 * This is the top level routine of the printer. 'p' points
2136 * to the 802.11 header of the packet, 'h->ts' is the timestamp,
2137 * 'h->len' is the length of the packet off the wire, and 'h->caplen'
2138 * is the number of bytes actually captured.
2139 */
2140 u_int
2141 ieee802_11_if_print(netdissect_options *ndo,
2142 const struct pcap_pkthdr *h, const u_char *p)
2143 {
2144 return ieee802_11_print(ndo, p, h->len, h->caplen, 0, 0);
2145 }
2146
2147
2148 /* $FreeBSD: src/sys/net80211/ieee80211_radiotap.h,v 1.5 2005/01/22 20:12:05 sam Exp $ */
2149 /* NetBSD: ieee802_11_radio.h,v 1.2 2006/02/26 03:04:03 dyoung Exp */
2150
2151 /*-
2152 * Copyright (c) 2003, 2004 David Young. All rights reserved.
2153 *
2154 * Redistribution and use in source and binary forms, with or without
2155 * modification, are permitted provided that the following conditions
2156 * are met:
2157 * 1. Redistributions of source code must retain the above copyright
2158 * notice, this list of conditions and the following disclaimer.
2159 * 2. Redistributions in binary form must reproduce the above copyright
2160 * notice, this list of conditions and the following disclaimer in the
2161 * documentation and/or other materials provided with the distribution.
2162 * 3. The name of David Young may not be used to endorse or promote
2163 * products derived from this software without specific prior
2164 * written permission.
2165 *
2166 * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
2167 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
2168 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
2169 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DAVID
2170 * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2171 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
2172 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2173 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2174 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2175 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2176 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
2177 * OF SUCH DAMAGE.
2178 */
2179
2180 /* A generic radio capture format is desirable. It must be
2181 * rigidly defined (e.g., units for fields should be given),
2182 * and easily extensible.
2183 *
2184 * The following is an extensible radio capture format. It is
2185 * based on a bitmap indicating which fields are present.
2186 *
2187 * I am trying to describe precisely what the application programmer
2188 * should expect in the following, and for that reason I tell the
2189 * units and origin of each measurement (where it applies), or else I
2190 * use sufficiently weaselly language ("is a monotonically nondecreasing
2191 * function of...") that I cannot set false expectations for lawyerly
2192 * readers.
2193 */
2194
2195 /*
2196 * The radio capture header precedes the 802.11 header.
2197 *
2198 * Note well: all radiotap fields are little-endian.
2199 */
2200 struct ieee80211_radiotap_header {
2201 uint8_t it_version; /* Version 0. Only increases
2202 * for drastic changes,
2203 * introduction of compatible
2204 * new fields does not count.
2205 */
2206 uint8_t it_pad;
2207 uint16_t it_len; /* length of the whole
2208 * header in bytes, including
2209 * it_version, it_pad,
2210 * it_len, and data fields.
2211 */
2212 uint32_t it_present; /* A bitmap telling which
2213 * fields are present. Set bit 31
2214 * (0x80000000) to extend the
2215 * bitmap by another 32 bits.
2216 * Additional extensions are made
2217 * by setting bit 31.
2218 */
2219 };
2220
2221 /* Name Data type Units
2222 * ---- --------- -----
2223 *
2224 * IEEE80211_RADIOTAP_TSFT uint64_t microseconds
2225 *
2226 * Value in microseconds of the MAC's 64-bit 802.11 Time
2227 * Synchronization Function timer when the first bit of the
2228 * MPDU arrived at the MAC. For received frames, only.
2229 *
2230 * IEEE80211_RADIOTAP_CHANNEL 2 x uint16_t MHz, bitmap
2231 *
2232 * Tx/Rx frequency in MHz, followed by flags (see below).
2233 * Note that IEEE80211_RADIOTAP_XCHANNEL must be used to
2234 * represent an HT channel as there is not enough room in
2235 * the flags word.
2236 *
2237 * IEEE80211_RADIOTAP_FHSS uint16_t see below
2238 *
2239 * For frequency-hopping radios, the hop set (first byte)
2240 * and pattern (second byte).
2241 *
2242 * IEEE80211_RADIOTAP_RATE uint8_t 500kb/s or index
2243 *
2244 * Tx/Rx data rate. If bit 0x80 is set then it represents an
2245 * an MCS index and not an IEEE rate.
2246 *
2247 * IEEE80211_RADIOTAP_DBM_ANTSIGNAL int8_t decibels from
2248 * one milliwatt (dBm)
2249 *
2250 * RF signal power at the antenna, decibel difference from
2251 * one milliwatt.
2252 *
2253 * IEEE80211_RADIOTAP_DBM_ANTNOISE int8_t decibels from
2254 * one milliwatt (dBm)
2255 *
2256 * RF noise power at the antenna, decibel difference from one
2257 * milliwatt.
2258 *
2259 * IEEE80211_RADIOTAP_DB_ANTSIGNAL uint8_t decibel (dB)
2260 *
2261 * RF signal power at the antenna, decibel difference from an
2262 * arbitrary, fixed reference.
2263 *
2264 * IEEE80211_RADIOTAP_DB_ANTNOISE uint8_t decibel (dB)
2265 *
2266 * RF noise power at the antenna, decibel difference from an
2267 * arbitrary, fixed reference point.
2268 *
2269 * IEEE80211_RADIOTAP_LOCK_QUALITY uint16_t unitless
2270 *
2271 * Quality of Barker code lock. Unitless. Monotonically
2272 * nondecreasing with "better" lock strength. Called "Signal
2273 * Quality" in datasheets. (Is there a standard way to measure
2274 * this?)
2275 *
2276 * IEEE80211_RADIOTAP_TX_ATTENUATION uint16_t unitless
2277 *
2278 * Transmit power expressed as unitless distance from max
2279 * power set at factory calibration. 0 is max power.
2280 * Monotonically nondecreasing with lower power levels.
2281 *
2282 * IEEE80211_RADIOTAP_DB_TX_ATTENUATION uint16_t decibels (dB)
2283 *
2284 * Transmit power expressed as decibel distance from max power
2285 * set at factory calibration. 0 is max power. Monotonically
2286 * nondecreasing with lower power levels.
2287 *
2288 * IEEE80211_RADIOTAP_DBM_TX_POWER int8_t decibels from
2289 * one milliwatt (dBm)
2290 *
2291 * Transmit power expressed as dBm (decibels from a 1 milliwatt
2292 * reference). This is the absolute power level measured at
2293 * the antenna port.
2294 *
2295 * IEEE80211_RADIOTAP_FLAGS uint8_t bitmap
2296 *
2297 * Properties of transmitted and received frames. See flags
2298 * defined below.
2299 *
2300 * IEEE80211_RADIOTAP_ANTENNA uint8_t antenna index
2301 *
2302 * Unitless indication of the Rx/Tx antenna for this packet.
2303 * The first antenna is antenna 0.
2304 *
2305 * IEEE80211_RADIOTAP_RX_FLAGS uint16_t bitmap
2306 *
2307 * Properties of received frames. See flags defined below.
2308 *
2309 * IEEE80211_RADIOTAP_XCHANNEL uint32_t bitmap
2310 * uint16_t MHz
2311 * uint8_t channel number
2312 * uint8_t .5 dBm
2313 *
2314 * Extended channel specification: flags (see below) followed by
2315 * frequency in MHz, the corresponding IEEE channel number, and
2316 * finally the maximum regulatory transmit power cap in .5 dBm
2317 * units. This property supersedes IEEE80211_RADIOTAP_CHANNEL
2318 * and only one of the two should be present.
2319 *
2320 * IEEE80211_RADIOTAP_MCS uint8_t known
2321 * uint8_t flags
2322 * uint8_t mcs
2323 *
2324 * Bitset indicating which fields have known values, followed
2325 * by bitset of flag values, followed by the MCS rate index as
2326 * in IEEE 802.11n.
2327 *
2328 *
2329 * IEEE80211_RADIOTAP_AMPDU_STATUS u32, u16, u8, u8 unitless
2330 *
2331 * Contains the AMPDU information for the subframe.
2332 *
2333 * IEEE80211_RADIOTAP_VHT u16, u8, u8, u8[4], u8, u8, u16
2334 *
2335 * Contains VHT information about this frame.
2336 *
2337 * IEEE80211_RADIOTAP_VENDOR_NAMESPACE
2338 * uint8_t OUI[3]
2339 * uint8_t subspace
2340 * uint16_t length
2341 *
2342 * The Vendor Namespace Field contains three sub-fields. The first
2343 * sub-field is 3 bytes long. It contains the vendor's IEEE 802
2344 * Organizationally Unique Identifier (OUI). The fourth byte is a
2345 * vendor-specific "namespace selector."
2346 *
2347 */
2348 enum ieee80211_radiotap_type {
2349 IEEE80211_RADIOTAP_TSFT = 0,
2350 IEEE80211_RADIOTAP_FLAGS = 1,
2351 IEEE80211_RADIOTAP_RATE = 2,
2352 IEEE80211_RADIOTAP_CHANNEL = 3,
2353 IEEE80211_RADIOTAP_FHSS = 4,
2354 IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
2355 IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
2356 IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
2357 IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
2358 IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
2359 IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
2360 IEEE80211_RADIOTAP_ANTENNA = 11,
2361 IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
2362 IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
2363 IEEE80211_RADIOTAP_RX_FLAGS = 14,
2364 /* NB: gap for netbsd definitions */
2365 IEEE80211_RADIOTAP_XCHANNEL = 18,
2366 IEEE80211_RADIOTAP_MCS = 19,
2367 IEEE80211_RADIOTAP_AMPDU_STATUS = 20,
2368 IEEE80211_RADIOTAP_VHT = 21,
2369 IEEE80211_RADIOTAP_NAMESPACE = 29,
2370 IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
2371 IEEE80211_RADIOTAP_EXT = 31
2372 };
2373
2374 /* channel attributes */
2375 #define IEEE80211_CHAN_TURBO 0x00010 /* Turbo channel */
2376 #define IEEE80211_CHAN_CCK 0x00020 /* CCK channel */
2377 #define IEEE80211_CHAN_OFDM 0x00040 /* OFDM channel */
2378 #define IEEE80211_CHAN_2GHZ 0x00080 /* 2 GHz spectrum channel. */
2379 #define IEEE80211_CHAN_5GHZ 0x00100 /* 5 GHz spectrum channel */
2380 #define IEEE80211_CHAN_PASSIVE 0x00200 /* Only passive scan allowed */
2381 #define IEEE80211_CHAN_DYN 0x00400 /* Dynamic CCK-OFDM channel */
2382 #define IEEE80211_CHAN_GFSK 0x00800 /* GFSK channel (FHSS PHY) */
2383 #define IEEE80211_CHAN_GSM 0x01000 /* 900 MHz spectrum channel */
2384 #define IEEE80211_CHAN_STURBO 0x02000 /* 11a static turbo channel only */
2385 #define IEEE80211_CHAN_HALF 0x04000 /* Half rate channel */
2386 #define IEEE80211_CHAN_QUARTER 0x08000 /* Quarter rate channel */
2387 #define IEEE80211_CHAN_HT20 0x10000 /* HT 20 channel */
2388 #define IEEE80211_CHAN_HT40U 0x20000 /* HT 40 channel w/ ext above */
2389 #define IEEE80211_CHAN_HT40D 0x40000 /* HT 40 channel w/ ext below */
2390
2391 /* Useful combinations of channel characteristics, borrowed from Ethereal */
2392 #define IEEE80211_CHAN_A \
2393 (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM)
2394 #define IEEE80211_CHAN_B \
2395 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK)
2396 #define IEEE80211_CHAN_G \
2397 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN)
2398 #define IEEE80211_CHAN_TA \
2399 (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM | IEEE80211_CHAN_TURBO)
2400 #define IEEE80211_CHAN_TG \
2401 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN | IEEE80211_CHAN_TURBO)
2402
2403
2404 /* For IEEE80211_RADIOTAP_FLAGS */
2405 #define IEEE80211_RADIOTAP_F_CFP 0x01 /* sent/received
2406 * during CFP
2407 */
2408 #define IEEE80211_RADIOTAP_F_SHORTPRE 0x02 /* sent/received
2409 * with short
2410 * preamble
2411 */
2412 #define IEEE80211_RADIOTAP_F_WEP 0x04 /* sent/received
2413 * with WEP encryption
2414 */
2415 #define IEEE80211_RADIOTAP_F_FRAG 0x08 /* sent/received
2416 * with fragmentation
2417 */
2418 #define IEEE80211_RADIOTAP_F_FCS 0x10 /* frame includes FCS */
2419 #define IEEE80211_RADIOTAP_F_DATAPAD 0x20 /* frame has padding between
2420 * 802.11 header and payload
2421 * (to 32-bit boundary)
2422 */
2423 #define IEEE80211_RADIOTAP_F_BADFCS 0x40 /* does not pass FCS check */
2424
2425 /* For IEEE80211_RADIOTAP_RX_FLAGS */
2426 #define IEEE80211_RADIOTAP_F_RX_BADFCS 0x0001 /* frame failed crc check */
2427 #define IEEE80211_RADIOTAP_F_RX_PLCP_CRC 0x0002 /* frame failed PLCP CRC check */
2428
2429 /* For IEEE80211_RADIOTAP_MCS known */
2430 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN 0x01
2431 #define IEEE80211_RADIOTAP_MCS_MCS_INDEX_KNOWN 0x02 /* MCS index field */
2432 #define IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN 0x04
2433 #define IEEE80211_RADIOTAP_MCS_HT_FORMAT_KNOWN 0x08
2434 #define IEEE80211_RADIOTAP_MCS_FEC_TYPE_KNOWN 0x10
2435 #define IEEE80211_RADIOTAP_MCS_STBC_KNOWN 0x20
2436 #define IEEE80211_RADIOTAP_MCS_NESS_KNOWN 0x40
2437 #define IEEE80211_RADIOTAP_MCS_NESS_BIT_1 0x80
2438
2439 /* For IEEE80211_RADIOTAP_MCS flags */
2440 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK 0x03
2441 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20 0
2442 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_40 1
2443 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20L 2
2444 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20U 3
2445 #define IEEE80211_RADIOTAP_MCS_SHORT_GI 0x04 /* short guard interval */
2446 #define IEEE80211_RADIOTAP_MCS_HT_GREENFIELD 0x08
2447 #define IEEE80211_RADIOTAP_MCS_FEC_LDPC 0x10
2448 #define IEEE80211_RADIOTAP_MCS_STBC_MASK 0x60
2449 #define IEEE80211_RADIOTAP_MCS_STBC_1 1
2450 #define IEEE80211_RADIOTAP_MCS_STBC_2 2
2451 #define IEEE80211_RADIOTAP_MCS_STBC_3 3
2452 #define IEEE80211_RADIOTAP_MCS_STBC_SHIFT 5
2453 #define IEEE80211_RADIOTAP_MCS_NESS_BIT_0 0x80
2454
2455 /* For IEEE80211_RADIOTAP_AMPDU_STATUS */
2456 #define IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN 0x0001
2457 #define IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN 0x0002
2458 #define IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN 0x0004
2459 #define IEEE80211_RADIOTAP_AMPDU_IS_LAST 0x0008
2460 #define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR 0x0010
2461 #define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN 0x0020
2462
2463 /* For IEEE80211_RADIOTAP_VHT known */
2464 #define IEEE80211_RADIOTAP_VHT_STBC_KNOWN 0x0001
2465 #define IEEE80211_RADIOTAP_VHT_TXOP_PS_NA_KNOWN 0x0002
2466 #define IEEE80211_RADIOTAP_VHT_GUARD_INTERVAL_KNOWN 0x0004
2467 #define IEEE80211_RADIOTAP_VHT_SGI_NSYM_DIS_KNOWN 0x0008
2468 #define IEEE80211_RADIOTAP_VHT_LDPC_EXTRA_OFDM_SYM_KNOWN 0x0010
2469 #define IEEE80211_RADIOTAP_VHT_BEAMFORMED_KNOWN 0x0020
2470 #define IEEE80211_RADIOTAP_VHT_BANDWIDTH_KNOWN 0x0040
2471 #define IEEE80211_RADIOTAP_VHT_GROUP_ID_KNOWN 0x0080
2472 #define IEEE80211_RADIOTAP_VHT_PARTIAL_AID_KNOWN 0x0100
2473
2474 /* For IEEE80211_RADIOTAP_VHT flags */
2475 #define IEEE80211_RADIOTAP_VHT_STBC 0x01
2476 #define IEEE80211_RADIOTAP_VHT_TXOP_PS_NA 0x02
2477 #define IEEE80211_RADIOTAP_VHT_SHORT_GI 0x04
2478 #define IEEE80211_RADIOTAP_VHT_SGI_NSYM_M10_9 0x08
2479 #define IEEE80211_RADIOTAP_VHT_LDPC_EXTRA_OFDM_SYM 0x10
2480 #define IEEE80211_RADIOTAP_VHT_BEAMFORMED 0x20
2481
2482 #define IEEE80211_RADIOTAP_VHT_BANDWIDTH_MASK 0x1f
2483
2484 #define IEEE80211_RADIOTAP_VHT_NSS_MASK 0x0f
2485 #define IEEE80211_RADIOTAP_VHT_MCS_MASK 0xf0
2486 #define IEEE80211_RADIOTAP_VHT_MCS_SHIFT 4
2487
2488 #define IEEE80211_RADIOTAP_CODING_LDPC_USERn 0x01
2489
2490 #define IEEE80211_CHAN_FHSS \
2491 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_GFSK)
2492 #define IEEE80211_CHAN_A \
2493 (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM)
2494 #define IEEE80211_CHAN_B \
2495 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK)
2496 #define IEEE80211_CHAN_PUREG \
2497 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_OFDM)
2498 #define IEEE80211_CHAN_G \
2499 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN)
2500
2501 #define IS_CHAN_FHSS(flags) \
2502 ((flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS)
2503 #define IS_CHAN_A(flags) \
2504 ((flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A)
2505 #define IS_CHAN_B(flags) \
2506 ((flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B)
2507 #define IS_CHAN_PUREG(flags) \
2508 ((flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG)
2509 #define IS_CHAN_G(flags) \
2510 ((flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G)
2511 #define IS_CHAN_ANYG(flags) \
2512 (IS_CHAN_PUREG(flags) || IS_CHAN_G(flags))
2513
2514 static void
2515 print_chaninfo(netdissect_options *ndo,
2516 uint16_t freq, int flags, int presentflags)
2517 {
2518 ND_PRINT((ndo, "%u MHz", freq));
2519 if (presentflags & (1 << IEEE80211_RADIOTAP_MCS)) {
2520 /*
2521 * We have the MCS field, so this is 11n, regardless
2522 * of what the channel flags say.
2523 */
2524 ND_PRINT((ndo, " 11n"));
2525 } else {
2526 if (IS_CHAN_FHSS(flags))
2527 ND_PRINT((ndo, " FHSS"));
2528 if (IS_CHAN_A(flags)) {
2529 if (flags & IEEE80211_CHAN_HALF)
2530 ND_PRINT((ndo, " 11a/10Mhz"));
2531 else if (flags & IEEE80211_CHAN_QUARTER)
2532 ND_PRINT((ndo, " 11a/5Mhz"));
2533 else
2534 ND_PRINT((ndo, " 11a"));
2535 }
2536 if (IS_CHAN_ANYG(flags)) {
2537 if (flags & IEEE80211_CHAN_HALF)
2538 ND_PRINT((ndo, " 11g/10Mhz"));
2539 else if (flags & IEEE80211_CHAN_QUARTER)
2540 ND_PRINT((ndo, " 11g/5Mhz"));
2541 else
2542 ND_PRINT((ndo, " 11g"));
2543 } else if (IS_CHAN_B(flags))
2544 ND_PRINT((ndo, " 11b"));
2545 if (flags & IEEE80211_CHAN_TURBO)
2546 ND_PRINT((ndo, " Turbo"));
2547 }
2548 /*
2549 * These apply to 11n.
2550 */
2551 if (flags & IEEE80211_CHAN_HT20)
2552 ND_PRINT((ndo, " ht/20"));
2553 else if (flags & IEEE80211_CHAN_HT40D)
2554 ND_PRINT((ndo, " ht/40-"));
2555 else if (flags & IEEE80211_CHAN_HT40U)
2556 ND_PRINT((ndo, " ht/40+"));
2557 ND_PRINT((ndo, " "));
2558 }
2559
2560 static int
2561 print_radiotap_field(netdissect_options *ndo,
2562 struct cpack_state *s, uint32_t bit, uint8_t *flagsp,
2563 uint32_t presentflags)
2564 {
2565 u_int i;
2566 int rc;
2567
2568 switch (bit) {
2569
2570 case IEEE80211_RADIOTAP_TSFT: {
2571 uint64_t tsft;
2572
2573 rc = cpack_uint64(s, &tsft);
2574 if (rc != 0)
2575 goto trunc;
2576 ND_PRINT((ndo, "%" PRIu64 "us tsft ", tsft));
2577 break;
2578 }
2579
2580 case IEEE80211_RADIOTAP_FLAGS: {
2581 uint8_t flagsval;
2582
2583 rc = cpack_uint8(s, &flagsval);
2584 if (rc != 0)
2585 goto trunc;
2586 *flagsp = flagsval;
2587 if (flagsval & IEEE80211_RADIOTAP_F_CFP)
2588 ND_PRINT((ndo, "cfp "));
2589 if (flagsval & IEEE80211_RADIOTAP_F_SHORTPRE)
2590 ND_PRINT((ndo, "short preamble "));
2591 if (flagsval & IEEE80211_RADIOTAP_F_WEP)
2592 ND_PRINT((ndo, "wep "));
2593 if (flagsval & IEEE80211_RADIOTAP_F_FRAG)
2594 ND_PRINT((ndo, "fragmented "));
2595 if (flagsval & IEEE80211_RADIOTAP_F_BADFCS)
2596 ND_PRINT((ndo, "bad-fcs "));
2597 break;
2598 }
2599
2600 case IEEE80211_RADIOTAP_RATE: {
2601 uint8_t rate;
2602
2603 rc = cpack_uint8(s, &rate);
2604 if (rc != 0)
2605 goto trunc;
2606 /*
2607 * XXX On FreeBSD rate & 0x80 means we have an MCS. On
2608 * Linux and AirPcap it does not. (What about
2609 * Mac OS X, NetBSD, OpenBSD, and DragonFly BSD?)
2610 *
2611 * This is an issue either for proprietary extensions
2612 * to 11a or 11g, which do exist, or for 11n
2613 * implementations that stuff a rate value into
2614 * this field, which also appear to exist.
2615 *
2616 * We currently handle that by assuming that
2617 * if the 0x80 bit is set *and* the remaining
2618 * bits have a value between 0 and 15 it's
2619 * an MCS value, otherwise it's a rate. If
2620 * there are cases where systems that use
2621 * "0x80 + MCS index" for MCS indices > 15,
2622 * or stuff a rate value here between 64 and
2623 * 71.5 Mb/s in here, we'll need a preference
2624 * setting. Such rates do exist, e.g. 11n
2625 * MCS 7 at 20 MHz with a long guard interval.
2626 */
2627 if (rate >= 0x80 && rate <= 0x8f) {
2628 /*
2629 * XXX - we don't know the channel width
2630 * or guard interval length, so we can't
2631 * convert this to a data rate.
2632 *
2633 * If you want us to show a data rate,
2634 * use the MCS field, not the Rate field;
2635 * the MCS field includes not only the
2636 * MCS index, it also includes bandwidth
2637 * and guard interval information.
2638 *
2639 * XXX - can we get the channel width
2640 * from XChannel and the guard interval
2641 * information from Flags, at least on
2642 * FreeBSD?
2643 */
2644 ND_PRINT((ndo, "MCS %u ", rate & 0x7f));
2645 } else
2646 ND_PRINT((ndo, "%2.1f Mb/s ", .5 * rate));
2647 break;
2648 }
2649
2650 case IEEE80211_RADIOTAP_CHANNEL: {
2651 uint16_t frequency;
2652 uint16_t flags;
2653
2654 rc = cpack_uint16(s, &frequency);
2655 if (rc != 0)
2656 goto trunc;
2657 rc = cpack_uint16(s, &flags);
2658 if (rc != 0)
2659 goto trunc;
2660 /*
2661 * If CHANNEL and XCHANNEL are both present, skip
2662 * CHANNEL.
2663 */
2664 if (presentflags & (1 << IEEE80211_RADIOTAP_XCHANNEL))
2665 break;
2666 print_chaninfo(ndo, frequency, flags, presentflags);
2667 break;
2668 }
2669
2670 case IEEE80211_RADIOTAP_FHSS: {
2671 uint8_t hopset;
2672 uint8_t hoppat;
2673
2674 rc = cpack_uint8(s, &hopset);
2675 if (rc != 0)
2676 goto trunc;
2677 rc = cpack_uint8(s, &hoppat);
2678 if (rc != 0)
2679 goto trunc;
2680 ND_PRINT((ndo, "fhset %d fhpat %d ", hopset, hoppat));
2681 break;
2682 }
2683
2684 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: {
2685 int8_t dbm_antsignal;
2686
2687 rc = cpack_int8(s, &dbm_antsignal);
2688 if (rc != 0)
2689 goto trunc;
2690 ND_PRINT((ndo, "%ddBm signal ", dbm_antsignal));
2691 break;
2692 }
2693
2694 case IEEE80211_RADIOTAP_DBM_ANTNOISE: {
2695 int8_t dbm_antnoise;
2696
2697 rc = cpack_int8(s, &dbm_antnoise);
2698 if (rc != 0)
2699 goto trunc;
2700 ND_PRINT((ndo, "%ddBm noise ", dbm_antnoise));
2701 break;
2702 }
2703
2704 case IEEE80211_RADIOTAP_LOCK_QUALITY: {
2705 uint16_t lock_quality;
2706
2707 rc = cpack_uint16(s, &lock_quality);
2708 if (rc != 0)
2709 goto trunc;
2710 ND_PRINT((ndo, "%u sq ", lock_quality));
2711 break;
2712 }
2713
2714 case IEEE80211_RADIOTAP_TX_ATTENUATION: {
2715 uint16_t tx_attenuation;
2716
2717 rc = cpack_uint16(s, &tx_attenuation);
2718 if (rc != 0)
2719 goto trunc;
2720 ND_PRINT((ndo, "%d tx power ", -(int)tx_attenuation));
2721 break;
2722 }
2723
2724 case IEEE80211_RADIOTAP_DB_TX_ATTENUATION: {
2725 uint8_t db_tx_attenuation;
2726
2727 rc = cpack_uint8(s, &db_tx_attenuation);
2728 if (rc != 0)
2729 goto trunc;
2730 ND_PRINT((ndo, "%ddB tx attenuation ", -(int)db_tx_attenuation));
2731 break;
2732 }
2733
2734 case IEEE80211_RADIOTAP_DBM_TX_POWER: {
2735 int8_t dbm_tx_power;
2736
2737 rc = cpack_int8(s, &dbm_tx_power);
2738 if (rc != 0)
2739 goto trunc;
2740 ND_PRINT((ndo, "%ddBm tx power ", dbm_tx_power));
2741 break;
2742 }
2743
2744 case IEEE80211_RADIOTAP_ANTENNA: {
2745 uint8_t antenna;
2746
2747 rc = cpack_uint8(s, &antenna);
2748 if (rc != 0)
2749 goto trunc;
2750 ND_PRINT((ndo, "antenna %u ", antenna));
2751 break;
2752 }
2753
2754 case IEEE80211_RADIOTAP_DB_ANTSIGNAL: {
2755 uint8_t db_antsignal;
2756
2757 rc = cpack_uint8(s, &db_antsignal);
2758 if (rc != 0)
2759 goto trunc;
2760 ND_PRINT((ndo, "%ddB signal ", db_antsignal));
2761 break;
2762 }
2763
2764 case IEEE80211_RADIOTAP_DB_ANTNOISE: {
2765 uint8_t db_antnoise;
2766
2767 rc = cpack_uint8(s, &db_antnoise);
2768 if (rc != 0)
2769 goto trunc;
2770 ND_PRINT((ndo, "%ddB noise ", db_antnoise));
2771 break;
2772 }
2773
2774 case IEEE80211_RADIOTAP_RX_FLAGS: {
2775 uint16_t rx_flags;
2776
2777 rc = cpack_uint16(s, &rx_flags);
2778 if (rc != 0)
2779 goto trunc;
2780 /* Do nothing for now */
2781 break;
2782 }
2783
2784 case IEEE80211_RADIOTAP_XCHANNEL: {
2785 uint32_t flags;
2786 uint16_t frequency;
2787 uint8_t channel;
2788 uint8_t maxpower;
2789
2790 rc = cpack_uint32(s, &flags);
2791 if (rc != 0)
2792 goto trunc;
2793 rc = cpack_uint16(s, &frequency);
2794 if (rc != 0)
2795 goto trunc;
2796 rc = cpack_uint8(s, &channel);
2797 if (rc != 0)
2798 goto trunc;
2799 rc = cpack_uint8(s, &maxpower);
2800 if (rc != 0)
2801 goto trunc;
2802 print_chaninfo(ndo, frequency, flags, presentflags);
2803 break;
2804 }
2805
2806 case IEEE80211_RADIOTAP_MCS: {
2807 uint8_t known;
2808 uint8_t flags;
2809 uint8_t mcs_index;
2810 static const char *ht_bandwidth[4] = {
2811 "20 MHz",
2812 "40 MHz",
2813 "20 MHz (L)",
2814 "20 MHz (U)"
2815 };
2816 float htrate;
2817
2818 rc = cpack_uint8(s, &known);
2819 if (rc != 0)
2820 goto trunc;
2821 rc = cpack_uint8(s, &flags);
2822 if (rc != 0)
2823 goto trunc;
2824 rc = cpack_uint8(s, &mcs_index);
2825 if (rc != 0)
2826 goto trunc;
2827 if (known & IEEE80211_RADIOTAP_MCS_MCS_INDEX_KNOWN) {
2828 /*
2829 * We know the MCS index.
2830 */
2831 if (mcs_index <= MAX_MCS_INDEX) {
2832 /*
2833 * And it's in-range.
2834 */
2835 if (known & (IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN|IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN)) {
2836 /*
2837 * And we know both the bandwidth and
2838 * the guard interval, so we can look
2839 * up the rate.
2840 */
2841 htrate =
2842 ieee80211_float_htrates \
2843 [mcs_index] \
2844 [((flags & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK) == IEEE80211_RADIOTAP_MCS_BANDWIDTH_40 ? 1 : 0)] \
2845 [((flags & IEEE80211_RADIOTAP_MCS_SHORT_GI) ? 1 : 0)];
2846 } else {
2847 /*
2848 * We don't know both the bandwidth
2849 * and the guard interval, so we can
2850 * only report the MCS index.
2851 */
2852 htrate = 0.0;
2853 }
2854 } else {
2855 /*
2856 * The MCS value is out of range.
2857 */
2858 htrate = 0.0;
2859 }
2860 if (htrate != 0.0) {
2861 /*
2862 * We have the rate.
2863 * Print it.
2864 */
2865 ND_PRINT((ndo, "%.1f Mb/s MCS %u ", htrate, mcs_index));
2866 } else {
2867 /*
2868 * We at least have the MCS index.
2869 * Print it.
2870 */
2871 ND_PRINT((ndo, "MCS %u ", mcs_index));
2872 }
2873 }
2874 if (known & IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN) {
2875 ND_PRINT((ndo, "%s ",
2876 ht_bandwidth[flags & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK]));
2877 }
2878 if (known & IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN) {
2879 ND_PRINT((ndo, "%s GI ",
2880 (flags & IEEE80211_RADIOTAP_MCS_SHORT_GI) ?
2881 "short" : "long"));
2882 }
2883 if (known & IEEE80211_RADIOTAP_MCS_HT_FORMAT_KNOWN) {
2884 ND_PRINT((ndo, "%s ",
2885 (flags & IEEE80211_RADIOTAP_MCS_HT_GREENFIELD) ?
2886 "greenfield" : "mixed"));
2887 }
2888 if (known & IEEE80211_RADIOTAP_MCS_FEC_TYPE_KNOWN) {
2889 ND_PRINT((ndo, "%s FEC ",
2890 (flags & IEEE80211_RADIOTAP_MCS_FEC_LDPC) ?
2891 "LDPC" : "BCC"));
2892 }
2893 if (known & IEEE80211_RADIOTAP_MCS_STBC_KNOWN) {
2894 ND_PRINT((ndo, "RX-STBC%u ",
2895 (flags & IEEE80211_RADIOTAP_MCS_STBC_MASK) >> IEEE80211_RADIOTAP_MCS_STBC_SHIFT));
2896 }
2897 break;
2898 }
2899
2900 case IEEE80211_RADIOTAP_AMPDU_STATUS: {
2901 uint32_t reference_num;
2902 uint16_t flags;
2903 uint8_t delim_crc;
2904 uint8_t reserved;
2905
2906 rc = cpack_uint32(s, &reference_num);
2907 if (rc != 0)
2908 goto trunc;
2909 rc = cpack_uint16(s, &flags);
2910 if (rc != 0)
2911 goto trunc;
2912 rc = cpack_uint8(s, &delim_crc);
2913 if (rc != 0)
2914 goto trunc;
2915 rc = cpack_uint8(s, &reserved);
2916 if (rc != 0)
2917 goto trunc;
2918 /* Do nothing for now */
2919 break;
2920 }
2921
2922 case IEEE80211_RADIOTAP_VHT: {
2923 uint16_t known;
2924 uint8_t flags;
2925 uint8_t bandwidth;
2926 uint8_t mcs_nss[4];
2927 uint8_t coding;
2928 uint8_t group_id;
2929 uint16_t partial_aid;
2930 static const char *vht_bandwidth[32] = {
2931 "20 MHz",
2932 "40 MHz",
2933 "20 MHz (L)",
2934 "20 MHz (U)",
2935 "80 MHz",
2936 "80 MHz (L)",
2937 "80 MHz (U)",
2938 "80 MHz (LL)",
2939 "80 MHz (LU)",
2940 "80 MHz (UL)",
2941 "80 MHz (UU)",
2942 "160 MHz",
2943 "160 MHz (L)",
2944 "160 MHz (U)",
2945 "160 MHz (LL)",
2946 "160 MHz (LU)",
2947 "160 MHz (UL)",
2948 "160 MHz (UU)",
2949 "160 MHz (LLL)",
2950 "160 MHz (LLU)",
2951 "160 MHz (LUL)",
2952 "160 MHz (UUU)",
2953 "160 MHz (ULL)",
2954 "160 MHz (ULU)",
2955 "160 MHz (UUL)",
2956 "160 MHz (UUU)",
2957 "unknown (26)",
2958 "unknown (27)",
2959 "unknown (28)",
2960 "unknown (29)",
2961 "unknown (30)",
2962 "unknown (31)"
2963 };
2964
2965 rc = cpack_uint16(s, &known);
2966 if (rc != 0)
2967 goto trunc;
2968 rc = cpack_uint8(s, &flags);
2969 if (rc != 0)
2970 goto trunc;
2971 rc = cpack_uint8(s, &bandwidth);
2972 if (rc != 0)
2973 goto trunc;
2974 for (i = 0; i < 4; i++) {
2975 rc = cpack_uint8(s, &mcs_nss[i]);
2976 if (rc != 0)
2977 goto trunc;
2978 }
2979 rc = cpack_uint8(s, &coding);
2980 if (rc != 0)
2981 goto trunc;
2982 rc = cpack_uint8(s, &group_id);
2983 if (rc != 0)
2984 goto trunc;
2985 rc = cpack_uint16(s, &partial_aid);
2986 if (rc != 0)
2987 goto trunc;
2988 for (i = 0; i < 4; i++) {
2989 u_int nss, mcs;
2990 nss = mcs_nss[i] & IEEE80211_RADIOTAP_VHT_NSS_MASK;
2991 mcs = (mcs_nss[i] & IEEE80211_RADIOTAP_VHT_MCS_MASK) >> IEEE80211_RADIOTAP_VHT_MCS_SHIFT;
2992
2993 if (nss == 0)
2994 continue;
2995
2996 ND_PRINT((ndo, "User %u MCS %u ", i, mcs));
2997 ND_PRINT((ndo, "%s FEC ",
2998 (coding & (IEEE80211_RADIOTAP_CODING_LDPC_USERn << i)) ?
2999 "LDPC" : "BCC"));
3000 }
3001 if (known & IEEE80211_RADIOTAP_VHT_BANDWIDTH_KNOWN) {
3002 ND_PRINT((ndo, "%s ",
3003 vht_bandwidth[bandwidth & IEEE80211_RADIOTAP_VHT_BANDWIDTH_MASK]));
3004 }
3005 if (known & IEEE80211_RADIOTAP_VHT_GUARD_INTERVAL_KNOWN) {
3006 ND_PRINT((ndo, "%s GI ",
3007 (flags & IEEE80211_RADIOTAP_VHT_SHORT_GI) ?
3008 "short" : "long"));
3009 }
3010 break;
3011 }
3012
3013 default:
3014 /* this bit indicates a field whose
3015 * size we do not know, so we cannot
3016 * proceed. Just print the bit number.
3017 */
3018 ND_PRINT((ndo, "[bit %u] ", bit));
3019 return -1;
3020 }
3021
3022 return 0;
3023
3024 trunc:
3025 ND_PRINT((ndo, "%s", tstr));
3026 return rc;
3027 }
3028
3029
3030 static int
3031 print_in_radiotap_namespace(netdissect_options *ndo,
3032 struct cpack_state *s, uint8_t *flags,
3033 uint32_t presentflags, int bit0)
3034 {
3035 #define BITNO_32(x) (((x) >> 16) ? 16 + BITNO_16((x) >> 16) : BITNO_16((x)))
3036 #define BITNO_16(x) (((x) >> 8) ? 8 + BITNO_8((x) >> 8) : BITNO_8((x)))
3037 #define BITNO_8(x) (((x) >> 4) ? 4 + BITNO_4((x) >> 4) : BITNO_4((x)))
3038 #define BITNO_4(x) (((x) >> 2) ? 2 + BITNO_2((x) >> 2) : BITNO_2((x)))
3039 #define BITNO_2(x) (((x) & 2) ? 1 : 0)
3040 uint32_t present, next_present;
3041 int bitno;
3042 enum ieee80211_radiotap_type bit;
3043 int rc;
3044
3045 for (present = presentflags; present; present = next_present) {
3046 /*
3047 * Clear the least significant bit that is set.
3048 */
3049 next_present = present & (present - 1);
3050
3051 /*
3052 * Get the bit number, within this presence word,
3053 * of the remaining least significant bit that
3054 * is set.
3055 */
3056 bitno = BITNO_32(present ^ next_present);
3057
3058 /*
3059 * Stop if this is one of the "same meaning
3060 * in all presence flags" bits.
3061 */
3062 if (bitno >= IEEE80211_RADIOTAP_NAMESPACE)
3063 break;
3064
3065 /*
3066 * Get the radiotap bit number of that bit.
3067 */
3068 bit = (enum ieee80211_radiotap_type)(bit0 + bitno);
3069
3070 rc = print_radiotap_field(ndo, s, bit, flags, presentflags);
3071 if (rc != 0)
3072 return rc;
3073 }
3074
3075 return 0;
3076 }
3077
3078 u_int
3079 ieee802_11_radio_print(netdissect_options *ndo,
3080 const u_char *p, u_int length, u_int caplen)
3081 {
3082 #define BIT(n) (1U << n)
3083 #define IS_EXTENDED(__p) \
3084 (EXTRACT_LE_32BITS(__p) & BIT(IEEE80211_RADIOTAP_EXT)) != 0
3085
3086 struct cpack_state cpacker;
3087 const struct ieee80211_radiotap_header *hdr;
3088 uint32_t presentflags;
3089 const uint32_t *presentp, *last_presentp;
3090 int vendor_namespace;
3091 uint8_t vendor_oui[3];
3092 uint8_t vendor_subnamespace;
3093 uint16_t skip_length;
3094 int bit0;
3095 u_int len;
3096 uint8_t flags;
3097 int pad;
3098 u_int fcslen;
3099
3100 if (caplen < sizeof(*hdr)) {
3101 ND_PRINT((ndo, "%s", tstr));
3102 return caplen;
3103 }
3104
3105 hdr = (const struct ieee80211_radiotap_header *)p;
3106
3107 len = EXTRACT_LE_16BITS(&hdr->it_len);
3108 if (len < sizeof(*hdr)) {
3109 /*
3110 * The length is the length of the entire header, so
3111 * it must be as large as the fixed-length part of
3112 * the header.
3113 */
3114 ND_PRINT((ndo, "%s", tstr));
3115 return caplen;
3116 }
3117
3118 /*
3119 * If we don't have the entire radiotap header, just give up.
3120 */
3121 if (caplen < len) {
3122 ND_PRINT((ndo, "%s", tstr));
3123 return caplen;
3124 }
3125 cpack_init(&cpacker, (const uint8_t *)hdr, len); /* align against header start */
3126 cpack_advance(&cpacker, sizeof(*hdr)); /* includes the 1st bitmap */
3127 for (last_presentp = &hdr->it_present;
3128 (const u_char*)(last_presentp + 1) <= p + len &&
3129 IS_EXTENDED(last_presentp);
3130 last_presentp++)
3131 cpack_advance(&cpacker, sizeof(hdr->it_present)); /* more bitmaps */
3132
3133 /* are there more bitmap extensions than bytes in header? */
3134 if ((const u_char*)(last_presentp + 1) > p + len) {
3135 ND_PRINT((ndo, "%s", tstr));
3136 return caplen;
3137 }
3138
3139 /*
3140 * Start out at the beginning of the default radiotap namespace.
3141 */
3142 bit0 = 0;
3143 vendor_namespace = 0;
3144 memset(vendor_oui, 0, 3);
3145 vendor_subnamespace = 0;
3146 skip_length = 0;
3147 /* Assume no flags */
3148 flags = 0;
3149 /* Assume no Atheros padding between 802.11 header and body */
3150 pad = 0;
3151 /* Assume no FCS at end of frame */
3152 fcslen = 0;
3153 for (presentp = &hdr->it_present; presentp <= last_presentp;
3154 presentp++) {
3155 presentflags = EXTRACT_LE_32BITS(presentp);
3156
3157 /*
3158 * If this is a vendor namespace, we don't handle it.
3159 */
3160 if (vendor_namespace) {
3161 /*
3162 * Skip past the stuff we don't understand.
3163 * If we add support for any vendor namespaces,
3164 * it'd be added here; use vendor_oui and
3165 * vendor_subnamespace to interpret the fields.
3166 */
3167 if (cpack_advance(&cpacker, skip_length) != 0) {
3168 /*
3169 * Ran out of space in the packet.
3170 */
3171 break;
3172 }
3173
3174 /*
3175 * We've skipped it all; nothing more to
3176 * skip.
3177 */
3178 skip_length = 0;
3179 } else {
3180 if (print_in_radiotap_namespace(ndo, &cpacker,
3181 &flags, presentflags, bit0) != 0) {
3182 /*
3183 * Fatal error - can't process anything
3184 * more in the radiotap header.
3185 */
3186 break;
3187 }
3188 }
3189
3190 /*
3191 * Handle the namespace switch bits; we've already handled
3192 * the extension bit in all but the last word above.
3193 */
3194 switch (presentflags &
3195 (BIT(IEEE80211_RADIOTAP_NAMESPACE)|BIT(IEEE80211_RADIOTAP_VENDOR_NAMESPACE))) {
3196
3197 case 0:
3198 /*
3199 * We're not changing namespaces.
3200 * advance to the next 32 bits in the current
3201 * namespace.
3202 */
3203 bit0 += 32;
3204 break;
3205
3206 case BIT(IEEE80211_RADIOTAP_NAMESPACE):
3207 /*
3208 * We're switching to the radiotap namespace.
3209 * Reset the presence-bitmap index to 0, and
3210 * reset the namespace to the default radiotap
3211 * namespace.
3212 */
3213 bit0 = 0;
3214 vendor_namespace = 0;
3215 memset(vendor_oui, 0, 3);
3216 vendor_subnamespace = 0;
3217 skip_length = 0;
3218 break;
3219
3220 case BIT(IEEE80211_RADIOTAP_VENDOR_NAMESPACE):
3221 /*
3222 * We're switching to a vendor namespace.
3223 * Reset the presence-bitmap index to 0,
3224 * note that we're in a vendor namespace,
3225 * and fetch the fields of the Vendor Namespace
3226 * item.
3227 */
3228 bit0 = 0;
3229 vendor_namespace = 1;
3230 if ((cpack_align_and_reserve(&cpacker, 2)) == NULL) {
3231 ND_PRINT((ndo, "%s", tstr));
3232 break;
3233 }
3234 if (cpack_uint8(&cpacker, &vendor_oui[0]) != 0) {
3235 ND_PRINT((ndo, "%s", tstr));
3236 break;
3237 }
3238 if (cpack_uint8(&cpacker, &vendor_oui[1]) != 0) {
3239 ND_PRINT((ndo, "%s", tstr));
3240 break;
3241 }
3242 if (cpack_uint8(&cpacker, &vendor_oui[2]) != 0) {
3243 ND_PRINT((ndo, "%s", tstr));
3244 break;
3245 }
3246 if (cpack_uint8(&cpacker, &vendor_subnamespace) != 0) {
3247 ND_PRINT((ndo, "%s", tstr));
3248 break;
3249 }
3250 if (cpack_uint16(&cpacker, &skip_length) != 0) {
3251 ND_PRINT((ndo, "%s", tstr));
3252 break;
3253 }
3254 break;
3255
3256 default:
3257 /*
3258 * Illegal combination. The behavior in this
3259 * case is undefined by the radiotap spec; we
3260 * just ignore both bits.
3261 */
3262 break;
3263 }
3264 }
3265
3266 if (flags & IEEE80211_RADIOTAP_F_DATAPAD)
3267 pad = 1; /* Atheros padding */
3268 if (flags & IEEE80211_RADIOTAP_F_FCS)
3269 fcslen = 4; /* FCS at end of packet */
3270 return len + ieee802_11_print(ndo, p + len, length - len, caplen - len, pad,
3271 fcslen);
3272 #undef BITNO_32
3273 #undef BITNO_16
3274 #undef BITNO_8
3275 #undef BITNO_4
3276 #undef BITNO_2
3277 #undef BIT
3278 }
3279
3280 static u_int
3281 ieee802_11_avs_radio_print(netdissect_options *ndo,
3282 const u_char *p, u_int length, u_int caplen)
3283 {
3284 uint32_t caphdr_len;
3285
3286 if (caplen < 8) {
3287 ND_PRINT((ndo, "%s", tstr));
3288 return caplen;
3289 }
3290
3291 caphdr_len = EXTRACT_32BITS(p + 4);
3292 if (caphdr_len < 8) {
3293 /*
3294 * Yow! The capture header length is claimed not
3295 * to be large enough to include even the version
3296 * cookie or capture header length!
3297 */
3298 ND_PRINT((ndo, "%s", tstr));
3299 return caplen;
3300 }
3301
3302 if (caplen < caphdr_len) {
3303 ND_PRINT((ndo, "%s", tstr));
3304 return caplen;
3305 }
3306
3307 return caphdr_len + ieee802_11_print(ndo, p + caphdr_len,
3308 length - caphdr_len, caplen - caphdr_len, 0, 0);
3309 }
3310
3311 #define PRISM_HDR_LEN 144
3312
3313 #define WLANCAP_MAGIC_COOKIE_BASE 0x80211000
3314 #define WLANCAP_MAGIC_COOKIE_V1 0x80211001
3315 #define WLANCAP_MAGIC_COOKIE_V2 0x80211002
3316
3317 /*
3318 * For DLT_PRISM_HEADER; like DLT_IEEE802_11, but with an extra header,
3319 * containing information such as radio information, which we
3320 * currently ignore.
3321 *
3322 * If, however, the packet begins with WLANCAP_MAGIC_COOKIE_V1 or
3323 * WLANCAP_MAGIC_COOKIE_V2, it's really DLT_IEEE802_11_RADIO_AVS
3324 * (currently, on Linux, there's no ARPHRD_ type for
3325 * DLT_IEEE802_11_RADIO_AVS, as there is a ARPHRD_IEEE80211_PRISM
3326 * for DLT_PRISM_HEADER, so ARPHRD_IEEE80211_PRISM is used for
3327 * the AVS header, and the first 4 bytes of the header are used to
3328 * indicate whether it's a Prism header or an AVS header).
3329 */
3330 u_int
3331 prism_if_print(netdissect_options *ndo,
3332 const struct pcap_pkthdr *h, const u_char *p)
3333 {
3334 u_int caplen = h->caplen;
3335 u_int length = h->len;
3336 uint32_t msgcode;
3337
3338 if (caplen < 4) {
3339 ND_PRINT((ndo, "%s", tstr));
3340 return caplen;
3341 }
3342
3343 msgcode = EXTRACT_32BITS(p);
3344 if (msgcode == WLANCAP_MAGIC_COOKIE_V1 ||
3345 msgcode == WLANCAP_MAGIC_COOKIE_V2)
3346 return ieee802_11_avs_radio_print(ndo, p, length, caplen);
3347
3348 if (caplen < PRISM_HDR_LEN) {
3349 ND_PRINT((ndo, "%s", tstr));
3350 return caplen;
3351 }
3352
3353 return PRISM_HDR_LEN + ieee802_11_print(ndo, p + PRISM_HDR_LEN,
3354 length - PRISM_HDR_LEN, caplen - PRISM_HDR_LEN, 0, 0);
3355 }
3356
3357 /*
3358 * For DLT_IEEE802_11_RADIO; like DLT_IEEE802_11, but with an extra
3359 * header, containing information such as radio information.
3360 */
3361 u_int
3362 ieee802_11_radio_if_print(netdissect_options *ndo,
3363 const struct pcap_pkthdr *h, const u_char *p)
3364 {
3365 return ieee802_11_radio_print(ndo, p, h->len, h->caplen);
3366 }
3367
3368 /*
3369 * For DLT_IEEE802_11_RADIO_AVS; like DLT_IEEE802_11, but with an
3370 * extra header, containing information such as radio information,
3371 * which we currently ignore.
3372 */
3373 u_int
3374 ieee802_11_radio_avs_if_print(netdissect_options *ndo,
3375 const struct pcap_pkthdr *h, const u_char *p)
3376 {
3377 return ieee802_11_avs_radio_print(ndo, p, h->len, h->caplen);
3378 }
[mirror] the TCPdump network dissector