]> The Tcpdump Group git mirrors - tcpdump/blob - print-802_11.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge remote-tracking branch 'upstream/master'
[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 #ifndef lint
24 static const char rcsid[] _U_ =
25 "@(#) $Header: /tcpdump/master/tcpdump/print-802_11.c,v 1.49 2007-12-29 23:25:02 guy Exp $ (LBL)";
26 #endif
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <tcpdump-stdinc.h>
33
34 #include <stdio.h>
35 #include <pcap.h>
36 #include <string.h>
37
38 #include "interface.h"
39 #include "addrtoname.h"
40 #include "ethertype.h"
41
42 #include "extract.h"
43
44 #include "cpack.h"
45
46 #include "ieee802_11.h"
47 #include "ieee802_11_radio.h"
48
49 /* Radiotap state */
50 /* This is used to save state when parsing/processing parameters */
51 struct radiotap_state
52 {
53 u_int32_t present;
54
55 u_int8_t rate;
56 };
57
58 #define PRINT_SSID(p) \
59 if (p.ssid_present) { \
60 printf(" ("); \
61 fn_print(p.ssid.ssid, NULL); \
62 printf(")"); \
63 }
64
65 #define PRINT_RATE(_sep, _r, _suf) \
66 printf("%s%2.1f%s", _sep, (.5 * ((_r) & 0x7f)), _suf)
67 #define PRINT_RATES(p) \
68 if (p.rates_present) { \
69 int z; \
70 const char *sep = " ["; \
71 for (z = 0; z < p.rates.length ; z++) { \
72 PRINT_RATE(sep, p.rates.rate[z], \
73 (p.rates.rate[z] & 0x80 ? "*" : "")); \
74 sep = " "; \
75 } \
76 if (p.rates.length != 0) \
77 printf(" Mbit]"); \
78 }
79
80 #define PRINT_DS_CHANNEL(p) \
81 if (p.ds_present) \
82 printf(" CH: %u", p.ds.channel); \
83 printf("%s", \
84 CAPABILITY_PRIVACY(p.capability_info) ? ", PRIVACY" : "" );
85
86 #define MAX_MCS_INDEX 76
87
88 /*
89 * Indices are:
90 *
91 * the MCS index (0-76);
92 *
93 * 0 for 20 MHz, 1 for 40 MHz;
94 *
95 * 0 for a long guard interval, 1 for a short guard interval.
96 */
97 static const float ieee80211_float_htrates[MAX_MCS_INDEX+1][2][2] = {
98 /* MCS 0 */
99 { /* 20 Mhz */ { 6.5, /* SGI */ 7.2, },
100 /* 40 Mhz */ { 13.5, /* SGI */ 15.0, },
101 },
102
103 /* MCS 1 */
104 { /* 20 Mhz */ { 13.0, /* SGI */ 14.4, },
105 /* 40 Mhz */ { 27.0, /* SGI */ 30.0, },
106 },
107
108 /* MCS 2 */
109 { /* 20 Mhz */ { 19.5, /* SGI */ 21.7, },
110 /* 40 Mhz */ { 40.5, /* SGI */ 45.0, },
111 },
112
113 /* MCS 3 */
114 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
115 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
116 },
117
118 /* MCS 4 */
119 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
120 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
121 },
122
123 /* MCS 5 */
124 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
125 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
126 },
127
128 /* MCS 6 */
129 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
130 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
131 },
132
133 /* MCS 7 */
134 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
135 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
136 },
137
138 /* MCS 8 */
139 { /* 20 Mhz */ { 13.0, /* SGI */ 14.4, },
140 /* 40 Mhz */ { 27.0, /* SGI */ 30.0, },
141 },
142
143 /* MCS 9 */
144 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
145 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
146 },
147
148 /* MCS 10 */
149 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
150 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
151 },
152
153 /* MCS 11 */
154 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
155 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
156 },
157
158 /* MCS 12 */
159 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
160 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
161 },
162
163 /* MCS 13 */
164 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
165 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
166 },
167
168 /* MCS 14 */
169 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
170 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
171 },
172
173 /* MCS 15 */
174 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
175 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
176 },
177
178 /* MCS 16 */
179 { /* 20 Mhz */ { 19.5, /* SGI */ 21.7, },
180 /* 40 Mhz */ { 40.5, /* SGI */ 45.0, },
181 },
182
183 /* MCS 17 */
184 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
185 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
186 },
187
188 /* MCS 18 */
189 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
190 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
191 },
192
193 /* MCS 19 */
194 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
195 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
196 },
197
198 /* MCS 20 */
199 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
200 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
201 },
202
203 /* MCS 21 */
204 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
205 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
206 },
207
208 /* MCS 22 */
209 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
210 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
211 },
212
213 /* MCS 23 */
214 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
215 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
216 },
217
218 /* MCS 24 */
219 { /* 20 Mhz */ { 26.0, /* SGI */ 28.9, },
220 /* 40 Mhz */ { 54.0, /* SGI */ 60.0, },
221 },
222
223 /* MCS 25 */
224 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
225 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
226 },
227
228 /* MCS 26 */
229 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
230 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
231 },
232
233 /* MCS 27 */
234 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
235 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
236 },
237
238 /* MCS 28 */
239 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
240 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
241 },
242
243 /* MCS 29 */
244 { /* 20 Mhz */ { 208.0, /* SGI */ 231.1, },
245 /* 40 Mhz */ { 432.0, /* SGI */ 480.0, },
246 },
247
248 /* MCS 30 */
249 { /* 20 Mhz */ { 234.0, /* SGI */ 260.0, },
250 /* 40 Mhz */ { 486.0, /* SGI */ 540.0, },
251 },
252
253 /* MCS 31 */
254 { /* 20 Mhz */ { 260.0, /* SGI */ 288.9, },
255 /* 40 Mhz */ { 540.0, /* SGI */ 600.0, },
256 },
257
258 /* MCS 32 */
259 { /* 20 Mhz */ { 0.0, /* SGI */ 0.0, }, /* not valid */
260 /* 40 Mhz */ { 6.0, /* SGI */ 6.7, },
261 },
262
263 /* MCS 33 */
264 { /* 20 Mhz */ { 39.0, /* SGI */ 43.3, },
265 /* 40 Mhz */ { 81.0, /* SGI */ 90.0, },
266 },
267
268 /* MCS 34 */
269 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
270 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
271 },
272
273 /* MCS 35 */
274 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
275 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
276 },
277
278 /* MCS 36 */
279 { /* 20 Mhz */ { 58.5, /* SGI */ 65.0, },
280 /* 40 Mhz */ { 121.5, /* SGI */ 135.0, },
281 },
282
283 /* MCS 37 */
284 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
285 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
286 },
287
288 /* MCS 38 */
289 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
290 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
291 },
292
293 /* MCS 39 */
294 { /* 20 Mhz */ { 52.0, /* SGI */ 57.8, },
295 /* 40 Mhz */ { 108.0, /* SGI */ 120.0, },
296 },
297
298 /* MCS 40 */
299 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
300 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
301 },
302
303 /* MCS 41 */
304 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
305 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
306 },
307
308 /* MCS 42 */
309 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
310 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
311 },
312
313 /* MCS 43 */
314 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
315 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
316 },
317
318 /* MCS 44 */
319 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
320 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
321 },
322
323 /* MCS 45 */
324 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
325 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
326 },
327
328 /* MCS 46 */
329 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
330 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
331 },
332
333 /* MCS 47 */
334 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
335 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
336 },
337
338 /* MCS 48 */
339 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
340 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
341 },
342
343 /* MCS 49 */
344 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
345 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
346 },
347
348 /* MCS 50 */
349 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
350 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
351 },
352
353 /* MCS 51 */
354 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
355 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
356 },
357
358 /* MCS 52 */
359 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
360 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
361 },
362
363 /* MCS 53 */
364 { /* 20 Mhz */ { 65.0, /* SGI */ 72.2, },
365 /* 40 Mhz */ { 135.0, /* SGI */ 150.0, },
366 },
367
368 /* MCS 54 */
369 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
370 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
371 },
372
373 /* MCS 55 */
374 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
375 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
376 },
377
378 /* MCS 56 */
379 { /* 20 Mhz */ { 78.0, /* SGI */ 86.7, },
380 /* 40 Mhz */ { 162.0, /* SGI */ 180.0, },
381 },
382
383 /* MCS 57 */
384 { /* 20 Mhz */ { 91.0, /* SGI */ 101.1, },
385 /* 40 Mhz */ { 189.0, /* SGI */ 210.0, },
386 },
387
388 /* MCS 58 */
389 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
390 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
391 },
392
393 /* MCS 59 */
394 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
395 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
396 },
397
398 /* MCS 60 */
399 { /* 20 Mhz */ { 104.0, /* SGI */ 115.6, },
400 /* 40 Mhz */ { 216.0, /* SGI */ 240.0, },
401 },
402
403 /* MCS 61 */
404 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
405 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
406 },
407
408 /* MCS 62 */
409 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
410 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
411 },
412
413 /* MCS 63 */
414 { /* 20 Mhz */ { 130.0, /* SGI */ 144.4, },
415 /* 40 Mhz */ { 270.0, /* SGI */ 300.0, },
416 },
417
418 /* MCS 64 */
419 { /* 20 Mhz */ { 143.0, /* SGI */ 158.9, },
420 /* 40 Mhz */ { 297.0, /* SGI */ 330.0, },
421 },
422
423 /* MCS 65 */
424 { /* 20 Mhz */ { 97.5, /* SGI */ 108.3, },
425 /* 40 Mhz */ { 202.5, /* SGI */ 225.0, },
426 },
427
428 /* MCS 66 */
429 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
430 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
431 },
432
433 /* MCS 67 */
434 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
435 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
436 },
437
438 /* MCS 68 */
439 { /* 20 Mhz */ { 117.0, /* SGI */ 130.0, },
440 /* 40 Mhz */ { 243.0, /* SGI */ 270.0, },
441 },
442
443 /* MCS 69 */
444 { /* 20 Mhz */ { 136.5, /* SGI */ 151.7, },
445 /* 40 Mhz */ { 283.5, /* SGI */ 315.0, },
446 },
447
448 /* MCS 70 */
449 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
450 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
451 },
452
453 /* MCS 71 */
454 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
455 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
456 },
457
458 /* MCS 72 */
459 { /* 20 Mhz */ { 156.0, /* SGI */ 173.3, },
460 /* 40 Mhz */ { 324.0, /* SGI */ 360.0, },
461 },
462
463 /* MCS 73 */
464 { /* 20 Mhz */ { 175.5, /* SGI */ 195.0, },
465 /* 40 Mhz */ { 364.5, /* SGI */ 405.0, },
466 },
467
468 /* MCS 74 */
469 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
470 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
471 },
472
473 /* MCS 75 */
474 { /* 20 Mhz */ { 195.0, /* SGI */ 216.7, },
475 /* 40 Mhz */ { 405.0, /* SGI */ 450.0, },
476 },
477
478 /* MCS 76 */
479 { /* 20 Mhz */ { 214.5, /* SGI */ 238.3, },
480 /* 40 Mhz */ { 445.5, /* SGI */ 495.0, },
481 },
482 };
483
484 static const char *auth_alg_text[]={"Open System","Shared Key","EAP"};
485 #define NUM_AUTH_ALGS (sizeof auth_alg_text / sizeof auth_alg_text[0])
486
487 static const char *status_text[] = {
488 "Successful", /* 0 */
489 "Unspecified failure", /* 1 */
490 "Reserved", /* 2 */
491 "Reserved", /* 3 */
492 "Reserved", /* 4 */
493 "Reserved", /* 5 */
494 "Reserved", /* 6 */
495 "Reserved", /* 7 */
496 "Reserved", /* 8 */
497 "Reserved", /* 9 */
498 "Cannot Support all requested capabilities in the Capability "
499 "Information field", /* 10 */
500 "Reassociation denied due to inability to confirm that association "
501 "exists", /* 11 */
502 "Association denied due to reason outside the scope of the "
503 "standard", /* 12 */
504 "Responding station does not support the specified authentication "
505 "algorithm ", /* 13 */
506 "Received an Authentication frame with authentication transaction "
507 "sequence number out of expected sequence", /* 14 */
508 "Authentication rejected because of challenge failure", /* 15 */
509 "Authentication rejected due to timeout waiting for next frame in "
510 "sequence", /* 16 */
511 "Association denied because AP is unable to handle additional"
512 "associated stations", /* 17 */
513 "Association denied due to requesting station not supporting all of "
514 "the data rates in BSSBasicRateSet parameter", /* 18 */
515 "Association denied due to requesting station not supporting "
516 "short preamble operation", /* 19 */
517 "Association denied due to requesting station not supporting "
518 "PBCC encoding", /* 20 */
519 "Association denied due to requesting station not supporting "
520 "channel agility", /* 21 */
521 "Association request rejected because Spectrum Management "
522 "capability is required", /* 22 */
523 "Association request rejected because the information in the "
524 "Power Capability element is unacceptable", /* 23 */
525 "Association request rejected because the information in the "
526 "Supported Channels element is unacceptable", /* 24 */
527 "Association denied due to requesting station not supporting "
528 "short slot operation", /* 25 */
529 "Association denied due to requesting station not supporting "
530 "DSSS-OFDM operation", /* 26 */
531 "Association denied because the requested STA does not support HT "
532 "features", /* 27 */
533 "Reserved", /* 28 */
534 "Association denied because the requested STA does not support "
535 "the PCO transition time required by the AP", /* 29 */
536 "Reserved", /* 30 */
537 "Reserved", /* 31 */
538 "Unspecified, QoS-related failure", /* 32 */
539 "Association denied due to QAP having insufficient bandwidth "
540 "to handle another QSTA", /* 33 */
541 "Association denied due to excessive frame loss rates and/or "
542 "poor conditions on current operating channel", /* 34 */
543 "Association (with QBSS) denied due to requesting station not "
544 "supporting the QoS facility", /* 35 */
545 "Association denied due to requesting station not supporting "
546 "Block Ack", /* 36 */
547 "The request has been declined", /* 37 */
548 "The request has not been successful as one or more parameters "
549 "have invalid values", /* 38 */
550 "The TS has not been created because the request cannot be honored. "
551 "However, a suggested TSPEC is provided so that the initiating QSTA"
552 "may attempt to set another TS with the suggested changes to the "
553 "TSPEC", /* 39 */
554 "Invalid Information Element", /* 40 */
555 "Group Cipher is not valid", /* 41 */
556 "Pairwise Cipher is not valid", /* 42 */
557 "AKMP is not valid", /* 43 */
558 "Unsupported RSN IE version", /* 44 */
559 "Invalid RSN IE Capabilities", /* 45 */
560 "Cipher suite is rejected per security policy", /* 46 */
561 "The TS has not been created. However, the HC may be capable of "
562 "creating a TS, in response to a request, after the time indicated "
563 "in the TS Delay element", /* 47 */
564 "Direct Link is not allowed in the BSS by policy", /* 48 */
565 "Destination STA is not present within this QBSS.", /* 49 */
566 "The Destination STA is not a QSTA.", /* 50 */
567
568 };
569 #define NUM_STATUSES (sizeof status_text / sizeof status_text[0])
570
571 static const char *reason_text[] = {
572 "Reserved", /* 0 */
573 "Unspecified reason", /* 1 */
574 "Previous authentication no longer valid", /* 2 */
575 "Deauthenticated because sending station is leaving (or has left) "
576 "IBSS or ESS", /* 3 */
577 "Disassociated due to inactivity", /* 4 */
578 "Disassociated because AP is unable to handle all currently "
579 " associated stations", /* 5 */
580 "Class 2 frame received from nonauthenticated station", /* 6 */
581 "Class 3 frame received from nonassociated station", /* 7 */
582 "Disassociated because sending station is leaving "
583 "(or has left) BSS", /* 8 */
584 "Station requesting (re)association is not authenticated with "
585 "responding station", /* 9 */
586 "Disassociated because the information in the Power Capability "
587 "element is unacceptable", /* 10 */
588 "Disassociated because the information in the SupportedChannels "
589 "element is unacceptable", /* 11 */
590 "Invalid Information Element", /* 12 */
591 "Reserved", /* 13 */
592 "Michael MIC failure", /* 14 */
593 "4-Way Handshake timeout", /* 15 */
594 "Group key update timeout", /* 16 */
595 "Information element in 4-Way Handshake different from (Re)Association"
596 "Request/Probe Response/Beacon", /* 17 */
597 "Group Cipher is not valid", /* 18 */
598 "AKMP is not valid", /* 20 */
599 "Unsupported RSN IE version", /* 21 */
600 "Invalid RSN IE Capabilities", /* 22 */
601 "IEEE 802.1X Authentication failed", /* 23 */
602 "Cipher suite is rejected per security policy", /* 24 */
603 "Reserved", /* 25 */
604 "Reserved", /* 26 */
605 "Reserved", /* 27 */
606 "Reserved", /* 28 */
607 "Reserved", /* 29 */
608 "Reserved", /* 30 */
609 "TS deleted because QoS AP lacks sufficient bandwidth for this "
610 "QoS STA due to a change in BSS service characteristics or "
611 "operational mode (e.g. an HT BSS change from 40 MHz channel "
612 "to 20 MHz channel)", /* 31 */
613 "Disassociated for unspecified, QoS-related reason", /* 32 */
614 "Disassociated because QoS AP lacks sufficient bandwidth for this "
615 "QoS STA", /* 33 */
616 "Disassociated because of excessive number of frames that need to be "
617 "acknowledged, but are not acknowledged for AP transmissions "
618 "and/or poor channel conditions", /* 34 */
619 "Disassociated because STA is transmitting outside the limits "
620 "of its TXOPs", /* 35 */
621 "Requested from peer STA as the STA is leaving the BSS "
622 "(or resetting)", /* 36 */
623 "Requested from peer STA as it does not want to use the "
624 "mechanism", /* 37 */
625 "Requested from peer STA as the STA received frames using the "
626 "mechanism for which a set up is required", /* 38 */
627 "Requested from peer STA due to time out", /* 39 */
628 "Reserved", /* 40 */
629 "Reserved", /* 41 */
630 "Reserved", /* 42 */
631 "Reserved", /* 43 */
632 "Reserved", /* 44 */
633 "Peer STA does not support the requested cipher suite", /* 45 */
634 "Association denied due to requesting STA not supporting HT "
635 "features", /* 46 */
636 };
637 #define NUM_REASONS (sizeof reason_text / sizeof reason_text[0])
638
639 static int
640 wep_print(const u_char *p)
641 {
642 u_int32_t iv;
643
644 if (!TTEST2(*p, IEEE802_11_IV_LEN + IEEE802_11_KID_LEN))
645 return 0;
646 iv = EXTRACT_LE_32BITS(p);
647
648 printf("Data IV:%3x Pad %x KeyID %x", IV_IV(iv), IV_PAD(iv),
649 IV_KEYID(iv));
650
651 return 1;
652 }
653
654 static int
655 parse_elements(struct mgmt_body_t *pbody, const u_char *p, int offset,
656 u_int length)
657 {
658 u_int elementlen;
659 struct ssid_t ssid;
660 struct challenge_t challenge;
661 struct rates_t rates;
662 struct ds_t ds;
663 struct cf_t cf;
664 struct tim_t tim;
665
666 /*
667 * We haven't seen any elements yet.
668 */
669 pbody->challenge_present = 0;
670 pbody->ssid_present = 0;
671 pbody->rates_present = 0;
672 pbody->ds_present = 0;
673 pbody->cf_present = 0;
674 pbody->tim_present = 0;
675
676 while (length != 0) {
677 if (!TTEST2(*(p + offset), 1))
678 return 0;
679 if (length < 1)
680 return 0;
681 switch (*(p + offset)) {
682 case E_SSID:
683 if (!TTEST2(*(p + offset), 2))
684 return 0;
685 if (length < 2)
686 return 0;
687 memcpy(&ssid, p + offset, 2);
688 offset += 2;
689 length -= 2;
690 if (ssid.length != 0) {
691 if (ssid.length > sizeof(ssid.ssid) - 1)
692 return 0;
693 if (!TTEST2(*(p + offset), ssid.length))
694 return 0;
695 if (length < ssid.length)
696 return 0;
697 memcpy(&ssid.ssid, p + offset, ssid.length);
698 offset += ssid.length;
699 length -= ssid.length;
700 }
701 ssid.ssid[ssid.length] = '\0';
702 /*
703 * Present and not truncated.
704 *
705 * If we haven't already seen an SSID IE,
706 * copy this one, otherwise ignore this one,
707 * so we later report the first one we saw.
708 */
709 if (!pbody->ssid_present) {
710 pbody->ssid = ssid;
711 pbody->ssid_present = 1;
712 }
713 break;
714 case E_CHALLENGE:
715 if (!TTEST2(*(p + offset), 2))
716 return 0;
717 if (length < 2)
718 return 0;
719 memcpy(&challenge, p + offset, 2);
720 offset += 2;
721 length -= 2;
722 if (challenge.length != 0) {
723 if (challenge.length >
724 sizeof(challenge.text) - 1)
725 return 0;
726 if (!TTEST2(*(p + offset), challenge.length))
727 return 0;
728 if (length < challenge.length)
729 return 0;
730 memcpy(&challenge.text, p + offset,
731 challenge.length);
732 offset += challenge.length;
733 length -= challenge.length;
734 }
735 challenge.text[challenge.length] = '\0';
736 /*
737 * Present and not truncated.
738 *
739 * If we haven't already seen a challenge IE,
740 * copy this one, otherwise ignore this one,
741 * so we later report the first one we saw.
742 */
743 if (!pbody->challenge_present) {
744 pbody->challenge = challenge;
745 pbody->challenge_present = 1;
746 }
747 break;
748 case E_RATES:
749 if (!TTEST2(*(p + offset), 2))
750 return 0;
751 if (length < 2)
752 return 0;
753 memcpy(&rates, p + offset, 2);
754 offset += 2;
755 length -= 2;
756 if (rates.length != 0) {
757 if (rates.length > sizeof rates.rate)
758 return 0;
759 if (!TTEST2(*(p + offset), rates.length))
760 return 0;
761 if (length < rates.length)
762 return 0;
763 memcpy(&rates.rate, p + offset, rates.length);
764 offset += rates.length;
765 length -= rates.length;
766 }
767 /*
768 * Present and not truncated.
769 *
770 * If we haven't already seen a rates IE,
771 * copy this one if it's not zero-length,
772 * otherwise ignore this one, so we later
773 * report the first one we saw.
774 *
775 * We ignore zero-length rates IEs as some
776 * devices seem to put a zero-length rates
777 * IE, followed by an SSID IE, followed by
778 * a non-zero-length rates IE into frames,
779 * even though IEEE Std 802.11-2007 doesn't
780 * seem to indicate that a zero-length rates
781 * IE is valid.
782 */
783 if (!pbody->rates_present && rates.length != 0) {
784 pbody->rates = rates;
785 pbody->rates_present = 1;
786 }
787 break;
788 case E_DS:
789 if (!TTEST2(*(p + offset), 3))
790 return 0;
791 if (length < 3)
792 return 0;
793 memcpy(&ds, p + offset, 3);
794 offset += 3;
795 length -= 3;
796 /*
797 * Present and not truncated.
798 *
799 * If we haven't already seen a DS IE,
800 * copy this one, otherwise ignore this one,
801 * so we later report the first one we saw.
802 */
803 if (!pbody->ds_present) {
804 pbody->ds = ds;
805 pbody->ds_present = 1;
806 }
807 break;
808 case E_CF:
809 if (!TTEST2(*(p + offset), 8))
810 return 0;
811 if (length < 8)
812 return 0;
813 memcpy(&cf, p + offset, 8);
814 offset += 8;
815 length -= 8;
816 /*
817 * Present and not truncated.
818 *
819 * If we haven't already seen a CF IE,
820 * copy this one, otherwise ignore this one,
821 * so we later report the first one we saw.
822 */
823 if (!pbody->cf_present) {
824 pbody->cf = cf;
825 pbody->cf_present = 1;
826 }
827 break;
828 case E_TIM:
829 if (!TTEST2(*(p + offset), 2))
830 return 0;
831 if (length < 2)
832 return 0;
833 memcpy(&tim, p + offset, 2);
834 offset += 2;
835 length -= 2;
836 if (!TTEST2(*(p + offset), 3))
837 return 0;
838 if (length < 3)
839 return 0;
840 memcpy(&tim.count, p + offset, 3);
841 offset += 3;
842 length -= 3;
843
844 if (tim.length <= 3)
845 break;
846 if (tim.length - 3 > (int)sizeof tim.bitmap)
847 return 0;
848 if (!TTEST2(*(p + offset), tim.length - 3))
849 return 0;
850 if (length < (u_int)(tim.length - 3))
851 return 0;
852 memcpy(tim.bitmap, p + (tim.length - 3),
853 (tim.length - 3));
854 offset += tim.length - 3;
855 length -= tim.length - 3;
856 /*
857 * Present and not truncated.
858 *
859 * If we haven't already seen a TIM IE,
860 * copy this one, otherwise ignore this one,
861 * so we later report the first one we saw.
862 */
863 if (!pbody->tim_present) {
864 pbody->tim = tim;
865 pbody->tim_present = 1;
866 }
867 break;
868 default:
869 #if 0
870 printf("(1) unhandled element_id (%d) ",
871 *(p + offset));
872 #endif
873 if (!TTEST2(*(p + offset), 2))
874 return 0;
875 if (length < 2)
876 return 0;
877 elementlen = *(p + offset + 1);
878 if (!TTEST2(*(p + offset + 2), elementlen))
879 return 0;
880 if (length < elementlen + 2)
881 return 0;
882 offset += elementlen + 2;
883 length -= elementlen + 2;
884 break;
885 }
886 }
887
888 /* No problems found. */
889 return 1;
890 }
891
892 /*********************************************************************************
893 * Print Handle functions for the management frame types
894 *********************************************************************************/
895
896 static int
897 handle_beacon(const u_char *p, u_int length)
898 {
899 struct mgmt_body_t pbody;
900 int offset = 0;
901 int ret;
902
903 memset(&pbody, 0, sizeof(pbody));
904
905 if (!TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
906 IEEE802_11_CAPINFO_LEN))
907 return 0;
908 if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
909 IEEE802_11_CAPINFO_LEN)
910 return 0;
911 memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
912 offset += IEEE802_11_TSTAMP_LEN;
913 length -= IEEE802_11_TSTAMP_LEN;
914 pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
915 offset += IEEE802_11_BCNINT_LEN;
916 length -= IEEE802_11_BCNINT_LEN;
917 pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
918 offset += IEEE802_11_CAPINFO_LEN;
919 length -= IEEE802_11_CAPINFO_LEN;
920
921 ret = parse_elements(&pbody, p, offset, length);
922
923 PRINT_SSID(pbody);
924 PRINT_RATES(pbody);
925 printf(" %s",
926 CAPABILITY_ESS(pbody.capability_info) ? "ESS" : "IBSS");
927 PRINT_DS_CHANNEL(pbody);
928
929 return ret;
930 }
931
932 static int
933 handle_assoc_request(const u_char *p, u_int length)
934 {
935 struct mgmt_body_t pbody;
936 int offset = 0;
937 int ret;
938
939 memset(&pbody, 0, sizeof(pbody));
940
941 if (!TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN))
942 return 0;
943 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN)
944 return 0;
945 pbody.capability_info = EXTRACT_LE_16BITS(p);
946 offset += IEEE802_11_CAPINFO_LEN;
947 length -= IEEE802_11_CAPINFO_LEN;
948 pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
949 offset += IEEE802_11_LISTENINT_LEN;
950 length -= IEEE802_11_LISTENINT_LEN;
951
952 ret = parse_elements(&pbody, p, offset, length);
953
954 PRINT_SSID(pbody);
955 PRINT_RATES(pbody);
956 return ret;
957 }
958
959 static int
960 handle_assoc_response(const u_char *p, u_int length)
961 {
962 struct mgmt_body_t pbody;
963 int offset = 0;
964 int ret;
965
966 memset(&pbody, 0, sizeof(pbody));
967
968 if (!TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
969 IEEE802_11_AID_LEN))
970 return 0;
971 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
972 IEEE802_11_AID_LEN)
973 return 0;
974 pbody.capability_info = EXTRACT_LE_16BITS(p);
975 offset += IEEE802_11_CAPINFO_LEN;
976 length -= IEEE802_11_CAPINFO_LEN;
977 pbody.status_code = EXTRACT_LE_16BITS(p+offset);
978 offset += IEEE802_11_STATUS_LEN;
979 length -= IEEE802_11_STATUS_LEN;
980 pbody.aid = EXTRACT_LE_16BITS(p+offset);
981 offset += IEEE802_11_AID_LEN;
982 length -= IEEE802_11_AID_LEN;
983
984 ret = parse_elements(&pbody, p, offset, length);
985
986 printf(" AID(%x) :%s: %s", ((u_int16_t)(pbody.aid << 2 )) >> 2 ,
987 CAPABILITY_PRIVACY(pbody.capability_info) ? " PRIVACY " : "",
988 (pbody.status_code < NUM_STATUSES
989 ? status_text[pbody.status_code]
990 : "n/a"));
991
992 return ret;
993 }
994
995 static int
996 handle_reassoc_request(const u_char *p, u_int length)
997 {
998 struct mgmt_body_t pbody;
999 int offset = 0;
1000 int ret;
1001
1002 memset(&pbody, 0, sizeof(pbody));
1003
1004 if (!TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1005 IEEE802_11_AP_LEN))
1006 return 0;
1007 if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1008 IEEE802_11_AP_LEN)
1009 return 0;
1010 pbody.capability_info = EXTRACT_LE_16BITS(p);
1011 offset += IEEE802_11_CAPINFO_LEN;
1012 length -= IEEE802_11_CAPINFO_LEN;
1013 pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
1014 offset += IEEE802_11_LISTENINT_LEN;
1015 length -= IEEE802_11_LISTENINT_LEN;
1016 memcpy(&pbody.ap, p+offset, IEEE802_11_AP_LEN);
1017 offset += IEEE802_11_AP_LEN;
1018 length -= IEEE802_11_AP_LEN;
1019
1020 ret = parse_elements(&pbody, p, offset, length);
1021
1022 PRINT_SSID(pbody);
1023 printf(" AP : %s", etheraddr_string( pbody.ap ));
1024
1025 return ret;
1026 }
1027
1028 static int
1029 handle_reassoc_response(const u_char *p, u_int length)
1030 {
1031 /* Same as a Association Reponse */
1032 return handle_assoc_response(p, length);
1033 }
1034
1035 static int
1036 handle_probe_request(const u_char *p, u_int length)
1037 {
1038 struct mgmt_body_t pbody;
1039 int offset = 0;
1040 int ret;
1041
1042 memset(&pbody, 0, sizeof(pbody));
1043
1044 ret = parse_elements(&pbody, p, offset, length);
1045
1046 PRINT_SSID(pbody);
1047 PRINT_RATES(pbody);
1048
1049 return ret;
1050 }
1051
1052 static int
1053 handle_probe_response(const u_char *p, u_int length)
1054 {
1055 struct mgmt_body_t pbody;
1056 int offset = 0;
1057 int ret;
1058
1059 memset(&pbody, 0, sizeof(pbody));
1060
1061 if (!TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1062 IEEE802_11_CAPINFO_LEN))
1063 return 0;
1064 if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1065 IEEE802_11_CAPINFO_LEN)
1066 return 0;
1067 memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
1068 offset += IEEE802_11_TSTAMP_LEN;
1069 length -= IEEE802_11_TSTAMP_LEN;
1070 pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
1071 offset += IEEE802_11_BCNINT_LEN;
1072 length -= IEEE802_11_BCNINT_LEN;
1073 pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
1074 offset += IEEE802_11_CAPINFO_LEN;
1075 length -= IEEE802_11_CAPINFO_LEN;
1076
1077 ret = parse_elements(&pbody, p, offset, length);
1078
1079 PRINT_SSID(pbody);
1080 PRINT_RATES(pbody);
1081 PRINT_DS_CHANNEL(pbody);
1082
1083 return ret;
1084 }
1085
1086 static int
1087 handle_atim(void)
1088 {
1089 /* the frame body for ATIM is null. */
1090 return 1;
1091 }
1092
1093 static int
1094 handle_disassoc(const u_char *p, u_int length)
1095 {
1096 struct mgmt_body_t pbody;
1097
1098 memset(&pbody, 0, sizeof(pbody));
1099
1100 if (!TTEST2(*p, IEEE802_11_REASON_LEN))
1101 return 0;
1102 if (length < IEEE802_11_REASON_LEN)
1103 return 0;
1104 pbody.reason_code = EXTRACT_LE_16BITS(p);
1105
1106 printf(": %s",
1107 (pbody.reason_code < NUM_REASONS)
1108 ? reason_text[pbody.reason_code]
1109 : "Reserved" );
1110
1111 return 1;
1112 }
1113
1114 static int
1115 handle_auth(const u_char *p, u_int length)
1116 {
1117 struct mgmt_body_t pbody;
1118 int offset = 0;
1119 int ret;
1120
1121 memset(&pbody, 0, sizeof(pbody));
1122
1123 if (!TTEST2(*p, 6))
1124 return 0;
1125 if (length < 6)
1126 return 0;
1127 pbody.auth_alg = EXTRACT_LE_16BITS(p);
1128 offset += 2;
1129 length -= 2;
1130 pbody.auth_trans_seq_num = EXTRACT_LE_16BITS(p + offset);
1131 offset += 2;
1132 length -= 2;
1133 pbody.status_code = EXTRACT_LE_16BITS(p + offset);
1134 offset += 2;
1135 length -= 2;
1136
1137 ret = parse_elements(&pbody, p, offset, length);
1138
1139 if ((pbody.auth_alg == 1) &&
1140 ((pbody.auth_trans_seq_num == 2) ||
1141 (pbody.auth_trans_seq_num == 3))) {
1142 printf(" (%s)-%x [Challenge Text] %s",
1143 (pbody.auth_alg < NUM_AUTH_ALGS)
1144 ? auth_alg_text[pbody.auth_alg]
1145 : "Reserved",
1146 pbody.auth_trans_seq_num,
1147 ((pbody.auth_trans_seq_num % 2)
1148 ? ((pbody.status_code < NUM_STATUSES)
1149 ? status_text[pbody.status_code]
1150 : "n/a") : ""));
1151 return ret;
1152 }
1153 printf(" (%s)-%x: %s",
1154 (pbody.auth_alg < NUM_AUTH_ALGS)
1155 ? auth_alg_text[pbody.auth_alg]
1156 : "Reserved",
1157 pbody.auth_trans_seq_num,
1158 (pbody.auth_trans_seq_num % 2)
1159 ? ((pbody.status_code < NUM_STATUSES)
1160 ? status_text[pbody.status_code]
1161 : "n/a")
1162 : "");
1163
1164 return ret;
1165 }
1166
1167 static int
1168 handle_deauth(const struct mgmt_header_t *pmh, const u_char *p, u_int length)
1169 {
1170 struct mgmt_body_t pbody;
1171 int offset = 0;
1172 const char *reason = NULL;
1173
1174 memset(&pbody, 0, sizeof(pbody));
1175
1176 if (!TTEST2(*p, IEEE802_11_REASON_LEN))
1177 return 0;
1178 if (length < IEEE802_11_REASON_LEN)
1179 return 0;
1180 pbody.reason_code = EXTRACT_LE_16BITS(p);
1181 offset += IEEE802_11_REASON_LEN;
1182 length -= IEEE802_11_REASON_LEN;
1183
1184 reason = (pbody.reason_code < NUM_REASONS)
1185 ? reason_text[pbody.reason_code]
1186 : "Reserved";
1187
1188 if (eflag) {
1189 printf(": %s", reason);
1190 } else {
1191 printf(" (%s): %s", etheraddr_string(pmh->sa), reason);
1192 }
1193 return 1;
1194 }
1195
1196 #define PRINT_HT_ACTION(v) (\
1197 (v) == 0 ? printf("TxChWidth") : \
1198 (v) == 1 ? printf("MIMOPwrSave") : \
1199 printf("Act#%d", (v)) \
1200 )
1201 #define PRINT_BA_ACTION(v) (\
1202 (v) == 0 ? printf("ADDBA Request") : \
1203 (v) == 1 ? printf("ADDBA Response") : \
1204 (v) == 2 ? printf("DELBA") : \
1205 printf("Act#%d", (v)) \
1206 )
1207 #define PRINT_MESHLINK_ACTION(v) (\
1208 (v) == 0 ? printf("Request") : \
1209 (v) == 1 ? printf("Report") : \
1210 printf("Act#%d", (v)) \
1211 )
1212 #define PRINT_MESHPEERING_ACTION(v) (\
1213 (v) == 0 ? printf("Open") : \
1214 (v) == 1 ? printf("Confirm") : \
1215 (v) == 2 ? printf("Close") : \
1216 printf("Act#%d", (v)) \
1217 )
1218 #define PRINT_MESHPATH_ACTION(v) (\
1219 (v) == 0 ? printf("Request") : \
1220 (v) == 1 ? printf("Report") : \
1221 (v) == 2 ? printf("Error") : \
1222 (v) == 3 ? printf("RootAnnouncement") : \
1223 printf("Act#%d", (v)) \
1224 )
1225
1226 #define PRINT_MESH_ACTION(v) (\
1227 (v) == 0 ? printf("MeshLink") : \
1228 (v) == 1 ? printf("HWMP") : \
1229 (v) == 2 ? printf("Gate Announcement") : \
1230 (v) == 3 ? printf("Congestion Control") : \
1231 (v) == 4 ? printf("MCCA Setup Request") : \
1232 (v) == 5 ? printf("MCCA Setup Reply") : \
1233 (v) == 6 ? printf("MCCA Advertisement Request") : \
1234 (v) == 7 ? printf("MCCA Advertisement") : \
1235 (v) == 8 ? printf("MCCA Teardown") : \
1236 (v) == 9 ? printf("TBTT Adjustment Request") : \
1237 (v) == 10 ? printf("TBTT Adjustment Response") : \
1238 printf("Act#%d", (v)) \
1239 )
1240 #define PRINT_MULTIHOP_ACTION(v) (\
1241 (v) == 0 ? printf("Proxy Update") : \
1242 (v) == 1 ? printf("Proxy Update Confirmation") : \
1243 printf("Act#%d", (v)) \
1244 )
1245 #define PRINT_SELFPROT_ACTION(v) (\
1246 (v) == 1 ? printf("Peering Open") : \
1247 (v) == 2 ? printf("Peering Confirm") : \
1248 (v) == 3 ? printf("Peering Close") : \
1249 (v) == 4 ? printf("Group Key Inform") : \
1250 (v) == 5 ? printf("Group Key Acknowledge") : \
1251 printf("Act#%d", (v)) \
1252 )
1253
1254 static int
1255 handle_action(const struct mgmt_header_t *pmh, const u_char *p, u_int length)
1256 {
1257 if (!TTEST2(*p, 2))
1258 return 0;
1259 if (length < 2)
1260 return 0;
1261 if (eflag) {
1262 printf(": ");
1263 } else {
1264 printf(" (%s): ", etheraddr_string(pmh->sa));
1265 }
1266 switch (p[0]) {
1267 case 0: printf("Spectrum Management Act#%d", p[1]); break;
1268 case 1: printf("QoS Act#%d", p[1]); break;
1269 case 2: printf("DLS Act#%d", p[1]); break;
1270 case 3: printf("BA "); PRINT_BA_ACTION(p[1]); break;
1271 case 7: printf("HT "); PRINT_HT_ACTION(p[1]); break;
1272 case 13: printf("MeshAction "); PRINT_MESH_ACTION(p[1]); break;
1273 case 14:
1274 printf("MultiohopAction ");
1275 PRINT_MULTIHOP_ACTION(p[1]); break;
1276 case 15:
1277 printf("SelfprotectAction ");
1278 PRINT_SELFPROT_ACTION(p[1]); break;
1279 case 127: printf("Vendor Act#%d", p[1]); break;
1280 default:
1281 printf("Reserved(%d) Act#%d", p[0], p[1]);
1282 break;
1283 }
1284 return 1;
1285 }
1286
1287
1288 /*********************************************************************************
1289 * Print Body funcs
1290 *********************************************************************************/
1291
1292
1293 static int
1294 mgmt_body_print(u_int16_t fc, const struct mgmt_header_t *pmh,
1295 const u_char *p, u_int length)
1296 {
1297 switch (FC_SUBTYPE(fc)) {
1298 case ST_ASSOC_REQUEST:
1299 printf("Assoc Request");
1300 return handle_assoc_request(p, length);
1301 case ST_ASSOC_RESPONSE:
1302 printf("Assoc Response");
1303 return handle_assoc_response(p, length);
1304 case ST_REASSOC_REQUEST:
1305 printf("ReAssoc Request");
1306 return handle_reassoc_request(p, length);
1307 case ST_REASSOC_RESPONSE:
1308 printf("ReAssoc Response");
1309 return handle_reassoc_response(p, length);
1310 case ST_PROBE_REQUEST:
1311 printf("Probe Request");
1312 return handle_probe_request(p, length);
1313 case ST_PROBE_RESPONSE:
1314 printf("Probe Response");
1315 return handle_probe_response(p, length);
1316 case ST_BEACON:
1317 printf("Beacon");
1318 return handle_beacon(p, length);
1319 case ST_ATIM:
1320 printf("ATIM");
1321 return handle_atim();
1322 case ST_DISASSOC:
1323 printf("Disassociation");
1324 return handle_disassoc(p, length);
1325 case ST_AUTH:
1326 printf("Authentication");
1327 if (!TTEST2(*p, 3))
1328 return 0;
1329 if ((p[0] == 0 ) && (p[1] == 0) && (p[2] == 0)) {
1330 printf("Authentication (Shared-Key)-3 ");
1331 return wep_print(p);
1332 }
1333 return handle_auth(p, length);
1334 case ST_DEAUTH:
1335 printf("DeAuthentication");
1336 return handle_deauth(pmh, p, length);
1337 break;
1338 case ST_ACTION:
1339 printf("Action");
1340 return handle_action(pmh, p, length);
1341 break;
1342 default:
1343 printf("Unhandled Management subtype(%x)",
1344 FC_SUBTYPE(fc));
1345 return 1;
1346 }
1347 }
1348
1349
1350 /*********************************************************************************
1351 * Handles printing all the control frame types
1352 *********************************************************************************/
1353
1354 static int
1355 ctrl_body_print(u_int16_t fc, const u_char *p)
1356 {
1357 switch (FC_SUBTYPE(fc)) {
1358 case CTRL_CONTROL_WRAPPER:
1359 printf("Control Wrapper");
1360 /* XXX - requires special handling */
1361 break;
1362 case CTRL_BAR:
1363 printf("BAR");
1364 if (!TTEST2(*p, CTRL_BAR_HDRLEN))
1365 return 0;
1366 if (!eflag)
1367 printf(" RA:%s TA:%s CTL(%x) SEQ(%u) ",
1368 etheraddr_string(((const struct ctrl_bar_t *)p)->ra),
1369 etheraddr_string(((const struct ctrl_bar_t *)p)->ta),
1370 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_t *)p)->ctl)),
1371 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_t *)p)->seq)));
1372 break;
1373 case CTRL_BA:
1374 printf("BA");
1375 if (!TTEST2(*p, CTRL_BA_HDRLEN))
1376 return 0;
1377 if (!eflag)
1378 printf(" RA:%s ",
1379 etheraddr_string(((const struct ctrl_ba_t *)p)->ra));
1380 break;
1381 case CTRL_PS_POLL:
1382 printf("Power Save-Poll");
1383 if (!TTEST2(*p, CTRL_PS_POLL_HDRLEN))
1384 return 0;
1385 printf(" AID(%x)",
1386 EXTRACT_LE_16BITS(&(((const struct ctrl_ps_poll_t *)p)->aid)));
1387 break;
1388 case CTRL_RTS:
1389 printf("Request-To-Send");
1390 if (!TTEST2(*p, CTRL_RTS_HDRLEN))
1391 return 0;
1392 if (!eflag)
1393 printf(" TA:%s ",
1394 etheraddr_string(((const struct ctrl_rts_t *)p)->ta));
1395 break;
1396 case CTRL_CTS:
1397 printf("Clear-To-Send");
1398 if (!TTEST2(*p, CTRL_CTS_HDRLEN))
1399 return 0;
1400 if (!eflag)
1401 printf(" RA:%s ",
1402 etheraddr_string(((const struct ctrl_cts_t *)p)->ra));
1403 break;
1404 case CTRL_ACK:
1405 printf("Acknowledgment");
1406 if (!TTEST2(*p, CTRL_ACK_HDRLEN))
1407 return 0;
1408 if (!eflag)
1409 printf(" RA:%s ",
1410 etheraddr_string(((const struct ctrl_ack_t *)p)->ra));
1411 break;
1412 case CTRL_CF_END:
1413 printf("CF-End");
1414 if (!TTEST2(*p, CTRL_END_HDRLEN))
1415 return 0;
1416 if (!eflag)
1417 printf(" RA:%s ",
1418 etheraddr_string(((const struct ctrl_end_t *)p)->ra));
1419 break;
1420 case CTRL_END_ACK:
1421 printf("CF-End+CF-Ack");
1422 if (!TTEST2(*p, CTRL_END_ACK_HDRLEN))
1423 return 0;
1424 if (!eflag)
1425 printf(" RA:%s ",
1426 etheraddr_string(((const struct ctrl_end_ack_t *)p)->ra));
1427 break;
1428 default:
1429 printf("Unknown Ctrl Subtype");
1430 }
1431 return 1;
1432 }
1433
1434 /*
1435 * Print Header funcs
1436 */
1437
1438 /*
1439 * Data Frame - Address field contents
1440 *
1441 * To Ds | From DS | Addr 1 | Addr 2 | Addr 3 | Addr 4
1442 * 0 | 0 | DA | SA | BSSID | n/a
1443 * 0 | 1 | DA | BSSID | SA | n/a
1444 * 1 | 0 | BSSID | SA | DA | n/a
1445 * 1 | 1 | RA | TA | DA | SA
1446 */
1447
1448 static void
1449 data_header_print(u_int16_t fc, const u_char *p, const u_int8_t **srcp,
1450 const u_int8_t **dstp)
1451 {
1452 u_int subtype = FC_SUBTYPE(fc);
1453
1454 if (DATA_FRAME_IS_CF_ACK(subtype) || DATA_FRAME_IS_CF_POLL(subtype) ||
1455 DATA_FRAME_IS_QOS(subtype)) {
1456 printf("CF ");
1457 if (DATA_FRAME_IS_CF_ACK(subtype)) {
1458 if (DATA_FRAME_IS_CF_POLL(subtype))
1459 printf("Ack/Poll");
1460 else
1461 printf("Ack");
1462 } else {
1463 if (DATA_FRAME_IS_CF_POLL(subtype))
1464 printf("Poll");
1465 }
1466 if (DATA_FRAME_IS_QOS(subtype))
1467 printf("+QoS");
1468 printf(" ");
1469 }
1470
1471 #define ADDR1 (p + 4)
1472 #define ADDR2 (p + 10)
1473 #define ADDR3 (p + 16)
1474 #define ADDR4 (p + 24)
1475
1476 if (!FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1477 if (srcp != NULL)
1478 *srcp = ADDR2;
1479 if (dstp != NULL)
1480 *dstp = ADDR1;
1481 if (!eflag)
1482 return;
1483 printf("DA:%s SA:%s BSSID:%s ",
1484 etheraddr_string(ADDR1), etheraddr_string(ADDR2),
1485 etheraddr_string(ADDR3));
1486 } else if (!FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1487 if (srcp != NULL)
1488 *srcp = ADDR3;
1489 if (dstp != NULL)
1490 *dstp = ADDR1;
1491 if (!eflag)
1492 return;
1493 printf("DA:%s BSSID:%s SA:%s ",
1494 etheraddr_string(ADDR1), etheraddr_string(ADDR2),
1495 etheraddr_string(ADDR3));
1496 } else if (FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1497 if (srcp != NULL)
1498 *srcp = ADDR2;
1499 if (dstp != NULL)
1500 *dstp = ADDR3;
1501 if (!eflag)
1502 return;
1503 printf("BSSID:%s SA:%s DA:%s ",
1504 etheraddr_string(ADDR1), etheraddr_string(ADDR2),
1505 etheraddr_string(ADDR3));
1506 } else if (FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1507 if (srcp != NULL)
1508 *srcp = ADDR4;
1509 if (dstp != NULL)
1510 *dstp = ADDR3;
1511 if (!eflag)
1512 return;
1513 printf("RA:%s TA:%s DA:%s SA:%s ",
1514 etheraddr_string(ADDR1), etheraddr_string(ADDR2),
1515 etheraddr_string(ADDR3), etheraddr_string(ADDR4));
1516 }
1517
1518 #undef ADDR1
1519 #undef ADDR2
1520 #undef ADDR3
1521 #undef ADDR4
1522 }
1523
1524 static void
1525 mgmt_header_print(const u_char *p, const u_int8_t **srcp,
1526 const u_int8_t **dstp)
1527 {
1528 const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
1529
1530 if (srcp != NULL)
1531 *srcp = hp->sa;
1532 if (dstp != NULL)
1533 *dstp = hp->da;
1534 if (!eflag)
1535 return;
1536
1537 printf("BSSID:%s DA:%s SA:%s ",
1538 etheraddr_string((hp)->bssid), etheraddr_string((hp)->da),
1539 etheraddr_string((hp)->sa));
1540 }
1541
1542 static void
1543 ctrl_header_print(u_int16_t fc, const u_char *p, const u_int8_t **srcp,
1544 const u_int8_t **dstp)
1545 {
1546 if (srcp != NULL)
1547 *srcp = NULL;
1548 if (dstp != NULL)
1549 *dstp = NULL;
1550 if (!eflag)
1551 return;
1552
1553 switch (FC_SUBTYPE(fc)) {
1554 case CTRL_BAR:
1555 printf(" RA:%s TA:%s CTL(%x) SEQ(%u) ",
1556 etheraddr_string(((const struct ctrl_bar_t *)p)->ra),
1557 etheraddr_string(((const struct ctrl_bar_t *)p)->ta),
1558 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_t *)p)->ctl)),
1559 EXTRACT_LE_16BITS(&(((const struct ctrl_bar_t *)p)->seq)));
1560 break;
1561 case CTRL_BA:
1562 printf("RA:%s ",
1563 etheraddr_string(((const struct ctrl_ba_t *)p)->ra));
1564 break;
1565 case CTRL_PS_POLL:
1566 printf("BSSID:%s TA:%s ",
1567 etheraddr_string(((const struct ctrl_ps_poll_t *)p)->bssid),
1568 etheraddr_string(((const struct ctrl_ps_poll_t *)p)->ta));
1569 break;
1570 case CTRL_RTS:
1571 printf("RA:%s TA:%s ",
1572 etheraddr_string(((const struct ctrl_rts_t *)p)->ra),
1573 etheraddr_string(((const struct ctrl_rts_t *)p)->ta));
1574 break;
1575 case CTRL_CTS:
1576 printf("RA:%s ",
1577 etheraddr_string(((const struct ctrl_cts_t *)p)->ra));
1578 break;
1579 case CTRL_ACK:
1580 printf("RA:%s ",
1581 etheraddr_string(((const struct ctrl_ack_t *)p)->ra));
1582 break;
1583 case CTRL_CF_END:
1584 printf("RA:%s BSSID:%s ",
1585 etheraddr_string(((const struct ctrl_end_t *)p)->ra),
1586 etheraddr_string(((const struct ctrl_end_t *)p)->bssid));
1587 break;
1588 case CTRL_END_ACK:
1589 printf("RA:%s BSSID:%s ",
1590 etheraddr_string(((const struct ctrl_end_ack_t *)p)->ra),
1591 etheraddr_string(((const struct ctrl_end_ack_t *)p)->bssid));
1592 break;
1593 default:
1594 printf("(H) Unknown Ctrl Subtype");
1595 break;
1596 }
1597 }
1598
1599 static int
1600 extract_header_length(u_int16_t fc)
1601 {
1602 int len;
1603
1604 switch (FC_TYPE(fc)) {
1605 case T_MGMT:
1606 return MGMT_HDRLEN;
1607 case T_CTRL:
1608 switch (FC_SUBTYPE(fc)) {
1609 case CTRL_BAR:
1610 return CTRL_BAR_HDRLEN;
1611 case CTRL_PS_POLL:
1612 return CTRL_PS_POLL_HDRLEN;
1613 case CTRL_RTS:
1614 return CTRL_RTS_HDRLEN;
1615 case CTRL_CTS:
1616 return CTRL_CTS_HDRLEN;
1617 case CTRL_ACK:
1618 return CTRL_ACK_HDRLEN;
1619 case CTRL_CF_END:
1620 return CTRL_END_HDRLEN;
1621 case CTRL_END_ACK:
1622 return CTRL_END_ACK_HDRLEN;
1623 default:
1624 return 0;
1625 }
1626 case T_DATA:
1627 len = (FC_TO_DS(fc) && FC_FROM_DS(fc)) ? 30 : 24;
1628 if (DATA_FRAME_IS_QOS(FC_SUBTYPE(fc)))
1629 len += 2;
1630 return len;
1631 default:
1632 printf("unknown IEEE802.11 frame type (%d)", FC_TYPE(fc));
1633 return 0;
1634 }
1635 }
1636
1637 static int
1638 extract_mesh_header_length(const u_char *p)
1639 {
1640 return (p[0] &~ 3) ? 0 : 6*(1 + (p[0] & 3));
1641 }
1642
1643 /*
1644 * Print the 802.11 MAC header if eflag is set, and set "*srcp" and "*dstp"
1645 * to point to the source and destination MAC addresses in any case if
1646 * "srcp" and "dstp" aren't null.
1647 */
1648 static void
1649 ieee_802_11_hdr_print(u_int16_t fc, const u_char *p, u_int hdrlen,
1650 u_int meshdrlen, const u_int8_t **srcp, const u_int8_t **dstp)
1651 {
1652 if (vflag) {
1653 if (FC_MORE_DATA(fc))
1654 printf("More Data ");
1655 if (FC_MORE_FLAG(fc))
1656 printf("More Fragments ");
1657 if (FC_POWER_MGMT(fc))
1658 printf("Pwr Mgmt ");
1659 if (FC_RETRY(fc))
1660 printf("Retry ");
1661 if (FC_ORDER(fc))
1662 printf("Strictly Ordered ");
1663 if (FC_WEP(fc))
1664 printf("WEP Encrypted ");
1665 if (FC_TYPE(fc) != T_CTRL || FC_SUBTYPE(fc) != CTRL_PS_POLL)
1666 printf("%dus ",
1667 EXTRACT_LE_16BITS(
1668 &((const struct mgmt_header_t *)p)->duration));
1669 }
1670 if (meshdrlen != 0) {
1671 const struct meshcntl_t *mc =
1672 (const struct meshcntl_t *)&p[hdrlen - meshdrlen];
1673 int ae = mc->flags & 3;
1674
1675 printf("MeshData (AE %d TTL %u seq %u", ae, mc->ttl,
1676 EXTRACT_LE_32BITS(mc->seq));
1677 if (ae > 0)
1678 printf(" A4:%s", etheraddr_string(mc->addr4));
1679 if (ae > 1)
1680 printf(" A5:%s", etheraddr_string(mc->addr5));
1681 if (ae > 2)
1682 printf(" A6:%s", etheraddr_string(mc->addr6));
1683 printf(") ");
1684 }
1685
1686 switch (FC_TYPE(fc)) {
1687 case T_MGMT:
1688 mgmt_header_print(p, srcp, dstp);
1689 break;
1690 case T_CTRL:
1691 ctrl_header_print(fc, p, srcp, dstp);
1692 break;
1693 case T_DATA:
1694 data_header_print(fc, p, srcp, dstp);
1695 break;
1696 default:
1697 printf("(header) unknown IEEE802.11 frame type (%d)",
1698 FC_TYPE(fc));
1699 *srcp = NULL;
1700 *dstp = NULL;
1701 break;
1702 }
1703 }
1704
1705 #ifndef roundup2
1706 #define roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
1707 #endif
1708
1709 static u_int
1710 ieee802_11_print(const u_char *p, u_int length, u_int orig_caplen, int pad,
1711 u_int fcslen)
1712 {
1713 u_int16_t fc;
1714 u_int caplen, hdrlen, meshdrlen;
1715 const u_int8_t *src, *dst;
1716 u_short extracted_ethertype;
1717
1718 caplen = orig_caplen;
1719 /* Remove FCS, if present */
1720 if (length < fcslen) {
1721 printf("[|802.11]");
1722 return caplen;
1723 }
1724 length -= fcslen;
1725 if (caplen > length) {
1726 /* Amount of FCS in actual packet data, if any */
1727 fcslen = caplen - length;
1728 caplen -= fcslen;
1729 snapend -= fcslen;
1730 }
1731
1732 if (caplen < IEEE802_11_FC_LEN) {
1733 printf("[|802.11]");
1734 return orig_caplen;
1735 }
1736
1737 fc = EXTRACT_LE_16BITS(p);
1738 hdrlen = extract_header_length(fc);
1739 if (pad)
1740 hdrlen = roundup2(hdrlen, 4);
1741 if (Hflag && FC_TYPE(fc) == T_DATA &&
1742 DATA_FRAME_IS_QOS(FC_SUBTYPE(fc))) {
1743 meshdrlen = extract_mesh_header_length(p+hdrlen);
1744 hdrlen += meshdrlen;
1745 } else
1746 meshdrlen = 0;
1747
1748
1749 if (caplen < hdrlen) {
1750 printf("[|802.11]");
1751 return hdrlen;
1752 }
1753
1754 ieee_802_11_hdr_print(fc, p, hdrlen, meshdrlen, &src, &dst);
1755
1756 /*
1757 * Go past the 802.11 header.
1758 */
1759 length -= hdrlen;
1760 caplen -= hdrlen;
1761 p += hdrlen;
1762
1763 switch (FC_TYPE(fc)) {
1764 case T_MGMT:
1765 if (!mgmt_body_print(fc,
1766 (const struct mgmt_header_t *)(p - hdrlen), p, length)) {
1767 printf("[|802.11]");
1768 return hdrlen;
1769 }
1770 break;
1771 case T_CTRL:
1772 if (!ctrl_body_print(fc, p - hdrlen)) {
1773 printf("[|802.11]");
1774 return hdrlen;
1775 }
1776 break;
1777 case T_DATA:
1778 if (DATA_FRAME_IS_NULL(FC_SUBTYPE(fc)))
1779 return hdrlen; /* no-data frame */
1780 /* There may be a problem w/ AP not having this bit set */
1781 if (FC_WEP(fc)) {
1782 if (!wep_print(p)) {
1783 printf("[|802.11]");
1784 return hdrlen;
1785 }
1786 } else if (llc_print(p, length, caplen, dst, src,
1787 &extracted_ethertype) == 0) {
1788 /*
1789 * Some kinds of LLC packet we cannot
1790 * handle intelligently
1791 */
1792 if (!eflag)
1793 ieee_802_11_hdr_print(fc, p - hdrlen, hdrlen,
1794 meshdrlen, NULL, NULL);
1795 if (extracted_ethertype)
1796 printf("(LLC %s) ",
1797 etherproto_string(
1798 htons(extracted_ethertype)));
1799 if (!suppress_default_print)
1800 default_print(p, caplen);
1801 }
1802 break;
1803 default:
1804 printf("unknown 802.11 frame type (%d)", FC_TYPE(fc));
1805 break;
1806 }
1807
1808 return hdrlen;
1809 }
1810
1811 /*
1812 * This is the top level routine of the printer. 'p' points
1813 * to the 802.11 header of the packet, 'h->ts' is the timestamp,
1814 * 'h->len' is the length of the packet off the wire, and 'h->caplen'
1815 * is the number of bytes actually captured.
1816 */
1817 u_int
1818 ieee802_11_if_print(const struct pcap_pkthdr *h, const u_char *p)
1819 {
1820 return ieee802_11_print(p, h->len, h->caplen, 0, 0);
1821 }
1822
1823 #define IEEE80211_CHAN_FHSS \
1824 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_GFSK)
1825 #define IEEE80211_CHAN_A \
1826 (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM)
1827 #define IEEE80211_CHAN_B \
1828 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK)
1829 #define IEEE80211_CHAN_PUREG \
1830 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_OFDM)
1831 #define IEEE80211_CHAN_G \
1832 (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN)
1833
1834 #define IS_CHAN_FHSS(flags) \
1835 ((flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS)
1836 #define IS_CHAN_A(flags) \
1837 ((flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A)
1838 #define IS_CHAN_B(flags) \
1839 ((flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B)
1840 #define IS_CHAN_PUREG(flags) \
1841 ((flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG)
1842 #define IS_CHAN_G(flags) \
1843 ((flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G)
1844 #define IS_CHAN_ANYG(flags) \
1845 (IS_CHAN_PUREG(flags) || IS_CHAN_G(flags))
1846
1847 static void
1848 print_chaninfo(int freq, int flags)
1849 {
1850 printf("%u MHz", freq);
1851 if (IS_CHAN_FHSS(flags))
1852 printf(" FHSS");
1853 if (IS_CHAN_A(flags)) {
1854 if (flags & IEEE80211_CHAN_HALF)
1855 printf(" 11a/10Mhz");
1856 else if (flags & IEEE80211_CHAN_QUARTER)
1857 printf(" 11a/5Mhz");
1858 else
1859 printf(" 11a");
1860 }
1861 if (IS_CHAN_ANYG(flags)) {
1862 if (flags & IEEE80211_CHAN_HALF)
1863 printf(" 11g/10Mhz");
1864 else if (flags & IEEE80211_CHAN_QUARTER)
1865 printf(" 11g/5Mhz");
1866 else
1867 printf(" 11g");
1868 } else if (IS_CHAN_B(flags))
1869 printf(" 11b");
1870 if (flags & IEEE80211_CHAN_TURBO)
1871 printf(" Turbo");
1872 if (flags & IEEE80211_CHAN_HT20)
1873 printf(" ht/20");
1874 else if (flags & IEEE80211_CHAN_HT40D)
1875 printf(" ht/40-");
1876 else if (flags & IEEE80211_CHAN_HT40U)
1877 printf(" ht/40+");
1878 printf(" ");
1879 }
1880
1881 static int
1882 print_radiotap_field(struct cpack_state *s, u_int32_t bit, u_int8_t *flags,
1883 struct radiotap_state *state, u_int32_t presentflags)
1884 {
1885 union {
1886 int8_t i8;
1887 u_int8_t u8;
1888 int16_t i16;
1889 u_int16_t u16;
1890 u_int32_t u32;
1891 u_int64_t u64;
1892 } u, u2, u3, u4;
1893 int rc;
1894
1895 switch (bit) {
1896 case IEEE80211_RADIOTAP_FLAGS:
1897 rc = cpack_uint8(s, &u.u8);
1898 if (rc != 0)
1899 break;
1900 *flags = u.u8;
1901 break;
1902 case IEEE80211_RADIOTAP_RATE:
1903 rc = cpack_uint8(s, &u.u8);
1904 if (rc != 0)
1905 break;
1906
1907 /* Save state rate */
1908 state->rate = u.u8;
1909 break;
1910 case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
1911 case IEEE80211_RADIOTAP_DB_ANTNOISE:
1912 case IEEE80211_RADIOTAP_ANTENNA:
1913 rc = cpack_uint8(s, &u.u8);
1914 break;
1915 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
1916 case IEEE80211_RADIOTAP_DBM_ANTNOISE:
1917 rc = cpack_int8(s, &u.i8);
1918 break;
1919 case IEEE80211_RADIOTAP_CHANNEL:
1920 rc = cpack_uint16(s, &u.u16);
1921 if (rc != 0)
1922 break;
1923 rc = cpack_uint16(s, &u2.u16);
1924 break;
1925 case IEEE80211_RADIOTAP_FHSS:
1926 case IEEE80211_RADIOTAP_LOCK_QUALITY:
1927 case IEEE80211_RADIOTAP_TX_ATTENUATION:
1928 case IEEE80211_RADIOTAP_RX_FLAGS:
1929 rc = cpack_uint16(s, &u.u16);
1930 break;
1931 case IEEE80211_RADIOTAP_DB_TX_ATTENUATION:
1932 rc = cpack_uint8(s, &u.u8);
1933 break;
1934 case IEEE80211_RADIOTAP_DBM_TX_POWER:
1935 rc = cpack_int8(s, &u.i8);
1936 break;
1937 case IEEE80211_RADIOTAP_TSFT:
1938 rc = cpack_uint64(s, &u.u64);
1939 break;
1940 case IEEE80211_RADIOTAP_XCHANNEL:
1941 rc = cpack_uint32(s, &u.u32);
1942 if (rc != 0)
1943 break;
1944 rc = cpack_uint16(s, &u2.u16);
1945 if (rc != 0)
1946 break;
1947 rc = cpack_uint8(s, &u3.u8);
1948 if (rc != 0)
1949 break;
1950 rc = cpack_uint8(s, &u4.u8);
1951 break;
1952 case IEEE80211_RADIOTAP_MCS:
1953 rc = cpack_uint8(s, &u.u8);
1954 if (rc != 0)
1955 break;
1956 rc = cpack_uint8(s, &u2.u8);
1957 if (rc != 0)
1958 break;
1959 rc = cpack_uint8(s, &u3.u8);
1960 break;
1961 case IEEE80211_RADIOTAP_VENDOR_NAMESPACE: {
1962 u_int8_t vns[3];
1963 u_int16_t length;
1964 u_int8_t subspace;
1965
1966 if ((cpack_align_and_reserve(s, 2)) == NULL) {
1967 rc = -1;
1968 break;
1969 }
1970
1971 rc = cpack_uint8(s, &vns[0]);
1972 if (rc != 0)
1973 break;
1974 rc = cpack_uint8(s, &vns[1]);
1975 if (rc != 0)
1976 break;
1977 rc = cpack_uint8(s, &vns[2]);
1978 if (rc != 0)
1979 break;
1980 rc = cpack_uint8(s, &subspace);
1981 if (rc != 0)
1982 break;
1983 rc = cpack_uint16(s, &length);
1984 if (rc != 0)
1985 break;
1986
1987 /* Skip up to length */
1988 s->c_next += length;
1989 break;
1990 }
1991 default:
1992 /* this bit indicates a field whose
1993 * size we do not know, so we cannot
1994 * proceed. Just print the bit number.
1995 */
1996 printf("[bit %u] ", bit);
1997 return -1;
1998 }
1999
2000 if (rc != 0) {
2001 printf("[|802.11]");
2002 return rc;
2003 }
2004
2005 /* Preserve the state present flags */
2006 state->present = presentflags;
2007
2008 switch (bit) {
2009 case IEEE80211_RADIOTAP_CHANNEL:
2010 /*
2011 * If CHANNEL and XCHANNEL are both present, skip
2012 * CHANNEL.
2013 */
2014 if (presentflags & (1 << IEEE80211_RADIOTAP_XCHANNEL))
2015 break;
2016 print_chaninfo(u.u16, u2.u16);
2017 break;
2018 case IEEE80211_RADIOTAP_FHSS:
2019 printf("fhset %d fhpat %d ", u.u16 & 0xff, (u.u16 >> 8) & 0xff);
2020 break;
2021 case IEEE80211_RADIOTAP_RATE:
2022 /*
2023 * XXX On FreeBSD rate & 0x80 means we have an MCS. On
2024 * Linux and AirPcap it does not. (What about
2025 * Mac OS X, NetBSD, OpenBSD, and DragonFly BSD?)
2026 *
2027 * This is an issue either for proprietary extensions
2028 * to 11a or 11g, which do exist, or for 11n
2029 * implementations that stuff a rate value into
2030 * this field, which also appear to exist.
2031 *
2032 * We currently handle that by assuming that
2033 * if the 0x80 bit is set *and* the remaining
2034 * bits have a value between 0 and 15 it's
2035 * an MCS value, otherwise it's a rate. If
2036 * there are cases where systems that use
2037 * "0x80 + MCS index" for MCS indices > 15,
2038 * or stuff a rate value here between 64 and
2039 * 71.5 Mb/s in here, we'll need a preference
2040 * setting. Such rates do exist, e.g. 11n
2041 * MCS 7 at 20 MHz with a long guard interval.
2042 */
2043 if (u.u8 >= 0x80 && u.u8 <= 0x8f) {
2044 /*
2045 * XXX - we don't know the channel width
2046 * or guard interval length, so we can't
2047 * convert this to a data rate.
2048 *
2049 * If you want us to show a data rate,
2050 * use the MCS field, not the Rate field;
2051 * the MCS field includes not only the
2052 * MCS index, it also includes bandwidth
2053 * and guard interval information.
2054 *
2055 * XXX - can we get the channel width
2056 * from XChannel and the guard interval
2057 * information from Flags, at least on
2058 * FreeBSD?
2059 */
2060 printf("MCS %u ", u.u8 & 0x7f);
2061 } else
2062 printf("%2.1f Mb/s ", .5*u.u8);
2063 break;
2064 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
2065 printf("%ddB signal ", u.i8);
2066 break;
2067 case IEEE80211_RADIOTAP_DBM_ANTNOISE:
2068 printf("%ddB noise ", u.i8);
2069 break;
2070 case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
2071 printf("%ddB signal ", u.u8);
2072 break;
2073 case IEEE80211_RADIOTAP_DB_ANTNOISE:
2074 printf("%ddB noise ", u.u8);
2075 break;
2076 case IEEE80211_RADIOTAP_LOCK_QUALITY:
2077 printf("%u sq ", u.u16);
2078 break;
2079 case IEEE80211_RADIOTAP_TX_ATTENUATION:
2080 printf("%d tx power ", -(int)u.u16);
2081 break;
2082 case IEEE80211_RADIOTAP_DB_TX_ATTENUATION:
2083 printf("%ddB tx power ", -(int)u.u8);
2084 break;
2085 case IEEE80211_RADIOTAP_DBM_TX_POWER:
2086 printf("%ddBm tx power ", u.i8);
2087 break;
2088 case IEEE80211_RADIOTAP_FLAGS:
2089 if (u.u8 & IEEE80211_RADIOTAP_F_CFP)
2090 printf("cfp ");
2091 if (u.u8 & IEEE80211_RADIOTAP_F_SHORTPRE)
2092 printf("short preamble ");
2093 if (u.u8 & IEEE80211_RADIOTAP_F_WEP)
2094 printf("wep ");
2095 if (u.u8 & IEEE80211_RADIOTAP_F_FRAG)
2096 printf("fragmented ");
2097 if (u.u8 & IEEE80211_RADIOTAP_F_BADFCS)
2098 printf("bad-fcs ");
2099 break;
2100 case IEEE80211_RADIOTAP_ANTENNA:
2101 printf("antenna %d ", u.u8);
2102 break;
2103 case IEEE80211_RADIOTAP_TSFT:
2104 printf("%" PRIu64 "us tsft ", u.u64);
2105 break;
2106 case IEEE80211_RADIOTAP_RX_FLAGS:
2107 /* Do nothing for now */
2108 break;
2109 case IEEE80211_RADIOTAP_XCHANNEL:
2110 print_chaninfo(u2.u16, u.u32);
2111 break;
2112 case IEEE80211_RADIOTAP_MCS: {
2113 static const char *bandwidth[4] = {
2114 "20 MHz",
2115 "40 MHz",
2116 "20 MHz (L)",
2117 "20 MHz (U)"
2118 };
2119 float htrate;
2120
2121 if (u.u8 & IEEE80211_RADIOTAP_MCS_MCS_INDEX_KNOWN) {
2122 /*
2123 * We know the MCS index.
2124 */
2125 if (u3.u8 <= MAX_MCS_INDEX) {
2126 /*
2127 * And it's in-range.
2128 */
2129 if (u.u8 & (IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN|IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN)) {
2130 /*
2131 * And we know both the bandwidth and
2132 * the guard interval, so we can look
2133 * up the rate.
2134 */
2135 htrate =
2136 ieee80211_float_htrates \
2137 [u3.u8] \
2138 [((u2.u8 & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK) == IEEE80211_RADIOTAP_MCS_BANDWIDTH_40 ? 1 : 0)] \
2139 [((u2.u8 & IEEE80211_RADIOTAP_MCS_SHORT_GI) ? 1 : 0)];
2140 } else {
2141 /*
2142 * We don't know both the bandwidth
2143 * and the guard interval, so we can
2144 * only report the MCS index.
2145 */
2146 htrate = 0.0;
2147 }
2148 } else {
2149 /*
2150 * The MCS value is out of range.
2151 */
2152 htrate = 0.0;
2153 }
2154 if (htrate != 0.0) {
2155 /*
2156 * We have the rate.
2157 * Print it.
2158 */
2159 printf("%.1f Mb/s MCS %u ", htrate, u3.u8);
2160 } else {
2161 /*
2162 * We at least have the MCS index.
2163 * Print it.
2164 */
2165 printf("MCS %u ", u3.u8);
2166 }
2167 }
2168 if (u.u8 & IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN) {
2169 printf("%s ",
2170 bandwidth[u2.u8 & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK]);
2171 }
2172 if (u.u8 & IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN) {
2173 printf("%s GI ",
2174 (u2.u8 & IEEE80211_RADIOTAP_MCS_SHORT_GI) ?
2175 "short" : "lon");
2176 }
2177 if (u.u8 & IEEE80211_RADIOTAP_MCS_HT_FORMAT_KNOWN) {
2178 printf("%s ",
2179 (u2.u8 & IEEE80211_RADIOTAP_MCS_HT_GREENFIELD) ?
2180 "greenfield" : "mixed");
2181 }
2182 if (u.u8 & IEEE80211_RADIOTAP_MCS_FEC_TYPE_KNOWN) {
2183 printf("%s FEC ",
2184 (u2.u8 & IEEE80211_RADIOTAP_MCS_FEC_LDPC) ?
2185 "LDPC" : "BCC");
2186 }
2187 break;
2188 }
2189 }
2190 return 0;
2191 }
2192
2193 static u_int
2194 ieee802_11_radio_print(const u_char *p, u_int length, u_int caplen)
2195 {
2196 #define BITNO_32(x) (((x) >> 16) ? 16 + BITNO_16((x) >> 16) : BITNO_16((x)))
2197 #define BITNO_16(x) (((x) >> 8) ? 8 + BITNO_8((x) >> 8) : BITNO_8((x)))
2198 #define BITNO_8(x) (((x) >> 4) ? 4 + BITNO_4((x) >> 4) : BITNO_4((x)))
2199 #define BITNO_4(x) (((x) >> 2) ? 2 + BITNO_2((x) >> 2) : BITNO_2((x)))
2200 #define BITNO_2(x) (((x) & 2) ? 1 : 0)
2201 #define BIT(n) (1U << n)
2202 #define IS_EXTENDED(__p) \
2203 (EXTRACT_LE_32BITS(__p) & BIT(IEEE80211_RADIOTAP_EXT)) != 0
2204
2205 struct cpack_state cpacker;
2206 struct ieee80211_radiotap_header *hdr;
2207 u_int32_t present, next_present;
2208 u_int32_t presentflags = 0;
2209 u_int32_t *presentp, *last_presentp;
2210 enum ieee80211_radiotap_type bit;
2211 int bit0;
2212 const u_char *iter;
2213 u_int len;
2214 u_int8_t flags;
2215 int pad;
2216 u_int fcslen;
2217 struct radiotap_state state;
2218
2219 if (caplen < sizeof(*hdr)) {
2220 printf("[|802.11]");
2221 return caplen;
2222 }
2223
2224 hdr = (struct ieee80211_radiotap_header *)p;
2225
2226 len = EXTRACT_LE_16BITS(&hdr->it_len);
2227
2228 if (caplen < len) {
2229 printf("[|802.11]");
2230 return caplen;
2231 }
2232 for (last_presentp = &hdr->it_present;
2233 IS_EXTENDED(last_presentp) &&
2234 (u_char*)(last_presentp + 1) <= p + len;
2235 last_presentp++);
2236
2237 /* are there more bitmap extensions than bytes in header? */
2238 if (IS_EXTENDED(last_presentp)) {
2239 printf("[|802.11]");
2240 return caplen;
2241 }
2242
2243 iter = (u_char*)(last_presentp + 1);
2244
2245 if (cpack_init(&cpacker, (u_int8_t*)iter, len - (iter - p)) != 0) {
2246 /* XXX */
2247 printf("[|802.11]");
2248 return caplen;
2249 }
2250
2251 /* Assume no flags */
2252 flags = 0;
2253 /* Assume no Atheros padding between 802.11 header and body */
2254 pad = 0;
2255 /* Assume no FCS at end of frame */
2256 fcslen = 0;
2257 for (bit0 = 0, presentp = &hdr->it_present; presentp <= last_presentp;
2258 presentp++, bit0 += 32) {
2259 presentflags = EXTRACT_LE_32BITS(presentp);
2260
2261 /* Clear state. */
2262 memset(&state, 0, sizeof(state));
2263
2264 for (present = EXTRACT_LE_32BITS(presentp); present;
2265 present = next_present) {
2266 /* clear the least significant bit that is set */
2267 next_present = present & (present - 1);
2268
2269 /* extract the least significant bit that is set */
2270 bit = (enum ieee80211_radiotap_type)
2271 (bit0 + BITNO_32(present ^ next_present));
2272
2273 if (print_radiotap_field(&cpacker, bit, &flags, &state, presentflags) != 0)
2274 goto out;
2275 }
2276 }
2277
2278 out:
2279 if (flags & IEEE80211_RADIOTAP_F_DATAPAD)
2280 pad = 1; /* Atheros padding */
2281 if (flags & IEEE80211_RADIOTAP_F_FCS)
2282 fcslen = 4; /* FCS at end of packet */
2283 return len + ieee802_11_print(p + len, length - len, caplen - len, pad,
2284 fcslen);
2285 #undef BITNO_32
2286 #undef BITNO_16
2287 #undef BITNO_8
2288 #undef BITNO_4
2289 #undef BITNO_2
2290 #undef BIT
2291 }
2292
2293 static u_int
2294 ieee802_11_avs_radio_print(const u_char *p, u_int length, u_int caplen)
2295 {
2296 u_int32_t caphdr_len;
2297
2298 if (caplen < 8) {
2299 printf("[|802.11]");
2300 return caplen;
2301 }
2302
2303 caphdr_len = EXTRACT_32BITS(p + 4);
2304 if (caphdr_len < 8) {
2305 /*
2306 * Yow! The capture header length is claimed not
2307 * to be large enough to include even the version
2308 * cookie or capture header length!
2309 */
2310 printf("[|802.11]");
2311 return caplen;
2312 }
2313
2314 if (caplen < caphdr_len) {
2315 printf("[|802.11]");
2316 return caplen;
2317 }
2318
2319 return caphdr_len + ieee802_11_print(p + caphdr_len,
2320 length - caphdr_len, caplen - caphdr_len, 0, 0);
2321 }
2322
2323 #define PRISM_HDR_LEN 144
2324
2325 #define WLANCAP_MAGIC_COOKIE_BASE 0x80211000
2326 #define WLANCAP_MAGIC_COOKIE_V1 0x80211001
2327 #define WLANCAP_MAGIC_COOKIE_V2 0x80211002
2328
2329 /*
2330 * For DLT_PRISM_HEADER; like DLT_IEEE802_11, but with an extra header,
2331 * containing information such as radio information, which we
2332 * currently ignore.
2333 *
2334 * If, however, the packet begins with WLANCAP_MAGIC_COOKIE_V1 or
2335 * WLANCAP_MAGIC_COOKIE_V2, it's really DLT_IEEE802_11_RADIO_AVS
2336 * (currently, on Linux, there's no ARPHRD_ type for
2337 * DLT_IEEE802_11_RADIO_AVS, as there is a ARPHRD_IEEE80211_PRISM
2338 * for DLT_PRISM_HEADER, so ARPHRD_IEEE80211_PRISM is used for
2339 * the AVS header, and the first 4 bytes of the header are used to
2340 * indicate whether it's a Prism header or an AVS header).
2341 */
2342 u_int
2343 prism_if_print(const struct pcap_pkthdr *h, const u_char *p)
2344 {
2345 u_int caplen = h->caplen;
2346 u_int length = h->len;
2347 u_int32_t msgcode;
2348
2349 if (caplen < 4) {
2350 printf("[|802.11]");
2351 return caplen;
2352 }
2353
2354 msgcode = EXTRACT_32BITS(p);
2355 if (msgcode == WLANCAP_MAGIC_COOKIE_V1 ||
2356 msgcode == WLANCAP_MAGIC_COOKIE_V2)
2357 return ieee802_11_avs_radio_print(p, length, caplen);
2358
2359 if (caplen < PRISM_HDR_LEN) {
2360 printf("[|802.11]");
2361 return caplen;
2362 }
2363
2364 return PRISM_HDR_LEN + ieee802_11_print(p + PRISM_HDR_LEN,
2365 length - PRISM_HDR_LEN, caplen - PRISM_HDR_LEN, 0, 0);
2366 }
2367
2368 /*
2369 * For DLT_IEEE802_11_RADIO; like DLT_IEEE802_11, but with an extra
2370 * header, containing information such as radio information.
2371 */
2372 u_int
2373 ieee802_11_radio_if_print(const struct pcap_pkthdr *h, const u_char *p)
2374 {
2375 return ieee802_11_radio_print(p, h->len, h->caplen);
2376 }
2377
2378 /*
2379 * For DLT_IEEE802_11_RADIO_AVS; like DLT_IEEE802_11, but with an
2380 * extra header, containing information such as radio information,
2381 * which we currently ignore.
2382 */
2383 u_int
2384 ieee802_11_radio_avs_if_print(const struct pcap_pkthdr *h, const u_char *p)
2385 {
2386 return ieee802_11_avs_radio_print(p, h->len, h->caplen);
2387 }
[mirror] the TCPdump network dissector