contrib/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                                 if (!ND_TTEST2(*(p + offset), ssid.length))
1043                                         return 0;
1044                                 if (length < ssid.length)
1045                                         return 0;
1046                                 memcpy(&ssid.ssid, p + offset, ssid.length);
1047                                 offset += ssid.length;
1048                                 length -= ssid.length;
1049                         }
1050                         ssid.ssid[ssid.length] = '\0';
1051                         /*
1052                          * Present and not truncated.
1053                          *
1054                          * If we haven't already seen an SSID IE,
1055                          * copy this one, otherwise ignore this one,
1056                          * so we later report the first one we saw.
1057                          */
1058                         if (!pbody->ssid_present) {
1059                                 pbody->ssid = ssid;
1060                                 pbody->ssid_present = 1;
1061                         }
1062                         break;
1063                 case E_CHALLENGE:
1064                         memcpy(&challenge, p + offset, 2);
1065                         offset += 2;
1066                         length -= 2;
1067                         if (challenge.length != 0) {
1068                                 if (challenge.length >
1069                                     sizeof(challenge.text) - 1)
1070                                         return 0;
1071                                 if (!ND_TTEST2(*(p + offset), challenge.length))
1072                                         return 0;
1073                                 if (length < challenge.length)
1074                                         return 0;
1075                                 memcpy(&challenge.text, p + offset,
1076                                     challenge.length);
1077                                 offset += challenge.length;
1078                                 length -= challenge.length;
1079                         }
1080                         challenge.text[challenge.length] = '\0';
1081                         /*
1082                          * Present and not truncated.
1083                          *
1084                          * If we haven't already seen a challenge IE,
1085                          * copy this one, otherwise ignore this one,
1086                          * so we later report the first one we saw.
1087                          */
1088                         if (!pbody->challenge_present) {
1089                                 pbody->challenge = challenge;
1090                                 pbody->challenge_present = 1;
1091                         }
1092                         break;
1093                 case E_RATES:
1094                         memcpy(&rates, p + offset, 2);
1095                         offset += 2;
1096                         length -= 2;
1097                         if (rates.length != 0) {
1098                                 if (rates.length > sizeof rates.rate)
1099                                         return 0;
1100                                 if (!ND_TTEST2(*(p + offset), rates.length))
1101                                         return 0;
1102                                 if (length < rates.length)
1103                                         return 0;
1104                                 memcpy(&rates.rate, p + offset, rates.length);
1105                                 offset += rates.length;
1106                                 length -= rates.length;
1107                         }
1108                         /*
1109                          * Present and not truncated.
1110                          *
1111                          * If we haven't already seen a rates IE,
1112                          * copy this one if it's not zero-length,
1113                          * otherwise ignore this one, so we later
1114                          * report the first one we saw.
1115                          *
1116                          * We ignore zero-length rates IEs as some
1117                          * devices seem to put a zero-length rates
1118                          * IE, followed by an SSID IE, followed by
1119                          * a non-zero-length rates IE into frames,
1120                          * even though IEEE Std 802.11-2007 doesn't
1121                          * seem to indicate that a zero-length rates
1122                          * IE is valid.
1123                          */
1124                         if (!pbody->rates_present && rates.length != 0) {
1125                                 pbody->rates = rates;
1126                                 pbody->rates_present = 1;
1127                         }
1128                         break;
1129                 case E_DS:
1130                         memcpy(&ds, p + offset, 2);
1131                         offset += 2;
1132                         length -= 2;
1133                         if (ds.length != 1) {
1134                                 offset += ds.length;
1135                                 length -= ds.length;
1136                                 break;
1137                         }
1138                         ds.channel = *(p + offset);
1139                         offset += 1;
1140                         length -= 1;
1141                         /*
1142                          * Present and not truncated.
1143                          *
1144                          * If we haven't already seen a DS IE,
1145                          * copy this one, otherwise ignore this one,
1146                          * so we later report the first one we saw.
1147                          */
1148                         if (!pbody->ds_present) {
1149                                 pbody->ds = ds;
1150                                 pbody->ds_present = 1;
1151                         }
1152                         break;
1153                 case E_CF:
1154                         memcpy(&cf, p + offset, 2);
1155                         offset += 2;
1156                         length -= 2;
1157                         if (cf.length != 6) {
1158                                 offset += cf.length;
1159                                 length -= cf.length;
1160                                 break;
1161                         }
1162                         memcpy(&cf.count, p + offset, 6);
1163                         offset += 6;
1164                         length -= 6;
1165                         /*
1166                          * Present and not truncated.
1167                          *
1168                          * If we haven't already seen a CF IE,
1169                          * copy this one, otherwise ignore this one,
1170                          * so we later report the first one we saw.
1171                          */
1172                         if (!pbody->cf_present) {
1173                                 pbody->cf = cf;
1174                                 pbody->cf_present = 1;
1175                         }
1176                         break;
1177                 case E_TIM:
1178                         memcpy(&tim, p + offset, 2);
1179                         offset += 2;
1180                         length -= 2;
1181                         if (tim.length <= 3) {
1182                                 offset += tim.length;
1183                                 length -= tim.length;
1184                                 break;
1185                         }
1186                         if (tim.length - 3 > (int)sizeof tim.bitmap)
1187                                 return 0;
1188                         memcpy(&tim.count, p + offset, 3);
1189                         offset += 3;
1190                         length -= 3;
1191
1192                         memcpy(tim.bitmap, p + (tim.length - 3),
1193                             (tim.length - 3));
1194                         offset += tim.length - 3;
1195                         length -= tim.length - 3;
1196                         /*
1197                          * Present and not truncated.
1198                          *
1199                          * If we haven't already seen a TIM IE,
1200                          * copy this one, otherwise ignore this one,
1201                          * so we later report the first one we saw.
1202                          */
1203                         if (!pbody->tim_present) {
1204                                 pbody->tim = tim;
1205                                 pbody->tim_present = 1;
1206                         }
1207                         break;
1208                 default:
1209 #if 0
1210                         ND_PRINT((ndo, "(1) unhandled element_id (%d)  ",
1211                             *(p + offset)));
1212 #endif
1213                         offset += 2 + elementlen;
1214                         length -= 2 + elementlen;
1215                         break;
1216                 }
1217         }
1218
1219         /* No problems found. */
1220         return 1;
1221 }
1222
1223 /*********************************************************************************
1224  * Print Handle functions for the management frame types
1225  *********************************************************************************/
1226
1227 static int
1228 handle_beacon(netdissect_options *ndo,
1229               const u_char *p, u_int length)
1230 {
1231         struct mgmt_body_t pbody;
1232         int offset = 0;
1233         int ret;
1234
1235         memset(&pbody, 0, sizeof(pbody));
1236
1237         if (!ND_TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1238             IEEE802_11_CAPINFO_LEN))
1239                 return 0;
1240         if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1241             IEEE802_11_CAPINFO_LEN)
1242                 return 0;
1243         memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
1244         offset += IEEE802_11_TSTAMP_LEN;
1245         length -= IEEE802_11_TSTAMP_LEN;
1246         pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
1247         offset += IEEE802_11_BCNINT_LEN;
1248         length -= IEEE802_11_BCNINT_LEN;
1249         pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
1250         offset += IEEE802_11_CAPINFO_LEN;
1251         length -= IEEE802_11_CAPINFO_LEN;
1252
1253         ret = parse_elements(ndo, &pbody, p, offset, length);
1254
1255         PRINT_SSID(pbody);
1256         PRINT_RATES(pbody);
1257         ND_PRINT((ndo, " %s",
1258             CAPABILITY_ESS(pbody.capability_info) ? "ESS" : "IBSS"));
1259         PRINT_DS_CHANNEL(pbody);
1260
1261         return ret;
1262 }
1263
1264 static int
1265 handle_assoc_request(netdissect_options *ndo,
1266                      const u_char *p, u_int length)
1267 {
1268         struct mgmt_body_t pbody;
1269         int offset = 0;
1270         int ret;
1271
1272         memset(&pbody, 0, sizeof(pbody));
1273
1274         if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN))
1275                 return 0;
1276         if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN)
1277                 return 0;
1278         pbody.capability_info = EXTRACT_LE_16BITS(p);
1279         offset += IEEE802_11_CAPINFO_LEN;
1280         length -= IEEE802_11_CAPINFO_LEN;
1281         pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
1282         offset += IEEE802_11_LISTENINT_LEN;
1283         length -= IEEE802_11_LISTENINT_LEN;
1284
1285         ret = parse_elements(ndo, &pbody, p, offset, length);
1286
1287         PRINT_SSID(pbody);
1288         PRINT_RATES(pbody);
1289         return ret;
1290 }
1291
1292 static int
1293 handle_assoc_response(netdissect_options *ndo,
1294                       const u_char *p, u_int length)
1295 {
1296         struct mgmt_body_t pbody;
1297         int offset = 0;
1298         int ret;
1299
1300         memset(&pbody, 0, sizeof(pbody));
1301
1302         if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
1303             IEEE802_11_AID_LEN))
1304                 return 0;
1305         if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_STATUS_LEN +
1306             IEEE802_11_AID_LEN)
1307                 return 0;
1308         pbody.capability_info = EXTRACT_LE_16BITS(p);
1309         offset += IEEE802_11_CAPINFO_LEN;
1310         length -= IEEE802_11_CAPINFO_LEN;
1311         pbody.status_code = EXTRACT_LE_16BITS(p+offset);
1312         offset += IEEE802_11_STATUS_LEN;
1313         length -= IEEE802_11_STATUS_LEN;
1314         pbody.aid = EXTRACT_LE_16BITS(p+offset);
1315         offset += IEEE802_11_AID_LEN;
1316         length -= IEEE802_11_AID_LEN;
1317
1318         ret = parse_elements(ndo, &pbody, p, offset, length);
1319
1320         ND_PRINT((ndo, " AID(%x) :%s: %s", ((uint16_t)(pbody.aid << 2 )) >> 2 ,
1321             CAPABILITY_PRIVACY(pbody.capability_info) ? " PRIVACY " : "",
1322             (pbody.status_code < NUM_STATUSES
1323                 ? status_text[pbody.status_code]
1324                 : "n/a")));
1325
1326         return ret;
1327 }
1328
1329 static int
1330 handle_reassoc_request(netdissect_options *ndo,
1331                        const u_char *p, u_int length)
1332 {
1333         struct mgmt_body_t pbody;
1334         int offset = 0;
1335         int ret;
1336
1337         memset(&pbody, 0, sizeof(pbody));
1338
1339         if (!ND_TTEST2(*p, IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1340             IEEE802_11_AP_LEN))
1341                 return 0;
1342         if (length < IEEE802_11_CAPINFO_LEN + IEEE802_11_LISTENINT_LEN +
1343             IEEE802_11_AP_LEN)
1344                 return 0;
1345         pbody.capability_info = EXTRACT_LE_16BITS(p);
1346         offset += IEEE802_11_CAPINFO_LEN;
1347         length -= IEEE802_11_CAPINFO_LEN;
1348         pbody.listen_interval = EXTRACT_LE_16BITS(p+offset);
1349         offset += IEEE802_11_LISTENINT_LEN;
1350         length -= IEEE802_11_LISTENINT_LEN;
1351         memcpy(&pbody.ap, p+offset, IEEE802_11_AP_LEN);
1352         offset += IEEE802_11_AP_LEN;
1353         length -= IEEE802_11_AP_LEN;
1354
1355         ret = parse_elements(ndo, &pbody, p, offset, length);
1356
1357         PRINT_SSID(pbody);
1358         ND_PRINT((ndo, " AP : %s", etheraddr_string(ndo,  pbody.ap )));
1359
1360         return ret;
1361 }
1362
1363 static int
1364 handle_reassoc_response(netdissect_options *ndo,
1365                         const u_char *p, u_int length)
1366 {
1367         /* Same as a Association Reponse */
1368         return handle_assoc_response(ndo, p, length);
1369 }
1370
1371 static int
1372 handle_probe_request(netdissect_options *ndo,
1373                      const u_char *p, u_int length)
1374 {
1375         struct mgmt_body_t  pbody;
1376         int offset = 0;
1377         int ret;
1378
1379         memset(&pbody, 0, sizeof(pbody));
1380
1381         ret = parse_elements(ndo, &pbody, p, offset, length);
1382
1383         PRINT_SSID(pbody);
1384         PRINT_RATES(pbody);
1385
1386         return ret;
1387 }
1388
1389 static int
1390 handle_probe_response(netdissect_options *ndo,
1391                       const u_char *p, u_int length)
1392 {
1393         struct mgmt_body_t  pbody;
1394         int offset = 0;
1395         int ret;
1396
1397         memset(&pbody, 0, sizeof(pbody));
1398
1399         if (!ND_TTEST2(*p, IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1400             IEEE802_11_CAPINFO_LEN))
1401                 return 0;
1402         if (length < IEEE802_11_TSTAMP_LEN + IEEE802_11_BCNINT_LEN +
1403             IEEE802_11_CAPINFO_LEN)
1404                 return 0;
1405         memcpy(&pbody.timestamp, p, IEEE802_11_TSTAMP_LEN);
1406         offset += IEEE802_11_TSTAMP_LEN;
1407         length -= IEEE802_11_TSTAMP_LEN;
1408         pbody.beacon_interval = EXTRACT_LE_16BITS(p+offset);
1409         offset += IEEE802_11_BCNINT_LEN;
1410         length -= IEEE802_11_BCNINT_LEN;
1411         pbody.capability_info = EXTRACT_LE_16BITS(p+offset);
1412         offset += IEEE802_11_CAPINFO_LEN;
1413         length -= IEEE802_11_CAPINFO_LEN;
1414
1415         ret = parse_elements(ndo, &pbody, p, offset, length);
1416
1417         PRINT_SSID(pbody);
1418         PRINT_RATES(pbody);
1419         PRINT_DS_CHANNEL(pbody);
1420
1421         return ret;
1422 }
1423
1424 static int
1425 handle_atim(void)
1426 {
1427         /* the frame body for ATIM is null. */
1428         return 1;
1429 }
1430
1431 static int
1432 handle_disassoc(netdissect_options *ndo,
1433                 const u_char *p, u_int length)
1434 {
1435         struct mgmt_body_t  pbody;
1436
1437         memset(&pbody, 0, sizeof(pbody));
1438
1439         if (!ND_TTEST2(*p, IEEE802_11_REASON_LEN))
1440                 return 0;
1441         if (length < IEEE802_11_REASON_LEN)
1442                 return 0;
1443         pbody.reason_code = EXTRACT_LE_16BITS(p);
1444
1445         ND_PRINT((ndo, ": %s",
1446             (pbody.reason_code < NUM_REASONS)
1447                 ? reason_text[pbody.reason_code]
1448                 : "Reserved"));
1449
1450         return 1;
1451 }
1452
1453 static int
1454 handle_auth(netdissect_options *ndo,
1455             const u_char *p, u_int length)
1456 {
1457         struct mgmt_body_t  pbody;
1458         int offset = 0;
1459         int ret;
1460
1461         memset(&pbody, 0, sizeof(pbody));
1462
1463         if (!ND_TTEST2(*p, 6))
1464                 return 0;
1465         if (length < 6)
1466                 return 0;
1467         pbody.auth_alg = EXTRACT_LE_16BITS(p);
1468         offset += 2;
1469         length -= 2;
1470         pbody.auth_trans_seq_num = EXTRACT_LE_16BITS(p + offset);
1471         offset += 2;
1472         length -= 2;
1473         pbody.status_code = EXTRACT_LE_16BITS(p + offset);
1474         offset += 2;
1475         length -= 2;
1476
1477         ret = parse_elements(ndo, &pbody, p, offset, length);
1478
1479         if ((pbody.auth_alg == 1) &&
1480             ((pbody.auth_trans_seq_num == 2) ||
1481              (pbody.auth_trans_seq_num == 3))) {
1482                 ND_PRINT((ndo, " (%s)-%x [Challenge Text] %s",
1483                     (pbody.auth_alg < NUM_AUTH_ALGS)
1484                         ? auth_alg_text[pbody.auth_alg]
1485                         : "Reserved",
1486                     pbody.auth_trans_seq_num,
1487                     ((pbody.auth_trans_seq_num % 2)
1488                         ? ((pbody.status_code < NUM_STATUSES)
1489                                ? status_text[pbody.status_code]
1490                                : "n/a") : "")));
1491                 return ret;
1492         }
1493         ND_PRINT((ndo, " (%s)-%x: %s",
1494             (pbody.auth_alg < NUM_AUTH_ALGS)
1495                 ? auth_alg_text[pbody.auth_alg]
1496                 : "Reserved",
1497             pbody.auth_trans_seq_num,
1498             (pbody.auth_trans_seq_num % 2)
1499                 ? ((pbody.status_code < NUM_STATUSES)
1500                     ? status_text[pbody.status_code]
1501                     : "n/a")
1502                 : ""));
1503
1504         return ret;
1505 }
1506
1507 static int
1508 handle_deauth(netdissect_options *ndo,
1509               const uint8_t *src, const u_char *p, u_int length)
1510 {
1511         struct mgmt_body_t  pbody;
1512         const char *reason = NULL;
1513
1514         memset(&pbody, 0, sizeof(pbody));
1515
1516         if (!ND_TTEST2(*p, IEEE802_11_REASON_LEN))
1517                 return 0;
1518         if (length < IEEE802_11_REASON_LEN)
1519                 return 0;
1520         pbody.reason_code = EXTRACT_LE_16BITS(p);
1521
1522         reason = (pbody.reason_code < NUM_REASONS)
1523                         ? reason_text[pbody.reason_code]
1524                         : "Reserved";
1525
1526         if (ndo->ndo_eflag) {
1527                 ND_PRINT((ndo, ": %s", reason));
1528         } else {
1529                 ND_PRINT((ndo, " (%s): %s", etheraddr_string(ndo, src), reason));
1530         }
1531         return 1;
1532 }
1533
1534 #define PRINT_HT_ACTION(v) (\
1535         (v) == 0 ? ND_PRINT((ndo, "TxChWidth")) : \
1536         (v) == 1 ? ND_PRINT((ndo, "MIMOPwrSave")) : \
1537                    ND_PRINT((ndo, "Act#%d", (v))) \
1538 )
1539 #define PRINT_BA_ACTION(v) (\
1540         (v) == 0 ? ND_PRINT((ndo, "ADDBA Request")) : \
1541         (v) == 1 ? ND_PRINT((ndo, "ADDBA Response")) : \
1542         (v) == 2 ? ND_PRINT((ndo, "DELBA")) : \
1543                    ND_PRINT((ndo, "Act#%d", (v))) \
1544 )
1545 #define PRINT_MESHLINK_ACTION(v) (\
1546         (v) == 0 ? ND_PRINT((ndo, "Request")) : \
1547         (v) == 1 ? ND_PRINT((ndo, "Report")) : \
1548                    ND_PRINT((ndo, "Act#%d", (v))) \
1549 )
1550 #define PRINT_MESHPEERING_ACTION(v) (\
1551         (v) == 0 ? ND_PRINT((ndo, "Open")) : \
1552         (v) == 1 ? ND_PRINT((ndo, "Confirm")) : \
1553         (v) == 2 ? ND_PRINT((ndo, "Close")) : \
1554                    ND_PRINT((ndo, "Act#%d", (v))) \
1555 )
1556 #define PRINT_MESHPATH_ACTION(v) (\
1557         (v) == 0 ? ND_PRINT((ndo, "Request")) : \
1558         (v) == 1 ? ND_PRINT((ndo, "Report")) : \
1559         (v) == 2 ? ND_PRINT((ndo, "Error")) : \
1560         (v) == 3 ? ND_PRINT((ndo, "RootAnnouncement")) : \
1561                    ND_PRINT((ndo, "Act#%d", (v))) \
1562 )
1563
1564 #define PRINT_MESH_ACTION(v) (\
1565         (v) == 0 ? ND_PRINT((ndo, "MeshLink")) : \
1566         (v) == 1 ? ND_PRINT((ndo, "HWMP")) : \
1567         (v) == 2 ? ND_PRINT((ndo, "Gate Announcement")) : \
1568         (v) == 3 ? ND_PRINT((ndo, "Congestion Control")) : \
1569         (v) == 4 ? ND_PRINT((ndo, "MCCA Setup Request")) : \
1570         (v) == 5 ? ND_PRINT((ndo, "MCCA Setup Reply")) : \
1571         (v) == 6 ? ND_PRINT((ndo, "MCCA Advertisement Request")) : \
1572         (v) == 7 ? ND_PRINT((ndo, "MCCA Advertisement")) : \
1573         (v) == 8 ? ND_PRINT((ndo, "MCCA Teardown")) : \
1574         (v) == 9 ? ND_PRINT((ndo, "TBTT Adjustment Request")) : \
1575         (v) == 10 ? ND_PRINT((ndo, "TBTT Adjustment Response")) : \
1576                    ND_PRINT((ndo, "Act#%d", (v))) \
1577 )
1578 #define PRINT_MULTIHOP_ACTION(v) (\
1579         (v) == 0 ? ND_PRINT((ndo, "Proxy Update")) : \
1580         (v) == 1 ? ND_PRINT((ndo, "Proxy Update Confirmation")) : \
1581                    ND_PRINT((ndo, "Act#%d", (v))) \
1582 )
1583 #define PRINT_SELFPROT_ACTION(v) (\
1584         (v) == 1 ? ND_PRINT((ndo, "Peering Open")) : \
1585         (v) == 2 ? ND_PRINT((ndo, "Peering Confirm")) : \
1586         (v) == 3 ? ND_PRINT((ndo, "Peering Close")) : \
1587         (v) == 4 ? ND_PRINT((ndo, "Group Key Inform")) : \
1588         (v) == 5 ? ND_PRINT((ndo, "Group Key Acknowledge")) : \
1589                    ND_PRINT((ndo, "Act#%d", (v))) \
1590 )
1591
1592 static int
1593 handle_action(netdissect_options *ndo,
1594               const uint8_t *src, const u_char *p, u_int length)
1595 {
1596         if (!ND_TTEST2(*p, 2))
1597                 return 0;
1598         if (length < 2)
1599                 return 0;
1600         if (ndo->ndo_eflag) {
1601                 ND_PRINT((ndo, ": "));
1602         } else {
1603                 ND_PRINT((ndo, " (%s): ", etheraddr_string(ndo, src)));
1604         }
1605         switch (p[0]) {
1606         case 0: ND_PRINT((ndo, "Spectrum Management Act#%d", p[1])); break;
1607         case 1: ND_PRINT((ndo, "QoS Act#%d", p[1])); break;
1608         case 2: ND_PRINT((ndo, "DLS Act#%d", p[1])); break;
1609         case 3: ND_PRINT((ndo, "BA ")); PRINT_BA_ACTION(p[1]); break;
1610         case 7: ND_PRINT((ndo, "HT ")); PRINT_HT_ACTION(p[1]); break;
1611         case 13: ND_PRINT((ndo, "MeshAction ")); PRINT_MESH_ACTION(p[1]); break;
1612         case 14:
1613                 ND_PRINT((ndo, "MultiohopAction "));
1614                 PRINT_MULTIHOP_ACTION(p[1]); break;
1615         case 15:
1616                 ND_PRINT((ndo, "SelfprotectAction "));
1617                 PRINT_SELFPROT_ACTION(p[1]); break;
1618         case 127: ND_PRINT((ndo, "Vendor Act#%d", p[1])); break;
1619         default:
1620                 ND_PRINT((ndo, "Reserved(%d) Act#%d", p[0], p[1]));
1621                 break;
1622         }
1623         return 1;
1624 }
1625
1626
1627 /*********************************************************************************
1628  * Print Body funcs
1629  *********************************************************************************/
1630
1631
1632 static int
1633 mgmt_body_print(netdissect_options *ndo,
1634                 uint16_t fc, const uint8_t *src, const u_char *p, u_int length)
1635 {
1636         ND_PRINT((ndo, "%s", tok2str(st_str, "Unhandled Management subtype(%x)", FC_SUBTYPE(fc))));
1637
1638         /* There may be a problem w/ AP not having this bit set */
1639         if (FC_PROTECTED(fc))
1640                 return wep_print(ndo, p);
1641         switch (FC_SUBTYPE(fc)) {
1642         case ST_ASSOC_REQUEST:
1643                 return handle_assoc_request(ndo, p, length);
1644         case ST_ASSOC_RESPONSE:
1645                 return handle_assoc_response(ndo, p, length);
1646         case ST_REASSOC_REQUEST:
1647                 return handle_reassoc_request(ndo, p, length);
1648         case ST_REASSOC_RESPONSE:
1649                 return handle_reassoc_response(ndo, p, length);
1650         case ST_PROBE_REQUEST:
1651                 return handle_probe_request(ndo, p, length);
1652         case ST_PROBE_RESPONSE:
1653                 return handle_probe_response(ndo, p, length);
1654         case ST_BEACON:
1655                 return handle_beacon(ndo, p, length);
1656         case ST_ATIM:
1657                 return handle_atim();
1658         case ST_DISASSOC:
1659                 return handle_disassoc(ndo, p, length);
1660         case ST_AUTH:
1661                 return handle_auth(ndo, p, length);
1662         case ST_DEAUTH:
1663                 return handle_deauth(ndo, src, p, length);
1664         case ST_ACTION:
1665                 return handle_action(ndo, src, p, length);
1666         default:
1667                 return 1;
1668         }
1669 }
1670
1671
1672 /*********************************************************************************
1673  * Handles printing all the control frame types
1674  *********************************************************************************/
1675
1676 static int
1677 ctrl_body_print(netdissect_options *ndo,
1678                 uint16_t fc, const u_char *p)
1679 {
1680         ND_PRINT((ndo, "%s", tok2str(ctrl_str, "Unknown Ctrl Subtype", FC_SUBTYPE(fc))));
1681         switch (FC_SUBTYPE(fc)) {
1682         case CTRL_CONTROL_WRAPPER:
1683                 /* XXX - requires special handling */
1684                 break;
1685         case CTRL_BAR:
1686                 if (!ND_TTEST2(*p, CTRL_BAR_HDRLEN))
1687                         return 0;
1688                 if (!ndo->ndo_eflag)
1689                         ND_PRINT((ndo, " RA:%s TA:%s CTL(%x) SEQ(%u) ",
1690                             etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
1691                             etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
1692                             EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->ctl)),
1693                             EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->seq))));
1694                 break;
1695         case CTRL_BA:
1696                 if (!ND_TTEST2(*p, CTRL_BA_HDRLEN))
1697                         return 0;
1698                 if (!ndo->ndo_eflag)
1699                         ND_PRINT((ndo, " RA:%s ",
1700                             etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra)));
1701                 break;
1702         case CTRL_PS_POLL:
1703                 if (!ND_TTEST2(*p, CTRL_PS_POLL_HDRLEN))
1704                         return 0;
1705                 ND_PRINT((ndo, " AID(%x)",
1706                     EXTRACT_LE_16BITS(&(((const struct ctrl_ps_poll_hdr_t *)p)->aid))));
1707                 break;
1708         case CTRL_RTS:
1709                 if (!ND_TTEST2(*p, CTRL_RTS_HDRLEN))
1710                         return 0;
1711                 if (!ndo->ndo_eflag)
1712                         ND_PRINT((ndo, " TA:%s ",
1713                             etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta)));
1714                 break;
1715         case CTRL_CTS:
1716                 if (!ND_TTEST2(*p, CTRL_CTS_HDRLEN))
1717                         return 0;
1718                 if (!ndo->ndo_eflag)
1719                         ND_PRINT((ndo, " RA:%s ",
1720                             etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra)));
1721                 break;
1722         case CTRL_ACK:
1723                 if (!ND_TTEST2(*p, CTRL_ACK_HDRLEN))
1724                         return 0;
1725                 if (!ndo->ndo_eflag)
1726                         ND_PRINT((ndo, " RA:%s ",
1727                             etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra)));
1728                 break;
1729         case CTRL_CF_END:
1730                 if (!ND_TTEST2(*p, CTRL_END_HDRLEN))
1731                         return 0;
1732                 if (!ndo->ndo_eflag)
1733                         ND_PRINT((ndo, " RA:%s ",
1734                             etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra)));
1735                 break;
1736         case CTRL_END_ACK:
1737                 if (!ND_TTEST2(*p, CTRL_END_ACK_HDRLEN))
1738                         return 0;
1739                 if (!ndo->ndo_eflag)
1740                         ND_PRINT((ndo, " RA:%s ",
1741                             etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra)));
1742                 break;
1743         }
1744         return 1;
1745 }
1746
1747 /*
1748  *  Data Frame - Address field contents
1749  *
1750  *  To Ds  | From DS | Addr 1 | Addr 2 | Addr 3 | Addr 4
1751  *    0    |  0      |  DA    | SA     | BSSID  | n/a
1752  *    0    |  1      |  DA    | BSSID  | SA     | n/a
1753  *    1    |  0      |  BSSID | SA     | DA     | n/a
1754  *    1    |  1      |  RA    | TA     | DA     | SA
1755  */
1756
1757 /*
1758  * Function to get source and destination MAC addresses for a data frame.
1759  */
1760 static void
1761 get_data_src_dst_mac(uint16_t fc, const u_char *p, const uint8_t **srcp,
1762                      const uint8_t **dstp)
1763 {
1764 #define ADDR1  (p + 4)
1765 #define ADDR2  (p + 10)
1766 #define ADDR3  (p + 16)
1767 #define ADDR4  (p + 24)
1768
1769         if (!FC_TO_DS(fc)) {
1770                 if (!FC_FROM_DS(fc)) {
1771                         /* not To DS and not From DS */
1772                         *srcp = ADDR2;
1773                         *dstp = ADDR1;
1774                 } else {
1775                         /* not To DS and From DS */
1776                         *srcp = ADDR3;
1777                         *dstp = ADDR1;
1778                 }
1779         } else {
1780                 if (!FC_FROM_DS(fc)) {
1781                         /* From DS and not To DS */
1782                         *srcp = ADDR2;
1783                         *dstp = ADDR3;
1784                 } else {
1785                         /* To DS and From DS */
1786                         *srcp = ADDR4;
1787                         *dstp = ADDR3;
1788                 }
1789         }
1790
1791 #undef ADDR1
1792 #undef ADDR2
1793 #undef ADDR3
1794 #undef ADDR4
1795 }
1796
1797 static void
1798 get_mgmt_src_dst_mac(const u_char *p, const uint8_t **srcp, const uint8_t **dstp)
1799 {
1800         const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
1801
1802         if (srcp != NULL)
1803                 *srcp = hp->sa;
1804         if (dstp != NULL)
1805                 *dstp = hp->da;
1806 }
1807
1808 /*
1809  * Print Header funcs
1810  */
1811
1812 static void
1813 data_header_print(netdissect_options *ndo, uint16_t fc, const u_char *p)
1814 {
1815         u_int subtype = FC_SUBTYPE(fc);
1816
1817         if (DATA_FRAME_IS_CF_ACK(subtype) || DATA_FRAME_IS_CF_POLL(subtype) ||
1818             DATA_FRAME_IS_QOS(subtype)) {
1819                 ND_PRINT((ndo, "CF "));
1820                 if (DATA_FRAME_IS_CF_ACK(subtype)) {
1821                         if (DATA_FRAME_IS_CF_POLL(subtype))
1822                                 ND_PRINT((ndo, "Ack/Poll"));
1823                         else
1824                                 ND_PRINT((ndo, "Ack"));
1825                 } else {
1826                         if (DATA_FRAME_IS_CF_POLL(subtype))
1827                                 ND_PRINT((ndo, "Poll"));
1828                 }
1829                 if (DATA_FRAME_IS_QOS(subtype))
1830                         ND_PRINT((ndo, "+QoS"));
1831                 ND_PRINT((ndo, " "));
1832         }
1833
1834 #define ADDR1  (p + 4)
1835 #define ADDR2  (p + 10)
1836 #define ADDR3  (p + 16)
1837 #define ADDR4  (p + 24)
1838
1839         if (!FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1840                 ND_PRINT((ndo, "DA:%s SA:%s BSSID:%s ",
1841                     etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1842                     etheraddr_string(ndo, ADDR3)));
1843         } else if (!FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1844                 ND_PRINT((ndo, "DA:%s BSSID:%s SA:%s ",
1845                     etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1846                     etheraddr_string(ndo, ADDR3)));
1847         } else if (FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
1848                 ND_PRINT((ndo, "BSSID:%s SA:%s DA:%s ",
1849                     etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1850                     etheraddr_string(ndo, ADDR3)));
1851         } else if (FC_TO_DS(fc) && FC_FROM_DS(fc)) {
1852                 ND_PRINT((ndo, "RA:%s TA:%s DA:%s SA:%s ",
1853                     etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
1854                     etheraddr_string(ndo, ADDR3), etheraddr_string(ndo, ADDR4)));
1855         }
1856
1857 #undef ADDR1
1858 #undef ADDR2
1859 #undef ADDR3
1860 #undef ADDR4
1861 }
1862
1863 static void
1864 mgmt_header_print(netdissect_options *ndo, const u_char *p)
1865 {
1866         const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
1867
1868         ND_PRINT((ndo, "BSSID:%s DA:%s SA:%s ",
1869             etheraddr_string(ndo, (hp)->bssid), etheraddr_string(ndo, (hp)->da),
1870             etheraddr_string(ndo, (hp)->sa)));
1871 }
1872
1873 static void
1874 ctrl_header_print(netdissect_options *ndo, uint16_t fc, const u_char *p)
1875 {
1876         switch (FC_SUBTYPE(fc)) {
1877         case CTRL_BAR:
1878                 ND_PRINT((ndo, " RA:%s TA:%s CTL(%x) SEQ(%u) ",
1879                     etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
1880                     etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
1881                     EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->ctl)),
1882                     EXTRACT_LE_16BITS(&(((const struct ctrl_bar_hdr_t *)p)->seq))));
1883                 break;
1884         case CTRL_BA:
1885                 ND_PRINT((ndo, "RA:%s ",
1886                     etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra)));
1887                 break;
1888         case CTRL_PS_POLL:
1889                 ND_PRINT((ndo, "BSSID:%s TA:%s ",
1890                     etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->bssid),
1891                     etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->ta)));
1892                 break;
1893         case CTRL_RTS:
1894                 ND_PRINT((ndo, "RA:%s TA:%s ",
1895                     etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ra),
1896                     etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta)));
1897                 break;
1898         case CTRL_CTS:
1899                 ND_PRINT((ndo, "RA:%s ",
1900                     etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra)));
1901                 break;
1902         case CTRL_ACK:
1903                 ND_PRINT((ndo, "RA:%s ",
1904                     etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra)));
1905                 break;
1906         case CTRL_CF_END:
1907                 ND_PRINT((ndo, "RA:%s BSSID:%s ",
1908                     etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra),
1909                     etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->bssid)));
1910                 break;
1911         case CTRL_END_ACK:
1912                 ND_PRINT((ndo, "RA:%s BSSID:%s ",
1913                     etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra),
1914                     etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->bssid)));
1915                 break;
1916         default:
1917                 /* We shouldn't get here - we should already have quit */
1918                 break;
1919         }
1920 }
1921
1922 static int
1923 extract_header_length(netdissect_options *ndo,
1924                       uint16_t fc)
1925 {
1926         int len;
1927
1928         switch (FC_TYPE(fc)) {
1929         case T_MGMT:
1930                 return MGMT_HDRLEN;
1931         case T_CTRL:
1932                 switch (FC_SUBTYPE(fc)) {
1933                 case CTRL_CONTROL_WRAPPER:
1934                         return CTRL_CONTROL_WRAPPER_HDRLEN;
1935                 case CTRL_BAR:
1936                         return CTRL_BAR_HDRLEN;
1937                 case CTRL_BA:
1938                         return CTRL_BA_HDRLEN;
1939                 case CTRL_PS_POLL:
1940                         return CTRL_PS_POLL_HDRLEN;
1941                 case CTRL_RTS:
1942                         return CTRL_RTS_HDRLEN;
1943                 case CTRL_CTS:
1944                         return CTRL_CTS_HDRLEN;
1945                 case CTRL_ACK:
1946                         return CTRL_ACK_HDRLEN;
1947                 case CTRL_CF_END:
1948                         return CTRL_END_HDRLEN;
1949                 case CTRL_END_ACK:
1950                         return CTRL_END_ACK_HDRLEN;
1951                 default:
1952                         ND_PRINT((ndo, "unknown 802.11 ctrl frame subtype (%d)", FC_SUBTYPE(fc)));
1953                         return 0;
1954                 }
1955         case T_DATA:
1956                 len = (FC_TO_DS(fc) && FC_FROM_DS(fc)) ? 30 : 24;
1957                 if (DATA_FRAME_IS_QOS(FC_SUBTYPE(fc)))
1958                         len += 2;
1959                 return len;
1960         default:
1961                 ND_PRINT((ndo, "unknown 802.11 frame type (%d)", FC_TYPE(fc)));
1962                 return 0;
1963         }
1964 }
1965
1966 static int
1967 extract_mesh_header_length(const u_char *p)
1968 {
1969         return (p[0] &~ 3) ? 0 : 6*(1 + (p[0] & 3));
1970 }
1971
1972 /*
1973  * Print the 802.11 MAC header.
1974  */
1975 static void
1976 ieee_802_11_hdr_print(netdissect_options *ndo,
1977                       uint16_t fc, const u_char *p, u_int hdrlen,
1978                       u_int meshdrlen)
1979 {
1980         if (ndo->ndo_vflag) {
1981                 if (FC_MORE_DATA(fc))
1982                         ND_PRINT((ndo, "More Data "));
1983                 if (FC_MORE_FLAG(fc))
1984                         ND_PRINT((ndo, "More Fragments "));
1985                 if (FC_POWER_MGMT(fc))
1986                         ND_PRINT((ndo, "Pwr Mgmt "));
1987                 if (FC_RETRY(fc))
1988                         ND_PRINT((ndo, "Retry "));
1989                 if (FC_ORDER(fc))
1990                         ND_PRINT((ndo, "Strictly Ordered "));
1991                 if (FC_PROTECTED(fc))
1992                         ND_PRINT((ndo, "Protected "));
1993                 if (FC_TYPE(fc) != T_CTRL || FC_SUBTYPE(fc) != CTRL_PS_POLL)
1994                         ND_PRINT((ndo, "%dus ",
1995                             EXTRACT_LE_16BITS(
1996                                 &((const struct mgmt_header_t *)p)->duration)));
1997         }
1998         if (meshdrlen != 0) {
1999                 const struct meshcntl_t *mc =
2000                     (const struct meshcntl_t *)&p[hdrlen - meshdrlen];
2001                 int ae = mc->flags & 3;
2002
2003                 ND_PRINT((ndo, "MeshData (AE %d TTL %u seq %u", ae, mc->ttl,
2004                     EXTRACT_LE_32BITS(mc->seq)));
2005                 if (ae > 0)
2006                         ND_PRINT((ndo, " A4:%s", etheraddr_string(ndo, mc->addr4)));
2007                 if (ae > 1)
2008                         ND_PRINT((ndo, " A5:%s", etheraddr_string(ndo, mc->addr5)));
2009                 if (ae > 2)
2010                         ND_PRINT((ndo, " A6:%s", etheraddr_string(ndo, mc->addr6)));
2011                 ND_PRINT((ndo, ") "));
2012         }
2013
2014         switch (FC_TYPE(fc)) {
2015         case T_MGMT:
2016                 mgmt_header_print(ndo, p);
2017                 break;
2018         case T_CTRL:
2019                 ctrl_header_print(ndo, fc, p);
2020                 break;
2021         case T_DATA:
2022                 data_header_print(ndo, fc, p);
2023                 break;
2024         default:
2025                 break;
2026         }
2027 }
2028
2029 #ifndef roundup2
2030 #define roundup2(x, y)  (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
2031 #endif
2032
2033 static const char tstr[] = "[|802.11]";
2034
2035 static u_int
2036 ieee802_11_print(netdissect_options *ndo,
2037                  const u_char *p, u_int length, u_int orig_caplen, int pad,
2038                  u_int fcslen)
2039 {
2040         uint16_t fc;
2041         u_int caplen, hdrlen, meshdrlen;
2042         struct lladdr_info src, dst;
2043         int llc_hdrlen;
2044
2045         caplen = orig_caplen;
2046         /* Remove FCS, if present */
2047         if (length < fcslen) {
2048                 ND_PRINT((ndo, "%s", tstr));
2049                 return caplen;
2050         }
2051         length -= fcslen;
2052         if (caplen > length) {
2053                 /* Amount of FCS in actual packet data, if any */
2054                 fcslen = caplen - length;
2055                 caplen -= fcslen;
2056                 ndo->ndo_snapend -= fcslen;
2057         }
2058
2059         if (caplen < IEEE802_11_FC_LEN) {
2060                 ND_PRINT((ndo, "%s", tstr));
2061                 return orig_caplen;
2062         }
2063
2064         fc = EXTRACT_LE_16BITS(p);
2065         hdrlen = extract_header_length(ndo, fc);
2066         if (hdrlen == 0) {
2067                 /* Unknown frame type or control frame subtype; quit. */
2068                 return (0);
2069         }
2070         if (pad)
2071                 hdrlen = roundup2(hdrlen, 4);
2072         if (ndo->ndo_Hflag && FC_TYPE(fc) == T_DATA &&
2073             DATA_FRAME_IS_QOS(FC_SUBTYPE(fc))) {
2074                 meshdrlen = extract_mesh_header_length(p+hdrlen);
2075                 hdrlen += meshdrlen;
2076         } else
2077                 meshdrlen = 0;
2078
2079         if (caplen < hdrlen) {
2080                 ND_PRINT((ndo, "%s", tstr));
2081                 return hdrlen;
2082         }
2083
2084         if (ndo->ndo_eflag)
2085                 ieee_802_11_hdr_print(ndo, fc, p, hdrlen, meshdrlen);
2086
2087         /*
2088          * Go past the 802.11 header.
2089          */
2090         length -= hdrlen;
2091         caplen -= hdrlen;
2092         p += hdrlen;
2093
2094         src.addr_string = etheraddr_string;
2095         dst.addr_string = etheraddr_string;
2096         switch (FC_TYPE(fc)) {
2097         case T_MGMT:
2098                 get_mgmt_src_dst_mac(p - hdrlen, &src.addr, &dst.addr);
2099                 if (!mgmt_body_print(ndo, fc, src.addr, p, length)) {
2100                         ND_PRINT((ndo, "%s", tstr));
2101                         return hdrlen;
2102                 }
2103                 break;
2104         case T_CTRL:
2105                 if (!ctrl_body_print(ndo, fc, p - hdrlen)) {
2106                         ND_PRINT((ndo, "%s", tstr));
2107                         return hdrlen;
2108                 }
2109                 break;
2110         case T_DATA:
2111                 if (DATA_FRAME_IS_NULL(FC_SUBTYPE(fc)))
2112                         return hdrlen;  /* no-data frame */
2113                 /* There may be a problem w/ AP not having this bit set */
2114                 if (FC_PROTECTED(fc)) {
2115                         ND_PRINT((ndo, "Data"));
2116                         if (!wep_print(ndo, p)) {
2117                                 ND_PRINT((ndo, "%s", tstr));
2118                                 return hdrlen;
2119                         }
2120                 } else {
2121                         get_data_src_dst_mac(fc, p - hdrlen, &src.addr, &dst.addr);
2122                         llc_hdrlen = llc_print(ndo, p, length, caplen, &src, &dst);
2123                         if (llc_hdrlen < 0) {
2124                                 /*
2125                                  * Some kinds of LLC packet we cannot
2126                                  * handle intelligently
2127                                  */
2128                                 if (!ndo->ndo_suppress_default_print)
2129                                         ND_DEFAULTPRINT(p, caplen);
2130                                 llc_hdrlen = -llc_hdrlen;
2131                         }
2132                         hdrlen += llc_hdrlen;
2133                 }
2134                 break;
2135         default:
2136                 /* We shouldn't get here - we should already have quit */
2137                 break;
2138         }
2139
2140         return hdrlen;
2141 }
2142
2143 /*
2144  * This is the top level routine of the printer.  'p' points
2145  * to the 802.11 header of the packet, 'h->ts' is the timestamp,
2146  * 'h->len' is the length of the packet off the wire, and 'h->caplen'
2147  * is the number of bytes actually captured.
2148  */
2149 u_int
2150 ieee802_11_if_print(netdissect_options *ndo,
2151                     const struct pcap_pkthdr *h, const u_char *p)
2152 {
2153         return ieee802_11_print(ndo, p, h->len, h->caplen, 0, 0);
2154 }
2155
2156
2157 /* $FreeBSD: projects/clang400-import/contrib/tcpdump/print-802_11.c 276788 2015-01-07 19:55:18Z delphij $ */
2158 /* NetBSD: ieee802_11_radio.h,v 1.2 2006/02/26 03:04:03 dyoung Exp  */
2159
2160 /*-
2161  * Copyright (c) 2003, 2004 David Young.  All rights reserved.
2162  *
2163  * Redistribution and use in source and binary forms, with or without
2164  * modification, are permitted provided that the following conditions
2165  * are met:
2166  * 1. Redistributions of source code must retain the above copyright
2167  *    notice, this list of conditions and the following disclaimer.
2168  * 2. Redistributions in binary form must reproduce the above copyright
2169  *    notice, this list of conditions and the following disclaimer in the
2170  *    documentation and/or other materials provided with the distribution.
2171  * 3. The name of David Young may not be used to endorse or promote
2172  *    products derived from this software without specific prior
2173  *    written permission.
2174  *
2175  * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
2176  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
2177  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
2178  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DAVID
2179  * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2180  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
2181  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2182  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2183  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2184  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2185  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
2186  * OF SUCH DAMAGE.
2187  */
2188
2189 /* A generic radio capture format is desirable. It must be
2190  * rigidly defined (e.g., units for fields should be given),
2191  * and easily extensible.
2192  *
2193  * The following is an extensible radio capture format. It is
2194  * based on a bitmap indicating which fields are present.
2195  *
2196  * I am trying to describe precisely what the application programmer
2197  * should expect in the following, and for that reason I tell the
2198  * units and origin of each measurement (where it applies), or else I
2199  * use sufficiently weaselly language ("is a monotonically nondecreasing
2200  * function of...") that I cannot set false expectations for lawyerly
2201  * readers.
2202  */
2203
2204 /*
2205  * The radio capture header precedes the 802.11 header.
2206  *
2207  * Note well: all radiotap fields are little-endian.
2208  */
2209 struct ieee80211_radiotap_header {
2210         uint8_t         it_version;     /* Version 0. Only increases
2211                                          * for drastic changes,
2212                                          * introduction of compatible
2213                                          * new fields does not count.
2214                                          */
2215         uint8_t         it_pad;
2216         uint16_t        it_len;         /* length of the whole
2217                                          * header in bytes, including
2218                                          * it_version, it_pad,
2219                                          * it_len, and data fields.
2220                                          */
2221         uint32_t        it_present;     /* A bitmap telling which
2222                                          * fields are present. Set bit 31
2223                                          * (0x80000000) to extend the
2224                                          * bitmap by another 32 bits.
2225                                          * Additional extensions are made
2226                                          * by setting bit 31.
2227                                          */
2228 };
2229
2230 /* Name                                 Data type       Units
2231  * ----                                 ---------       -----
2232  *
2233  * IEEE80211_RADIOTAP_TSFT              uint64_t       microseconds
2234  *
2235  *      Value in microseconds of the MAC's 64-bit 802.11 Time
2236  *      Synchronization Function timer when the first bit of the
2237  *      MPDU arrived at the MAC. For received frames, only.
2238  *
2239  * IEEE80211_RADIOTAP_CHANNEL           2 x uint16_t   MHz, bitmap
2240  *
2241  *      Tx/Rx frequency in MHz, followed by flags (see below).
2242  *      Note that IEEE80211_RADIOTAP_XCHANNEL must be used to
2243  *      represent an HT channel as there is not enough room in
2244  *      the flags word.
2245  *
2246  * IEEE80211_RADIOTAP_FHSS              uint16_t       see below
2247  *
2248  *      For frequency-hopping radios, the hop set (first byte)
2249  *      and pattern (second byte).
2250  *
2251  * IEEE80211_RADIOTAP_RATE              uint8_t        500kb/s or index
2252  *
2253  *      Tx/Rx data rate.  If bit 0x80 is set then it represents an
2254  *      an MCS index and not an IEEE rate.
2255  *
2256  * IEEE80211_RADIOTAP_DBM_ANTSIGNAL     int8_t          decibels from
2257  *                                                      one milliwatt (dBm)
2258  *
2259  *      RF signal power at the antenna, decibel difference from
2260  *      one milliwatt.
2261  *
2262  * IEEE80211_RADIOTAP_DBM_ANTNOISE      int8_t          decibels from
2263  *                                                      one milliwatt (dBm)
2264  *
2265  *      RF noise power at the antenna, decibel difference from one
2266  *      milliwatt.
2267  *
2268  * IEEE80211_RADIOTAP_DB_ANTSIGNAL      uint8_t        decibel (dB)
2269  *
2270  *      RF signal power at the antenna, decibel difference from an
2271  *      arbitrary, fixed reference.
2272  *
2273  * IEEE80211_RADIOTAP_DB_ANTNOISE       uint8_t        decibel (dB)
2274  *
2275  *      RF noise power at the antenna, decibel difference from an
2276  *      arbitrary, fixed reference point.
2277  *
2278  * IEEE80211_RADIOTAP_LOCK_QUALITY      uint16_t       unitless
2279  *
2280  *      Quality of Barker code lock. Unitless. Monotonically
2281  *      nondecreasing with "better" lock strength. Called "Signal
2282  *      Quality" in datasheets.  (Is there a standard way to measure
2283  *      this?)
2284  *
2285  * IEEE80211_RADIOTAP_TX_ATTENUATION    uint16_t       unitless
2286  *
2287  *      Transmit power expressed as unitless distance from max
2288  *      power set at factory calibration.  0 is max power.
2289  *      Monotonically nondecreasing with lower power levels.
2290  *
2291  * IEEE80211_RADIOTAP_DB_TX_ATTENUATION uint16_t       decibels (dB)
2292  *
2293  *      Transmit power expressed as decibel distance from max power
2294  *      set at factory calibration.  0 is max power.  Monotonically
2295  *      nondecreasing with lower power levels.
2296  *
2297  * IEEE80211_RADIOTAP_DBM_TX_POWER      int8_t          decibels from
2298  *                                                      one milliwatt (dBm)
2299  *
2300  *      Transmit power expressed as dBm (decibels from a 1 milliwatt
2301  *      reference). This is the absolute power level measured at
2302  *      the antenna port.
2303  *
2304  * IEEE80211_RADIOTAP_FLAGS             uint8_t        bitmap
2305  *
2306  *      Properties of transmitted and received frames. See flags
2307  *      defined below.
2308  *
2309  * IEEE80211_RADIOTAP_ANTENNA           uint8_t        antenna index
2310  *
2311  *      Unitless indication of the Rx/Tx antenna for this packet.
2312  *      The first antenna is antenna 0.
2313  *
2314  * IEEE80211_RADIOTAP_RX_FLAGS          uint16_t       bitmap
2315  *
2316  *     Properties of received frames. See flags defined below.
2317  *
2318  * IEEE80211_RADIOTAP_XCHANNEL          uint32_t        bitmap
2319  *                                      uint16_t        MHz
2320  *                                      uint8_t         channel number
2321  *                                      uint8_t         .5 dBm
2322  *
2323  *      Extended channel specification: flags (see below) followed by
2324  *      frequency in MHz, the corresponding IEEE channel number, and
2325  *      finally the maximum regulatory transmit power cap in .5 dBm
2326  *      units.  This property supersedes IEEE80211_RADIOTAP_CHANNEL
2327  *      and only one of the two should be present.
2328  *
2329  * IEEE80211_RADIOTAP_MCS               uint8_t         known
2330  *                                      uint8_t         flags
2331  *                                      uint8_t         mcs
2332  *
2333  *      Bitset indicating which fields have known values, followed
2334  *      by bitset of flag values, followed by the MCS rate index as
2335  *      in IEEE 802.11n.
2336  *
2337  *
2338  * IEEE80211_RADIOTAP_AMPDU_STATUS      u32, u16, u8, u8        unitless
2339  *
2340  *      Contains the AMPDU information for the subframe.
2341  *
2342  * IEEE80211_RADIOTAP_VHT       u16, u8, u8, u8[4], u8, u8, u16
2343  *
2344  *      Contains VHT information about this frame.
2345  *
2346  * IEEE80211_RADIOTAP_VENDOR_NAMESPACE
2347  *                                      uint8_t  OUI[3]
2348  *                                   uint8_t  subspace
2349  *                                   uint16_t length
2350  *
2351  *     The Vendor Namespace Field contains three sub-fields. The first
2352  *     sub-field is 3 bytes long. It contains the vendor's IEEE 802
2353  *     Organizationally Unique Identifier (OUI). The fourth byte is a
2354  *     vendor-specific "namespace selector."
2355  *
2356  */
2357 enum ieee80211_radiotap_type {
2358         IEEE80211_RADIOTAP_TSFT = 0,
2359         IEEE80211_RADIOTAP_FLAGS = 1,
2360         IEEE80211_RADIOTAP_RATE = 2,
2361         IEEE80211_RADIOTAP_CHANNEL = 3,
2362         IEEE80211_RADIOTAP_FHSS = 4,
2363         IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
2364         IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
2365         IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
2366         IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
2367         IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
2368         IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
2369         IEEE80211_RADIOTAP_ANTENNA = 11,
2370         IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
2371         IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
2372         IEEE80211_RADIOTAP_RX_FLAGS = 14,
2373         /* NB: gap for netbsd definitions */
2374         IEEE80211_RADIOTAP_XCHANNEL = 18,
2375         IEEE80211_RADIOTAP_MCS = 19,
2376         IEEE80211_RADIOTAP_AMPDU_STATUS = 20,
2377         IEEE80211_RADIOTAP_VHT = 21,
2378         IEEE80211_RADIOTAP_NAMESPACE = 29,
2379         IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
2380         IEEE80211_RADIOTAP_EXT = 31
2381 };
2382
2383 /* channel attributes */
2384 #define IEEE80211_CHAN_TURBO    0x00010 /* Turbo channel */
2385 #define IEEE80211_CHAN_CCK      0x00020 /* CCK channel */
2386 #define IEEE80211_CHAN_OFDM     0x00040 /* OFDM channel */
2387 #define IEEE80211_CHAN_2GHZ     0x00080 /* 2 GHz spectrum channel. */
2388 #define IEEE80211_CHAN_5GHZ     0x00100 /* 5 GHz spectrum channel */
2389 #define IEEE80211_CHAN_PASSIVE  0x00200 /* Only passive scan allowed */
2390 #define IEEE80211_CHAN_DYN      0x00400 /* Dynamic CCK-OFDM channel */
2391 #define IEEE80211_CHAN_GFSK     0x00800 /* GFSK channel (FHSS PHY) */
2392 #define IEEE80211_CHAN_GSM      0x01000 /* 900 MHz spectrum channel */
2393 #define IEEE80211_CHAN_STURBO   0x02000 /* 11a static turbo channel only */
2394 #define IEEE80211_CHAN_HALF     0x04000 /* Half rate channel */
2395 #define IEEE80211_CHAN_QUARTER  0x08000 /* Quarter rate channel */
2396 #define IEEE80211_CHAN_HT20     0x10000 /* HT 20 channel */
2397 #define IEEE80211_CHAN_HT40U    0x20000 /* HT 40 channel w/ ext above */
2398 #define IEEE80211_CHAN_HT40D    0x40000 /* HT 40 channel w/ ext below */
2399
2400 /* Useful combinations of channel characteristics, borrowed from Ethereal */
2401 #define IEEE80211_CHAN_A \
2402         (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM)
2403 #define IEEE80211_CHAN_B \
2404         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK)
2405 #define IEEE80211_CHAN_G \
2406         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN)
2407 #define IEEE80211_CHAN_TA \
2408         (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM | IEEE80211_CHAN_TURBO)
2409 #define IEEE80211_CHAN_TG \
2410         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN  | IEEE80211_CHAN_TURBO)
2411
2412
2413 /* For IEEE80211_RADIOTAP_FLAGS */
2414 #define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
2415                                                  * during CFP
2416                                                  */
2417 #define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
2418                                                  * with short
2419                                                  * preamble
2420                                                  */
2421 #define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
2422                                                  * with WEP encryption
2423                                                  */
2424 #define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
2425                                                  * with fragmentation
2426                                                  */
2427 #define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
2428 #define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
2429                                                  * 802.11 header and payload
2430                                                  * (to 32-bit boundary)
2431                                                  */
2432 #define IEEE80211_RADIOTAP_F_BADFCS     0x40    /* does not pass FCS check */
2433
2434 /* For IEEE80211_RADIOTAP_RX_FLAGS */
2435 #define IEEE80211_RADIOTAP_F_RX_BADFCS  0x0001  /* frame failed crc check */
2436 #define IEEE80211_RADIOTAP_F_RX_PLCP_CRC        0x0002  /* frame failed PLCP CRC check */
2437
2438 /* For IEEE80211_RADIOTAP_MCS known */
2439 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN          0x01
2440 #define IEEE80211_RADIOTAP_MCS_MCS_INDEX_KNOWN          0x02    /* MCS index field */
2441 #define IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN     0x04
2442 #define IEEE80211_RADIOTAP_MCS_HT_FORMAT_KNOWN          0x08
2443 #define IEEE80211_RADIOTAP_MCS_FEC_TYPE_KNOWN           0x10
2444 #define IEEE80211_RADIOTAP_MCS_STBC_KNOWN               0x20
2445 #define IEEE80211_RADIOTAP_MCS_NESS_KNOWN               0x40
2446 #define IEEE80211_RADIOTAP_MCS_NESS_BIT_1               0x80
2447
2448 /* For IEEE80211_RADIOTAP_MCS flags */
2449 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK   0x03
2450 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20     0
2451 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_40     1
2452 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20L    2
2453 #define IEEE80211_RADIOTAP_MCS_BANDWIDTH_20U    3
2454 #define IEEE80211_RADIOTAP_MCS_SHORT_GI         0x04 /* short guard interval */
2455 #define IEEE80211_RADIOTAP_MCS_HT_GREENFIELD    0x08
2456 #define IEEE80211_RADIOTAP_MCS_FEC_LDPC         0x10
2457 #define IEEE80211_RADIOTAP_MCS_STBC_MASK        0x60
2458 #define         IEEE80211_RADIOTAP_MCS_STBC_1   1
2459 #define         IEEE80211_RADIOTAP_MCS_STBC_2   2
2460 #define         IEEE80211_RADIOTAP_MCS_STBC_3   3
2461 #define IEEE80211_RADIOTAP_MCS_STBC_SHIFT       5
2462 #define IEEE80211_RADIOTAP_MCS_NESS_BIT_0       0x80
2463
2464 /* For IEEE80211_RADIOTAP_AMPDU_STATUS */
2465 #define IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN         0x0001
2466 #define IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN             0x0002
2467 #define IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN             0x0004
2468 #define IEEE80211_RADIOTAP_AMPDU_IS_LAST                0x0008
2469 #define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR          0x0010
2470 #define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN        0x0020
2471
2472 /* For IEEE80211_RADIOTAP_VHT known */
2473 #define IEEE80211_RADIOTAP_VHT_STBC_KNOWN                       0x0001
2474 #define IEEE80211_RADIOTAP_VHT_TXOP_PS_NA_KNOWN                 0x0002
2475 #define IEEE80211_RADIOTAP_VHT_GUARD_INTERVAL_KNOWN             0x0004
2476 #define IEEE80211_RADIOTAP_VHT_SGI_NSYM_DIS_KNOWN               0x0008
2477 #define IEEE80211_RADIOTAP_VHT_LDPC_EXTRA_OFDM_SYM_KNOWN        0x0010
2478 #define IEEE80211_RADIOTAP_VHT_BEAMFORMED_KNOWN                 0x0020
2479 #define IEEE80211_RADIOTAP_VHT_BANDWIDTH_KNOWN                  0x0040
2480 #define IEEE80211_RADIOTAP_VHT_GROUP_ID_KNOWN                   0x0080
2481 #define IEEE80211_RADIOTAP_VHT_PARTIAL_AID_KNOWN                0x0100
2482
2483 /* For IEEE80211_RADIOTAP_VHT flags */
2484 #define IEEE80211_RADIOTAP_VHT_STBC                     0x01
2485 #define IEEE80211_RADIOTAP_VHT_TXOP_PS_NA               0x02
2486 #define IEEE80211_RADIOTAP_VHT_SHORT_GI                 0x04
2487 #define IEEE80211_RADIOTAP_VHT_SGI_NSYM_M10_9           0x08
2488 #define IEEE80211_RADIOTAP_VHT_LDPC_EXTRA_OFDM_SYM      0x10
2489 #define IEEE80211_RADIOTAP_VHT_BEAMFORMED               0x20
2490
2491 #define IEEE80211_RADIOTAP_VHT_BANDWIDTH_MASK   0x1f
2492
2493 #define IEEE80211_RADIOTAP_VHT_NSS_MASK         0x0f
2494 #define IEEE80211_RADIOTAP_VHT_MCS_MASK         0xf0
2495 #define IEEE80211_RADIOTAP_VHT_MCS_SHIFT        4
2496
2497 #define IEEE80211_RADIOTAP_CODING_LDPC_USERn                    0x01
2498
2499 #define IEEE80211_CHAN_FHSS \
2500         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_GFSK)
2501 #define IEEE80211_CHAN_A \
2502         (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM)
2503 #define IEEE80211_CHAN_B \
2504         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK)
2505 #define IEEE80211_CHAN_PUREG \
2506         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_OFDM)
2507 #define IEEE80211_CHAN_G \
2508         (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN)
2509
2510 #define IS_CHAN_FHSS(flags) \
2511         ((flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS)
2512 #define IS_CHAN_A(flags) \
2513         ((flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A)
2514 #define IS_CHAN_B(flags) \
2515         ((flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B)
2516 #define IS_CHAN_PUREG(flags) \
2517         ((flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG)
2518 #define IS_CHAN_G(flags) \
2519         ((flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G)
2520 #define IS_CHAN_ANYG(flags) \
2521         (IS_CHAN_PUREG(flags) || IS_CHAN_G(flags))
2522
2523 static void
2524 print_chaninfo(netdissect_options *ndo,
2525                uint16_t freq, int flags, int presentflags)
2526 {
2527         ND_PRINT((ndo, "%u MHz", freq));
2528         if (presentflags & (1 << IEEE80211_RADIOTAP_MCS)) {
2529                 /*
2530                  * We have the MCS field, so this is 11n, regardless
2531                  * of what the channel flags say.
2532                  */
2533                 ND_PRINT((ndo, " 11n"));
2534         } else {
2535                 if (IS_CHAN_FHSS(flags))
2536                         ND_PRINT((ndo, " FHSS"));
2537                 if (IS_CHAN_A(flags)) {
2538                         if (flags & IEEE80211_CHAN_HALF)
2539                                 ND_PRINT((ndo, " 11a/10Mhz"));
2540                         else if (flags & IEEE80211_CHAN_QUARTER)
2541                                 ND_PRINT((ndo, " 11a/5Mhz"));
2542                         else
2543                                 ND_PRINT((ndo, " 11a"));
2544                 }
2545                 if (IS_CHAN_ANYG(flags)) {
2546                         if (flags & IEEE80211_CHAN_HALF)
2547                                 ND_PRINT((ndo, " 11g/10Mhz"));
2548                         else if (flags & IEEE80211_CHAN_QUARTER)
2549                                 ND_PRINT((ndo, " 11g/5Mhz"));
2550                         else
2551                                 ND_PRINT((ndo, " 11g"));
2552                 } else if (IS_CHAN_B(flags))
2553                         ND_PRINT((ndo, " 11b"));
2554                 if (flags & IEEE80211_CHAN_TURBO)
2555                         ND_PRINT((ndo, " Turbo"));
2556         }
2557         /*
2558          * These apply to 11n.
2559          */
2560         if (flags & IEEE80211_CHAN_HT20)
2561                 ND_PRINT((ndo, " ht/20"));
2562         else if (flags & IEEE80211_CHAN_HT40D)
2563                 ND_PRINT((ndo, " ht/40-"));
2564         else if (flags & IEEE80211_CHAN_HT40U)
2565                 ND_PRINT((ndo, " ht/40+"));
2566         ND_PRINT((ndo, " "));
2567 }
2568
2569 static int
2570 print_radiotap_field(netdissect_options *ndo,
2571                      struct cpack_state *s, uint32_t bit, uint8_t *flagsp,
2572                      uint32_t presentflags)
2573 {
2574         u_int i;
2575         int rc;
2576
2577         switch (bit) {
2578
2579         case IEEE80211_RADIOTAP_TSFT: {
2580                 uint64_t tsft;
2581
2582                 rc = cpack_uint64(s, &tsft);
2583                 if (rc != 0)
2584                         goto trunc;
2585                 ND_PRINT((ndo, "%" PRIu64 "us tsft ", tsft));
2586                 break;
2587                 }
2588
2589         case IEEE80211_RADIOTAP_FLAGS: {
2590                 uint8_t flagsval;
2591
2592                 rc = cpack_uint8(s, &flagsval);
2593                 if (rc != 0)
2594                         goto trunc;
2595                 *flagsp = flagsval;
2596                 if (flagsval & IEEE80211_RADIOTAP_F_CFP)
2597                         ND_PRINT((ndo, "cfp "));
2598                 if (flagsval & IEEE80211_RADIOTAP_F_SHORTPRE)
2599                         ND_PRINT((ndo, "short preamble "));
2600                 if (flagsval & IEEE80211_RADIOTAP_F_WEP)
2601                         ND_PRINT((ndo, "wep "));
2602                 if (flagsval & IEEE80211_RADIOTAP_F_FRAG)
2603                         ND_PRINT((ndo, "fragmented "));
2604                 if (flagsval & IEEE80211_RADIOTAP_F_BADFCS)
2605                         ND_PRINT((ndo, "bad-fcs "));
2606                 break;
2607                 }
2608
2609         case IEEE80211_RADIOTAP_RATE: {
2610                 uint8_t rate;
2611
2612                 rc = cpack_uint8(s, &rate);
2613                 if (rc != 0)
2614                         goto trunc;
2615                 /*
2616                  * XXX On FreeBSD rate & 0x80 means we have an MCS. On
2617                  * Linux and AirPcap it does not.  (What about
2618                  * Mac OS X, NetBSD, OpenBSD, and DragonFly BSD?)
2619                  *
2620                  * This is an issue either for proprietary extensions
2621                  * to 11a or 11g, which do exist, or for 11n
2622                  * implementations that stuff a rate value into
2623                  * this field, which also appear to exist.
2624                  *
2625                  * We currently handle that by assuming that
2626                  * if the 0x80 bit is set *and* the remaining
2627                  * bits have a value between 0 and 15 it's
2628                  * an MCS value, otherwise it's a rate.  If
2629                  * there are cases where systems that use
2630                  * "0x80 + MCS index" for MCS indices > 15,
2631                  * or stuff a rate value here between 64 and
2632                  * 71.5 Mb/s in here, we'll need a preference
2633                  * setting.  Such rates do exist, e.g. 11n
2634                  * MCS 7 at 20 MHz with a long guard interval.
2635                  */
2636                 if (rate >= 0x80 && rate <= 0x8f) {
2637                         /*
2638                          * XXX - we don't know the channel width
2639                          * or guard interval length, so we can't
2640                          * convert this to a data rate.
2641                          *
2642                          * If you want us to show a data rate,
2643                          * use the MCS field, not the Rate field;
2644                          * the MCS field includes not only the
2645                          * MCS index, it also includes bandwidth
2646                          * and guard interval information.
2647                          *
2648                          * XXX - can we get the channel width
2649                          * from XChannel and the guard interval
2650                          * information from Flags, at least on
2651                          * FreeBSD?
2652                          */
2653                         ND_PRINT((ndo, "MCS %u ", rate & 0x7f));
2654                 } else
2655                         ND_PRINT((ndo, "%2.1f Mb/s ", .5 * rate));
2656                 break;
2657                 }
2658
2659         case IEEE80211_RADIOTAP_CHANNEL: {
2660                 uint16_t frequency;
2661                 uint16_t flags;
2662
2663                 rc = cpack_uint16(s, &frequency);
2664                 if (rc != 0)
2665                         goto trunc;
2666                 rc = cpack_uint16(s, &flags);
2667                 if (rc != 0)
2668                         goto trunc;
2669                 /*
2670                  * If CHANNEL and XCHANNEL are both present, skip
2671                  * CHANNEL.
2672                  */
2673                 if (presentflags & (1 << IEEE80211_RADIOTAP_XCHANNEL))
2674                         break;
2675                 print_chaninfo(ndo, frequency, flags, presentflags);
2676                 break;
2677                 }
2678
2679         case IEEE80211_RADIOTAP_FHSS: {
2680                 uint8_t hopset;
2681                 uint8_t hoppat;
2682
2683                 rc = cpack_uint8(s, &hopset);
2684                 if (rc != 0)
2685                         goto trunc;
2686                 rc = cpack_uint8(s, &hoppat);
2687                 if (rc != 0)
2688                         goto trunc;
2689                 ND_PRINT((ndo, "fhset %d fhpat %d ", hopset, hoppat));
2690                 break;
2691                 }
2692
2693         case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: {
2694                 int8_t dbm_antsignal;
2695
2696                 rc = cpack_int8(s, &dbm_antsignal);
2697                 if (rc != 0)
2698                         goto trunc;
2699                 ND_PRINT((ndo, "%ddBm signal ", dbm_antsignal));
2700                 break;
2701                 }
2702
2703         case IEEE80211_RADIOTAP_DBM_ANTNOISE: {
2704                 int8_t dbm_antnoise;
2705
2706                 rc = cpack_int8(s, &dbm_antnoise);
2707                 if (rc != 0)
2708                         goto trunc;
2709                 ND_PRINT((ndo, "%ddBm noise ", dbm_antnoise));
2710                 break;
2711                 }
2712
2713         case IEEE80211_RADIOTAP_LOCK_QUALITY: {
2714                 uint16_t lock_quality;
2715
2716                 rc = cpack_uint16(s, &lock_quality);
2717                 if (rc != 0)
2718                         goto trunc;
2719                 ND_PRINT((ndo, "%u sq ", lock_quality));
2720                 break;
2721                 }
2722
2723         case IEEE80211_RADIOTAP_TX_ATTENUATION: {
2724                 uint16_t tx_attenuation;
2725
2726                 rc = cpack_uint16(s, &tx_attenuation);
2727                 if (rc != 0)
2728                         goto trunc;
2729                 ND_PRINT((ndo, "%d tx power ", -(int)tx_attenuation));
2730                 break;
2731                 }
2732
2733         case IEEE80211_RADIOTAP_DB_TX_ATTENUATION: {
2734                 uint8_t db_tx_attenuation;
2735
2736                 rc = cpack_uint8(s, &db_tx_attenuation);
2737                 if (rc != 0)
2738                         goto trunc;
2739                 ND_PRINT((ndo, "%ddB tx attenuation ", -(int)db_tx_attenuation));
2740                 break;
2741                 }
2742
2743         case IEEE80211_RADIOTAP_DBM_TX_POWER: {
2744                 int8_t dbm_tx_power;
2745
2746                 rc = cpack_int8(s, &dbm_tx_power);
2747                 if (rc != 0)
2748                         goto trunc;
2749                 ND_PRINT((ndo, "%ddBm tx power ", dbm_tx_power));
2750                 break;
2751                 }
2752
2753         case IEEE80211_RADIOTAP_ANTENNA: {
2754                 uint8_t antenna;
2755
2756                 rc = cpack_uint8(s, &antenna);
2757                 if (rc != 0)
2758                         goto trunc;
2759                 ND_PRINT((ndo, "antenna %u ", antenna));
2760                 break;
2761                 }
2762
2763         case IEEE80211_RADIOTAP_DB_ANTSIGNAL: {
2764                 uint8_t db_antsignal;
2765
2766                 rc = cpack_uint8(s, &db_antsignal);
2767                 if (rc != 0)
2768                         goto trunc;
2769                 ND_PRINT((ndo, "%ddB signal ", db_antsignal));
2770                 break;
2771                 }
2772
2773         case IEEE80211_RADIOTAP_DB_ANTNOISE: {
2774                 uint8_t db_antnoise;
2775
2776                 rc = cpack_uint8(s, &db_antnoise);
2777                 if (rc != 0)
2778                         goto trunc;
2779                 ND_PRINT((ndo, "%ddB noise ", db_antnoise));
2780                 break;
2781                 }
2782
2783         case IEEE80211_RADIOTAP_RX_FLAGS: {
2784                 uint16_t rx_flags;
2785
2786                 rc = cpack_uint16(s, &rx_flags);
2787                 if (rc != 0)
2788                         goto trunc;
2789                 /* Do nothing for now */
2790                 break;
2791                 }
2792
2793         case IEEE80211_RADIOTAP_XCHANNEL: {
2794                 uint32_t flags;
2795                 uint16_t frequency;
2796                 uint8_t channel;
2797                 uint8_t maxpower;
2798
2799                 rc = cpack_uint32(s, &flags);
2800                 if (rc != 0)
2801                         goto trunc;
2802                 rc = cpack_uint16(s, &frequency);
2803                 if (rc != 0)
2804                         goto trunc;
2805                 rc = cpack_uint8(s, &channel);
2806                 if (rc != 0)
2807                         goto trunc;
2808                 rc = cpack_uint8(s, &maxpower);
2809                 if (rc != 0)
2810                         goto trunc;
2811                 print_chaninfo(ndo, frequency, flags, presentflags);
2812                 break;
2813                 }
2814
2815         case IEEE80211_RADIOTAP_MCS: {
2816                 uint8_t known;
2817                 uint8_t flags;
2818                 uint8_t mcs_index;
2819                 static const char *ht_bandwidth[4] = {
2820                         "20 MHz",
2821                         "40 MHz",
2822                         "20 MHz (L)",
2823                         "20 MHz (U)"
2824                 };
2825                 float htrate;
2826
2827                 rc = cpack_uint8(s, &known);
2828                 if (rc != 0)
2829                         goto trunc;
2830                 rc = cpack_uint8(s, &flags);
2831                 if (rc != 0)
2832                         goto trunc;
2833                 rc = cpack_uint8(s, &mcs_index);
2834                 if (rc != 0)
2835                         goto trunc;
2836                 if (known & IEEE80211_RADIOTAP_MCS_MCS_INDEX_KNOWN) {
2837                         /*
2838                          * We know the MCS index.
2839                          */
2840                         if (mcs_index <= MAX_MCS_INDEX) {
2841                                 /*
2842                                  * And it's in-range.
2843                                  */
2844                                 if (known & (IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN|IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN)) {
2845                                         /*
2846                                          * And we know both the bandwidth and
2847                                          * the guard interval, so we can look
2848                                          * up the rate.
2849                                          */
2850                                         htrate =
2851                                                 ieee80211_float_htrates \
2852                                                         [mcs_index] \
2853                                                         [((flags & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK) == IEEE80211_RADIOTAP_MCS_BANDWIDTH_40 ? 1 : 0)] \
2854                                                         [((flags & IEEE80211_RADIOTAP_MCS_SHORT_GI) ? 1 : 0)];
2855                                 } else {
2856                                         /*
2857                                          * We don't know both the bandwidth
2858                                          * and the guard interval, so we can
2859                                          * only report the MCS index.
2860                                          */
2861                                         htrate = 0.0;
2862                                 }
2863                         } else {
2864                                 /*
2865                                  * The MCS value is out of range.
2866                                  */
2867                                 htrate = 0.0;
2868                         }
2869                         if (htrate != 0.0) {
2870                                 /*
2871                                  * We have the rate.
2872                                  * Print it.
2873                                  */
2874                                 ND_PRINT((ndo, "%.1f Mb/s MCS %u ", htrate, mcs_index));
2875                         } else {
2876                                 /*
2877                                  * We at least have the MCS index.
2878                                  * Print it.
2879                                  */
2880                                 ND_PRINT((ndo, "MCS %u ", mcs_index));
2881                         }
2882                 }
2883                 if (known & IEEE80211_RADIOTAP_MCS_BANDWIDTH_KNOWN) {
2884                         ND_PRINT((ndo, "%s ",
2885                                 ht_bandwidth[flags & IEEE80211_RADIOTAP_MCS_BANDWIDTH_MASK]));
2886                 }
2887                 if (known & IEEE80211_RADIOTAP_MCS_GUARD_INTERVAL_KNOWN) {
2888                         ND_PRINT((ndo, "%s GI ",
2889                                 (flags & IEEE80211_RADIOTAP_MCS_SHORT_GI) ?
2890                                 "short" : "long"));
2891                 }
2892                 if (known & IEEE80211_RADIOTAP_MCS_HT_FORMAT_KNOWN) {
2893                         ND_PRINT((ndo, "%s ",
2894                                 (flags & IEEE80211_RADIOTAP_MCS_HT_GREENFIELD) ?
2895                                 "greenfield" : "mixed"));
2896                 }
2897                 if (known & IEEE80211_RADIOTAP_MCS_FEC_TYPE_KNOWN) {
2898                         ND_PRINT((ndo, "%s FEC ",
2899                                 (flags & IEEE80211_RADIOTAP_MCS_FEC_LDPC) ?
2900                                 "LDPC" : "BCC"));
2901                 }
2902                 if (known & IEEE80211_RADIOTAP_MCS_STBC_KNOWN) {
2903                         ND_PRINT((ndo, "RX-STBC%u ",
2904                                 (flags & IEEE80211_RADIOTAP_MCS_STBC_MASK) >> IEEE80211_RADIOTAP_MCS_STBC_SHIFT));
2905                 }
2906                 break;
2907                 }
2908
2909         case IEEE80211_RADIOTAP_AMPDU_STATUS: {
2910                 uint32_t reference_num;
2911                 uint16_t flags;
2912                 uint8_t delim_crc;
2913                 uint8_t reserved;
2914
2915                 rc = cpack_uint32(s, &reference_num);
2916                 if (rc != 0)
2917                         goto trunc;
2918                 rc = cpack_uint16(s, &flags);
2919                 if (rc != 0)
2920                         goto trunc;
2921                 rc = cpack_uint8(s, &delim_crc);
2922                 if (rc != 0)
2923                         goto trunc;
2924                 rc = cpack_uint8(s, &reserved);
2925                 if (rc != 0)
2926                         goto trunc;
2927                 /* Do nothing for now */
2928                 break;
2929                 }
2930
2931         case IEEE80211_RADIOTAP_VHT: {
2932                 uint16_t known;
2933                 uint8_t flags;
2934                 uint8_t bandwidth;
2935                 uint8_t mcs_nss[4];
2936                 uint8_t coding;
2937                 uint8_t group_id;
2938                 uint16_t partial_aid;
2939                 static const char *vht_bandwidth[32] = {
2940                         "20 MHz",
2941                         "40 MHz",
2942                         "20 MHz (L)",
2943                         "20 MHz (U)",
2944                         "80 MHz",
2945                         "80 MHz (L)",
2946                         "80 MHz (U)",
2947                         "80 MHz (LL)",
2948                         "80 MHz (LU)",
2949                         "80 MHz (UL)",
2950                         "80 MHz (UU)",
2951                         "160 MHz",
2952                         "160 MHz (L)",
2953                         "160 MHz (U)",
2954                         "160 MHz (LL)",
2955                         "160 MHz (LU)",
2956                         "160 MHz (UL)",
2957                         "160 MHz (UU)",
2958                         "160 MHz (LLL)",
2959                         "160 MHz (LLU)",
2960                         "160 MHz (LUL)",
2961                         "160 MHz (UUU)",
2962                         "160 MHz (ULL)",
2963                         "160 MHz (ULU)",
2964                         "160 MHz (UUL)",
2965                         "160 MHz (UUU)",
2966                         "unknown (26)",
2967                         "unknown (27)",
2968                         "unknown (28)",
2969                         "unknown (29)",
2970                         "unknown (30)",
2971                         "unknown (31)"
2972                 };
2973
2974                 rc = cpack_uint16(s, &known);
2975                 if (rc != 0)
2976                         goto trunc;
2977                 rc = cpack_uint8(s, &flags);
2978                 if (rc != 0)
2979                         goto trunc;
2980                 rc = cpack_uint8(s, &bandwidth);
2981                 if (rc != 0)
2982                         goto trunc;
2983                 for (i = 0; i < 4; i++) {
2984                         rc = cpack_uint8(s, &mcs_nss[i]);
2985                         if (rc != 0)
2986                                 goto trunc;
2987                 }
2988                 rc = cpack_uint8(s, &coding);
2989                 if (rc != 0)
2990                         goto trunc;
2991                 rc = cpack_uint8(s, &group_id);
2992                 if (rc != 0)
2993                         goto trunc;
2994                 rc = cpack_uint16(s, &partial_aid);
2995                 if (rc != 0)
2996                         goto trunc;
2997                 for (i = 0; i < 4; i++) {
2998                         u_int nss, mcs;
2999                         nss = mcs_nss[i] & IEEE80211_RADIOTAP_VHT_NSS_MASK;
3000                         mcs = (mcs_nss[i] & IEEE80211_RADIOTAP_VHT_MCS_MASK) >> IEEE80211_RADIOTAP_VHT_MCS_SHIFT;
3001
3002                         if (nss == 0)
3003                                 continue;
3004
3005                         ND_PRINT((ndo, "User %u MCS %u ", i, mcs));
3006                         ND_PRINT((ndo, "%s FEC ",
3007                                 (coding & (IEEE80211_RADIOTAP_CODING_LDPC_USERn << i)) ?
3008                                 "LDPC" : "BCC"));
3009                 }
3010                 if (known & IEEE80211_RADIOTAP_VHT_BANDWIDTH_KNOWN) {
3011                         ND_PRINT((ndo, "%s ",
3012                                 vht_bandwidth[bandwidth & IEEE80211_RADIOTAP_VHT_BANDWIDTH_MASK]));
3013                 }
3014                 if (known & IEEE80211_RADIOTAP_VHT_GUARD_INTERVAL_KNOWN) {
3015                         ND_PRINT((ndo, "%s GI ",
3016                                 (flags & IEEE80211_RADIOTAP_VHT_SHORT_GI) ?
3017                                 "short" : "long"));
3018                 }
3019                 break;
3020                 }
3021
3022         default:
3023                 /* this bit indicates a field whose
3024                  * size we do not know, so we cannot
3025                  * proceed.  Just print the bit number.
3026                  */
3027                 ND_PRINT((ndo, "[bit %u] ", bit));
3028                 return -1;
3029         }
3030
3031         return 0;
3032
3033 trunc:
3034         ND_PRINT((ndo, "%s", tstr));
3035         return rc;
3036 }
3037
3038
3039 static int
3040 print_in_radiotap_namespace(netdissect_options *ndo,
3041                             struct cpack_state *s, uint8_t *flags,
3042                             uint32_t presentflags, int bit0)
3043 {
3044 #define BITNO_32(x) (((x) >> 16) ? 16 + BITNO_16((x) >> 16) : BITNO_16((x)))
3045 #define BITNO_16(x) (((x) >> 8) ? 8 + BITNO_8((x) >> 8) : BITNO_8((x)))
3046 #define BITNO_8(x) (((x) >> 4) ? 4 + BITNO_4((x) >> 4) : BITNO_4((x)))
3047 #define BITNO_4(x) (((x) >> 2) ? 2 + BITNO_2((x) >> 2) : BITNO_2((x)))
3048 #define BITNO_2(x) (((x) & 2) ? 1 : 0)
3049         uint32_t present, next_present;
3050         int bitno;
3051         enum ieee80211_radiotap_type bit;
3052         int rc;
3053
3054         for (present = presentflags; present; present = next_present) {
3055                 /*
3056                  * Clear the least significant bit that is set.
3057                  */
3058                 next_present = present & (present - 1);
3059
3060                 /*
3061                  * Get the bit number, within this presence word,
3062                  * of the remaining least significant bit that
3063                  * is set.
3064                  */
3065                 bitno = BITNO_32(present ^ next_present);
3066
3067                 /*
3068                  * Stop if this is one of the "same meaning
3069                  * in all presence flags" bits.
3070                  */
3071                 if (bitno >= IEEE80211_RADIOTAP_NAMESPACE)
3072                         break;
3073
3074                 /*
3075                  * Get the radiotap bit number of that bit.
3076                  */
3077                 bit = (enum ieee80211_radiotap_type)(bit0 + bitno);
3078
3079                 rc = print_radiotap_field(ndo, s, bit, flags, presentflags);
3080                 if (rc != 0)
3081                         return rc;
3082         }
3083
3084         return 0;
3085 }
3086
3087 static u_int
3088 ieee802_11_radio_print(netdissect_options *ndo,
3089                        const u_char *p, u_int length, u_int caplen)
3090 {
3091 #define BIT(n)  (1U << n)
3092 #define IS_EXTENDED(__p)        \
3093             (EXTRACT_LE_32BITS(__p) & BIT(IEEE80211_RADIOTAP_EXT)) != 0
3094
3095         struct cpack_state cpacker;
3096         const struct ieee80211_radiotap_header *hdr;
3097         uint32_t presentflags;
3098         const uint32_t *presentp, *last_presentp;
3099         int vendor_namespace;
3100         uint8_t vendor_oui[3];
3101         uint8_t vendor_subnamespace;
3102         uint16_t skip_length;
3103         int bit0;
3104         u_int len;
3105         uint8_t flags;
3106         int pad;
3107         u_int fcslen;
3108
3109         if (caplen < sizeof(*hdr)) {
3110                 ND_PRINT((ndo, "%s", tstr));
3111                 return caplen;
3112         }
3113
3114         hdr = (const struct ieee80211_radiotap_header *)p;
3115
3116         len = EXTRACT_LE_16BITS(&hdr->it_len);
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 }