static int
dissect_trailer_extn(proto_tree *ltp_tree, tvbuff_t *tvb,int frame_offset,int trl_extn_cnt){
guint8 extn_type[LTP_MAX_TRL_EXTN];
guint64 length[LTP_MAX_TRL_EXTN];
guint64 value[LTP_MAX_TRL_EXTN];
int length_size[LTP_MAX_TRL_EXTN];
int value_size[LTP_MAX_TRL_EXTN];
int i;
int extn_offset = 0;
proto_item *ltp_trl_extn_item;
proto_tree *ltp_trl_extn_tree;
DISSECTOR_ASSERT(trl_extn_cnt < LTP_MAX_TRL_EXTN);
for(i = 0; i < trl_extn_cnt; i++){
extn_type[i] = tvb_get_guint8(tvb,frame_offset);
extn_offset++;
if((unsigned)(frame_offset + extn_offset) >= tvb_length(tvb)){
return 0;
}
length[i] = evaluate_sdnv_64(tvb,frame_offset,&length_size[i]);
extn_offset += length_size[i];
if((unsigned)(frame_offset + extn_offset) >= tvb_length(tvb)){
return 0;
}
value[i] = evaluate_sdnv_64(tvb,frame_offset,&value_size[i]);
extn_offset += value_size[i];
if((unsigned)(frame_offset + extn_offset) >= tvb_length(tvb)){
return 0;
}
}
ltp_trl_extn_item = proto_tree_add_text(ltp_tree, tvb,frame_offset, extn_offset, "Header Extension");
ltp_trl_extn_tree = proto_item_add_subtree(ltp_trl_extn_item, ett_trl_extn);
for(i = 0; i < trl_extn_cnt; i++){
proto_tree_add_uint_format_value(ltp_trl_extn_tree, hf_ltp_trl_extn_tag, tvb, frame_offset, 1, extn_type[i], "%x (%s)", extn_type[i], val_to_str(extn_type[i],extn_tag_codes,"Unassigned/Reserved"));
proto_tree_add_uint64_format(ltp_trl_extn_tree, hf_ltp_trl_extn_len, tvb, frame_offset, length_size[i], length[i], "Length [%d]: %"G_GINT64_MODIFIER"d",i+1,length[i]);
frame_offset += length_size[i];
proto_tree_add_uint64_format(ltp_trl_extn_tree, hf_ltp_trl_extn_val, tvb, frame_offset, value_size[i], value[i], "Value [%d]: %"G_GINT64_MODIFIER"d",i+0,value[i]);
frame_offset += value_size[i];
}
return extn_offset;
}
static int
dissect_header_extn(proto_tree *ltp_tree, tvbuff_t *tvb,int frame_offset,int hdr_extn_cnt){
guint8 extn_type[LTP_MAX_HDR_EXTN];
guint64 length[LTP_MAX_HDR_EXTN];
guint64 value[LTP_MAX_HDR_EXTN];
int length_size[LTP_MAX_HDR_EXTN];
int value_size[LTP_MAX_HDR_EXTN];
int i;
int extn_offset = 0;
proto_tree *ltp_hdr_extn_tree;
/* There can be more than one header extensions */
for(i = 0; i < hdr_extn_cnt; i++){
extn_type[i] = tvb_get_guint8(tvb,frame_offset);
extn_offset++;
if((unsigned)(frame_offset + extn_offset) >= tvb_captured_length(tvb)){
return 0;
}
length[i] = evaluate_sdnv_64(tvb,frame_offset,&length_size[i]);
extn_offset += length_size[i];
if((unsigned)(frame_offset + extn_offset) >= tvb_captured_length(tvb)){
return 0;
}
value[i] = evaluate_sdnv_64(tvb,frame_offset,&value_size[i]);
extn_offset += value_size[i];
if((unsigned)(frame_offset + extn_offset) >= tvb_captured_length(tvb)){
return 0;
}
}
ltp_hdr_extn_tree = proto_tree_add_subtree(ltp_tree, tvb,frame_offset, extn_offset, ett_hdr_extn, NULL, "Header Extension");
for(i = 0; i < hdr_extn_cnt; i++){
proto_tree_add_uint_format_value(ltp_hdr_extn_tree, hf_ltp_hdr_extn_tag, tvb, frame_offset, 1, extn_type[i], "%x (%s)", extn_type[i], val_to_str_const(extn_type[i],extn_tag_codes,"Unassigned/Reserved"));
proto_tree_add_uint64_format(ltp_hdr_extn_tree, hf_ltp_hdr_extn_len, tvb, frame_offset, length_size[i],length[i], "Length [%d]: %"G_GINT64_MODIFIER"d",i+1,length[i]);
frame_offset += length_size[i];
proto_tree_add_uint64_format(ltp_hdr_extn_tree, hf_ltp_hdr_extn_val, tvb, frame_offset, value_size[i],value[i], "Value [%d]: %"G_GINT64_MODIFIER"d",i+1,value[i]);
frame_offset += value_size[i];
}
return extn_offset;
}
/*
* Dissect 802.11 with a variable-length link-layer header and a pseudo-
* header containing radio information.
*/
static void
dissect_radio (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
{
proto_item *ti = NULL;
proto_tree *radio_tree = NULL;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Radio");
col_clear(pinfo->cinfo, COL_INFO);
/* Add the radio information to the column information */
col_add_fstr(pinfo->cinfo, COL_TX_RATE, "%u.%u",
pinfo->pseudo_header->ieee_802_11.data_rate / 2,
pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
/*
* For tagged Peek files, this is presumably signal strength as a
* percentage of the maximum, as it is for classic Peek files,
* i.e. (RXVECTOR RSSI/RXVECTOR RSSI_Max)*100, or, at least, that's
* what I infer it is, given what the WildPackets note "Converting
* Signal Strength Percentage to dBm Values" says.
*
* It also says that the conversion the percentage to a dBm value is
* an adapter-dependent process, so, as we don't know what type of
* adapter was used to do the capture, we can't do the conversion.
*
* It's *probably* something similar for other capture file formats.
*/
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u%%",
pinfo->pseudo_header->ieee_802_11.signal_level);
if (tree) {
ti = proto_tree_add_item(tree, proto_radio, tvb, 0, 0, ENC_NA);
radio_tree = proto_item_add_subtree (ti, ett_radio);
proto_tree_add_uint64_format(radio_tree, hf_data_rate, tvb, 0, 0,
(guint64)pinfo->pseudo_header->ieee_802_11.data_rate * 500000,
"Data Rate: %u.%u Mb/s",
pinfo->pseudo_header->ieee_802_11.data_rate / 2,
pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
proto_tree_add_uint(radio_tree, hf_channel, tvb, 0, 0,
pinfo->pseudo_header->ieee_802_11.channel);
proto_tree_add_uint_format(radio_tree, hf_signal_strength, tvb, 0, 0,
pinfo->pseudo_header->ieee_802_11.signal_level,
"Signal Strength: %u%%",
pinfo->pseudo_header->ieee_802_11.signal_level);
}
/* dissect the 802.11 header next */
pinfo->current_proto = "IEEE 802.11";
call_dissector(ieee80211_handle, tvb, pinfo, tree);
}
static int
dissect_trailer_extn(proto_tree *ltp_tree, tvbuff_t *tvb,int frame_offset,int trl_extn_cnt){
guint8 extn_type[LTP_MAX_TRL_EXTN];
gint64 length[LTP_MAX_TRL_EXTN];
int length_size[LTP_MAX_TRL_EXTN];
int i;
int extn_offset = 0;
proto_tree *ltp_trl_extn_tree;
DISSECTOR_ASSERT(trl_extn_cnt < LTP_MAX_TRL_EXTN);
for(i = 0; i < trl_extn_cnt; i++){
extn_type[i] = tvb_get_guint8(tvb,frame_offset);
extn_offset++;
if((unsigned)(frame_offset + extn_offset) >= tvb_captured_length(tvb)){
return 0;
}
length[i] = evaluate_sdnv_64(tvb,frame_offset+1,&length_size[i]);
extn_offset += length_size[i];
if((guint64)(frame_offset + extn_offset + length_size[i] + length[i]) >= tvb_captured_length(tvb)){
return 0;
}
/* From RFC-5326, the total length of the Trailer Extension Tree will be length of the following:
a) Extension type length (1 byte)
b) The length of the 'length' field (as defined by the SDNV which handles dynamic size)
c) The length of the value field which is the decoded length */
extn_offset += (int)length[i];
}
ltp_trl_extn_tree = proto_tree_add_subtree(ltp_tree, tvb,frame_offset, extn_offset, ett_trl_extn, NULL, "Trailer Extension");
for(i = 0; i < trl_extn_cnt; i++){
proto_tree_add_uint_format_value(ltp_trl_extn_tree, hf_ltp_trl_extn_tag, tvb, frame_offset, 1, extn_type[i], "%x (%s)", extn_type[i], val_to_str_const(extn_type[i],extn_tag_codes,"Unassigned/Reserved"));
frame_offset += 1;
proto_tree_add_uint64_format(ltp_trl_extn_tree, hf_ltp_trl_extn_len, tvb, frame_offset, length_size[i], length[i], "Length [%d]: %"G_GINT64_MODIFIER"d",i+1,length[i]);
frame_offset += length_size[i];
proto_tree_add_item (ltp_trl_extn_tree, hf_ltp_trl_extn_val, tvb, frame_offset, (int)length[i], ENC_NA);
frame_offset += (int)length[i];
}
return extn_offset;
}
static void
dissect_airopeek(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *airopeek_tree = NULL;
proto_item *ti;
guint8 data_rate;
guint8 signal_level;
tvbuff_t *next_tvb;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "AiroPeek");
col_clear(pinfo->cinfo, COL_INFO);
/* Dissect the header */
if (tree) {
ti = proto_tree_add_item(tree, proto_airopeek, tvb, 0, 4, ENC_NA);
airopeek_tree = proto_item_add_subtree(ti, ett_airopeek);
}
data_rate = tvb_get_guint8(tvb, 0);
/* Add the radio information to the column information */
col_add_fstr(pinfo->cinfo, COL_TX_RATE, "%u.%u",
data_rate / 2,
data_rate & 1 ? 5 : 0);
if (tree) {
proto_tree_add_uint64_format(airopeek_tree, hf_data_rate, tvb, 0, 1,
(guint64)data_rate * 500000,
"Data Rate: %u.%u Mb/s",
data_rate / 2,
data_rate & 1 ? 5 : 0);
}
if (tree)
proto_tree_add_item(airopeek_tree, hf_channel, tvb, 1, 1, ENC_NA);
signal_level = tvb_get_guint8(tvb, 2);
/* XX - this is a percentage, not a dBm or normalized or raw RSSI */
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u", signal_level);
if (tree) {
proto_tree_add_uint_format(airopeek_tree, hf_signal_strength, tvb, 2, 1,
signal_level,
"Signal Strength: %u%%",
signal_level);
}
/* dissect the 802.11 header next */
pinfo->current_proto = "IEEE 802.11";
next_tvb = tvb_new_subset_remaining(tvb, 4);
call_dissector(ieee80211_handle, next_tvb, pinfo, tree);
}
/*
* Dissect 802.11 with a variable-length link-layer header and a pseudo-
* header containing radio information.
*/
static void
dissect_radio (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
{
proto_item *ti = NULL;
proto_tree *radio_tree = NULL;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Radio");
col_clear(pinfo->cinfo, COL_INFO);
/* Add the radio information to the column information */
col_add_fstr(pinfo->cinfo, COL_TX_RATE, "%u.%u",
pinfo->pseudo_header->ieee_802_11.data_rate / 2,
pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
/* XX - this is a percentage, not a dBm or normalized or raw RSSI */
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u",
pinfo->pseudo_header->ieee_802_11.signal_level);
if (tree) {
ti = proto_tree_add_item(tree, proto_radio, tvb, 0, 0, ENC_NA);
radio_tree = proto_item_add_subtree (ti, ett_radio);
proto_tree_add_uint64_format(radio_tree, hf_data_rate, tvb, 0, 0,
(guint64)pinfo->pseudo_header->ieee_802_11.data_rate * 500000,
"Data Rate: %u.%u Mb/s",
pinfo->pseudo_header->ieee_802_11.data_rate / 2,
pinfo->pseudo_header->ieee_802_11.data_rate & 1 ? 5 : 0);
proto_tree_add_uint(radio_tree, hf_channel, tvb, 0, 0,
pinfo->pseudo_header->ieee_802_11.channel);
proto_tree_add_uint_format(radio_tree, hf_signal_strength, tvb, 0, 0,
pinfo->pseudo_header->ieee_802_11.signal_level,
"Signal Strength: %u%%",
pinfo->pseudo_header->ieee_802_11.signal_level);
}
/* dissect the 802.11 header next */
pinfo->current_proto = "IEEE 802.11";
call_dissector(ieee80211_handle, tvb, pinfo, tree);
}
static int
dissect_report_segment(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ltp_tree, int frame_offset) {
guint64 rpt_sno;
guint64 chkp_sno;
guint64 upper_bound;
guint64 lower_bound;
int rcpt_clm_cnt;
guint64 offset;
guint64 length;
int rpt_sno_size;
int chkp_sno_size;
int upper_bound_size;
int lower_bound_size;
int rcpt_clm_cnt_size;
int offset_size;
int length_size;
int segment_offset = 0;
int i;
proto_item *ltp_rpt_item;
proto_item *ltp_rpt_clm_item;
proto_tree *ltp_rpt_tree;
proto_tree *ltp_rpt_clm_tree;
/* Create the subtree for report segment under the main LTP tree and all the report segment fields under it */
ltp_rpt_item = proto_tree_add_text(ltp_tree, tvb, frame_offset, -1, "Report Segment");
ltp_rpt_tree = proto_item_add_subtree(ltp_rpt_item, ett_rpt_segm);
/* Extract the report segment info */
rpt_sno = evaluate_sdnv_64(tvb, frame_offset, &rpt_sno_size);
proto_tree_add_uint64(ltp_rpt_tree, hf_ltp_rpt_sno, tvb, frame_offset + segment_offset, rpt_sno_size, rpt_sno);
segment_offset += rpt_sno_size;
chkp_sno = evaluate_sdnv_64(tvb, frame_offset + segment_offset, &chkp_sno_size);
proto_tree_add_uint64(ltp_rpt_tree, hf_ltp_rpt_chkp, tvb, frame_offset + segment_offset, chkp_sno_size, chkp_sno);
segment_offset += chkp_sno_size;
upper_bound = evaluate_sdnv(tvb, frame_offset + segment_offset, &upper_bound_size);
proto_tree_add_uint64(ltp_rpt_tree, hf_ltp_rpt_ub, tvb, frame_offset + segment_offset, upper_bound_size, upper_bound);
segment_offset += upper_bound_size;
lower_bound = evaluate_sdnv(tvb, frame_offset + segment_offset, &lower_bound_size);
proto_tree_add_uint64(ltp_rpt_tree, hf_ltp_rpt_lb, tvb, frame_offset + segment_offset, lower_bound_size, lower_bound);
segment_offset += lower_bound_size;
rcpt_clm_cnt = evaluate_sdnv(tvb, frame_offset + segment_offset, &rcpt_clm_cnt_size);
if (rcpt_clm_cnt < 0){
proto_item_set_end(ltp_rpt_item, tvb, frame_offset + segment_offset);
expert_add_info_format(pinfo, ltp_tree, PI_UNDECODED, PI_ERROR, "Negative reception claim count: %d", rcpt_clm_cnt);
return 0;
}
/* Each reception claim is at least 2 bytes, so if the count is larger than the
* max number of claims we can possibly squeeze into the remaining tvbuff, then
* the packet is malformed.
*/
if (rcpt_clm_cnt > tvb_length_remaining(tvb, frame_offset + segment_offset) / 2) {
proto_item_set_end(ltp_rpt_item, tvb, frame_offset + segment_offset);
expert_add_info_format(pinfo, ltp_tree, PI_MALFORMED, PI_ERROR,
"Reception claim count impossibly large: %d > %d", rcpt_clm_cnt,
tvb_length_remaining(tvb, frame_offset + segment_offset) / 2);
return 0;
}
proto_tree_add_uint(ltp_rpt_tree, hf_ltp_rpt_clm_cnt, tvb, frame_offset + segment_offset, rcpt_clm_cnt_size, rcpt_clm_cnt);
segment_offset += rcpt_clm_cnt_size;
ltp_rpt_clm_item = proto_tree_add_text(ltp_rpt_tree, tvb, frame_offset + segment_offset, -1, "Reception claims");
ltp_rpt_clm_tree = proto_item_add_subtree(ltp_rpt_clm_item, ett_rpt_clm);
/* There can be multiple reception claims in the same report segment */
for(i = 0; i<rcpt_clm_cnt; i++){
offset = evaluate_sdnv(tvb,frame_offset + segment_offset, &offset_size);
proto_tree_add_uint64_format(ltp_rpt_clm_tree, hf_ltp_rpt_clm_off, tvb, frame_offset + segment_offset, offset_size, offset,
"Offset[%d] : %"G_GINT64_MODIFIER"d", i, offset);
segment_offset += offset_size;
length = evaluate_sdnv(tvb,frame_offset + segment_offset, &length_size);
proto_tree_add_uint64_format(ltp_rpt_clm_tree, hf_ltp_rpt_clm_len, tvb, frame_offset + segment_offset, length_size, length,
"Length[%d] : %"G_GINT64_MODIFIER"d",i, length);
segment_offset += length_size;
}
proto_item_set_end(ltp_rpt_clm_item, tvb, frame_offset + segment_offset);
proto_item_set_end(ltp_rpt_item, tvb, frame_offset + segment_offset);
return segment_offset;
}
static void
dissect_wlancap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *wlan_tree = NULL;
proto_item *ti;
tvbuff_t *next_tvb;
int offset;
guint32 version;
guint32 length;
guint32 channel;
guint32 datarate;
guint32 ssi_type;
guint32 antnoise;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "WLAN");
col_clear(pinfo->cinfo, COL_INFO);
offset = 0;
version = tvb_get_ntohl(tvb, offset) - WLANCAP_MAGIC_COOKIE_BASE;
length = tvb_get_ntohl(tvb, offset+4);
col_add_fstr(pinfo->cinfo, COL_INFO, "AVS WLAN Capture v%x, Length %d",version, length);
if (version > 2) {
goto skip;
}
/* Dissect the AVS header */
if (tree) {
ti = proto_tree_add_item(tree, proto_wlancap, tvb, 0, length, ENC_NA);
wlan_tree = proto_item_add_subtree(ti, ett_radio);
proto_tree_add_item(wlan_tree, hf_wlan_magic, tvb, offset, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(wlan_tree, hf_wlan_version, tvb, offset, 4, ENC_BIG_ENDIAN);
}
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_length, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_mactime, tvb, offset, 8, ENC_BIG_ENDIAN);
offset+=8;
if (tree)
proto_tree_add_item(wlan_tree, hf_hosttime, tvb, offset, 8, ENC_BIG_ENDIAN);
offset+=8;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_phytype, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
/* XXX cook channel (fh uses different numbers) */
channel = tvb_get_ntohl(tvb, offset);
if (channel < 256) {
col_add_fstr(pinfo->cinfo, COL_FREQ_CHAN, "%u", channel);
if (tree)
proto_tree_add_uint(wlan_tree, hf_channel, tvb, offset, 4, channel);
} else if (channel < 10000) {
col_add_fstr(pinfo->cinfo, COL_FREQ_CHAN, "%u MHz", channel);
if (tree)
proto_tree_add_uint_format(wlan_tree, hf_channel_frequency, tvb, offset,
4, channel, "Frequency: %u MHz", channel);
} else {
col_add_fstr(pinfo->cinfo, COL_FREQ_CHAN, "%u KHz", channel);
if (tree)
proto_tree_add_uint_format(wlan_tree, hf_channel_frequency, tvb, offset,
4, channel, "Frequency: %u KHz", channel);
}
offset+=4;
datarate = tvb_get_ntohl(tvb, offset);
if (datarate < 100000) {
/* In units of 100 Kb/s; convert to b/s */
datarate *= 100000;
}
col_add_fstr(pinfo->cinfo, COL_TX_RATE, "%u.%u",
datarate / 1000000,
((datarate % 1000000) > 500000) ? 5 : 0);
if (tree) {
proto_tree_add_uint64_format(wlan_tree, hf_data_rate, tvb, offset, 4,
datarate,
"Data Rate: %u.%u Mb/s",
datarate/1000000,
((datarate % 1000000) > 500000) ? 5 : 0);
}
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_antenna, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_priority, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
ssi_type = tvb_get_ntohl(tvb, offset);
if (tree)
proto_tree_add_uint(wlan_tree, hf_wlan_ssi_type, tvb, offset, 4, ssi_type);
offset+=4;
switch (ssi_type) {
case SSI_NONE:
default:
/* either there is no SSI information, or we don't know what type it is */
break;
case SSI_NORM_RSSI:
/* Normalized RSSI */
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u (norm)", tvb_get_ntohl(tvb, offset));
if (tree)
proto_tree_add_item(wlan_tree, hf_normrssi_antsignal, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
case SSI_DBM:
/* dBm */
col_add_fstr(pinfo->cinfo, COL_RSSI, "%d dBm", tvb_get_ntohl(tvb, offset));
if (tree)
proto_tree_add_item(wlan_tree, hf_dbm_antsignal, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
case SSI_RAW_RSSI:
/* Raw RSSI */
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u (raw)", tvb_get_ntohl(tvb, offset));
if (tree)
proto_tree_add_item(wlan_tree, hf_rawrssi_antsignal, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
}
offset+=4;
antnoise = tvb_get_ntohl(tvb, offset);
/* 0xffffffff means "hardware does not provide noise data" */
if (antnoise != 0xffffffff) {
switch (ssi_type) {
case SSI_NONE:
default:
/* either there is no SSI information, or we don't know what type it is */
break;
case SSI_NORM_RSSI:
/* Normalized RSSI */
if (tree)
proto_tree_add_uint(wlan_tree, hf_normrssi_antnoise, tvb, offset, 4, antnoise);
break;
case SSI_DBM:
/* dBm */
if (tree)
proto_tree_add_int(wlan_tree, hf_dbm_antnoise, tvb, offset, 4, antnoise);
break;
case SSI_RAW_RSSI:
/* Raw RSSI */
if (tree)
proto_tree_add_uint(wlan_tree, hf_rawrssi_antnoise, tvb, offset, 4, antnoise);
break;
}
}
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_preamble, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_encoding, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (version > 1) {
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_sequence, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_drops, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_receiver_addr, tvb, offset, 6, ENC_NA);
offset+=6;
if (tree)
proto_tree_add_item(wlan_tree, hf_wlan_padding, tvb, offset, 2, ENC_NA);
offset+=2;
}
skip:
offset = length;
/* dissect the 802.11 header next */
next_tvb = tvb_new_subset_remaining(tvb, offset);
call_dissector(ieee80211_handle, next_tvb, pinfo, tree);
}
