packet-ieee80211.c

Upload User: szdxsy
Upload Date: 2009-12-28
Package Size: 6759k
Code Size: 114k
Category: Sniffer Package capture
Development Platform: Visual C++
  1. /* packet-ieee80211.c
  2.  * Routines for Wireless LAN (IEEE 802.11) dissection
  3.  * Copyright 2000, Axis Communications AB
  4.  * Inquiries/bugreports should be sent to Johan.Jorgensen@axis.com
  5.  *
  6.  * $Id: packet-ieee80211.c 13039 2005-01-14 18:05:08Z guy $
  7.  *
  8.  * Ethereal - Network traffic analyzer
  9.  * By Gerald Combs <gerald@ethereal.com>
  10.  * Copyright 1998 Gerald Combs
  11.  *
  12.  * Copied from README.developer
  13.  *
  14.  * This program is free software; you can redistribute it and/or
  15.  * modify it under the terms of the GNU General Public License
  16.  * as published by the Free Software Foundation; either version 2
  17.  * of the License, or (at your option) any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software
  26.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27.  *
  28.  * Credits:
  29.  *
  30.  * The following people helped me by pointing out bugs etc. Thank you!
  31.  *
  32.  * Marco Molteni
  33.  * Lena-Marie Nilsson
  34.  * Magnus Hultman-Persson
  35.  */
  36. /*
  37.  * 09/12/2003 - Added dissection of country information tag
  38.  *
  39.  * Ritchie<at>tipsybottle.com
  40.  *
  41.  * 03/22/2004 - Added dissection of RSN IE
  42.  * Jouni Malinen <jkmaline@cc.hut.fi>
  43.  */
  44. #ifdef HAVE_CONFIG_H
  45. # include "config.h"
  46. #endif
  47. #include <stdio.h>
  48. #include <stdlib.h>
  49. #ifdef NEED_SNPRINTF_H
  50. # include "snprintf.h"
  51. #endif
  52. #include <string.h>
  53. #include <glib.h>
  54. #include <epan/bitswap.h>
  55. #include <epan/proto.h>
  56. #include <epan/packet.h>
  57. #include <epan/addr_resolv.h>
  58. #include <epan/strutil.h>
  59. #include <epan/prefs.h>
  60. #include "reassemble.h"
  61. #include "packet-ipx.h"
  62. #include "packet-llc.h"
  63. #include "packet-ieee80211.h"
  64. #include "etypes.h"
  65. #include <epan/crc32.h>
  66. #include <epan/tap.h>
  67. #include <ctype.h>
  68. #include "isprint.h"
  69. /* Defragment fragmented 802.11 datagrams */
  70. static gboolean wlan_defragment = TRUE;
  71. /* Check for the presence of the 802.11 FCS */
  72. static gboolean wlan_check_fcs = FALSE;
  73. /* Ignore the WEP bit; assume packet is decrypted */
  74. static gboolean wlan_ignore_wep = FALSE;
  75. /* Tables for reassembly of fragments. */
  76. static GHashTable *wlan_fragment_table = NULL;
  77. static GHashTable *wlan_reassembled_table = NULL;
  78. /* Stuff for the WEP decoder */
  79. static guint num_wepkeys = 0;
  80. static guint8 **wep_keys = NULL;
  81. static int *wep_keylens = NULL;
  82. static void init_wepkeys(void);
  83. static int wep_decrypt(guint8 *buf, guint32 len, int key_override);
  84. static tvbuff_t *try_decrypt_wep(tvbuff_t *tvb, guint32 offset, guint32 len);
  85. static int weak_iv(guchar *iv);
  86. #define SSWAP(a,b) {guint8 tmp = s[a]; s[a] = s[b]; s[b] = tmp;}
  87. /* #define USE_ENV */
  88. /* When this is set, an unlimited number of WEP keys can be set in the
  89.    environment:
  90.    ETHEREAL_WEPKEYNUM=##
  91.    ETHEREAL_WEPKEY1=aa:bb:cc:dd:...
  92.    ETHEREAL_WEPKEY2=aa:bab:cc:dd:ee:...
  93.    ... you get the idea.
  94.    otherwise you're limited to specifying four keys in the preference system.
  95.  */
  96. #ifndef USE_ENV
  97. static char *wep_keystr[] = {NULL, NULL, NULL, NULL};
  98. #endif
  99. /* ************************************************************************* */
  100. /*                          Miscellaneous Constants                          */
  101. /* ************************************************************************* */
  102. #define SHORT_STR 256
  103. /* ************************************************************************* */
  104. /*  Define some very useful macros that are used to analyze frame types etc. */
  105. /* ************************************************************************* */
  106. #define COMPOSE_FRAME_TYPE(x) (((x & 0x0C)<< 2)+((x & 0xF0) >> 4)) /* Create key to (sub)type */
  107. #define COOK_PROT_VERSION(x)  ((x) & 0x3)
  108. #define COOK_FRAME_TYPE(x)    (((x) & 0xC) >> 2)
  109. #define COOK_FRAME_SUBTYPE(x) (((x) & 0xF0) >> 4)
  110. #define COOK_ADDR_SELECTOR(x) ((x) & 0x300)
  111. #define COOK_ASSOC_ID(x)      ((x) & 0x3FFF)
  112. #define COOK_FRAGMENT_NUMBER(x) ((x) & 0x000F)
  113. #define COOK_SEQUENCE_NUMBER(x) (((x) & 0xFFF0) >> 4)
  114. #define COOK_QOS_PRIORITY(x)    ((x) & 0x0007)
  115. #define COOK_QOS_ACK_POLICY(x)  (((x) & 0x0060) >> 5)
  116. #define COOK_FLAGS(x)           (((x) & 0xFF00) >> 8)
  117. #define COOK_DS_STATUS(x)       ((x) & 0x3)
  118. #define COOK_WEP_KEY(x)       (((x) & 0xC0) >> 6)
  119. #define KEY_EXTIV 0x20
  120. #define EXTIV_LEN 8
  121. #define FLAG_TO_DS 0x01
  122. #define FLAG_FROM_DS 0x02
  123. #define FLAG_MORE_FRAGMENTS 0x04
  124. #define FLAG_RETRY 0x08
  125. #define FLAG_POWER_MGT 0x10
  126. #define FLAG_MORE_DATA 0x20
  127. #define FLAG_WEP 0x40
  128. #define FLAG_ORDER 0x80
  129. #define IS_TO_DS(x)            ((x) & FLAG_TO_DS)
  130. #define IS_FROM_DS(x)          ((x) & FLAG_FROM_DS)
  131. #define HAVE_FRAGMENTS(x)      ((x) & FLAG_MORE_FRAGMENTS)
  132. #define IS_RETRY(x)            ((x) & FLAG_RETRY)
  133. #define POWER_MGT_STATUS(x)    ((x) & FLAG_POWER_MGT)
  134. #define HAS_MORE_DATA(x)       ((x) & FLAG_MORE_DATA)
  135. #define IS_WEP(x)              (!wlan_ignore_wep && ((x) & FLAG_WEP))
  136. #define IS_STRICTLY_ORDERED(x) ((x) & FLAG_ORDER)
  137. #define MGT_RESERVED_RANGE(x)  (((x>=0x06)&&(x<=0x07))||((x>=0x0D)&&(x<=0x0F)))
  138. #define CTRL_RESERVED_RANGE(x) ((x>=0x10)&&(x<=0x19))
  139. #define DATA_RESERVED_RANGE(x) ((x>=0x28)&&(x<=0x2f))
  140. #define SPEC_RESERVED_RANGE(x) ((x>=0x30)&&(x<=0x3f))
  141. /* ************************************************************************* */
  142. /*              Constants used to identify cooked frame types                */
  143. /* ************************************************************************* */
  144. #define MGT_FRAME            0x00 /* Frame type is management */
  145. #define CONTROL_FRAME        0x01 /* Frame type is control */
  146. #define DATA_FRAME           0x02 /* Frame type is Data */
  147. #define DATA_SHORT_HDR_LEN     24
  148. #define DATA_LONG_HDR_LEN      30
  149. #define MGT_FRAME_HDR_LEN      24 /* Length of Managment frame-headers */
  150. #define MGT_ASSOC_REQ        0x00 /* Management - association request        */
  151. #define MGT_ASSOC_RESP       0x01 /* Management - association response       */
  152. #define MGT_REASSOC_REQ      0x02 /* Management - reassociation request      */
  153. #define MGT_REASSOC_RESP     0x03 /* Management - reassociation response     */
  154. #define MGT_PROBE_REQ        0x04 /* Management - Probe request              */
  155. #define MGT_PROBE_RESP       0x05 /* Management - Probe response             */
  156. #define MGT_BEACON           0x08 /* Management - Beacon frame               */
  157. #define MGT_ATIM             0x09 /* Management - ATIM                       */
  158. #define MGT_DISASS           0x0A /* Management - Disassociation             */
  159. #define MGT_AUTHENTICATION   0x0B /* Management - Authentication             */
  160. #define MGT_DEAUTHENTICATION 0x0C /* Management - Deauthentication           */
  161. #define MGT_ACTION           0x0D /* Management - Action */
  162. #define CTRL_PS_POLL         0x1A /* Control - power-save poll               */
  163. #define CTRL_RTS             0x1B /* Control - request to send               */
  164. #define CTRL_CTS             0x1C /* Control - clear to send                 */
  165. #define CTRL_ACKNOWLEDGEMENT 0x1D /* Control - acknowledgement               */
  166. #define CTRL_CFP_END         0x1E /* Control - contention-free period end    */
  167. #define CTRL_CFP_ENDACK      0x1F /* Control - contention-free period end/ack */
  168. #define DATA                 0x20 /* Data - Data                             */
  169. #define DATA_CF_ACK          0x21 /* Data - Data + CF acknowledge            */
  170. #define DATA_CF_POLL         0x22 /* Data - Data + CF poll                   */
  171. #define DATA_CF_ACK_POLL     0x23 /* Data - Data + CF acknowledge + CF poll  */
  172. #define DATA_NULL_FUNCTION   0x24 /* Data - Null function (no data)          */
  173. #define DATA_CF_ACK_NOD      0x25 /* Data - CF ack (no data)                 */
  174. #define DATA_CF_POLL_NOD     0x26       /* Data - Data + CF poll (No data)         */
  175. #define DATA_CF_ACK_POLL_NOD 0x27 /* Data - CF ack + CF poll (no data)       */
  176. #define DATA_QOS_DATA        0x28 /* Data - QoS Data                         */
  177. #define DATA_QOS_NULL        0x2c /* Data - QoS Null                         */
  178. #define DATA_ADDR_T1         0
  179. #define DATA_ADDR_T2         (FLAG_FROM_DS << 8)
  180. #define DATA_ADDR_T3         (FLAG_TO_DS << 8)
  181. #define DATA_ADDR_T4         ((FLAG_TO_DS|FLAG_FROM_DS) << 8)
  182. /* ************************************************************************* */
  183. /*          Macros used to extract information about fixed fields            */
  184. /* ************************************************************************* */
  185. #define ESS_SET(x) ((x) & 0x0001)
  186. #define IBSS_SET(x) ((x) & 0x0002)
  187. /* ************************************************************************* */
  188. /*        Logical field codes (dissector's encoding of fixed fields)         */
  189. /* ************************************************************************* */
  190. #define FIELD_TIMESTAMP       0x01 /* 64-bit timestamp                       */
  191. #define FIELD_BEACON_INTERVAL 0x02 /* 16-bit beacon interval                 */
  192. #define FIELD_CAP_INFO        0x03 /* Add capability information tree        */
  193. #define FIELD_AUTH_ALG        0x04 /* Authentication algorithm used          */
  194. #define FIELD_AUTH_TRANS_SEQ  0x05 /* Authentication sequence number         */
  195. #define FIELD_CURRENT_AP_ADDR 0x06
  196. #define FIELD_LISTEN_IVAL     0x07
  197. #define FIELD_REASON_CODE     0x08
  198. #define FIELD_ASSOC_ID        0x09
  199. #define FIELD_STATUS_CODE     0x0A
  200. #define FIELD_CATEGORY_CODE   0x0B /* Management action category */
  201. #define FIELD_ACTION_CODE     0x0C /* Management action code */
  202. #define FIELD_DIALOG_TOKEN    0x0D /* Management action dialog token */
  203. #define FIELD_WME_ACTION_CODE 0x0E /* Management notification action code */
  204. #define FIELD_WME_DIALOG_TOKEN 0x0F /* Management notification dialog token */
  205. #define FIELD_WME_STATUS_CODE 0x10 /* Management notification setup response status code */
  206. /* ************************************************************************* */
  207. /*        Logical field codes (IEEE 802.11 encoding of tags)                 */
  208. /* ************************************************************************* */
  209. #define TAG_SSID                 0x00
  210. #define TAG_SUPP_RATES           0x01
  211. #define TAG_FH_PARAMETER         0x02
  212. #define TAG_DS_PARAMETER         0x03
  213. #define TAG_CF_PARAMETER         0x04
  214. #define TAG_TIM                  0x05
  215. #define TAG_IBSS_PARAMETER       0x06
  216. #define TAG_COUNTRY_INFO         0x07
  217. #define TAG_FH_HOPPING_PARAMETER 0x08
  218. #define TAG_FH_HOPPING_TABLE     0x09
  219. #define TAG_CHALLENGE_TEXT       0x10
  220. #define TAG_ERP_INFO             0x2A
  221. #define TAG_ERP_INFO_OLD         0x2F /* IEEE Std 802.11g/D4.0 */
  222. #define TAG_RSN_IE               0x30
  223. #define TAG_EXT_SUPP_RATES       0x32
  224. #define TAG_VENDOR_SPECIFIC_IE  0xDD
  225. #define WPA_OUI "x00x50xF2"
  226. #define RSN_OUI "x00x0FxAC"
  227. #define WME_OUI "x00x50xF2"
  228. #define PMKID_LEN 16
  229. /* ************************************************************************* */
  230. /*                         Frame types, and their names                      */
  231. /* ************************************************************************* */
  232. static const value_string frame_type_subtype_vals[] = {
  233. {MGT_ASSOC_REQ,        "Association Request"},
  234. {MGT_ASSOC_RESP,       "Association Response"},
  235. {MGT_REASSOC_REQ,      "Reassociation Request"},
  236. {MGT_REASSOC_RESP,     "Reassociation Response"},
  237. {MGT_PROBE_REQ,        "Probe Request"},
  238. {MGT_PROBE_RESP,       "Probe Response"},
  239. {MGT_BEACON,           "Beacon frame"},
  240. {MGT_ATIM,             "ATIM"},
  241. {MGT_DISASS,           "Dissassociate"},
  242. {MGT_AUTHENTICATION,   "Authentication"},
  243. {MGT_DEAUTHENTICATION, "Deauthentication"},
  244. {MGT_ACTION,           "Action"},
  245. {CTRL_PS_POLL,         "Power-Save poll"},
  246. {CTRL_RTS,             "Request-to-send"},
  247. {CTRL_CTS,             "Clear-to-send"},
  248. {CTRL_ACKNOWLEDGEMENT, "Acknowledgement"},
  249. {CTRL_CFP_END,         "CF-End (Control-frame)"},
  250. {CTRL_CFP_ENDACK,      "CF-End + CF-Ack (Control-frame)"},
  251. {DATA,                 "Data"},
  252. {DATA_CF_ACK,          "Data + CF-Acknowledgement"},
  253. {DATA_CF_POLL,         "Data + CF-Poll"},
  254. {DATA_CF_ACK_POLL,     "Data + CF-Acknowledgement/Poll"},
  255. {DATA_NULL_FUNCTION,   "Null function (No data)"},
  256. {DATA_CF_ACK_NOD,      "Data + Acknowledgement (No data)"},
  257. {DATA_CF_POLL_NOD,     "Data + CF-Poll (No data)"},
  258. {DATA_CF_ACK_POLL_NOD, "Data + CF-Acknowledgement/Poll (No data)"},
  259. {DATA_QOS_DATA,        "QoS Data"},
  260. {DATA_QOS_NULL,        "QoS Null (No data)"},
  261. {0,                    NULL}
  262. };
  263. /* ************************************************************************* */
  264. /*                             802.1D Tag Names                              */
  265. /* ************************************************************************* */
  266. static const char *qos_tags[8] = {
  267. "Best Effort",
  268. "Background",
  269. "Spare",
  270. "Excellent Effort",
  271. "Controlled Load",
  272. "Video",
  273. "Voice",
  274. "Network Control"
  275. };
  276. /* ************************************************************************* */
  277. /*                 WME Access Category Names (by 802.1D Tag)                 */
  278. /* ************************************************************************* */
  279. static const char *qos_acs[8] = {
  280. "Best Effort",
  281. "Background",
  282. "Background",
  283. "Video",
  284. "Video",
  285. "Video",
  286. "Voice",
  287. "Voice"
  288. };
  289. /* ************************************************************************* */
  290. /*                   WME Access Category Names (by WME ACI)                  */
  291. /* ************************************************************************* */
  292. static const char *wme_acs[4] = {
  293. "Best Effort",
  294. "Background",
  295. "Video",
  296. "Voice",
  297. };
  298. static int proto_wlan = -1;
  299. /* ************************************************************************* */
  300. /*                Header field info values for radio information             */
  301. /* ************************************************************************* */
  302. static int hf_data_rate = -1;
  303. static int hf_channel = -1;
  304. static int hf_signal_strength = -1;
  305. /* ************************************************************************* */
  306. /*                Header field info values for FC-field                      */
  307. /* ************************************************************************* */
  308. static int hf_fc_field = -1;
  309. static int hf_fc_proto_version = -1;
  310. static int hf_fc_frame_type = -1;
  311. static int hf_fc_frame_subtype = -1;
  312. static int hf_fc_frame_type_subtype = -1;
  313. static int hf_fc_flags = -1;
  314. static int hf_fc_to_ds = -1;
  315. static int hf_fc_from_ds = -1;
  316. static int hf_fc_data_ds = -1;
  317. static int hf_fc_more_frag = -1;
  318. static int hf_fc_retry = -1;
  319. static int hf_fc_pwr_mgt = -1;
  320. static int hf_fc_more_data = -1;
  321. static int hf_fc_wep = -1;
  322. static int hf_fc_order = -1;
  323. /* ************************************************************************* */
  324. /*                   Header values for Duration/ID field                     */
  325. /* ************************************************************************* */
  326. static int hf_did_duration = -1;
  327. static int hf_assoc_id = -1;
  328. /* ************************************************************************* */
  329. /*         Header values for different address-fields (all 4 of them)        */
  330. /* ************************************************************************* */
  331. static int hf_addr_da = -1; /* Destination address subfield */
  332. static int hf_addr_sa = -1; /* Source address subfield */
  333. static int hf_addr_ra = -1; /* Receiver address subfield */
  334. static int hf_addr_ta = -1; /* Transmitter address subfield */
  335. static int hf_addr_bssid = -1; /* address is bssid */
  336. static int hf_addr = -1; /* Source or destination address subfield */
  337. /* ************************************************************************* */
  338. /*                Header values for QoS control field                        */
  339. /* ************************************************************************* */
  340. static int hf_qos_priority = -1;
  341. static int hf_qos_ack_policy = -1;
  342. /* ************************************************************************* */
  343. /*                Header values for sequence number field                    */
  344. /* ************************************************************************* */
  345. static int hf_frag_number = -1;
  346. static int hf_seq_number = -1;
  347. /* ************************************************************************* */
  348. /*                   Header values for Frame Check field                     */
  349. /* ************************************************************************* */
  350. static int hf_fcs = -1;
  351. /* ************************************************************************* */
  352. /*                   Header values for reassembly                            */
  353. /* ************************************************************************* */
  354. static int hf_fragments = -1;
  355. static int hf_fragment = -1;
  356. static int hf_fragment_overlap = -1;
  357. static int hf_fragment_overlap_conflict = -1;
  358. static int hf_fragment_multiple_tails = -1;
  359. static int hf_fragment_too_long_fragment = -1;
  360. static int hf_fragment_error = -1;
  361. static int hf_reassembled_in = -1;
  362. static int proto_wlan_mgt = -1;
  363. /* ************************************************************************* */
  364. /*                      Fixed fields found in mgt frames                     */
  365. /* ************************************************************************* */
  366. static int ff_auth_alg = -1; /* Authentication algorithm field            */
  367. static int ff_auth_seq = -1; /* Authentication transaction sequence       */
  368. static int ff_current_ap = -1; /* Current AP MAC address                    */
  369. static int ff_listen_ival = -1; /* Listen interval fixed field               */
  370. static int ff_timestamp = -1; /* 64 bit timestamp                          */
  371. static int ff_beacon_interval = -1; /* 16 bit Beacon interval            */
  372. static int ff_assoc_id = -1; /* 16 bit AID field                          */
  373. static int ff_reason = -1; /* 16 bit reason code                        */
  374. static int ff_status_code = -1; /* Status code                               */
  375. static int ff_category_code = -1; /* 8 bit Category code */
  376. static int ff_action_code = -1; /* 8 bit Action code */
  377. static int ff_dialog_token = -1; /* 8 bit Dialog token */
  378. static int ff_wme_action_code = -1; /* Management notification action code */
  379. static int ff_wme_status_code = -1; /* Management notification setup response status code */
  380. /* ************************************************************************* */
  381. /*            Flags found in the capability field (fixed field)              */
  382. /* ************************************************************************* */
  383. static int ff_capture = -1;
  384. static int ff_cf_ess = -1;
  385. static int ff_cf_ibss = -1;
  386. static int ff_cf_sta_poll = -1; /* CF pollable status for a STA            */
  387. static int ff_cf_ap_poll = -1; /* CF pollable status for an AP            */
  388. static int ff_cf_privacy = -1;
  389. static int ff_cf_preamble = -1;
  390. static int ff_cf_pbcc = -1;
  391. static int ff_cf_agility = -1;
  392. static int ff_short_slot_time = -1;
  393. static int ff_dsss_ofdm = -1;
  394. /* ************************************************************************* */
  395. /*                       Tagged value format fields                          */
  396. /* ************************************************************************* */
  397. static int tag_number = -1;
  398. static int tag_length = -1;
  399. static int tag_interpretation = -1;
  400. static int hf_fixed_parameters = -1; /* Protocol payload for management frames */
  401. static int hf_tagged_parameters = -1; /* Fixed payload item */
  402. static int hf_wep_iv = -1;
  403. static int hf_wep_iv_weak = -1;
  404. static int hf_tkip_extiv = -1;
  405. static int hf_ccmp_extiv = -1;
  406. static int hf_wep_key = -1;
  407. static int hf_wep_icv = -1;
  408. static int rsn_cap = -1;
  409. static int rsn_cap_preauth = -1;
  410. static int rsn_cap_no_pairwise = -1;
  411. static int rsn_cap_ptksa_replay_counter = -1;
  412. static int rsn_cap_gtksa_replay_counter = -1;
  413. /* ************************************************************************* */
  414. /*                               Protocol trees                              */
  415. /* ************************************************************************* */
  416. static gint ett_80211 = -1;
  417. static gint ett_proto_flags = -1;
  418. static gint ett_cap_tree = -1;
  419. static gint ett_fc_tree = -1;
  420. static gint ett_fragments = -1;
  421. static gint ett_fragment = -1;
  422. static gint ett_80211_mgt = -1;
  423. static gint ett_fixed_parameters = -1;
  424. static gint ett_tagged_parameters = -1;
  425. static gint ett_qos_parameters = -1;
  426. static gint ett_wep_parameters = -1;
  427. static gint ett_rsn_cap_tree = -1;
  428. static const fragment_items frag_items = {
  429. &ett_fragment,
  430. &ett_fragments,
  431. &hf_fragments,
  432. &hf_fragment,
  433. &hf_fragment_overlap,
  434. &hf_fragment_overlap_conflict,
  435. &hf_fragment_multiple_tails,
  436. &hf_fragment_too_long_fragment,
  437. &hf_fragment_error,
  438. &hf_reassembled_in,
  439. "fragments"
  440. };
  441. static dissector_handle_t llc_handle;
  442. static dissector_handle_t ipx_handle;
  443. static dissector_handle_t eth_withoutfcs_handle;
  444. static dissector_handle_t data_handle;
  445. static int wlan_tap = -1;
  446. /* ************************************************************************* */
  447. /*            Return the length of the current header (in bytes)             */
  448. /* ************************************************************************* */
  449. static int
  450. find_header_length (guint16 fcf)
  451. {
  452.   int len;
  453.   switch (COOK_FRAME_TYPE (fcf)) {
  454.   case MGT_FRAME:
  455.     return MGT_FRAME_HDR_LEN;
  456.   case CONTROL_FRAME:
  457.     switch (COMPOSE_FRAME_TYPE (fcf)) {
  458.     case CTRL_CTS:
  459.     case CTRL_ACKNOWLEDGEMENT:
  460.       return 10;
  461.     case CTRL_RTS:
  462.     case CTRL_PS_POLL:
  463.     case CTRL_CFP_END:
  464.     case CTRL_CFP_ENDACK:
  465.       return 16;
  466.     }
  467.     return 4; /* XXX */
  468.   case DATA_FRAME:
  469.     len = (COOK_ADDR_SELECTOR(fcf) == DATA_ADDR_T4) ? DATA_LONG_HDR_LEN :
  470.       DATA_SHORT_HDR_LEN;
  471.     switch (COMPOSE_FRAME_TYPE (fcf)) {
  472.     case DATA_QOS_DATA:
  473.     case DATA_QOS_NULL:
  474.       return len + 2;
  475.     default:
  476.       return len;
  477.     }
  478.   default:
  479.     return 4; /* XXX */
  480.   }
  481. }
  482. /* ************************************************************************* */
  483. /*          This is the capture function used to update packet counts        */
  484. /* ************************************************************************* */
  485. static void
  486. capture_ieee80211_common (const guchar * pd, int offset, int len,
  487.   packet_counts * ld, gboolean fixed_length_header)
  488. {
  489.   guint16 fcf, hdr_length;
  490.   if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
  491.     ld->other++;
  492.     return;
  493.   }
  494.   fcf = pletohs (&pd[0]);
  495.   if (IS_WEP(COOK_FLAGS(fcf)))
  496.     {
  497.       ld->other++;
  498.       return;
  499.     }
  500.   switch (COMPOSE_FRAME_TYPE (fcf))
  501.     {
  502.     case DATA: /* We got a data frame */
  503.     case DATA_CF_ACK: /* Data with ACK */
  504.     case DATA_CF_POLL:
  505.     case DATA_CF_ACK_POLL:
  506.     case DATA_QOS_DATA:
  507.       if (fixed_length_header)
  508.         hdr_length = DATA_LONG_HDR_LEN;
  509.       else
  510.         hdr_length = find_header_length (fcf);
  511.       /* I guess some bridges take Netware Ethernet_802_3 frames,
  512.          which are 802.3 frames (with a length field rather than
  513.          a type field, but with no 802.2 header in the payload),
  514.          and just stick the payload into an 802.11 frame.  I've seen
  515.          captures that show frames of that sort.
  516.          This means we have to do the same check for Netware 802.3 -
  517.          or, if you will, "Netware 802.11" - that we do in the
  518.          Ethernet dissector, i.e. checking for 0xffff as the first
  519.          four bytes of the payload and, if we find it, treating it
  520.          as an IPX frame. */
  521.       if (!BYTES_ARE_IN_FRAME(offset+hdr_length, len, 2)) {
  522.         ld->other++;
  523.         return;
  524.       }
  525.       if (pd[offset+hdr_length] == 0xff && pd[offset+hdr_length+1] == 0xff) {
  526.         capture_ipx (ld);
  527.       }
  528.       else {
  529.         capture_llc (pd, offset + hdr_length, len, ld);
  530.       }
  531.       break;
  532.     default:
  533.       ld->other++;
  534.       break;
  535.     }
  536. }
  537. /*
  538.  * Handle 802.11 with a variable-length link-layer header.
  539.  */
  540. void
  541. capture_ieee80211 (const guchar * pd, int offset, int len, packet_counts * ld)
  542. {
  543.   capture_ieee80211_common (pd, offset, len, ld, FALSE);
  544. }
  545. /*
  546.  * Handle 802.11 with a fixed-length link-layer header (padded to the
  547.  * maximum length).
  548.  */
  549. void
  550. capture_ieee80211_fixed (const guchar * pd, int offset, int len, packet_counts * ld)
  551. {
  552.   capture_ieee80211_common (pd, offset, len, ld, TRUE);
  553. }
  554. /* ************************************************************************* */
  555. /*          Add the subtree used to store the fixed parameters               */
  556. /* ************************************************************************* */
  557. static proto_tree *
  558. get_fixed_parameter_tree (proto_tree * tree, tvbuff_t *tvb, int start, int size)
  559. {
  560.   proto_item *fixed_fields;
  561.   fixed_fields =
  562.     proto_tree_add_uint_format (tree, hf_fixed_parameters, tvb, start,
  563. size, size, "Fixed parameters (%d bytes)",
  564. size);
  565.   return proto_item_add_subtree (fixed_fields, ett_fixed_parameters);
  566. }
  567. /* ************************************************************************* */
  568. /*            Add the subtree used to store tagged parameters                */
  569. /* ************************************************************************* */
  570. static proto_tree *
  571. get_tagged_parameter_tree (proto_tree * tree, tvbuff_t *tvb, int start, int size)
  572. {
  573.   proto_item *tagged_fields;
  574.   tagged_fields = proto_tree_add_uint_format (tree, hf_tagged_parameters,
  575.       tvb,
  576.       start,
  577.       size,
  578.       size,
  579.       "Tagged parameters (%d bytes)",
  580.       size);
  581.   return proto_item_add_subtree (tagged_fields, ett_tagged_parameters);
  582. }
  583. /* ************************************************************************* */
  584. /*              Dissect and add fixed mgmt fields to protocol tree           */
  585. /* ************************************************************************* */
  586. static void
  587. add_fixed_field (proto_tree * tree, tvbuff_t * tvb, int offset, int lfcode)
  588. {
  589.   const guint8 *dataptr;
  590.   char out_buff[SHORT_STR];
  591.   guint16 capability;
  592.   proto_item *cap_item;
  593.   static proto_tree *cap_tree;
  594.   double temp_double;
  595.   switch (lfcode)
  596.     {
  597.     case FIELD_TIMESTAMP:
  598.       dataptr = tvb_get_ptr (tvb, offset, 8);
  599.       memset (out_buff, 0, SHORT_STR);
  600.       snprintf (out_buff, SHORT_STR, "0x%02X%02X%02X%02X%02X%02X%02X%02X",
  601. dataptr[7],
  602. dataptr[6],
  603. dataptr[5],
  604. dataptr[4],
  605. dataptr[3],
  606. dataptr[2],
  607. dataptr[1],
  608. dataptr[0]);
  609.       proto_tree_add_string (tree, ff_timestamp, tvb, offset, 8, out_buff);
  610.       break;
  611.     case FIELD_BEACON_INTERVAL:
  612.       temp_double = (double) tvb_get_letohs (tvb, offset);
  613.       temp_double = temp_double * 1024 / 1000000;
  614.       proto_tree_add_double_format (tree, ff_beacon_interval, tvb, offset, 2,
  615.     temp_double,"Beacon Interval: %f [Seconds]",
  616.     temp_double);
  617.       break;
  618.     case FIELD_CAP_INFO:
  619.       capability = tvb_get_letohs (tvb, offset);
  620.       cap_item = proto_tree_add_uint_format (tree, ff_capture,
  621.      tvb, offset, 2,
  622.      capability,
  623.      "Capability Information: 0x%04X",
  624.      capability);
  625.       cap_tree = proto_item_add_subtree (cap_item, ett_cap_tree);
  626.       proto_tree_add_boolean (cap_tree, ff_cf_ess, tvb, offset, 2,
  627.       capability);
  628.       proto_tree_add_boolean (cap_tree, ff_cf_ibss, tvb, offset, 2,
  629.       capability);
  630.       if (ESS_SET (capability) != 0) /* This is an AP */
  631. proto_tree_add_uint (cap_tree, ff_cf_ap_poll, tvb, offset, 2,
  632.      capability);
  633.       else /* This is a STA */
  634. proto_tree_add_uint (cap_tree, ff_cf_sta_poll, tvb, offset, 2,
  635.      capability);
  636.       proto_tree_add_boolean (cap_tree, ff_cf_privacy, tvb, offset, 2,
  637.       capability);
  638.       proto_tree_add_boolean (cap_tree, ff_cf_preamble, tvb, offset, 2,
  639.       capability);
  640.       proto_tree_add_boolean (cap_tree, ff_cf_pbcc, tvb, offset, 2,
  641.       capability);
  642.       proto_tree_add_boolean (cap_tree, ff_cf_agility, tvb, offset, 2,
  643.       capability);
  644.       proto_tree_add_boolean (cap_tree, ff_short_slot_time, tvb, offset, 2,
  645.       capability);
  646.       proto_tree_add_boolean (cap_tree, ff_dsss_ofdm, tvb, offset, 2,
  647.       capability);
  648.       break;
  649.     case FIELD_AUTH_ALG:
  650.       proto_tree_add_item (tree, ff_auth_alg, tvb, offset, 2, TRUE);
  651.       break;
  652.     case FIELD_AUTH_TRANS_SEQ:
  653.       proto_tree_add_item (tree, ff_auth_seq, tvb, offset, 2, TRUE);
  654.       break;
  655.     case FIELD_CURRENT_AP_ADDR:
  656.       proto_tree_add_item (tree, ff_current_ap, tvb, offset, 6, FALSE);
  657.       break;
  658.     case FIELD_LISTEN_IVAL:
  659.       proto_tree_add_item (tree, ff_listen_ival, tvb, offset, 2, TRUE);
  660.       break;
  661.     case FIELD_REASON_CODE:
  662.       proto_tree_add_item (tree, ff_reason, tvb, offset, 2, TRUE);
  663.       break;
  664.     case FIELD_ASSOC_ID:
  665.       proto_tree_add_uint(tree, ff_assoc_id, tvb, offset, 2, 
  666.   COOK_ASSOC_ID(tvb_get_letohs(tvb,offset)));
  667.       /* proto_tree_add_item (tree, ff_assoc_id, tvb, offset, 2, TRUE); */
  668.       break;
  669.     case FIELD_STATUS_CODE:
  670.       proto_tree_add_item (tree, ff_status_code, tvb, offset, 2, TRUE);
  671.       break;
  672.     case FIELD_CATEGORY_CODE:
  673.       proto_tree_add_item (tree, ff_category_code, tvb, offset, 1, TRUE);
  674.       break;
  675.     case FIELD_ACTION_CODE:
  676.       proto_tree_add_item (tree, ff_action_code, tvb, offset, 1, TRUE);
  677.       break;
  678.     case FIELD_DIALOG_TOKEN:
  679.       proto_tree_add_item (tree, ff_dialog_token, tvb, offset, 1, TRUE);
  680.       break;
  681.     case FIELD_WME_ACTION_CODE:
  682.       proto_tree_add_item (tree, ff_wme_action_code, tvb, offset, 1, TRUE);
  683.       break;
  684.     case FIELD_WME_STATUS_CODE:
  685.       proto_tree_add_item (tree, ff_wme_status_code, tvb, offset, 1, TRUE);
  686.       break;
  687.     }
  688. }
  689. static char *wpa_cipher_str[] = 
  690. {
  691.   "NONE",
  692.   "WEP (40-bit)",
  693.   "TKIP",
  694.   "AES (OCB)",
  695.   "AES (CCM)",
  696.   "WEP (104-bit)",
  697. };
  698. static char *
  699. wpa_cipher_idx2str(guint idx)
  700. {
  701.   if (idx < sizeof(wpa_cipher_str)/sizeof(wpa_cipher_str[0]))
  702.     return wpa_cipher_str[idx];
  703.   return "UNKNOWN";
  704. }
  705. static char *wpa_keymgmt_str[] = 
  706. {
  707.   "NONE",
  708.   "WPA",
  709.   "PSK",
  710. };
  711. static char *
  712. wpa_keymgmt_idx2str(guint idx)
  713. {
  714.   if (idx < sizeof(wpa_keymgmt_str)/sizeof(wpa_keymgmt_str[0]))
  715.     return wpa_keymgmt_str[idx];
  716.   return "UNKNOWN";
  717. }
  718. static void 
  719. dissect_vendor_specific_ie(proto_tree * tree, tvbuff_t * tvb, int offset,
  720. guint32 tag_len, const guint8 *tag_val)
  721. {
  722.       guint32 tag_val_off = 0;
  723.       char out_buff[SHORT_STR], *pos;
  724.       guint i;
  725.       /* Wi-Fi Protected Access (WPA) Information Element */
  726.       if (tag_val_off + 6 <= tag_len && !memcmp(tag_val, WPA_OUI"x01", 4)) {
  727.         snprintf(out_buff, SHORT_STR, "WPA IE, type %u, version %u",
  728.                   tag_val[tag_val_off + 3], pletohs(&tag_val[tag_val_off + 4]));
  729.         proto_tree_add_string(tree, tag_interpretation, tvb, offset, 6, out_buff);
  730.         offset += 6;
  731.         tag_val_off += 6;
  732.         if (tag_val_off + 4 <= tag_len) {
  733.           /* multicast cipher suite */
  734.           if (!memcmp(&tag_val[tag_val_off], WPA_OUI, 3)) {
  735.             snprintf(out_buff, SHORT_STR, "Multicast cipher suite: %s", 
  736.                       wpa_cipher_idx2str(tag_val[tag_val_off + 3]));
  737.             proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  738.             offset += 4;
  739.             tag_val_off += 4;
  740.             /* unicast cipher suites */
  741.             if (tag_val_off + 2 <= tag_len) {
  742.               snprintf(out_buff, SHORT_STR, "# of unicast cipher suites: %u",
  743.                         pletohs(tag_val + tag_val_off));
  744.               proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  745.               offset += 2;
  746.               tag_val_off += 2;
  747.               i = 1;
  748.               while (tag_val_off + 4 <= tag_len) {
  749.                 if (!memcmp(&tag_val[tag_val_off], WPA_OUI, 3)) {
  750.                   snprintf(out_buff, SHORT_STR, "Unicast cipher suite %u: %s", 
  751.                             i, wpa_cipher_idx2str(tag_val[tag_val_off + 3]));
  752.                   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  753.                   offset += 4;
  754.                   tag_val_off += 4;
  755.                   i ++;
  756.                 }
  757.                 else
  758.                   break;
  759.               }
  760.       /* authenticated key management suites */
  761.               if (tag_val_off + 2 <= tag_len) {
  762.                 snprintf(out_buff, SHORT_STR, "# of auth key management suites: %u",
  763.                           pletohs(tag_val + tag_val_off));
  764.                 proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  765.                 offset += 2;
  766.                 tag_val_off += 2;
  767.                 i = 1;
  768.                 while (tag_val_off + 4 <= tag_len) {
  769.                   if (!memcmp(&tag_val[tag_val_off], WPA_OUI, 3)) {
  770.                     snprintf(out_buff, SHORT_STR, "auth key management suite %u: %s", 
  771.                               i, wpa_keymgmt_idx2str(tag_val[tag_val_off + 3]));
  772.                     proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  773.                     offset += 4;
  774.                     tag_val_off += 4;
  775.                     i ++;
  776.                   }
  777.                   else
  778.                     break;
  779.                 }
  780.               }
  781.             }
  782.           }
  783.         }
  784.         if (tag_val_off < tag_len)
  785.           proto_tree_add_string(tree, tag_interpretation, tvb,
  786.                                  offset, tag_len - tag_val_off, "Not interpreted");
  787.       } else if (tag_val_off + 7 <= tag_len && !memcmp(tag_val, WME_OUI"x02x00", 5)) {
  788.       /* Wireless Multimedia Enhancements (WME) Information Element */
  789.         snprintf(out_buff, SHORT_STR, "WME IE: type %u, subtype %u, version %u, parameter set %u",
  790.  tag_val[tag_val_off + 3], tag_val[tag_val_off + 4], tag_val[tag_val_off + 5],
  791.  tag_val[tag_val_off + 6]);
  792.         proto_tree_add_string(tree, tag_interpretation, tvb, offset, 7, out_buff);
  793.       } else if (tag_val_off + 24 <= tag_len && !memcmp(tag_val, WME_OUI"x02x01", 5)) {
  794.       /* Wireless Multimedia Enhancements (WME) Parameter Element */
  795.         snprintf(out_buff, SHORT_STR, "WME PE: type %u, subtype %u, version %u, parameter set %u",
  796.  tag_val[tag_val_off + 3], tag_val[tag_val_off + 4], tag_val[tag_val_off + 5],
  797.  tag_val[tag_val_off + 6]);
  798.         proto_tree_add_string(tree, tag_interpretation, tvb, offset, 7, out_buff);
  799. offset += 8;
  800. tag_val_off += 8;
  801. for (i = 0; i < 4; i++) {
  802.   snprintf(out_buff, SHORT_STR, "WME AC Parameters: ACI %u (%s), Admission Control %sMandatory, AIFSN %u, ECWmin %u, ECWmax %u, TXOP %u",
  803.    (tag_val[tag_val_off] & 0x60) >> 5,
  804.    wme_acs[(tag_val[tag_val_off] & 0x60) >> 5],
  805.    (tag_val[tag_val_off] & 0x10) ? "" : "not ",
  806.    tag_val[tag_val_off] & 0x0f,
  807.    tag_val[tag_val_off + 1] & 0x0f,
  808.    (tag_val[tag_val_off + 1] & 0xf0) >> 4,
  809.    tvb_get_letohs(tvb, offset + 2));
  810.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  811.   offset += 4;
  812.   tag_val_off += 4;
  813. }
  814.       } else if (tag_val_off + 56 <= tag_len && !memcmp(tag_val, WME_OUI"x02x02", 5)) {
  815.       /* Wireless Multimedia Enhancements (WME) TSPEC Element */
  816. guint16 ts_info, msdu_size, surplus_bandwidth;
  817. const char *direction[] = { "Uplink", "Downlink", "Reserved", "Bi-directional" };
  818. const value_string fields[] = {
  819.   {12, "Minimum Service Interval"},
  820.   {16, "Maximum Service Interval"},
  821.   {20, "Inactivity Interval"},
  822.   {24, "Service Start Time"},
  823.   {28, "Minimum Data Rate"},
  824.   {32, "Mean Data Rate"},
  825.   {36, "Maximum Burst Size"},
  826.   {40, "Minimum PHY Rate"},
  827.   {44, "Peak Data Rate"},
  828.   {48, "Delay Bound"},
  829.   {0, NULL}
  830. };
  831. char *field;
  832.         snprintf(out_buff, SHORT_STR, "WME TSPEC: type %u, subtype %u, version %u",
  833.  tag_val[tag_val_off + 3], tag_val[tag_val_off + 4], tag_val[tag_val_off + 5]);
  834.         proto_tree_add_string(tree, tag_interpretation, tvb, offset, 6, out_buff);
  835. offset += 6;
  836. tag_val_off += 6;
  837. ts_info = tvb_get_letohs(tvb, offset);
  838. snprintf(out_buff, SHORT_STR, "WME TS Info: Priority %u (%s) (%s), Contention-based access %sset, %s",
  839.  (ts_info >> 11) & 0x7, qos_tags[(ts_info >> 11) & 0x7], qos_acs[(ts_info >> 11) & 0x7],
  840.  (ts_info & 0x0080) ? "" : "not ",
  841.  direction[(ts_info >> 5) & 0x3]);
  842. proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  843. offset += 2;
  844. tag_val_off += 2;
  845. msdu_size = tvb_get_letohs(tvb, offset);
  846. snprintf(out_buff, SHORT_STR, "WME TSPEC: %s MSDU Size %u",
  847.  (msdu_size & 0x8000) ? "Fixed" : "Nominal", msdu_size & 0x7fff);
  848. proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  849. offset += 2;
  850. tag_val_off += 2;
  851. snprintf(out_buff, SHORT_STR, "WME TSPEC: Maximum MSDU Size %u", tvb_get_letohs(tvb, offset));
  852. proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  853. offset += 2;
  854. tag_val_off += 2;
  855. while ((field = val_to_str(tag_val_off, fields, NULL))) {
  856.   snprintf(out_buff, SHORT_STR, "WME TSPEC: %s %u", field, tvb_get_letohl(tvb, offset));
  857.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  858.   offset += 4;
  859.   tag_val_off += 4;
  860.   if (tag_val_off == 52)
  861.     break;
  862. }
  863. surplus_bandwidth = tvb_get_letohs(tvb, offset);
  864. snprintf(out_buff, SHORT_STR, "WME TSPEC: Surplus Bandwidth Allowance Factor %u.%u",
  865.  (surplus_bandwidth >> 13) & 0x7, (surplus_bandwidth & 0x1fff));
  866. offset += 2;
  867. tag_val_off += 2;
  868. snprintf(out_buff, SHORT_STR, "WME TSPEC: Medium Time %u", tvb_get_letohs(tvb, offset));
  869. proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  870. offset += 2;
  871. tag_val_off += 2;  
  872.       } else if (tag_val_off + 4 <= tag_len && !memcmp(tag_val, RSN_OUI"x04", 4)) {
  873. /* IEEE 802.11i / Key Data Encapsulation / Data Type=4 - PMKID.
  874.  * This is only used within EAPOL-Key frame Key Data. */
  875. pos = out_buff;
  876. pos += snprintf(pos, out_buff + SHORT_STR - pos, "RSN PMKID: ");
  877. if (tag_len - 4 != PMKID_LEN) {
  878.   pos += snprintf(pos, out_buff + SHORT_STR - pos,
  879.   "(invalid PMKID len=%d, expected 16) ", tag_len - 4);
  880. }
  881. for (i = 0; i < tag_len - 4; i++) {
  882.   pos += snprintf(pos, out_buff + SHORT_STR - pos, "%02X",
  883.   tag_val[tag_val_off + 4 + i]);
  884. }
  885. proto_tree_add_string(tree, tag_interpretation, tvb, offset,
  886.       tag_len, out_buff);
  887.       } else
  888.         proto_tree_add_string(tree, tag_interpretation, 
  889.          tvb, offset, tag_len, "Not interpreted");
  890. }
  891. static void 
  892. dissect_rsn_ie(proto_tree * tree, tvbuff_t * tvb, int offset,
  893.        guint32 tag_len, const guint8 *tag_val)
  894. {
  895.   guint32 tag_val_off = 0;
  896.   guint16 rsn_capab;
  897.   char out_buff[SHORT_STR];
  898.   int i, j, count;
  899.   proto_item *cap_item;
  900.   proto_tree *cap_tree;
  901.   if (tag_val_off + 2 > tag_len) {
  902.     proto_tree_add_string(tree, tag_interpretation, tvb, offset, tag_len,
  903.   "Not interpreted");
  904.     return;
  905.   }
  906.   snprintf(out_buff, SHORT_STR, "RSN IE, version %u",
  907.    pletohs(&tag_val[tag_val_off]));
  908.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  909.   offset += 2;
  910.   tag_val_off += 2;
  911.   if (tag_val_off + 4 > tag_len)
  912.     goto done;
  913.   /* multicast cipher suite */
  914.   if (!memcmp(&tag_val[tag_val_off], RSN_OUI, 3)) {
  915.     snprintf(out_buff, SHORT_STR, "Multicast cipher suite: %s", 
  916.      wpa_cipher_idx2str(tag_val[tag_val_off + 3]));
  917.     proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  918.     offset += 4;
  919.     tag_val_off += 4;
  920.   }
  921.   if (tag_val_off + 2 > tag_len)
  922.     goto done;
  923.   /* unicast cipher suites */
  924.   count = pletohs(tag_val + tag_val_off);
  925.   snprintf(out_buff, SHORT_STR, "# of unicast cipher suites: %u", count);
  926.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  927.   offset += 2;
  928.   tag_val_off += 2;
  929.   i = 1;
  930.   while (tag_val_off + 4 <= tag_len && i <= count) {
  931.     if (memcmp(&tag_val[tag_val_off], RSN_OUI, 3) != 0)
  932.       goto done;
  933.     snprintf(out_buff, SHORT_STR, "Unicast cipher suite %u: %s",
  934.      i, wpa_cipher_idx2str(tag_val[tag_val_off + 3]));
  935.     proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  936.     offset += 4;
  937.     tag_val_off += 4;
  938.     i++;
  939.   }
  940.   if (i <= count || tag_val_off + 2 > tag_len)
  941.     goto done;
  942.   /* authenticated key management suites */
  943.   count = pletohs(tag_val + tag_val_off);
  944.   snprintf(out_buff, SHORT_STR, "# of auth key management suites: %u", count);
  945.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  946.   offset += 2;
  947.   tag_val_off += 2;
  948.   i = 1;
  949.   while (tag_val_off + 4 <= tag_len && i <= count) {
  950.     if (memcmp(&tag_val[tag_val_off], RSN_OUI, 3) != 0)
  951.       goto done;
  952.     snprintf(out_buff, SHORT_STR, "auth key management suite %u: %s", 
  953.      i, wpa_keymgmt_idx2str(tag_val[tag_val_off + 3]));
  954.     proto_tree_add_string(tree, tag_interpretation, tvb, offset, 4, out_buff);
  955.     offset += 4;
  956.     tag_val_off += 4;
  957.     i++;
  958.   }
  959.   if (i <= count || tag_val_off + 2 > tag_len)
  960.     goto done;
  961.   rsn_capab = pletohs(&tag_val[tag_val_off]);
  962.   snprintf(out_buff, SHORT_STR, "RSN Capabilities 0x%04x", rsn_capab);
  963.   cap_item = proto_tree_add_uint_format(tree, rsn_cap, tvb,
  964. offset, 2, rsn_capab,
  965. "RSN Capabilities: 0x%04X", rsn_capab);
  966.   cap_tree = proto_item_add_subtree(cap_item, ett_rsn_cap_tree);
  967.   proto_tree_add_boolean(cap_tree, rsn_cap_preauth, tvb, offset, 2,
  968.  rsn_capab);
  969.   proto_tree_add_boolean(cap_tree, rsn_cap_no_pairwise, tvb, offset, 2,
  970.  rsn_capab);
  971.   proto_tree_add_uint(cap_tree, rsn_cap_ptksa_replay_counter, tvb, offset, 2,
  972.       rsn_capab);
  973.   proto_tree_add_uint(cap_tree, rsn_cap_gtksa_replay_counter, tvb, offset, 2,
  974.       rsn_capab);
  975.   offset += 2;
  976.   tag_val_off += 2;
  977.   if (tag_val_off + 2 > tag_len)
  978.     goto done;
  979.   count = pletohs(tag_val + tag_val_off);
  980.   snprintf(out_buff, SHORT_STR, "# of PMKIDs: %u", count);
  981.   proto_tree_add_string(tree, tag_interpretation, tvb, offset, 2, out_buff);
  982.   offset += 2;
  983.   tag_val_off += 2;
  984.   /* PMKID List (16 * n octets) */
  985.   for (i = 0; i < count; i++) {
  986.     char *pos;
  987.     if (tag_val_off + PMKID_LEN > tag_len)
  988.       goto done;
  989.     pos = out_buff;
  990.     pos += snprintf(pos, out_buff + SHORT_STR - pos, "PMKID %u: ", i);
  991.     for (j = 0; j < PMKID_LEN; j++) {
  992.       pos += snprintf(pos, out_buff + SHORT_STR - pos, "%02X",
  993.       tag_val[tag_val_off + j]);
  994.     }
  995.     proto_tree_add_string(tree, tag_interpretation, tvb, offset,
  996.   PMKID_LEN, out_buff);
  997.     offset += PMKID_LEN;
  998.     tag_val_off += PMKID_LEN;
  999.   }
  1000.  done:
  1001.   if (tag_val_off < tag_len)
  1002.     proto_tree_add_string(tree, tag_interpretation, tvb, offset,
  1003.   tag_len - tag_val_off, "Not interpreted");
  1004. }
  1005. /* ************************************************************************* */
  1006. /*           Dissect and add tagged (optional) fields to proto tree          */
  1007. /* ************************************************************************* */
  1008. static const value_string tag_num_vals[] = {
  1009. { TAG_SSID,                 "SSID parameter set" },
  1010. { TAG_SUPP_RATES,           "Supported Rates" },
  1011. { TAG_FH_PARAMETER,         "FH Parameter set" },
  1012. { TAG_DS_PARAMETER,         "DS Parameter set" },
  1013. { TAG_CF_PARAMETER,         "CF Parameter set" },
  1014. { TAG_TIM,                  "(TIM) Traffic Indication Map" },
  1015. { TAG_IBSS_PARAMETER,       "IBSS Parameter set" },
  1016. { TAG_COUNTRY_INFO,         "Country Information" },
  1017. { TAG_FH_HOPPING_PARAMETER, "Hopping Pattern Parameters" },
  1018. { TAG_CHALLENGE_TEXT,       "Challenge text" },
  1019. { TAG_ERP_INFO,             "ERP Information" },
  1020. { TAG_ERP_INFO_OLD,         "ERP Information" },
  1021. { TAG_RSN_IE,               "RSN Information" },
  1022. { TAG_EXT_SUPP_RATES,       "Extended Supported Rates" },
  1023. { TAG_VENDOR_SPECIFIC_IE,   "Vendor Specific" },
  1024. { 0,                        NULL }
  1025. };
  1026. static const value_string environment_vals[] = {
  1027. { 0x20, "Any" },
  1028. { 0x4f, "Outdoor" },
  1029. { 0x49, "Indoor" },
  1030. { 0,    NULL }
  1031. };
  1032. static int
  1033. add_tagged_field (packet_info * pinfo, proto_tree * tree, tvbuff_t * tvb, int offset)
  1034. {
  1035.   const guint8 *tag_data_ptr;
  1036.   guint32 tag_no, tag_len;
  1037.   unsigned int i;
  1038.   int n, ret;
  1039.   char out_buff[SHORT_STR];
  1040.   char print_buff[SHORT_STR];
  1041.   tag_no = tvb_get_guint8(tvb, offset);
  1042.   proto_tree_add_uint_format (tree, tag_number, tvb, offset, 1, tag_no,
  1043.       "Tag Number: %u (%s)",
  1044.       tag_no,
  1045.       val_to_str(tag_no, tag_num_vals,
  1046.  (tag_no >= 17 && tag_no <= 31) ?
  1047.  "Reserved for challenge text" :
  1048.  "Reserved tag number"));
  1049.   tag_len = tvb_get_guint8(tvb, offset + 1);
  1050.   proto_tree_add_uint (tree, tag_length, tvb, offset + 1, 1, tag_len);
  1051.   tag_data_ptr = tvb_get_ptr (tvb, offset + 2, tag_len);
  1052.   switch (tag_no)
  1053.     {
  1054.     case TAG_SSID:
  1055.       memset (out_buff, 0, SHORT_STR);
  1056.       memcpy (out_buff, tag_data_ptr, (size_t) tag_len);
  1057.       out_buff[tag_len + 1] = 0;
  1058.       for (i = 0; i < tag_len; i++) {
  1059.   if (!isprint( (int) out_buff[i])) {
  1060.       print_buff[i]='.';
  1061.   } else {
  1062.       print_buff[i]=out_buff[i];
  1063.   }
  1064.       }
  1065.       print_buff[i] = 0;
  1066.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1067.      tag_len, out_buff);
  1068.       if (check_col (pinfo->cinfo, COL_INFO)) {
  1069.   if (tag_len > 0) {
  1070.               col_append_fstr(pinfo->cinfo, COL_INFO, ", SSID: "%s"", print_buff);
  1071.   } else {
  1072.               col_append_fstr(pinfo->cinfo, COL_INFO, ", SSID: Broadcast");
  1073.   }
  1074.       }
  1075.       break;
  1076.     case TAG_SUPP_RATES:
  1077.     case TAG_EXT_SUPP_RATES:
  1078.       memset (out_buff, 0, SHORT_STR);
  1079.       strcpy (out_buff, "Supported rates: ");
  1080.       n = strlen (out_buff);
  1081.       for (i = 0; i < tag_len && n < SHORT_STR; i++)
  1082. {
  1083.     ret = snprintf (out_buff + n, SHORT_STR - n, "%2.1f%s ",
  1084.    (tag_data_ptr[i] & 0x7F) * 0.5,
  1085.    (tag_data_ptr[i] & 0x80) ? "(B)" : "");
  1086.     if (ret == -1 || ret >= SHORT_STR - n) {
  1087.       /* Some versions of snprintf return -1 if they'd truncate
  1088.          the output. Others return <buf_size> or greater.  */
  1089.       break;
  1090.     }
  1091.     n += ret;
  1092. }
  1093.       if (n < SHORT_STR)
  1094. snprintf (out_buff + n, SHORT_STR - n, "[Mbit/sec]");
  1095.       out_buff[SHORT_STR-1] = '';
  1096.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1097.      tag_len, out_buff);
  1098.       break;
  1099.     case TAG_FH_PARAMETER:
  1100.       memset (out_buff, 0, SHORT_STR);
  1101.       snprintf (out_buff, SHORT_STR,
  1102. "Dwell time 0x%04X, Hop Set %2d, Hop Pattern %2d, "
  1103. "Hop Index %2d", pletohs (tag_data_ptr), tag_data_ptr[2],
  1104. tag_data_ptr[3], tag_data_ptr[4]);
  1105.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1106.      tag_len, out_buff);
  1107.       break;
  1108.     case TAG_DS_PARAMETER:
  1109.       memset (out_buff, 0, SHORT_STR);
  1110.       snprintf (out_buff, SHORT_STR, "Current Channel: %u", tag_data_ptr[0]);
  1111.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1112.      tag_len, out_buff);
  1113.       break;
  1114.     case TAG_CF_PARAMETER:
  1115.       memset (out_buff, 0, SHORT_STR);
  1116.       snprintf (out_buff, SHORT_STR,
  1117. "CFP count %u, CFP period %u, CFP max duration %u, "
  1118. "CFP Remaining %u", tag_data_ptr[0], tag_data_ptr[1],
  1119. pletohs (tag_data_ptr + 2), pletohs (tag_data_ptr + 4));
  1120.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1121.      tag_len, out_buff);
  1122.       break;
  1123.     case TAG_TIM:
  1124.       memset (out_buff, 0, SHORT_STR);
  1125.       snprintf (out_buff, SHORT_STR,
  1126. "DTIM count %u, DTIM period %u, Bitmap control 0x%X, "
  1127. "(Bitmap suppressed)", tag_data_ptr[0], tag_data_ptr[1],
  1128. tag_data_ptr[2]);
  1129.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1130.      tag_len, out_buff);
  1131.       break;
  1132.     case TAG_IBSS_PARAMETER:
  1133.       memset (out_buff, 0, SHORT_STR);
  1134.       snprintf (out_buff, SHORT_STR, "ATIM window 0x%X",
  1135. pletohs (tag_data_ptr));
  1136.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1137.      tag_len, out_buff);
  1138.       break;
  1139.     case TAG_COUNTRY_INFO:
  1140.       memset (out_buff, 0, SHORT_STR);
  1141.       snprintf (out_buff, SHORT_STR, "Country Code: %c%c, %s Environment",
  1142.                tag_data_ptr[0], tag_data_ptr[1], 
  1143.                val_to_str(tag_data_ptr[2], environment_vals,"Unknown (0x%02x)"));
  1144.       n = strlen (out_buff);
  1145.       for (i = 3; (i + 3) <= tag_len && n < SHORT_STR; i += 3)
  1146.       { 
  1147.         ret = snprintf(out_buff + n, SHORT_STR - n,
  1148.                        ", Start Channel: %u, Channels: %u, Max TX Power: %d dBm",
  1149.                        tag_data_ptr[i], tag_data_ptr[i + 1],
  1150.                        (gint)tag_data_ptr[i + 2]);
  1151.         if (ret == -1 || ret >= SHORT_STR - n) {
  1152.           /* Some versions of snprintf return -1 if they'd truncate
  1153.              the output. Others return <buf_size> or greater.  */
  1154.           break;
  1155.         }
  1156.         n += ret;
  1157.       }
  1158.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,tag_len, out_buff);
  1159.       break;
  1160.     case TAG_FH_HOPPING_PARAMETER:
  1161.       memset (out_buff, 0, SHORT_STR);
  1162.       snprintf (out_buff, SHORT_STR, "Prime Radix: %u, Number of Channels: %u", 
  1163.                        tag_data_ptr[0], tag_data_ptr[1]);
  1164.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2, tag_len, out_buff);
  1165.      
  1166.       break;
  1167.     case TAG_CHALLENGE_TEXT:
  1168.       memset (out_buff, 0, SHORT_STR);
  1169.       snprintf (out_buff, SHORT_STR, "Challenge text: %.47s", tag_data_ptr);
  1170.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1171.      tag_len, out_buff);
  1172.       break;
  1173.     case TAG_ERP_INFO:
  1174.     case TAG_ERP_INFO_OLD:
  1175.       memset (out_buff, 0, SHORT_STR);
  1176.       snprintf (out_buff, SHORT_STR,
  1177. "ERP info: 0x%x (%sNon-ERP STAs, %suse protection, %s preambles)",
  1178. tag_data_ptr[0],
  1179. tag_data_ptr[0] & 0x01 ? "" : "no ",
  1180. tag_data_ptr[0] & 0x02 ? "" : "do not ",
  1181. tag_data_ptr[0] & 0x04 ? "short or long": "long");
  1182.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1183.      tag_len, out_buff);
  1184.       break;
  1185.     case TAG_VENDOR_SPECIFIC_IE:
  1186.       dissect_vendor_specific_ie(tree, tvb, offset + 2, tag_len,
  1187.  tag_data_ptr);
  1188.       break;
  1189.     case TAG_RSN_IE:
  1190.       dissect_rsn_ie(tree, tvb, offset + 2, tag_len, tag_data_ptr);
  1191.       break;
  1192.     default:
  1193.       proto_tree_add_string (tree, tag_interpretation, tvb, offset + 2,
  1194.      tag_len, "Not interpreted");
  1195.       break;
  1196.     }
  1197.   return tag_len + 2;
  1198. }
  1199. void
  1200. ieee_80211_add_tagged_parameters (tvbuff_t * tvb, int offset, packet_info * pinfo,
  1201. proto_tree * tree, int tagged_parameters_len)
  1202. {
  1203.   int next_len;
  1204.   while (tagged_parameters_len > 0) {
  1205.     if ((next_len=add_tagged_field (pinfo, tree, tvb, offset))==0)
  1206.       break;
  1207.     if (next_len > tagged_parameters_len) {
  1208.       /* XXX - flag this as an error? */
  1209.       next_len = tagged_parameters_len;
  1210.     }
  1211.     offset += next_len;
  1212.     tagged_parameters_len -= next_len;
  1213.   }
  1214. }
  1215. /* ************************************************************************* */
  1216. /*                     Dissect 802.11 management frame                       */
  1217. /* ************************************************************************* */
  1218. static void
  1219. dissect_ieee80211_mgt (guint16 fcf, tvbuff_t * tvb, packet_info * pinfo,
  1220. proto_tree * tree)
  1221. {
  1222.       proto_item *ti = NULL;
  1223.       proto_tree *mgt_tree;
  1224.       proto_tree *fixed_tree;
  1225.       proto_tree *tagged_tree;
  1226.       int offset;
  1227.       int tagged_parameter_tree_len;
  1228.       CHECK_DISPLAY_AS_X(data_handle,proto_wlan_mgt, tvb, pinfo, tree);
  1229.       ti = proto_tree_add_item (tree, proto_wlan_mgt, tvb, 0, -1, FALSE);
  1230.       mgt_tree = proto_item_add_subtree (ti, ett_80211_mgt);
  1231.       switch (COMPOSE_FRAME_TYPE(fcf))
  1232. {
  1233. case MGT_ASSOC_REQ:
  1234.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 4);
  1235.   add_fixed_field (fixed_tree, tvb, 0, FIELD_CAP_INFO);
  1236.   add_fixed_field (fixed_tree, tvb, 2, FIELD_LISTEN_IVAL);
  1237.   offset = 4; /* Size of fixed fields */
  1238.   tagged_parameter_tree_len =
  1239.       tvb_reported_length_remaining(tvb, offset);
  1240.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1241.    tagged_parameter_tree_len);
  1242.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1243.       tagged_parameter_tree_len);
  1244.   break;
  1245. case MGT_ASSOC_RESP:
  1246.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 6);
  1247.   add_fixed_field (fixed_tree, tvb, 0, FIELD_CAP_INFO);
  1248.   add_fixed_field (fixed_tree, tvb, 2, FIELD_STATUS_CODE);
  1249.   add_fixed_field (fixed_tree, tvb, 4, FIELD_ASSOC_ID);
  1250.   offset = 6; /* Size of fixed fields */
  1251.   tagged_parameter_tree_len =
  1252.       tvb_reported_length_remaining(tvb, offset);
  1253.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1254.    tagged_parameter_tree_len);
  1255.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1256.       tagged_parameter_tree_len);
  1257.   break;
  1258. case MGT_REASSOC_REQ:
  1259.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 10);
  1260.   add_fixed_field (fixed_tree, tvb, 0, FIELD_CAP_INFO);
  1261.   add_fixed_field (fixed_tree, tvb, 2, FIELD_LISTEN_IVAL);
  1262.   add_fixed_field (fixed_tree, tvb, 4, FIELD_CURRENT_AP_ADDR);
  1263.   offset = 10; /* Size of fixed fields */
  1264.   tagged_parameter_tree_len =
  1265.       tvb_reported_length_remaining(tvb, offset);
  1266.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1267.    tagged_parameter_tree_len);
  1268.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1269.       tagged_parameter_tree_len);
  1270.   break;
  1271. case MGT_REASSOC_RESP:
  1272.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 10);
  1273.   add_fixed_field (fixed_tree, tvb, 0, FIELD_CAP_INFO);
  1274.   add_fixed_field (fixed_tree, tvb, 2, FIELD_STATUS_CODE);
  1275.   add_fixed_field (fixed_tree, tvb, 4, FIELD_ASSOC_ID);
  1276.   offset = 6; /* Size of fixed fields */
  1277.   tagged_parameter_tree_len =
  1278.       tvb_reported_length_remaining(tvb, offset);
  1279.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1280.    tagged_parameter_tree_len);
  1281.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1282.       tagged_parameter_tree_len);
  1283.   break;
  1284. case MGT_PROBE_REQ:
  1285.   offset = 0;
  1286.   tagged_parameter_tree_len =
  1287.       tvb_reported_length_remaining(tvb, offset);
  1288.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1289.    tagged_parameter_tree_len);
  1290.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1291.       tagged_parameter_tree_len);
  1292.   break;
  1293. case MGT_PROBE_RESP:
  1294.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 12);
  1295.   add_fixed_field (fixed_tree, tvb, 0, FIELD_TIMESTAMP);
  1296.   add_fixed_field (fixed_tree, tvb, 8, FIELD_BEACON_INTERVAL);
  1297.   add_fixed_field (fixed_tree, tvb, 10, FIELD_CAP_INFO);
  1298.   offset = 12; /* Size of fixed fields */
  1299.   tagged_parameter_tree_len =
  1300.       tvb_reported_length_remaining(tvb, offset);
  1301.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1302.    tagged_parameter_tree_len);
  1303.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1304.       tagged_parameter_tree_len);
  1305.   break;
  1306. case MGT_BEACON: /* Dissect protocol payload fields  */
  1307.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 12);
  1308.   add_fixed_field (fixed_tree, tvb, 0, FIELD_TIMESTAMP);
  1309.   add_fixed_field (fixed_tree, tvb, 8, FIELD_BEACON_INTERVAL);
  1310.   add_fixed_field (fixed_tree, tvb, 10, FIELD_CAP_INFO);
  1311.   offset = 12; /* Size of fixed fields */
  1312.   tagged_parameter_tree_len =
  1313.       tvb_reported_length_remaining(tvb, offset);
  1314.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1315.    tagged_parameter_tree_len);
  1316.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1317.       tagged_parameter_tree_len);
  1318.   break;
  1319. case MGT_ATIM:
  1320.   break;
  1321. case MGT_DISASS:
  1322.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 2);
  1323.   add_fixed_field (fixed_tree, tvb, 0, FIELD_REASON_CODE);
  1324.   break;
  1325. case MGT_AUTHENTICATION:
  1326.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 6);
  1327.   add_fixed_field (fixed_tree, tvb, 0, FIELD_AUTH_ALG);
  1328.   add_fixed_field (fixed_tree, tvb, 2, FIELD_AUTH_TRANS_SEQ);
  1329.   add_fixed_field (fixed_tree, tvb, 4, FIELD_STATUS_CODE);
  1330.   offset = 6; /* Size of fixed fields */
  1331.   tagged_parameter_tree_len =
  1332.   tvb_reported_length_remaining(tvb, offset);
  1333.   if (tagged_parameter_tree_len != 0)
  1334.     {
  1335.       tagged_tree = get_tagged_parameter_tree (mgt_tree,
  1336.        tvb,
  1337.        offset,
  1338.        tagged_parameter_tree_len);
  1339.       ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1340. tagged_parameter_tree_len);
  1341.     }
  1342.   break;
  1343. case MGT_DEAUTHENTICATION:
  1344.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 2);
  1345.   add_fixed_field (fixed_tree, tvb, 0, FIELD_REASON_CODE);
  1346.   break;
  1347. case MGT_ACTION:
  1348.   fixed_tree = get_fixed_parameter_tree (mgt_tree, tvb, 0, 3);
  1349.   add_fixed_field (fixed_tree, tvb, 0, FIELD_CATEGORY_CODE);
  1350.   switch (tvb_get_guint8(tvb, 0))
  1351.     {
  1352.     case 17: /* Management notification frame */
  1353.       add_fixed_field (fixed_tree, tvb, 1, FIELD_WME_ACTION_CODE);
  1354.       add_fixed_field (fixed_tree, tvb, 2, FIELD_DIALOG_TOKEN);
  1355.       add_fixed_field (fixed_tree, tvb, 3, FIELD_WME_STATUS_CODE);
  1356.       offset = 4; /* Size of fixed fields */
  1357.       tagged_parameter_tree_len =
  1358. tvb_reported_length_remaining(tvb, offset);
  1359.       if (tagged_parameter_tree_len != 0)
  1360. {
  1361.   tagged_tree = get_tagged_parameter_tree (mgt_tree, tvb, offset,
  1362.    tagged_parameter_tree_len);
  1363.   ieee_80211_add_tagged_parameters (tvb, offset, pinfo, tagged_tree,
  1364.     tagged_parameter_tree_len);
  1365. }
  1366.       break;
  1367.     default: /* Management action frame */
  1368.       add_fixed_field (fixed_tree, tvb, 1, FIELD_ACTION_CODE);
  1369.       add_fixed_field (fixed_tree, tvb, 2, FIELD_DIALOG_TOKEN);
  1370.       break;
  1371.     }
  1372.   break;
  1373. }
  1374. }
  1375. static void
  1376. set_src_addr_cols(packet_info *pinfo, const guint8 *addr, char *type)
  1377. {
  1378.   if (check_col(pinfo->cinfo, COL_RES_DL_SRC))
  1379.     col_add_fstr(pinfo->cinfo, COL_RES_DL_SRC, "%s (%s)",
  1380.     get_ether_name(addr), type);
  1381.   if (check_col(pinfo->cinfo, COL_UNRES_DL_SRC))
  1382.     col_add_fstr(pinfo->cinfo, COL_UNRES_DL_SRC, "%s (%s)",
  1383.      ether_to_str(addr), type);
  1384. }
  1385. static void
  1386. set_dst_addr_cols(packet_info *pinfo, const guint8 *addr, char *type)
  1387. {
  1388.   if (check_col(pinfo->cinfo, COL_RES_DL_DST))
  1389.     col_add_fstr(pinfo->cinfo, COL_RES_DL_DST, "%s (%s)",
  1390.      get_ether_name(addr), type);
  1391.   if (check_col(pinfo->cinfo, COL_UNRES_DL_DST))
  1392.     col_add_fstr(pinfo->cinfo, COL_UNRES_DL_DST, "%s (%s)",
  1393.      ether_to_str(addr), type);
  1394. }
  1395. typedef enum {
  1396.     ENCAP_802_2,
  1397.     ENCAP_IPX,
  1398.     ENCAP_ETHERNET
  1399. } encap_t;
  1400. /* ************************************************************************* */
  1401. /*                          Dissect 802.11 frame                             */
  1402. /* ************************************************************************* */
  1403. static void
  1404. dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo,
  1405.   proto_tree * tree, gboolean fixed_length_header,
  1406.   gboolean has_radio_information, gint fcs_len,
  1407.   gboolean wlan_broken_fc)
  1408. {
  1409.   guint16 fcf, flags, frame_type_subtype;
  1410.   guint16 seq_control;
  1411.   guint32 seq_number, frag_number;
  1412.   gboolean more_frags;
  1413.   const guint8 *src = NULL, *dst = NULL;
  1414.   proto_item *ti = NULL;
  1415.   proto_item *flag_item;
  1416.   proto_item *fc_item;
  1417.   proto_tree *hdr_tree = NULL;
  1418.   proto_tree *flag_tree;
  1419.   proto_tree *fc_tree;
  1420.   guint16 hdr_len;
  1421.   gboolean has_fcs;
  1422.   gint len, reported_len, ivlen;
  1423.   gboolean save_fragmented;
  1424.   tvbuff_t *volatile next_tvb = NULL;
  1425.   guint32 addr_type;
  1426.   volatile encap_t encap_type;
  1427.   guint8 octet1, octet2;
  1428.   char out_buff[SHORT_STR];
  1429.   gint is_iv_bad;
  1430.   guchar iv_buff[4];
  1431.   wlan_hdr *volatile whdr;
  1432.   static wlan_hdr whdrs[4];
  1433.   whdr= &whdrs[0];
  1434.   if (check_col (pinfo->cinfo, COL_PROTOCOL))
  1435.     col_set_str (pinfo->cinfo, COL_PROTOCOL, "IEEE 802.11");
  1436.   if (check_col (pinfo->cinfo, COL_INFO))
  1437.     col_clear (pinfo->cinfo, COL_INFO);
  1438.   /* Add the radio information, if present, to the column information */
  1439.   if (has_radio_information) {
  1440.     if (check_col(pinfo->cinfo, COL_TX_RATE)) {
  1441. col_add_fstr(pinfo->cinfo, COL_TX_RATE, "%u.%u",
  1442.    pinfo->pseudo_header->ieee_802_11.data_rate / 2,
  1443.    pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
  1444.     }
  1445.     if (check_col(pinfo->cinfo, COL_RSSI)) {
  1446.       /* XX - this is a percentage, not a dBm or normalized or raw RSSI */
  1447.       col_add_fstr(pinfo->cinfo, COL_RSSI, "%u",
  1448.    pinfo->pseudo_header->ieee_802_11.signal_level);
  1449.     }
  1450.   }
  1451.   fcf = tvb_get_letohs (tvb, 0);
  1452.   if (wlan_broken_fc) {
  1453.     /* Swap bytes */
  1454.     fcf = ((fcf & 0xff) << 8) | (((fcf & 0xff00) >> 8) & 0xff);
  1455.   }
  1456.   if (fixed_length_header)
  1457.     hdr_len = DATA_LONG_HDR_LEN;
  1458.   else
  1459.     hdr_len = find_header_length (fcf);
  1460.   frame_type_subtype = COMPOSE_FRAME_TYPE(fcf);
  1461.   if (check_col (pinfo->cinfo, COL_INFO))
  1462.       col_set_str (pinfo->cinfo, COL_INFO,
  1463.           val_to_str(frame_type_subtype, frame_type_subtype_vals,
  1464.               "Unrecognized (Reserved frame)"));
  1465.   flags = COOK_FLAGS (fcf);
  1466.   more_frags = HAVE_FRAGMENTS (flags);
  1467.   /* Add the radio information, if present, and the FC to the current tree */
  1468.   if (tree)
  1469.     {
  1470.       ti = proto_tree_add_protocol_format (tree, proto_wlan, tvb, 0, hdr_len,
  1471.    "IEEE 802.11");
  1472.       hdr_tree = proto_item_add_subtree (ti, ett_80211);
  1473.       if (has_radio_information) {
  1474. proto_tree_add_uint_format(hdr_tree, hf_data_rate,
  1475.    tvb, 0, 0,
  1476.    pinfo->pseudo_header->ieee_802_11.data_rate,
  1477.    "Data Rate: %u.%u Mb/s",
  1478.    pinfo->pseudo_header->ieee_802_11.data_rate / 2,
  1479.    pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
  1480. proto_tree_add_uint(hdr_tree, hf_channel,
  1481.     tvb, 0, 0,
  1482.     pinfo->pseudo_header->ieee_802_11.channel);
  1483. proto_tree_add_uint_format(hdr_tree, hf_signal_strength,
  1484.    tvb, 0, 0,
  1485.    pinfo->pseudo_header->ieee_802_11.signal_level,
  1486.    "Signal Strength: %u%%",
  1487.    pinfo->pseudo_header->ieee_802_11.signal_level);
  1488.       }
  1489.       proto_tree_add_uint (hdr_tree, hf_fc_frame_type_subtype,
  1490.    tvb, 
  1491.            wlan_broken_fc?1:0, 1,
  1492.    frame_type_subtype);
  1493.       fc_item = proto_tree_add_uint_format (hdr_tree, hf_fc_field, tvb, 
  1494.            0, 2,
  1495.     fcf,
  1496.     "Frame Control: 0x%04X (%s)",
  1497.     fcf, wlan_broken_fc?"Swapped":"Normal");
  1498.       fc_tree = proto_item_add_subtree (fc_item, ett_fc_tree);
  1499.       proto_tree_add_uint (fc_tree, hf_fc_proto_version, tvb, 
  1500.            wlan_broken_fc?1:0, 1,
  1501.    COOK_PROT_VERSION (fcf));
  1502.       proto_tree_add_uint (fc_tree, hf_fc_frame_type, tvb, 
  1503.            wlan_broken_fc?1:0, 1,
  1504.    COOK_FRAME_TYPE (fcf));
  1505.       proto_tree_add_uint (fc_tree, hf_fc_frame_subtype,
  1506.    tvb, 
  1507.    wlan_broken_fc?1:0, 1,
  1508.    COOK_FRAME_SUBTYPE (fcf));
  1509.       flag_item =
  1510. proto_tree_add_uint_format (fc_tree, hf_fc_flags, tvb, 
  1511.             wlan_broken_fc?0:1, 1,
  1512.     flags, "Flags: 0x%X", flags);
  1513.       flag_tree = proto_item_add_subtree (flag_item, ett_proto_flags);
  1514.       proto_tree_add_uint (flag_tree, hf_fc_data_ds, tvb, 
  1515.            wlan_broken_fc?0:1, 1,
  1516.    COOK_DS_STATUS (flags));
  1517.       proto_tree_add_boolean_hidden (flag_tree, hf_fc_to_ds, tvb, 1, 1, 
  1518.      flags);
  1519.       proto_tree_add_boolean_hidden (flag_tree, hf_fc_from_ds, tvb, 1, 1, 
  1520.      flags);
  1521.       proto_tree_add_boolean (flag_tree, hf_fc_more_frag, tvb, 
  1522.               wlan_broken_fc?0:1, 1,
  1523.       flags);
  1524.       proto_tree_add_boolean (flag_tree, hf_fc_retry, tvb, 
  1525.               wlan_broken_fc?0:1, 1, flags);
  1526.       proto_tree_add_boolean (flag_tree, hf_fc_pwr_mgt, tvb, 
  1527.               wlan_broken_fc?0:1, 1, flags);
  1528.       proto_tree_add_boolean (flag_tree, hf_fc_more_data, tvb, 
  1529.               wlan_broken_fc?0:1, 1,
  1530.       flags);
  1531.       proto_tree_add_boolean (flag_tree, hf_fc_wep, tvb,
  1532.               wlan_broken_fc?0:1, 1, flags);
  1533.       proto_tree_add_boolean (flag_tree, hf_fc_order, tvb, 
  1534.               wlan_broken_fc?0:1, 1, flags);
  1535.       if (frame_type_subtype == CTRL_PS_POLL)
  1536. proto_tree_add_uint(hdr_tree, hf_assoc_id,tvb,2,2,
  1537.     COOK_ASSOC_ID(tvb_get_letohs(tvb,2)));
  1538.       else
  1539.   proto_tree_add_uint (hdr_tree, hf_did_duration, tvb, 2, 2,
  1540.        tvb_get_letohs (tvb, 2));
  1541.     }
  1542.   /*
  1543.    * Decode the part of the frame header that isn't the same for all
  1544.    * frame types.
  1545.    */
  1546.   seq_control = 0;
  1547.   frag_number = 0;
  1548.   seq_number = 0;
  1549.   switch (COOK_FRAME_TYPE (fcf))
  1550.     {
  1551.     case MGT_FRAME:
  1552.       /*
  1553.        * All management frame types have the same header.
  1554.        */
  1555.       src = tvb_get_ptr (tvb, 10, 6);
  1556.       dst = tvb_get_ptr (tvb, 4, 6);
  1557.       SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, src);
  1558.       SET_ADDRESS(&pinfo->src, AT_ETHER, 6, src);
  1559.       SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, dst);
  1560.       SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, dst);
  1561.       /* for tap */
  1562.       SET_ADDRESS(&whdr->bssid, AT_ETHER, 6, tvb_get_ptr(tvb, 16,6));
  1563.       SET_ADDRESS(&whdr->src, AT_ETHER, 6, src);
  1564.       SET_ADDRESS(&whdr->dst, AT_ETHER, 6, dst);
  1565.       seq_control = tvb_get_letohs(tvb, 22);
  1566.       frag_number = COOK_FRAGMENT_NUMBER(seq_control);
  1567.       seq_number = COOK_SEQUENCE_NUMBER(seq_control);
  1568.       if (tree)
  1569. {
  1570.   proto_tree_add_ether (hdr_tree, hf_addr_da, tvb, 4, 6, dst);
  1571.   proto_tree_add_ether (hdr_tree, hf_addr_sa, tvb, 10, 6, src);
  1572.   /* add items for wlan.addr filter */
  1573.   proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 4, 6, dst);
  1574.   proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 10, 6, src);
  1575.   proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 16, 6,
  1576. tvb_get_ptr (tvb, 16, 6));
  1577.   proto_tree_add_uint (hdr_tree, hf_frag_number, tvb, 22, 2,
  1578.        frag_number);
  1579.   proto_tree_add_uint (hdr_tree, hf_seq_number, tvb, 22, 2,
  1580.        seq_number);
  1581. }
  1582.       break;
  1583.     case CONTROL_FRAME:
  1584.       switch (frame_type_subtype)
  1585. {
  1586. case CTRL_PS_POLL:
  1587.   src = tvb_get_ptr (tvb, 10, 6);
  1588.   dst = tvb_get_ptr (tvb, 4, 6);
  1589.   set_src_addr_cols(pinfo, src, "BSSID");
  1590.   set_dst_addr_cols(pinfo, dst, "BSSID");
  1591.   if (tree)
  1592.     {
  1593.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 4, 6, dst);
  1594.       proto_tree_add_ether (hdr_tree, hf_addr_ta, tvb, 10, 6, src);
  1595.     }
  1596.   break;
  1597. case CTRL_RTS:
  1598.   src = tvb_get_ptr (tvb, 10, 6);
  1599.   dst = tvb_get_ptr (tvb, 4, 6);
  1600.   set_src_addr_cols(pinfo, src, "TA");
  1601.   set_dst_addr_cols(pinfo, dst, "RA");
  1602.   if (tree)
  1603.     {
  1604.       proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6, dst);
  1605.       proto_tree_add_ether (hdr_tree, hf_addr_ta, tvb, 10, 6, src);
  1606.     }
  1607.   break;
  1608. case CTRL_CTS:
  1609.   dst = tvb_get_ptr (tvb, 4, 6);
  1610.   set_dst_addr_cols(pinfo, dst, "RA");
  1611.   if (tree)
  1612.     proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6, dst);
  1613.   break;
  1614. case CTRL_ACKNOWLEDGEMENT:
  1615.   dst = tvb_get_ptr (tvb, 4, 6);
  1616.   set_dst_addr_cols(pinfo, dst, "RA");
  1617.   if (tree)
  1618.     proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6, dst);
  1619.   break;
  1620. case CTRL_CFP_END:
  1621.   src = tvb_get_ptr (tvb, 10, 6);
  1622.   dst = tvb_get_ptr (tvb, 4, 6);
  1623.   set_src_addr_cols(pinfo, src, "BSSID");
  1624.   set_dst_addr_cols(pinfo, dst, "RA");
  1625.   if (tree)
  1626.     {
  1627.       proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6, dst);
  1628.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 10, 6, src);
  1629.     }
  1630.   break;
  1631. case CTRL_CFP_ENDACK:
  1632.   src = tvb_get_ptr (tvb, 10, 6);
  1633.   dst = tvb_get_ptr (tvb, 4, 6);
  1634.   set_src_addr_cols(pinfo, src, "BSSID");
  1635.   set_dst_addr_cols(pinfo, dst, "RA");
  1636.   if (tree)
  1637.     {
  1638.       proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6, dst);
  1639.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 10, 6, src);
  1640.     }
  1641.   break;
  1642. }
  1643.       break;
  1644.     case DATA_FRAME:
  1645.       addr_type = COOK_ADDR_SELECTOR (fcf);
  1646.       /* In order to show src/dst address we must always do the following */
  1647.       switch (addr_type)
  1648. {
  1649. case DATA_ADDR_T1:
  1650.   src = tvb_get_ptr (tvb, 10, 6);
  1651.   dst = tvb_get_ptr (tvb, 4, 6);
  1652.   break;
  1653. case DATA_ADDR_T2:
  1654.   src = tvb_get_ptr (tvb, 16, 6);
  1655.   dst = tvb_get_ptr (tvb, 4, 6);
  1656.   break;
  1657. case DATA_ADDR_T3:
  1658.   src = tvb_get_ptr (tvb, 10, 6);
  1659.   dst = tvb_get_ptr (tvb, 16, 6);
  1660.   break;
  1661. case DATA_ADDR_T4:
  1662.   src = tvb_get_ptr (tvb, 24, 6);
  1663.   dst = tvb_get_ptr (tvb, 16, 6);
  1664.   break;
  1665. }
  1666.       SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, src);
  1667.       SET_ADDRESS(&pinfo->src, AT_ETHER, 6, src);
  1668.       SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, dst);
  1669.       SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, dst);
  1670.       /* for tap */
  1671.       SET_ADDRESS(&whdr->bssid, AT_ETHER, 6, tvb_get_ptr(tvb, 16,6));
  1672.       SET_ADDRESS(&whdr->src, AT_ETHER, 6, src);
  1673.       SET_ADDRESS(&whdr->dst, AT_ETHER, 6, dst);
  1674.       seq_control = tvb_get_letohs(tvb, 22);
  1675.       frag_number = COOK_FRAGMENT_NUMBER(seq_control);
  1676.       seq_number = COOK_SEQUENCE_NUMBER(seq_control);
  1677.       /* Now if we have a tree we start adding stuff */
  1678.       if (tree)
  1679. {
  1680.   switch (addr_type)
  1681.     {
  1682.     case DATA_ADDR_T1:
  1683.       proto_tree_add_ether (hdr_tree, hf_addr_da, tvb, 4, 6, dst);
  1684.       proto_tree_add_ether (hdr_tree, hf_addr_sa, tvb, 10, 6, src);
  1685.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 16, 6,
  1686.     tvb_get_ptr (tvb, 16, 6));
  1687.       proto_tree_add_uint (hdr_tree, hf_frag_number, tvb, 22, 2,
  1688.    frag_number);
  1689.       proto_tree_add_uint (hdr_tree, hf_seq_number, tvb, 22, 2,
  1690.    seq_number);
  1691.       /* add items for wlan.addr filter */
  1692.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 4, 6, dst);
  1693.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 10, 6, src);
  1694.       break;
  1695.     case DATA_ADDR_T2:
  1696.       proto_tree_add_ether (hdr_tree, hf_addr_da, tvb, 4, 6, dst);
  1697.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 10, 6,
  1698.     tvb_get_ptr (tvb, 10, 6));
  1699.       proto_tree_add_ether (hdr_tree, hf_addr_sa, tvb, 16, 6, src);
  1700.       proto_tree_add_uint (hdr_tree, hf_frag_number, tvb, 22, 2,
  1701.    frag_number);
  1702.       proto_tree_add_uint (hdr_tree, hf_seq_number, tvb, 22, 2,
  1703.    seq_number);
  1704.       /* add items for wlan.addr filter */
  1705.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 4, 6, dst);
  1706.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 16, 6, src);
  1707.       break;
  1708.     case DATA_ADDR_T3:
  1709.       proto_tree_add_ether (hdr_tree, hf_addr_bssid, tvb, 4, 6,
  1710.     tvb_get_ptr (tvb, 4, 6));
  1711.       proto_tree_add_ether (hdr_tree, hf_addr_sa, tvb, 10, 6, src);
  1712.       proto_tree_add_ether (hdr_tree, hf_addr_da, tvb, 16, 6, dst);
  1713.       proto_tree_add_uint (hdr_tree, hf_frag_number, tvb, 22, 2,
  1714.    frag_number);
  1715.       proto_tree_add_uint (hdr_tree, hf_seq_number, tvb, 22, 2,
  1716.    seq_number);
  1717.       /* add items for wlan.addr filter */
  1718.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 10, 6, src);
  1719.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 16, 6, dst);
  1720.       break;
  1721.     case DATA_ADDR_T4:
  1722.       proto_tree_add_ether (hdr_tree, hf_addr_ra, tvb, 4, 6,
  1723.     tvb_get_ptr (tvb, 4, 6));
  1724.       proto_tree_add_ether (hdr_tree, hf_addr_ta, tvb, 10, 6,
  1725.     tvb_get_ptr (tvb, 10, 6));
  1726.       proto_tree_add_ether (hdr_tree, hf_addr_da, tvb, 16, 6, dst);
  1727.       proto_tree_add_uint (hdr_tree, hf_frag_number, tvb, 22, 2,
  1728.    frag_number);
  1729.       proto_tree_add_uint (hdr_tree, hf_seq_number, tvb, 22, 2,
  1730.    seq_number);
  1731.       proto_tree_add_ether (hdr_tree, hf_addr_sa, tvb, 24, 6, src);
  1732.       /* add items for wlan.addr filter */
  1733.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 16, 6, dst);
  1734.       proto_tree_add_ether_hidden(hdr_tree, hf_addr, tvb, 24, 6, src);
  1735.       break;
  1736.     }
  1737. }
  1738.       break;
  1739.     }
  1740.   len = tvb_length_remaining(tvb, hdr_len);
  1741.   reported_len = tvb_reported_length_remaining(tvb, hdr_len);
  1742.   switch (fcs_len)
  1743.     {
  1744.       case 0: /* Definitely has no FCS */
  1745.         has_fcs = FALSE;
  1746.         break;
  1747.       case 4: /* Definitely has an FCS */
  1748.         has_fcs = TRUE;
  1749.         break;
  1750.       default: /* Don't know - use "wlan_check_fcs" */
  1751.         has_fcs = wlan_check_fcs;
  1752.         break;
  1753.     }
  1754.   if (has_fcs)
  1755.     {
  1756.       /*
  1757.        * Well, this packet should, in theory, have an FCS.
  1758.        * Do we have the entire packet, and does it have enough data for
  1759.        * the FCS?
  1760.        */
  1761.       if (reported_len < 4)
  1762. {
  1763.   /*
  1764.    * The packet is claimed not to even have enough data for a 4-byte
  1765.    * FCS.
  1766.    * Pretend it doesn't have an FCS.
  1767.    */
  1768.   ;
  1769.         }
  1770.       else if (len < reported_len)
  1771. {
  1772.   /*
  1773.    * The packet is claimed to have enough data for a 4-byte FCS, but
  1774.    * we didn't capture all of the packet.
  1775.    * Slice off the 4-byte FCS from the reported length, and trim the
  1776.    * captured length so it's no more than the reported length; that
  1777.    * will slice off what of the FCS, if any, is in the captured
  1778.    * length.
  1779.    */
  1780.   reported_len -= 4;
  1781.   if (len > reported_len)
  1782.     len = reported_len;
  1783. }
  1784.       else
  1785. {
  1786.   /*
  1787.    * We have the entire packet, and it includes a 4-byte FCS.
  1788.    * Slice it off, and put it into the tree.
  1789.    */
  1790.   len -= 4;
  1791.   reported_len -= 4;
  1792.   if (tree)
  1793.     {
  1794.       guint32 fcs = crc32_802_tvb(tvb, hdr_len + len);
  1795.       guint32 sent_fcs = tvb_get_ntohl(tvb, hdr_len + len);
  1796.       if (fcs == sent_fcs)
  1797. proto_tree_add_uint_format(hdr_tree, hf_fcs, tvb,
  1798. hdr_len + len, 4, sent_fcs,
  1799. "Frame check sequence: 0x%08x (correct)", sent_fcs);
  1800.       else
  1801. proto_tree_add_uint_format(hdr_tree, hf_fcs, tvb,
  1802. hdr_len + len, 4, sent_fcs,
  1803. "Frame check sequence: 0x%08x (incorrect, should be 0x%08x)",
  1804. sent_fcs, fcs);
  1805.     }
  1806. }
  1807.     }
  1808.   if (tree && (frame_type_subtype == DATA_QOS_DATA || frame_type_subtype == DATA_QOS_NULL)) {
  1809.       proto_item *qos_fields;
  1810.       proto_tree *qos_tree;
  1811.       guint16 qos_control, qos_priority, qos_ack_policy;
  1812.       qos_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len - 2, 2,
  1813.        "QoS parameters");
  1814.       qos_tree = proto_item_add_subtree (qos_fields, ett_qos_parameters);
  1815.       qos_control = tvb_get_letohs(tvb, hdr_len - 2);
  1816.       qos_priority = COOK_QOS_PRIORITY(qos_control);
  1817.       qos_ack_policy = COOK_QOS_ACK_POLICY(qos_control);
  1818.       proto_tree_add_uint_format (qos_tree, hf_qos_priority, tvb,
  1819.   hdr_len - 2, 2, qos_priority,
  1820.   "Priority: %d (%s) (%s)",
  1821.   qos_priority, qos_tags[qos_priority], qos_acs[qos_priority]);
  1822.       proto_tree_add_uint_format (qos_tree, hf_qos_ack_policy, tvb,
  1823.   hdr_len - 2, 2, qos_ack_policy,
  1824.   "Ack Policy: %d (%sAcknowledge)", 
  1825.   qos_ack_policy, qos_ack_policy ? "Do not " : "");
  1826.   }
  1827.   /*
  1828.    * Only management and data frames have a body, so we don't have
  1829.    * anything more to do for other types of frames.
  1830.    */
  1831.   switch (COOK_FRAME_TYPE (fcf))
  1832.     {
  1833.     case MGT_FRAME:
  1834.       break;
  1835.     case DATA_FRAME:
  1836.       /*
  1837.        * No-data frames don't have a body.
  1838.        */
  1839.       switch (frame_type_subtype)
  1840. {
  1841. case DATA_NULL_FUNCTION:
  1842. case DATA_CF_ACK_NOD:
  1843. case DATA_CF_POLL_NOD:
  1844. case DATA_CF_ACK_POLL_NOD:
  1845. case DATA_QOS_NULL:
  1846.   return;
  1847. }
  1848. break;
  1849.     default:
  1850.       return;
  1851.     }
  1852.   if (IS_WEP(COOK_FLAGS(fcf))) {
  1853.     /*
  1854.      * It's a WEP-encrypted frame; dissect the WEP parameters and decrypt
  1855.      * the data, if we have a matching key.  Otherwise display it as data.
  1856.      */
  1857.     gboolean can_decrypt = FALSE;
  1858.     proto_tree *wep_tree = NULL;
  1859.     guint32 iv;
  1860.     guint8 key, keybyte;
  1861.     keybyte = tvb_get_guint8(tvb, hdr_len + 3);
  1862.     key = COOK_WEP_KEY(keybyte);
  1863.     if ((keybyte & KEY_EXTIV) && (len >= EXTIV_LEN)) {
  1864.       /* Extended IV; this frame is likely encrypted with TKIP or CCMP */
  1865.       if (tree) {
  1866. proto_item *extiv_fields;
  1867. extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8,
  1868.    "TKIP/CCMP parameters");
  1869. wep_tree = proto_item_add_subtree (extiv_fields, ett_wep_parameters);
  1870. /* It is unknown whether this is a TKIP or CCMP encrypted packet, so
  1871.  * display both packet number alternatives unless the ExtIV can be
  1872.  * determined to be possible only with one of the encryption protocols.
  1873.  */
  1874. if (tvb_get_guint8(tvb, hdr_len + 1) & 0x20) {
  1875.   snprintf(out_buff, SHORT_STR, "0x%08X%02X%02X",
  1876.    tvb_get_letohl(tvb, hdr_len + 4),
  1877.    tvb_get_guint8(tvb, hdr_len),
  1878.    tvb_get_guint8(tvb, hdr_len + 2));
  1879.   proto_tree_add_string(wep_tree, hf_tkip_extiv, tvb, hdr_len,
  1880. EXTIV_LEN, out_buff);
  1881. if (tvb_get_guint8(tvb, hdr_len + 2) == 0) {
  1882.   snprintf(out_buff, SHORT_STR, "0x%08X%02X%02X",
  1883.    tvb_get_letohl(tvb, hdr_len + 4),
  1884.    tvb_get_guint8(tvb, hdr_len + 1),
  1885.    tvb_get_guint8(tvb, hdr_len));
  1886.   proto_tree_add_string(wep_tree, hf_ccmp_extiv, tvb, hdr_len,
  1887. EXTIV_LEN, out_buff);
  1888. }
  1889.         proto_tree_add_uint(wep_tree, hf_wep_key, tvb, hdr_len + 3, 1, key);
  1890.       }
  1891.       /* Subtract out the length of the IV. */
  1892.       len -= EXTIV_LEN;
  1893.       reported_len -= EXTIV_LEN;
  1894.       ivlen = EXTIV_LEN;
  1895.       /* It is unknown whether this is TKIP or CCMP, so let's not even try to
  1896.        * parse TKIP Michael MIC+ICV or CCMP MIC. */
  1897.     } else {
  1898.       /* No Ext. IV - WEP packet */
  1899.       /*
  1900.        * XXX - pass the IV and key to "try_decrypt_wep()", and have it pass
  1901.        * them to "wep_decrypt()", rather than having "wep_decrypt()" extract
  1902.        * them itself.
  1903.        *
  1904.        * Also, just pass the data *following* the WEP parameters as the
  1905.        * buffer to decrypt.
  1906.        */
  1907.       iv = tvb_get_ntoh24(tvb, hdr_len);
  1908.       if (tree) {
  1909. proto_item *wep_fields;
  1910. wep_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 4,
  1911.  "WEP parameters");
  1912. wep_tree = proto_item_add_subtree (wep_fields, ett_wep_parameters);
  1913. proto_tree_add_uint (wep_tree, hf_wep_iv, tvb, hdr_len, 3, iv);
  1914. tvb_memcpy(tvb, iv_buff, hdr_len, 3);
  1915. is_iv_bad = weak_iv(iv_buff);
  1916. if (is_iv_bad != -1) {
  1917. proto_tree_add_boolean_format (wep_tree, hf_wep_iv_weak,
  1918.        tvb, 0, 0, TRUE,
  1919.        "Weak IV for key byte %d",
  1920.        is_iv_bad);
  1921. }
  1922.       }
  1923.       if (tree)
  1924.         proto_tree_add_uint (wep_tree, hf_wep_key, tvb, hdr_len + 3, 1, key);
  1925.       /* Subtract out the length of the IV. */
  1926.       len -= 4;
  1927.       reported_len -= 4;
  1928.       ivlen = 4;
  1929.       /*
  1930.        * Well, this packet should, in theory, have an ICV.
  1931.        * Do we have the entire packet, and does it have enough data for
  1932.        * the ICV?
  1933.        */
  1934.       if (reported_len < 4) {
  1935.         /*
  1936.  * The packet is claimed not to even have enough data for a
  1937.  * 4-byte ICV.
  1938.  * Pretend it doesn't have an ICV.
  1939.  */
  1940.         ;
  1941.       } else if (len < reported_len) {
  1942.         /*
  1943.  * The packet is claimed to have enough data for a 4-byte ICV,
  1944.  * but we didn't capture all of the packet.
  1945.  * Slice off the 4-byte ICV from the reported length, and trim
  1946.  * the captured length so it's no more than the reported length;
  1947.  * that will slice off what of the ICV, if any, is in the
  1948.  * captured length.
  1949.  *
  1950.  */
  1951.         reported_len -= 4;
  1952.         if (len > reported_len)
  1953.   len = reported_len;
  1954.       } else {
  1955.         /*
  1956.  * We have the entire packet, and it includes a 4-byte ICV.
  1957.  * Slice it off, and put it into the tree.
  1958.  *
  1959.  * We only support decrypting if we have the the ICV.
  1960.  *
  1961.  * XXX - the ICV is encrypted; we're putting the encrypted
  1962.  * value, not the decrypted value, into the tree.
  1963.  */
  1964.         len -= 4;
  1965. reported_len -= 4;
  1966. can_decrypt = TRUE;
  1967.       }
  1968.     }
  1969.     if (!can_decrypt || (next_tvb = try_decrypt_wep(tvb, hdr_len, reported_len + 8)) == NULL) {
  1970.       /*
  1971.        * WEP decode impossible or failed, treat payload as raw data
  1972.        * and don't attempt fragment reassembly or further dissection.
  1973.        */
  1974.       next_tvb = tvb_new_subset(tvb, hdr_len + ivlen, len, reported_len);
  1975.       if (tree && can_decrypt)
  1976. proto_tree_add_uint_format (wep_tree, hf_wep_icv, tvb, 
  1977.     hdr_len + ivlen + len, 4, 
  1978.     tvb_get_ntohl(tvb, hdr_len + ivlen + len),
  1979.     "WEP ICV: 0x%08x (not verified)", 
  1980.     tvb_get_ntohl(tvb, hdr_len + ivlen + len));
  1981.       if (pinfo->ethertype != ETHERTYPE_CENTRINO_PROMISC)
  1982.       {
  1983.         /* Some wireless drivers (such as Centrino) WEP payload already decrypted */
  1984.         call_dissector(data_handle, next_tvb, pinfo, tree);
  1985.         goto end_of_wlan;
  1986.       }
  1987.     } else {
  1988.       if (tree)
  1989. proto_tree_add_uint_format (wep_tree, hf_wep_icv, tvb, 
  1990.     hdr_len + ivlen + len, 4, 
  1991.     tvb_get_ntohl(tvb, hdr_len + ivlen + len),
  1992.     "WEP ICV: 0x%08x (correct)", 
  1993.     tvb_get_ntohl(tvb, hdr_len + ivlen + len));
  1994.       add_new_data_source(pinfo, next_tvb, "Decrypted WEP data");
  1995.     }
  1996.     /*
  1997.      * WEP decryption successful!
  1998.      *
  1999.      * Use the tvbuff we got back from the decryption; the data starts at
  2000.      * the beginning.  The lengths are already correct for the decoded WEP
  2001.      * payload.
  2002.      */
  2003.     hdr_len = 0;
  2004.   } else {
  2005.     /*
  2006.      * Not a WEP-encrypted frame; just use the data from the tvbuff
  2007.      * handed to us.
  2008.      *
  2009.      * The payload starts at "hdr_len" (i.e., just past the 802.11
  2010.      * MAC header), the length of data in the tvbuff following the
  2011.      * 802.11 header is "len", and the length of data in the packet
  2012.      * following the 802.11 header is "reported_len".
  2013.      */
  2014.     next_tvb = tvb;
  2015.   }
  2016.   /*
  2017.    * Do defragmentation if "wlan_defragment" is true, and we have more
  2018.    * fragments or this isn't the first fragment.
  2019.    *
  2020.    * We have to do some special handling to catch frames that
  2021.    * have the "More Fragments" indicator not set but that
  2022.    * don't show up as reassembled and don't have any other
  2023.    * fragments present.  Some networking interfaces appear
  2024.    * to do reassembly even when you're capturing raw packets
  2025.    * *and* show the reassembled packet without the "More
  2026.    * Fragments" indicator set *but* with a non-zero fragment
  2027.    * number.
  2028.    *
  2029.    * "fragment_add_seq_802_11()" handles that; we want to call it
  2030.    * even if we have a short frame, so that it does those checks - if
  2031.    * the frame is short, it doesn't do reassembly on it.
  2032.    *
  2033.    * (This could get some false positives if we really *did* only
  2034.    * capture the last fragment of a fragmented packet, but that's
  2035.    * life.)
  2036.    */
  2037.   save_fragmented = pinfo->fragmented;
  2038.   if (wlan_defragment && (more_frags || frag_number != 0)) {
  2039.     fragment_data *fd_head;
  2040.     /*
  2041.      * If we've already seen this frame, look it up in the
  2042.      * table of reassembled packets, otherwise add it to
  2043.      * whatever reassembly is in progress, if any, and see
  2044.      * if it's done.
  2045.      */
  2046.     fd_head = fragment_add_seq_802_11(next_tvb, hdr_len, pinfo, seq_number,
  2047.      wlan_fragment_table,
  2048.      wlan_reassembled_table,
  2049.      frag_number,
  2050.      reported_len,
  2051.      more_frags);
  2052.     next_tvb = process_reassembled_data(tvb, hdr_len, pinfo,
  2053. "Reassembled 802.11", fd_head,
  2054. &frag_items, NULL, hdr_tree);
  2055.   } else {
  2056.     /*
  2057.      * If this is the first fragment, dissect its contents, otherwise
  2058.      * just show it as a fragment.
  2059.      */
  2060.     if (frag_number != 0) {
  2061.       /* Not the first fragment - don't dissect it. */
  2062.       next_tvb = NULL;
  2063.     } else {
  2064.       /* First fragment, or not fragmented.  Dissect what we have here. */
  2065.       /* Get a tvbuff for the payload. */
  2066.       next_tvb = tvb_new_subset (next_tvb, hdr_len, len, reported_len);
  2067.       /*
  2068.        * If this is the first fragment, but not the only fragment,
  2069.        * tell the next protocol that.
  2070.        */
  2071.       if (more_frags)
  2072.         pinfo->fragmented = TRUE;
  2073.       else
  2074.         pinfo->fragmented = FALSE;
  2075.     }
  2076.   }
  2077.   if (next_tvb == NULL) {
  2078.     /* Just show this as an incomplete fragment. */
  2079.     if (check_col(pinfo->cinfo, COL_INFO))
  2080.       col_set_str(pinfo->cinfo, COL_INFO, "Fragmented IEEE 802.11 frame");
  2081.     next_tvb = tvb_new_subset (tvb, hdr_len, len, reported_len);
  2082.     call_dissector(data_handle, next_tvb, pinfo, tree);
  2083.     pinfo->fragmented = save_fragmented;
  2084.     goto end_of_wlan;
  2085.   }
  2086.   switch (COOK_FRAME_TYPE (fcf))
  2087.     {
  2088.     case MGT_FRAME:
  2089.       dissect_ieee80211_mgt (fcf, next_tvb, pinfo, tree);
  2090.       break;
  2091.     case DATA_FRAME:
  2092.       /* I guess some bridges take Netware Ethernet_802_3 frames,
  2093.          which are 802.3 frames (with a length field rather than
  2094.          a type field, but with no 802.2 header in the payload),
  2095.          and just stick the payload into an 802.11 frame.  I've seen
  2096.          captures that show frames of that sort.
  2097.          We also handle some odd form of encapsulation in which a
  2098.          complete Ethernet frame is encapsulated within an 802.11
  2099.          data frame, with no 802.2 header.  This has been seen
  2100.          from some hardware.
  2101.          So, if the packet doesn't start with 0xaa 0xaa:
  2102.            we first use the same scheme that linux-wlan-ng does to detect
  2103.            those encapsulated Ethernet frames, namely looking to see whether
  2104.            the frame either starts with 6 octets that match the destination
  2105.            address from the 802.11 header or has 6 octets that match the
  2106.            source address from the 802.11 header following the first 6 octets,
  2107.            and, if so, treat it as an encapsulated Ethernet frame;
  2108.            otherwise, we use the same scheme that we use in the Ethernet
  2109.            dissector to recognize Netware 802.3 frames, namely checking
  2110.            whether the packet starts with 0xff 0xff and, if so, treat it
  2111.            as an encapsulated IPX frame. */
  2112.       encap_type = ENCAP_802_2;
  2113.       TRY {
  2114.        octet1 = tvb_get_guint8(next_tvb, 0);
  2115.        octet2 = tvb_get_guint8(next_tvb, 1);
  2116.         if (octet1 != 0xaa || octet2 != 0xaa) {
  2117.           src = tvb_get_ptr (next_tvb, 6, 6);
  2118.           dst = tvb_get_ptr (next_tvb, 0, 6);
  2119.           if (memcmp(src, pinfo->dl_src.data, 6) == 0 ||
  2120.               memcmp(dst, pinfo->dl_dst.data, 6) == 0)
  2121.             encap_type = ENCAP_ETHERNET;
  2122.           else if (octet1 == 0xff && octet2 == 0xff)
  2123.             encap_type = ENCAP_IPX;
  2124.         }
  2125.       }
  2126.       CATCH2(BoundsError, ReportedBoundsError) {
  2127.     ; /* do nothing */
  2128.       }
  2129.       ENDTRY;
  2130.       switch (encap_type) {
  2131.       case ENCAP_802_2:
  2132.         call_dissector(llc_handle, next_tvb, pinfo, tree);
  2133.         break;
  2134.       case ENCAP_ETHERNET:
  2135.         call_dissector(eth_withoutfcs_handle, next_tvb, pinfo, tree);
  2136.         break;
  2137.       case ENCAP_IPX:
  2138.         call_dissector(ipx_handle, next_tvb, pinfo, tree);
  2139.         break;
  2140.       }
  2141.       break;
  2142.     }
  2143.   pinfo->fragmented = save_fragmented;
  2144.   end_of_wlan:
  2145.   tap_queue_packet(wlan_tap, pinfo, whdr);
  2146. }
  2147. /*
  2148.  * Dissect 802.11 with a variable-length link-layer header.
  2149.  */
  2150. static void
  2151. dissect_ieee80211 (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
  2152. {
  2153.   dissect_ieee80211_common (tvb, pinfo, tree, FALSE, FALSE,
  2154.       pinfo->pseudo_header->ieee_802_11.fcs_len, FALSE);
  2155. }
  2156. /*
  2157.  * Dissect 802.11 with a variable-length link-layer header and a pseudo-
  2158.  * header containing radio information.
  2159.  */
  2160. static void
  2161. dissect_ieee80211_radio (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
  2162. {
  2163.   dissect_ieee80211_common (tvb, pinfo, tree, FALSE, TRUE,
  2164.      pinfo->pseudo_header->ieee_802_11.fcs_len, FALSE);
  2165. }
  2166. /*
  2167.  * Dissect 802.11 with a variable-length link-layer header and a byte-swapped
  2168.  * control field (some hardware sends out LWAPP-encapsulated 802.11
  2169.  * packets with the control field byte swapped).
  2170.  */
  2171. static void
  2172. dissect_ieee80211_bsfc (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
  2173. {
  2174.   dissect_ieee80211_common (tvb, pinfo, tree, FALSE, FALSE, 0, TRUE);
  2175. }
  2176. /*
  2177.  * Dissect 802.11 with a fixed-length link-layer header (padded to the
  2178.  * maximum length).
  2179.  */
  2180. static void
  2181. dissect_ieee80211_fixed (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
  2182. {
  2183.   dissect_ieee80211_common (tvb, pinfo, tree, TRUE, FALSE, 0, FALSE);
  2184. }
  2185. static void
  2186. wlan_defragment_init(void)
  2187. {
  2188.   fragment_table_init(&wlan_fragment_table);
  2189.   reassembled_table_init(&wlan_reassembled_table);
  2190. }
  2191. void
  2192. proto_register_ieee80211 (void)
  2193. {
  2194.   static const value_string frame_type[] = {
  2195.     {MGT_FRAME,     "Management frame"},
  2196.     {CONTROL_FRAME, "Control frame"},
  2197.     {DATA_FRAME,    "Data frame"},
  2198.     {0,             NULL}
  2199.   };
  2200.   static const value_string tofrom_ds[] = {
  2201.     {0,                       "Not leaving DS or network is operating in AD-HOC mode (To DS: 0  From DS: 0)"},
  2202.     {FLAG_TO_DS,              "Frame is entering DS (To DS: 1  From DS: 0)"},
  2203.     {FLAG_FROM_DS,            "Frame is exiting DS (To DS: 0  From DS: 1)"},
  2204.     {FLAG_TO_DS|FLAG_FROM_DS, "Frame part of WDS (To DS: 1  From DS: 1)"},
  2205.     {0, NULL}
  2206.   };
  2207.   static const true_false_string tods_flag = {
  2208.     "Frame is entering DS",
  2209.     "Frame is not entering DS"
  2210.   };
  2211.   static const true_false_string fromds_flag = {
  2212.     "Frame is exiting DS",
  2213.     "Frame is not exiting DS"
  2214.   };
  2215.   static const true_false_string more_frags = {
  2216.     "More fragments follow",
  2217.     "This is the last fragment"
  2218.   };
  2219.   static const true_false_string retry_flags = {
  2220.     "Frame is being retransmitted",
  2221.     "Frame is not being retransmitted"
  2222.   };
  2223.   static const true_false_string pm_flags = {
  2224.     "STA will go to sleep",
  2225.     "STA will stay up"
  2226.   };
  2227.   static const true_false_string md_flags = {
  2228.     "Data is buffered for STA at AP",
  2229.     "No data buffered"
  2230.   };
  2231.   static const true_false_string wep_flags = {
  2232.     "WEP is enabled",
  2233.     "WEP is disabled"
  2234.   };
  2235.   static const true_false_string order_flags = {
  2236.     "Strictly ordered",
  2237.     "Not strictly ordered"
  2238.   };
  2239.   static const true_false_string cf_ess_flags = {
  2240.     "Transmitter is an AP",
  2241.     "Transmitter is a STA"
  2242.   };
  2243.   static const true_false_string cf_privacy_flags = {
  2244.     "AP/STA can support WEP",
  2245.     "AP/STA cannot support WEP"
  2246.   };
  2247.   static const true_false_string cf_preamble_flags = {
  2248.     "Short preamble allowed",
  2249.     "Short preamble not allowed"
  2250.   };
  2251.   static const true_false_string cf_pbcc_flags = {
  2252.     "PBCC modulation allowed",
  2253.     "PBCC modulation not allowed"
  2254.   };
  2255.   static const true_false_string cf_agility_flags = {
  2256.     "Channel agility in use",
  2257.     "Channel agility not in use"
  2258.   };
  2259.   static const true_false_string short_slot_time_flags = {
  2260.     "Short slot time in use",
  2261.     "Short slot time not in use"
  2262.   };
  2263.   static const true_false_string dsss_ofdm_flags = {
  2264.     "DSSS-OFDM modulation allowed",
  2265.     "DSSS-OFDM modulation not allowed"
  2266.   };
  2267.   static const true_false_string cf_ibss_flags = {
  2268.     "Transmitter belongs to an IBSS",
  2269.     "Transmitter belongs to a BSS"
  2270.   };
  2271.   static const value_string sta_cf_pollable[] = {
  2272.     {0x00, "Station is not CF-Pollable"},
  2273.     {0x02, "Station is CF-Pollable, "
  2274.      "not requesting to be placed on the  CF-polling list"},
  2275.     {0x01, "Station is CF-Pollable, "
  2276.      "requesting to be placed on the CF-polling list"},
  2277.     {0x03, "Station is CF-Pollable, requesting never to be polled"},
  2278.     {0, NULL}
  2279.   };
  2280.   static const value_string ap_cf_pollable[] = {
  2281.     {0x00, "No point coordinator at AP"},
  2282.     {0x02, "Point coordinator at AP for delivery only (no polling)"},
  2283.     {0x01, "Point coordinator at AP for delivery and polling"},
  2284.     {0x03, "Reserved"},
  2285.     {0, NULL}
  2286.   };
  2287.   static const value_string auth_alg[] = {
  2288.     {0x00, "Open System"},
  2289.     {0x01, "Shared key"},
  2290.     {0, NULL}
  2291.   };
  2292.   static const value_string reason_codes[] = {
  2293.     {0x00, "Reserved"},
  2294.     {0x01, "Unspecified reason"},
  2295.     {0x02, "Previous authentication no longer valid"},
  2296.     {0x03, "Deauthenticated because sending STA is leaving (has left) "
  2297.      "IBSS or ESS"},
  2298.     {0x04, "Disassociated due to inactivity"},
  2299.     {0x05, "Disassociated because AP is unable to handle all currently "
  2300.      "associated stations"},
  2301.     {0x06, "Class 2 frame received from nonauthenticated station"},
  2302.     {0x07, "Class 3 frame received from nonassociated station"},
  2303.     {0x08, "Disassociated because sending STA is leaving (has left) BSS"},
  2304.     {0x09, "Station requesting (re)association is not authenticated with "
  2305.      "responding station"},
  2306.     {0x0D, "Invalid Information Element"},
  2307.     {0x0E, "Michael MIC failure"},
  2308.     {0x0F, "4-Way Handshake timeout"},
  2309.     {0x10, "Group key update timeout"},
  2310.     {0x11, "Information element in 4-Way Handshake different from "
  2311.      "(Re)Association Request/Probe Response/Beacon"},
  2312.     {0x12, "Group Cipher is not valid"},
  2313.     {0x13, "Pairwise Cipher is not valid"},
  2314.     {0x14, "AKMP is not valid"},
  2315.     {0x15, "Unsupported RSN IE version"},
  2316.     {0x16, "Invalid RSN IE Capabilities"},
  2317.     {0x17, "IEEE 802.1X Authentication failed"},
  2318.     {0x18, "Cipher suite is rejected per security policy"},
  2319.     {0x00, NULL}
  2320.   };
  2321.   static const value_string status_codes[] = {
  2322.     {0x00, "Successful"},
  2323.     {0x01, "Unspecified failure"},
  2324.     {0x0A, "Cannot support all requested capabilities in the "
  2325.      "Capability information field"},
  2326.     {0x0B, "Reassociation denied due to inability to confirm that "
  2327.      "association exists"},
  2328.     {0x0C, "Association denied due to reason outside the scope of this "
  2329.      "standard"},
  2330.     {0x0D, "Responding station does not support the specified authentication "
  2331.      "algorithm"},
  2332.     {0x0E, "Received an Authentication frame with authentication sequence "
  2333.      "transaction sequence number out of expected sequence"},
  2334.     {0x0F, "Authentication rejected because of challenge failure"},
  2335.     {0x10, "Authentication rejected due to timeout waiting for next "
  2336.      "frame in sequence"},
  2337.     {0x11, "Association denied because AP is unable to handle additional "
  2338.      "associated stations"},
  2339.     {0x12, "Association denied due to requesting station not supporting all "
  2340.      "of the datarates in the BSSBasicServiceSet Parameter"},
  2341.     {0x13, "Association denied due to requesting station not supporting "
  2342.      "short preamble operation"},
  2343.     {0x14, "Association denied due to requesting station not supporting "
  2344.      "PBCC encoding"},
  2345.     {0x15, "Association denied due to requesting station not supporting "
  2346.      "channel agility"},
  2347.     {0x19, "Association denied due to requesting station not supporting "
  2348.      "short slot operation"},
  2349.     {0x1A, "Association denied due to requesting station not supporting "
  2350.      "DSSS-OFDM operation"},
  2351.     {0x28, "Invalid Information Element"},
  2352.     {0x29, "Group Cipher is not valid"},
  2353.     {0x2A, "Pairwise Cipher is not valid"},
  2354.     {0x2B, "AKMP is not valid"},
  2355.     {0x2C, "Unsupported RSN IE version"},
  2356.     {0x2D, "Invalid RSN IE Capabilities"},
  2357.     {0x2E, "Cipher suite is rejected per security policy"},
  2358.     {0x00, NULL}
  2359.   };
  2360.   static const value_string category_codes[] = {
  2361.     {0x11, "Management notification frame"},
  2362.     {0x00, NULL}
  2363.   };
  2364.   static const value_string action_codes[] = {
  2365.     {0x00, NULL}
  2366.   };
  2367.   static const value_string wme_action_codes[] = {
  2368.     {0x00, "Setup request"},
  2369.     {0x01, "Setup response"},
  2370.     {0x02, "Teardown"},
  2371.     {0x00, NULL}
  2372.   };
  2373.   static const value_string wme_status_codes[] = {
  2374.     {0x00, "Admission accepted"},
  2375.     {0x01, "Invalid parameters"},
  2376.     {0x03, "Refused"},
  2377.     {0x00, NULL}
  2378.   };
  2379.   static hf_register_info hf[] = {
  2380.     {&hf_data_rate,
  2381.      {"Data Rate", "wlan.data_rate", FT_UINT8, BASE_DEC, NULL, 0,
  2382.       "Data rate (.5 Mb/s units)", HFILL }},
  2383.     {&hf_channel,
  2384.      {"Channel", "wlan.channel", FT_UINT8, BASE_DEC, NULL, 0,
  2385.       "Radio channel", HFILL }},
  2386.     {&hf_signal_strength,
  2387.      {"Signal Strength", "wlan.signal_strength", FT_UINT8, BASE_DEC, NULL, 0,
  2388.       "Signal strength (percentage)", HFILL }},
  2389.     {&hf_fc_field,
  2390.      {"Frame Control Field", "wlan.fc", FT_UINT16, BASE_HEX, NULL, 0,
  2391.       "MAC Frame control", HFILL }},
  2392.     {&hf_fc_proto_version,
  2393.      {"Version", "wlan.fc.version", FT_UINT8, BASE_DEC, NULL, 0,
  2394.       "MAC Protocol version", HFILL }}, /* 0 */
  2395.     {&hf_fc_frame_type,
  2396.      {"Type", "wlan.fc.type", FT_UINT8, BASE_DEC, VALS(frame_type), 0,
  2397.       "Frame type", HFILL }},
  2398.     {&hf_fc_frame_subtype,
  2399.      {"Subtype", "wlan.fc.subtype", FT_UINT8, BASE_DEC, NULL, 0,
  2400.       "Frame subtype", HFILL }}, /* 2 */
  2401.     {&hf_fc_frame_type_subtype,
  2402.      {"Type/Subtype", "wlan.fc.type_subtype", FT_UINT16, BASE_DEC, VALS(frame_type_subtype_vals), 0,
  2403.       "Type and subtype combined", HFILL }},
  2404.     {&hf_fc_flags,
  2405.      {"Protocol Flags", "wlan.flags", FT_UINT8, BASE_HEX, NULL, 0,
  2406.       "Protocol flags", HFILL }},
  2407.     {&hf_fc_data_ds,
  2408.      {"DS status", "wlan.fc.ds", FT_UINT8, BASE_HEX, VALS (&tofrom_ds), 0,
  2409.       "Data-frame DS-traversal status", HFILL }}, /* 3 */
  2410.     {&hf_fc_to_ds,
  2411.      {"To DS", "wlan.fc.tods", FT_BOOLEAN, 8, TFS (&tods_flag), FLAG_TO_DS,
  2412.       "To DS flag", HFILL }}, /* 4 */
  2413.     {&hf_fc_from_ds,
  2414.      {"From DS", "wlan.fc.fromds", FT_BOOLEAN, 8, TFS (&fromds_flag), FLAG_FROM_DS,
  2415.       "From DS flag", HFILL }}, /* 5 */
  2416.     {&hf_fc_more_frag,
  2417.      {"More Fragments", "wlan.fc.frag", FT_BOOLEAN, 8, TFS (&more_frags), FLAG_MORE_FRAGMENTS,
  2418.       "More Fragments flag", HFILL }}, /* 6 */
  2419.     {&hf_fc_retry,
  2420.      {"Retry", "wlan.fc.retry", FT_BOOLEAN, 8, TFS (&retry_flags), FLAG_RETRY,
  2421.       "Retransmission flag", HFILL }},
  2422.     {&hf_fc_pwr_mgt,
  2423.      {"PWR MGT", "wlan.fc.pwrmgt", FT_BOOLEAN, 8, TFS (&pm_flags), FLAG_POWER_MGT,
  2424.       "Power management status", HFILL }},
  2425.     {&hf_fc_more_data,
  2426.      {"More Data", "wlan.fc.moredata", FT_BOOLEAN, 8, TFS (&md_flags), FLAG_MORE_DATA,
  2427.       "More data flag", HFILL }},
  2428.     {&hf_fc_wep,
  2429.      {"WEP flag", "wlan.fc.wep", FT_BOOLEAN, 8, TFS (&wep_flags), FLAG_WEP,
  2430.       "WEP flag", HFILL }},
  2431.     {&hf_fc_order,
  2432.      {"Order flag", "wlan.fc.order", FT_BOOLEAN, 8, TFS (&order_flags), FLAG_ORDER,
  2433.       "Strictly ordered flag", HFILL }},
  2434.     {&hf_assoc_id,
  2435.      {"Association ID","wlan.aid",FT_UINT16, BASE_DEC,NULL,0,
  2436.       "Association-ID field", HFILL }},
  2437.     {&hf_did_duration,
  2438.      {"Duration", "wlan.duration", FT_UINT16, BASE_DEC, NULL, 0,
  2439.       "Duration field", HFILL }},
  2440.     {&hf_addr_da,
  2441.      {"Destination address", "wlan.da", FT_ETHER, BASE_NONE, NULL, 0,
  2442.       "Destination Hardware Address", HFILL }},
  2443.     {&hf_addr_sa,
  2444.      {"Source address", "wlan.sa", FT_ETHER, BASE_NONE, NULL, 0,
  2445.       "Source Hardware Address", HFILL }},
  2446.     { &hf_addr,
  2447.       {"Source or Destination address", "wlan.addr", FT_ETHER, BASE_NONE, NULL, 0,
  2448.        "Source or Destination Hardware Address", HFILL }},
  2449.     {&hf_addr_ra,
  2450.      {"Receiver address", "wlan.ra", FT_ETHER, BASE_NONE, NULL, 0,
  2451.       "Receiving Station Hardware Address", HFILL }},
  2452.     {&hf_addr_ta,
  2453.      {"Transmitter address", "wlan.ta", FT_ETHER, BASE_NONE, NULL, 0,
  2454.       "Transmitting Station Hardware Address", HFILL }},
  2455.     {&hf_addr_bssid,
  2456.      {"BSS Id", "wlan.bssid", FT_ETHER, BASE_NONE, NULL, 0,
  2457.       "Basic Service Set ID", HFILL }},
  2458.     {&hf_frag_number,
  2459.      {"Fragment number", "wlan.frag", FT_UINT16, BASE_DEC, NULL, 0,
  2460.       "Fragment number", HFILL }},
  2461.     {&hf_seq_number,
  2462.      {"Sequence number", "wlan.seq", FT_UINT16, BASE_DEC, NULL, 0,
  2463.       "Sequence number", HFILL }},
  2464.     {&hf_qos_priority,
  2465.      {"Priority", "wlan.qos.priority", FT_UINT16, BASE_DEC, NULL, 0,
  2466.       "802.1D Tag", HFILL }},
  2467.     {&hf_qos_ack_policy,
  2468.      {"Ack Policy", "wlan.qos.ack", FT_UINT16, BASE_DEC, NULL, 0,
  2469.       "Ack Policy", HFILL }},
  2470.     {&hf_fcs,
  2471.      {"Frame check sequence", "wlan.fcs", FT_UINT32, BASE_HEX,
  2472.       NULL, 0, "FCS", HFILL }},
  2473.     {&hf_fragment_overlap,
  2474.       {"Fragment overlap", "wlan.fragment.overlap", FT_BOOLEAN, BASE_NONE,
  2475.        NULL, 0x0, "Fragment overlaps with other fragments", HFILL }},
  2476.     {&hf_fragment_overlap_conflict,
  2477.       {"Conflicting data in fragment overlap", "wlan.fragment.overlap.conflict",
  2478.        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
  2479.        "Overlapping fragments contained conflicting data", HFILL }},
  2480.     {&hf_fragment_multiple_tails,
  2481.       {"Multiple tail fragments found", "wlan.fragment.multipletails",
  2482.        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
  2483.        "Several tails were found when defragmenting the packet", HFILL }},
  2484.     {&hf_fragment_too_long_fragment,
  2485.       {"Fragment too long", "wlan.fragment.toolongfragment",
  2486.        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
  2487.        "Fragment contained data past end of packet", HFILL }},
  2488.     {&hf_fragment_error,
  2489.       {"Defragmentation error", "wlan.fragment.error",
  2490.        FT_FRAMENUM, BASE_NONE, NULL, 0x0,
  2491.        "Defragmentation error due to illegal fragments", HFILL }},
  2492.     {&hf_fragment,
  2493.       {"802.11 Fragment", "wlan.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
  2494.        "802.11 Fragment", HFILL }},
  2495.     {&hf_fragments,
  2496.       {"802.11 Fragments", "wlan.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
  2497.        "802.11 Fragments", HFILL }},
  2498.     {&hf_reassembled_in,
  2499.       {"Reassembled 802.11 in frame", "wlan.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
  2500.        "This 802.11 packet is reassembled in this frame", HFILL }},
  2501.     {&hf_wep_iv,
  2502.      {"Initialization Vector", "wlan.wep.iv", FT_UINT24, BASE_HEX, NULL, 0,
  2503.       "Initialization Vector", HFILL }},
  2504.     {&hf_wep_iv_weak,
  2505.      {"Weak IV", "wlan.wep.weakiv", FT_BOOLEAN,BASE_NONE, NULL,0x0,
  2506.        "Weak IV",HFILL}},
  2507.     {&hf_tkip_extiv,
  2508.      {"TKIP Ext. Initialization Vector", "wlan.tkip.extiv", FT_STRING,
  2509.       BASE_HEX, NULL, 0, "TKIP Extended Initialization Vector", HFILL }},
  2510.     {&hf_ccmp_extiv,
  2511.      {"CCMP Ext. Initialization Vector", "wlan.ccmp.extiv", FT_STRING,
  2512.       BASE_HEX, NULL, 0, "CCMP Extended Initialization Vector", HFILL }},
  2513.     {&hf_wep_key,
  2514.      {"Key", "wlan.wep.key", FT_UINT8, BASE_DEC, NULL, 0,
  2515.       "Key", HFILL }},
  2516.     {&hf_wep_icv,
  2517.      {"WEP ICV", "wlan.wep.icv", FT_UINT32, BASE_HEX, NULL, 0,
  2518.       "WEP ICV", HFILL }},
  2519.   };
  2520.   static const true_false_string rsn_preauth_flags = {
  2521.     "Transmitter supports pre-authentication",
  2522.     "Transmitter does not support pre-authentication"
  2523.   };
  2524.   static const true_false_string rsn_no_pairwise_flags = {
  2525.     "Transmitter cannot support WEP default key 0 simultaneously with "
  2526.     "Pairwise key",
  2527.     "Transmitter can support WEP default key 0 simultaneously with "
  2528.     "Pairwise key"
  2529.   };
  2530.   static const value_string rsn_cap_replay_counter[] = {
  2531.     {0x00, "1 replay counter per PTKSA/GTKSA/STAKeySA"},
  2532.     {0x01, "2 replay counters per PTKSA/GTKSA/STAKeySA"},
  2533.     {0x02, "4 replay counters per PTKSA/GTKSA/STAKeySA"},
  2534.     {0x03, "16 replay counters per PTKSA/GTKSA/STAKeySA"},
  2535.     {0, NULL}
  2536.   };
  2537.   static hf_register_info ff[] = {
  2538.     {&ff_timestamp,
  2539.      {"Timestamp", "wlan_mgt.fixed.timestamp", FT_STRING, BASE_NONE,
  2540.       NULL, 0, "", HFILL }},
  2541.     {&ff_auth_alg,
  2542.      {"Authentication Algorithm", "wlan_mgt.fixed.auth.alg",
  2543.       FT_UINT16, BASE_DEC, VALS (&auth_alg), 0, "", HFILL }},
  2544.     {&ff_beacon_interval,
  2545.      {"Beacon Interval", "wlan_mgt.fixed.beacon", FT_DOUBLE, BASE_DEC, NULL, 0,
  2546.       "", HFILL }},
  2547.     {&hf_fixed_parameters,
  2548.      {"Fixed parameters", "wlan_mgt.fixed.all", FT_UINT16, BASE_DEC, NULL, 0,
  2549.       "", HFILL }},
  2550.     {&hf_tagged_parameters,
  2551.      {"Tagged parameters", "wlan_mgt.tagged.all", FT_UINT16, BASE_DEC, NULL, 0,
  2552.       "", HFILL }},
  2553.     {&ff_capture,
  2554.      {"Capabilities", "wlan_mgt.fixed.capabilities", FT_UINT16, BASE_HEX, NULL, 0,
  2555.       "Capability information", HFILL }},
  2556.     {&ff_cf_ess,
  2557.      {"ESS capabilities", "wlan_mgt.fixed.capabilities.ess",
  2558.       FT_BOOLEAN, 16, TFS (&cf_ess_flags), 0x0001, "ESS capabilities", HFILL }},
  2559.     {&ff_cf_ibss,
  2560.      {"IBSS status", "wlan_mgt.fixed.capabilities.ibss",
  2561.       FT_BOOLEAN, 16, TFS (&cf_ibss_flags), 0x0002, "IBSS participation", HFILL }},
  2562.     {&ff_cf_sta_poll,
  2563.      {"CFP participation capabilities", "wlan_mgt.fixed.capabilities.cfpoll.sta",
  2564.       FT_UINT16, BASE_HEX, VALS (&sta_cf_pollable), 0x000C,
  2565.       "CF-Poll capabilities for a STA", HFILL }},
  2566.     {&ff_cf_ap_poll,
  2567.      {"CFP participation capabilities", "wlan_mgt.fixed.capabilities.cfpoll.ap",
  2568.       FT_UINT16, BASE_HEX, VALS (&ap_cf_pollable), 0x000C,
  2569.       "CF-Poll capabilities for an AP", HFILL }},
  2570.     {&ff_cf_privacy,
  2571.      {"Privacy", "wlan_mgt.fixed.capabilities.privacy",
  2572.       FT_BOOLEAN, 16, TFS (&cf_privacy_flags), 0x0010, "WEP support", HFILL }},
  2573.     {&ff_cf_preamble,
  2574.      {"Short Preamble", "wlan_mgt.fixed.capabilities.preamble",
  2575.       FT_BOOLEAN, 16, TFS (&cf_preamble_flags), 0x0020, "Short Preamble", HFILL }},
  2576.     {&ff_cf_pbcc,
  2577.      {"PBCC", "wlan_mgt.fixed.capabilities.pbcc",
  2578.       FT_BOOLEAN, 16, TFS (&cf_pbcc_flags), 0x0040, "PBCC Modulation", HFILL }},
  2579.     {&ff_cf_agility,
  2580.      {"Channel Agility", "wlan_mgt.fixed.capabilities.agility",
  2581.       FT_BOOLEAN, 16, TFS (&cf_agility_flags), 0x0080, "Channel Agility", HFILL }},
  2582.     {&ff_short_slot_time,
  2583.      {"Short Slot Time", "wlan_mgt.fixed.capabilities.short_slot_time",
  2584.       FT_BOOLEAN, 16, TFS (&short_slot_time_flags), 0x0400, "Short Slot Time",
  2585.       HFILL }},
  2586.     {&ff_dsss_ofdm,
  2587.      {"DSSS-OFDM", "wlan_mgt.fixed.capabilities.dsss_ofdm",
  2588.       FT_BOOLEAN, 16, TFS (&dsss_ofdm_flags), 0x2000, "DSSS-OFDM Modulation",
  2589.       HFILL }},
  2590.     {&ff_auth_seq,
  2591.      {"Authentication SEQ", "wlan_mgt.fixed.auth_seq",
  2592.       FT_UINT16, BASE_HEX, NULL, 0, "Authentication sequence number", HFILL }},
  2593.     {&ff_assoc_id,
  2594.      {"Association ID", "wlan_mgt.fixed.aid",
  2595.       FT_UINT16, BASE_HEX, NULL, 0, "Association ID", HFILL }},
  2596.     {&ff_listen_ival,
  2597.      {"Listen Interval", "wlan_mgt.fixed.listen_ival",
  2598.       FT_UINT16, BASE_HEX, NULL, 0, "Listen Interval", HFILL }},
  2599.     {&ff_current_ap,
  2600.      {"Current AP", "wlan_mgt.fixed.current_ap",
  2601.       FT_ETHER, BASE_NONE, NULL, 0, "MAC address of current AP", HFILL }},
  2602.     {&ff_reason,
  2603.      {"Reason code", "wlan_mgt.fixed.reason_code",
  2604.       FT_UINT16, BASE_HEX, VALS (&reason_codes), 0,
  2605.       "Reason for unsolicited notification", HFILL }},
  2606.     {&ff_status_code,
  2607.      {"Status code", "wlan_mgt.fixed.status_code",
  2608.       FT_UINT16, BASE_HEX, VALS (&status_codes), 0,
  2609.       "Status of requested event", HFILL }},
  2610.     {&ff_category_code,
  2611.      {"Category code", "wlan_mgt.fixed.category_code",
  2612.       FT_UINT16, BASE_HEX, VALS (&category_codes), 0,
  2613.       "Management action category", HFILL }},
  2614.     {&ff_action_code,
  2615.      {"Action code", "wlan_mgt.fixed.action_code",
  2616.       FT_UINT16, BASE_HEX, VALS (&action_codes), 0,
  2617.       "Management action code", HFILL }},
  2618.     {&ff_dialog_token,
  2619.      {"Dialog token", "wlan_mgt.fixed.dialog_token",
  2620.       FT_UINT16, BASE_HEX, NULL, 0, "Management action dialog token", HFILL }},
  2621.     {&ff_wme_action_code,
  2622.      {"Action code", "wlan_mgt.fixed.action_code",
  2623.       FT_UINT16, BASE_HEX, VALS (&wme_action_codes), 0,
  2624.       "Management notification action code", HFILL }},
  2625.     {&ff_wme_status_code,
  2626.      {"Status code", "wlan_mgt.fixed.status_code",
  2627.       FT_UINT16, BASE_HEX, VALS (&wme_status_codes), 0,
  2628.       "Management notification setup response status code", HFILL }},
  2629.     {&tag_number,
  2630.      {"Tag", "wlan_mgt.tag.number",
  2631.       FT_UINT8, BASE_DEC, VALS(tag_num_vals), 0,
  2632.       "Element ID", HFILL }},
  2633.     {&tag_length,
  2634.      {"Tag length", "wlan_mgt.tag.length",
  2635.       FT_UINT8, BASE_DEC, NULL, 0, "Length of tag", HFILL }},
  2636.     {&tag_interpretation,
  2637.      {"Tag interpretation", "wlan_mgt.tag.interpretation",
  2638.       FT_STRING, BASE_NONE, NULL, 0, "Interpretation of tag", HFILL }},
  2639.     {&rsn_cap,
  2640.      {"RSN Capabilities", "wlan_mgt.rsn.capabilities", FT_UINT16, BASE_HEX,
  2641.       NULL, 0, "RSN Capability information", HFILL }},
  2642.     {&rsn_cap_preauth,
  2643.      {"RSN Pre-Auth capabilities", "wlan_mgt.rsn.capabilities.preauth",
  2644.       FT_BOOLEAN, 16, TFS (&rsn_preauth_flags), 0x0001,
  2645.       "RSN Pre-Auth capabilities", HFILL }},
  2646.     {&rsn_cap_no_pairwise,
  2647.      {"RSN No Pairwise capabilities", "wlan_mgt.rsn.capabilities.no_pairwise",
  2648.       FT_BOOLEAN, 16, TFS (&rsn_no_pairwise_flags), 0x0002,
  2649.       "RSN No Pairwise capabilities", HFILL }},
  2650.     {&rsn_cap_ptksa_replay_counter,
  2651.      {"RSN PTKSA Replay Counter capabilities",
  2652.       "wlan_mgt.rsn.capabilities.ptksa_replay_counter",
  2653.       FT_UINT16, BASE_HEX, VALS (&rsn_cap_replay_counter), 0x000C,
  2654.       "RSN PTKSA Replay Counter capabilities", HFILL }},
  2655.     {&rsn_cap_gtksa_replay_counter,
  2656.      {"RSN GTKSA Replay Counter capabilities",
  2657.       "wlan_mgt.rsn.capabilities.gtksa_replay_counter",
  2658.       FT_UINT16, BASE_HEX, VALS (&rsn_cap_replay_counter), 0x0030,
  2659.       "RSN GTKSA Replay Counter capabilities", HFILL }},
  2660.   };
  2661.   static gint *tree_array[] = {
  2662.     &ett_80211,
  2663.     &ett_fc_tree,
  2664.     &ett_proto_flags,
  2665.     &ett_fragments,
  2666.     &ett_fragment,
  2667.     &ett_80211_mgt,
  2668.     &ett_fixed_parameters,
  2669.     &ett_tagged_parameters,
  2670.     &ett_qos_parameters,
  2671.     &ett_wep_parameters,
  2672.     &ett_cap_tree,
  2673.     &ett_rsn_cap_tree,
  2674.   };
  2675.   module_t *wlan_module;
  2676.   static const enum_val_t wep_keys_options[] = {
  2677.     {"0", "0", 0},
  2678.     {"1", "1", 1},
  2679.     {"2", "2", 2},
  2680.     {"3", "3", 3},
  2681.     {"4", "4", 4},
  2682.     {NULL, NULL, -1},
  2683.   };
  2684.   proto_wlan = proto_register_protocol ("IEEE 802.11 wireless LAN",
  2685. "IEEE 802.11", "wlan");
  2686.   proto_register_field_array (proto_wlan, hf, array_length (hf));
  2687.   proto_wlan_mgt = proto_register_protocol ("IEEE 802.11 wireless LAN management frame",
  2688. "802.11 MGT", "wlan_mgt");
  2689.   proto_register_field_array (proto_wlan_mgt, ff, array_length (ff));
  2690.   proto_register_subtree_array (tree_array, array_length (tree_array));
  2691.   register_dissector("wlan", dissect_ieee80211, proto_wlan);
  2692.   register_dissector("wlan_fixed", dissect_ieee80211_fixed, proto_wlan);
  2693.   register_dissector("wlan_bsfc", dissect_ieee80211_bsfc, proto_wlan);
  2694.   register_init_routine(wlan_defragment_init);
  2695.   wlan_tap = register_tap("wlan");
  2696.   /* Register configuration options */
  2697.   wlan_module = prefs_register_protocol(proto_wlan, init_wepkeys);
  2698.   prefs_register_bool_preference(wlan_module, "defragment",
  2699. "Reassemble fragmented 802.11 datagrams",
  2700. "Whether fragmented 802.11 datagrams should be reassembled",
  2701. &wlan_defragment);
  2702.   prefs_register_bool_preference(wlan_module, "check_fcs",
  2703.  "Assume packets have FCS",
  2704.  "Some 802.11 cards include the FCS at the end of a packet, others do not.",
  2705.  &wlan_check_fcs);
  2706.   prefs_register_bool_preference(wlan_module, "ignore_wep",
  2707.  "Ignore the WEP bit",
  2708.  "Some 802.11 cards leave the WEP bit set even though the packet is decrypted.",
  2709.  &wlan_ignore_wep);
  2710. #ifndef USE_ENV
  2711.   prefs_register_enum_preference(wlan_module, "wep_keys",
  2712.  "WEP key count",
  2713.  "How many WEP keys do we have to choose from? (0 to disable, up to 4)",
  2714.  &num_wepkeys, wep_keys_options, FALSE);
  2715.   prefs_register_string_preference(wlan_module, "wep_key1",
  2716.    "WEP key #1",
  2717.    "First WEP key (A:B:C:D:E) [40bit], (A:B:C:D:E:F:G:H:I:J:K:L:M) [104bit], or whatever key length you're using",
  2718.    &wep_keystr[0]);
  2719.   prefs_register_string_preference(wlan_module, "wep_key2",
  2720.    "WEP key #2",
  2721.    "Second WEP key (A:B:C:D:E) [40bit], (A:B:C:D:E:F:G:H:I:J:K:L:M) [104bit], or whatever key length you're using",
  2722.    &wep_keystr[1]);
  2723.   prefs_register_string_preference(wlan_module, "wep_key3",
  2724.    "WEP key #3",
  2725.    "Third WEP key (A:B:C:D:E) [40bit], (A:B:C:D:E:F:G:H:I:J:K:L:M) [104bit], or whatever key length you're using",
  2726.    &wep_keystr[2]);
  2727.   prefs_register_string_preference(wlan_module, "wep_key4",
  2728.    "WEP key #4",
  2729.    "Fourth WEP key (A:B:C:D:E) [40bit] (A:B:C:D:E:F:G:H:I:J:K:L:M) [104bit], or whatever key length you're using",
  2730.    &wep_keystr[3]);
  2731. #endif
  2732. }
  2733. void
  2734. proto_reg_handoff_ieee80211(void)
  2735. {
  2736.   dissector_handle_t ieee80211_handle;
  2737.   dissector_handle_t ieee80211_radio_handle;
  2738.   /*
  2739.    * Get handles for the LLC, IPX and Ethernet  dissectors.
  2740.    */
  2741.   llc_handle = find_dissector("llc");
  2742.   ipx_handle = find_dissector("ipx");
  2743.   eth_withoutfcs_handle = find_dissector("eth_withoutfcs");
  2744.   data_handle = find_dissector("data");
  2745.   ieee80211_handle = find_dissector("wlan");
  2746.   dissector_add("wtap_encap", WTAP_ENCAP_IEEE_802_11, ieee80211_handle);
  2747.   ieee80211_radio_handle = create_dissector_handle(dissect_ieee80211_radio,
  2748.    proto_wlan);
  2749.   dissector_add("wtap_encap", WTAP_ENCAP_IEEE_802_11_WITH_RADIO,
  2750. ieee80211_radio_handle);
  2751.   dissector_add("ethertype", ETHERTYPE_CENTRINO_PROMISC, ieee80211_handle);
  2752. }
  2753. static tvbuff_t *try_decrypt_wep(tvbuff_t *tvb, guint32 offset, guint32 len) {
  2754.   const guint8 *enc_data;
  2755.   guint8 *tmp = NULL;
  2756.   int i;
  2757.   tvbuff_t *decr_tvb = NULL;
  2758.   if (num_wepkeys < 1)
  2759.     return NULL;
  2760.   enc_data = tvb_get_ptr(tvb, offset, len);
  2761.   if ((tmp = g_malloc(len)) == NULL)
  2762.     return NULL;  /* krap! */
  2763.   /* try once with the key index in the packet, then look through our list. */
  2764.   for (i = -1; i < (int) num_wepkeys; i++) {
  2765.     /* copy the encrypted data over to the tmp buffer */
  2766. #if 0
  2767.     printf("trying %dn", i);
  2768. #endif
  2769.     memcpy(tmp, enc_data, len);
  2770.     if (wep_decrypt(tmp, len, i) == 0) {
  2771.       /* decrypt successful, let's set up a new data tvb. */
  2772.       decr_tvb = tvb_new_real_data(tmp, len-8, len-8);
  2773.       tvb_set_free_cb(decr_tvb, g_free);
  2774.       tvb_set_child_real_data_tvbuff(tvb, decr_tvb);
  2775.       goto done;
  2776.     }
  2777.   }
  2778.  done:
  2779.   if ((!decr_tvb) && (tmp))    g_free(tmp);
  2780. #if 0
  2781.   printf("de-wep %pn", decr_tvb);
  2782. #endif
  2783.   return decr_tvb;
  2784. }
  2785. /* de-weps the block.  if successful, buf* will point to the data start. */
  2786. static int wep_decrypt(guint8 *buf, guint32 len, int key_override) {
  2787.   guint32 i, j, k, crc, keylen;
  2788.   guint8 s[256], key[128], c_crc[4];
  2789.   guint8 keyidx, *dpos, *cpos;
  2790.   /* Needs to be at least 8 bytes of payload */
  2791.   if (len < 8)
  2792.     return -1;
  2793.   /* initialize the first bytes of the key from the IV */
  2794.   key[0] = buf[0];
  2795.   key[1] = buf[1];
  2796.   key[2] = buf[2];
  2797.   keyidx = COOK_WEP_KEY(buf[3]);
  2798.   if (key_override >= 0)
  2799.     keyidx = key_override;
  2800.   if (keyidx >= num_wepkeys)
  2801.     return -1;
  2802.   keylen = wep_keylens[keyidx];
  2803.   if (keylen == 0)
  2804.     return -1;
  2805.   if (wep_keys[keyidx] == NULL)
  2806.     return -1;
  2807.   keylen+=3;  /* add in ICV bytes */
  2808.   /* copy the rest of the key over from the designated key */
  2809.   memcpy(key+3, wep_keys[keyidx], wep_keylens[keyidx]);
  2810. #if 0
  2811.   printf("%d: %02x %02x %02x (%d %d) %02x:%02x:%02x:%02x:%02xn", len, key[0], key[1], key[2], keyidx, keylen, key[3], key[4], key[5], key[6], key[7]);
  2812. #endif
  2813.   /* set up the RC4 state */
  2814.   for (i = 0; i < 256; i++)
  2815.     s[i] = i;
  2816.   j = 0;
  2817.   for (i = 0; i < 256; i++) {
  2818.     j = (j + s[i] + key[i % keylen]) & 0xff;
  2819.     SSWAP(i,j);
  2820.   }
  2821.   /* Apply the RC4 to the data, update the CRC32 */
  2822.   cpos = buf+4;
  2823.   dpos = buf;
  2824.   crc = ~0;
  2825.   i = j = 0;
  2826.   for (k = 0; k < (len -8); k++) {
  2827.     i = (i+1) & 0xff;
  2828.     j = (j+s[i]) & 0xff;
  2829.     SSWAP(i,j);
  2830. #if 0
  2831.     printf("%d -- %02x ", k, *dpos);
  2832. #endif
  2833.     *dpos = *cpos++ ^ s[(s[i] + s[j]) & 0xff];
  2834. #if 0
  2835.     printf("%02xn", *dpos);
  2836. #endif
  2837.     crc = crc32_ccitt_table[(crc ^ *dpos++) & 0xff] ^ (crc >> 8);
  2838.   }
  2839.   crc = ~crc;
  2840.   /* now let's check the crc */
  2841.   c_crc[0] = crc;
  2842.   c_crc[1] = crc >> 8;
  2843.   c_crc[2] = crc >> 16;
  2844.   c_crc[3] = crc >> 24;
  2845.   for (k = 0; k < 4; k++) {
  2846.     i = (i + 1) & 0xff;
  2847.     j = (j+s[i]) & 0xff;
  2848.     SSWAP(i,j);
  2849. #if 0
  2850.     printf("-- %02x %02xn", *dpos, c_crc[k]);
  2851. #endif
  2852.     if ((*cpos++ ^ s[(s[i] + s[j]) & 0xff]) != c_crc[k])
  2853.       return -1; /* ICV mismatch */
  2854.   }
  2855.   return 0;
  2856. }
  2857. static void init_wepkeys(void) {
  2858.   char *tmp;
  2859.   guint i;
  2860.   GByteArray *bytes;
  2861.   gboolean res;
  2862. #ifdef USE_ENV
  2863.   guint8 buf[128];
  2864.   tmp = getenv("ETHEREAL_WEPKEYNUM");
  2865.   if (!tmp) {
  2866.     num_wepkeys = 0;
  2867.     return;
  2868.   }
  2869.   num_wepkeys = atoi(tmp);
  2870. #else
  2871.   if (num_wepkeys > 4)
  2872.     num_wepkeys = 4;
  2873. #endif
  2874.   if (num_wepkeys < 1)
  2875.     return;
  2876.   if (wep_keys)
  2877.     g_free(wep_keys);
  2878.   if (wep_keylens)
  2879.     g_free(wep_keylens);
  2880.   wep_keys = g_malloc(num_wepkeys * sizeof(guint8*));
  2881.   wep_keylens = g_malloc(num_wepkeys * sizeof(int));
  2882.   bytes = g_byte_array_new();
  2883.   for (i = 0 ; i < num_wepkeys; i++) {
  2884.     wep_keys[i] = NULL;
  2885.     wep_keylens[i] = 0;
  2886. #ifdef USE_ENV
  2887.     sprintf(buf, "ETHEREAL_WEPKEY%d", i+1);
  2888.     tmp = getenv(buf);
  2889. #else
  2890.     tmp = wep_keystr[i];
  2891. #endif
  2892.     if (tmp) {
  2893. #if 0
  2894. #ifdef USE_ENV
  2895.       printf("%s -- %sn", buf, tmp);
  2896. #else
  2897.       printf("%d -- %sn", i+1, tmp);
  2898. #endif
  2899. #endif
  2900.       if (wep_keys[i]) {
  2901. g_free(wep_keys[i]);
  2902.       }
  2903.       res = hex_str_to_bytes(tmp, bytes, FALSE);
  2904.       if (res && bytes->len > 0) {
  2905.         if (bytes->len > 32) {
  2906.   bytes->len = 32;
  2907. }
  2908. wep_keys[i] = g_malloc(32 * sizeof(guint8));
  2909. memset(wep_keys[i], 0, 32 * sizeof(guint8));
  2910. memcpy(wep_keys[i], bytes->data, bytes->len * sizeof(guint8));
  2911. wep_keylens[i] = bytes->len;
  2912. #if 0
  2913. printf("%d: %d bytesn", i, bytes->len);
  2914. printf("%d: %sn", i, bytes_to_str(bytes->data, bytes->len));
  2915. #endif
  2916.       } else {
  2917. #if 0
  2918. printf("res: %d  bytes->len: %dn", res, bytes->len);
  2919. #endif
  2920.         g_warning("Could not parse WEP key %d: %s", i + 1, tmp);
  2921.       }
  2922.     }
  2923.   }
  2924.   g_byte_array_free(bytes, TRUE);
  2925. }
  2926. /*
  2927.  * This code had been taken from AirSnort crack.c function classify()
  2928.  * Permission granted by snax <at> shmoo dot com
  2929.  * weak_iv - determine which key byte an iv is useful in resolving
  2930.  * parm     - p, pointer to the first byte of an IV
  2931.  * return   -  n - this IV is weak for byte n of a WEP key
  2932.  *            -1 - this IV is not weak for any key bytes
  2933.  *
  2934.  * This function tests for IVs that are known to satisfy the criteria
  2935.  * for a weak IV as specified in FMS section 7.1
  2936.  *
  2937.  */
  2938. static int
  2939. weak_iv(guchar *iv)
  2940. {
  2941.         guchar sum, k;
  2942.         if (iv[1] == 255 && iv[0] > 2 && iv[0] < 16) {
  2943.                 return iv[0] -3;
  2944.         }
  2945.         sum = iv[0] + iv[1];
  2946.         if (sum == 1) {
  2947.                 if (iv[2] <= 0x0a) {
  2948.                         return iv[2] +2;
  2949.                 }
  2950.                 else if (iv[2] == 0xff){
  2951.                         return 0;
  2952.                 }
  2953.         }
  2954.         k = 0xfe - iv[2];
  2955.         if (sum == k  && (iv[2] >= 0xf2 && iv[2] <= 0xfe && iv[2] != 0xfd)){
  2956.                 return k;
  2957.         }
  2958.         return -1;
  2959. }