static void
dissect_npmp_add_flow_message(tvbuff_t *message_tvb, proto_tree *message_tree)
{
guint32 retranstrials;
proto_item* onoffitem;
proto_tree* onofftree;
guint16 onoffevents;
guint32 onoffvalue;
unsigned int i;
ADD_FIELD_UINT(message_tree, addflow_flowid);
ADD_FIELD_UINT(message_tree, addflow_measurementid);
ADD_FIELD_UINT(message_tree, addflow_streamid);
ADD_FIELD_UINT(message_tree, addflow_protocol);
ADD_FIELD_UINT(message_tree, addflow_flags);
ADD_FIELD_STRING(message_tree, addflow_description);
proto_tree_add_double_format_value(message_tree, hf_addflow_ordered, message_tvb, offset_addflow_ordered, length_addflow_ordered,
100.0 * tvb_get_ntohl(message_tvb, offset_addflow_ordered) / (double)0xffffffff, "%1.3f%%",
100.0 * tvb_get_ntohl(message_tvb, offset_addflow_ordered) / (double)0xffffffff);
proto_tree_add_double_format_value(message_tree, hf_addflow_reliable, message_tvb, offset_addflow_reliable, length_addflow_reliable,
100.0 * tvb_get_ntohl(message_tvb, offset_addflow_reliable) / (double)0xffffffff, "%1.3f%%",
100.0 * tvb_get_ntohl(message_tvb, offset_addflow_reliable) / (double)0xffffffff);
retranstrials = tvb_get_ntohl(message_tvb, offset_addflow_retranstrials);
proto_tree_add_uint_format_value(message_tree, hf_addflow_retranstrials, message_tvb, offset_addflow_retranstrials, length_addflow_retranstrials,
retranstrials, (retranstrials & (1 << 31)) ? "%u ms" : "%u trials",
retranstrials &~ (1 << 31));
ADD_FIELD_UINT(message_tree, addflow_frameraterng);
ADD_FIELD_UINT(message_tree, addflow_framerate1);
ADD_FIELD_UINT(message_tree, addflow_framerate2);
ADD_FIELD_UINT(message_tree, addflow_framerate3);
ADD_FIELD_UINT(message_tree, addflow_framerate4);
ADD_FIELD_UINT(message_tree, addflow_framesizerng);
ADD_FIELD_UINT(message_tree, addflow_framesize1);
ADD_FIELD_UINT(message_tree, addflow_framesize2);
ADD_FIELD_UINT(message_tree, addflow_framesize3);
ADD_FIELD_UINT(message_tree, addflow_framesize4);
ADD_FIELD_UINT(message_tree, addflow_rcvbuffersize);
ADD_FIELD_UINT(message_tree, addflow_sndbuffersize);
ADD_FIELD_UINT(message_tree, addflow_maxmsgsize);
ADD_FIELD_UINT(message_tree, addflow_cmt);
ADD_FIELD_UINT(message_tree, addflow_ccid);
onoffitem = ADD_FIELD_UINT(message_tree, addflow_onoffevents);
onoffevents = tvb_get_ntohs(message_tvb, offset_addflow_onoffevents);
if (onoffevents > 0) {
onofftree = proto_item_add_subtree(onoffitem, ett_onoffarray);
for(i = 0;i < onoffevents;i++) {
onoffvalue = tvb_get_ntohl(message_tvb, offset_addflow_onoffeventarray + (int)(sizeof(guint32) * i));
proto_tree_add_uint_format(onofftree, hf_addflow_onoffeventarray, message_tvb,
offset_addflow_onoffeventarray + (int)(sizeof(guint32) * i), (int)sizeof(guint32),
onoffvalue, "%1.3f s: set to %s", onoffvalue / 1000.0, (i & 1) ? "OFF" : "ON");
}
}
}
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_value(airopeek_tree, hf_data_rate, tvb, 0, 1,
(guint64)data_rate * 500000,
"%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);
/*
* This is signal strength as a percentage of the maximum, 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.
*/
col_add_fstr(pinfo->cinfo, COL_RSSI, "%u%%", signal_level);
proto_tree_add_uint_format_value(airopeek_tree, hf_signal_strength, tvb, 2, 1,
signal_level,
"%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);
}
static void
esis_dissect_redirect_pdu( guint8 len, tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo) {
int offset = 0;
int tmpl = 0;
proto_tree *dest_tree, *subnet_tree, *network_tree;
offset += ESIS_HDR_FIXED_LENGTH;
tmpl = (int) tvb_get_guint8(tvb, offset);
dest_tree = proto_tree_add_subtree( tree, tvb, offset, tmpl + 1, ett_esis_dest_addr, NULL,
"### Destination Address Section ###" );
proto_tree_add_uint_format_value(dest_tree, hf_esis_dal, tvb, offset++, 1, tmpl, "%2u Octets", tmpl);
proto_tree_add_string( dest_tree, hf_esis_da, tvb, offset, tmpl,
print_nsap_net( tvb, offset, tmpl ) );
offset += tmpl;
len -= ( tmpl + 1 );
tmpl = (int) tvb_get_guint8(tvb, offset);
subnet_tree = proto_tree_add_subtree( tree, tvb, offset, tmpl + 1, ett_esis_subnetwork, NULL,
"### Subnetwork Address Section ###");
proto_tree_add_uint_format_value(subnet_tree, hf_esis_bsnpal, tvb, offset++, 1, tmpl, "%2u Octets", tmpl);
proto_tree_add_item(subnet_tree, hf_esis_bsnpa, tvb, offset, tmpl, ENC_NA);
offset += tmpl;
len -= ( tmpl + 1 );
tmpl = (int) tvb_get_guint8(tvb, offset);
if ( 0 == tmpl ) {
network_tree = proto_tree_add_subtree( tree, tvb, offset, 1, ett_esis_network, NULL,
"### No Network Entity Title Section ###" );
offset++;
len--;
}
else {
network_tree = proto_tree_add_subtree( tree, tvb, offset, 1, ett_esis_network, NULL,
"### Network Entity Title Section ###" );
proto_tree_add_uint_format_value(network_tree, hf_esis_netl, tvb, offset++, 1, tmpl, "%2u Octets", tmpl );
proto_tree_add_string( network_tree, hf_esis_net, tvb, offset, tmpl,
print_nsap_net( tvb, offset, tmpl ) );
offset += tmpl;
len -= ( tmpl + 1 );
}
dissect_osi_options( len, tvb, offset, network_tree, pinfo );
}
static void
dissect_idp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *idp_tree = NULL;
proto_item *ti = NULL;
guint16 length;
guint8 type;
tvbuff_t *next_tvb;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IDP");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
ti = proto_tree_add_item(tree, proto_idp, tvb, 0, IDP_HEADER_LEN, ENC_NA);
idp_tree = proto_item_add_subtree(ti, ett_idp);
}
proto_tree_add_item(idp_tree, hf_idp_checksum, tvb, 0, 2, ENC_BIG_ENDIAN);
length = tvb_get_ntohs(tvb, 2);
proto_tree_add_uint_format_value(idp_tree, hf_idp_len, tvb, 2, 2, length,
"%u bytes", length);
/* Adjust the tvbuff length to include only the IDP datagram. */
set_actual_length(tvb, length);
proto_tree_add_item(idp_tree, hf_idp_hops, tvb, 4, 1, ENC_BIG_ENDIAN);
type = tvb_get_guint8(tvb, 5);
proto_tree_add_uint(idp_tree, hf_idp_packet_type, tvb, 5, 1, type);
pinfo->ptype = PT_IDP;
/* Destination */
proto_tree_add_item(idp_tree, hf_idp_dnet, tvb, 6, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(idp_tree, hf_idp_dnode, tvb, 10, 6, ENC_NA);
pinfo->destport = tvb_get_ntohs(tvb, 16);
proto_tree_add_uint(idp_tree, hf_idp_dsocket, tvb, 16, 2,
pinfo->destport);
/* Source */
proto_tree_add_item(idp_tree, hf_idp_snet, tvb, 18, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(idp_tree, hf_idp_snode, tvb, 22, 6, ENC_NA);
pinfo->srcport = tvb_get_ntohs(tvb, 28);
proto_tree_add_uint(idp_tree, hf_idp_ssocket, tvb, 28, 2,
pinfo->srcport);
/* Make the next tvbuff */
next_tvb = tvb_new_subset_remaining(tvb, IDP_HEADER_LEN);
/*
* Hand off to the dissector for the packet type.
*/
if (dissector_try_uint(idp_type_dissector_table, type, next_tvb,
pinfo, tree))
return;
call_dissector(data_handle, next_tvb, pinfo, tree);
}
/* Get SEL Entry
*/
static void
rq43(tvbuff_t *tvb, proto_tree *tree)
{
guint8 v = tvb_get_guint8(tvb, 5);
proto_tree_add_item(tree, hf_ipmi_stor_43_rsrv_id, tvb, 0, 2, TRUE);
proto_tree_add_item(tree, hf_ipmi_stor_43_rec_id, tvb, 2, 2, TRUE);
proto_tree_add_item(tree, hf_ipmi_stor_43_offset, tvb, 4, 1, TRUE);
proto_tree_add_uint_format_value(tree, hf_ipmi_stor_43_count, tvb, 5, 1,
v, "%d%s", v, v == 0xff ? " (entire record)" : "");
}
void
nvme_publish_qid(proto_tree *tree, int field_index, guint16 qid)
{
proto_item *cmd_ref_item;
cmd_ref_item = proto_tree_add_uint_format_value(tree, field_index, NULL,
0, 0, qid,
qid ? "%d (IOQ)" : "%d (AQ)",
qid);
proto_item_set_generated(cmd_ref_item);
}
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 void dissect_auto_rp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint8 ver_type, rp_count;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Auto-RP");
col_clear(pinfo->cinfo, COL_INFO);
ver_type = tvb_get_guint8(tvb, 0);
rp_count = tvb_get_guint8(tvb, 1);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s (v%s) for %u RP%s",
val_to_str(lo_nibble(ver_type), auto_rp_type_vals, "Unknown"),
val_to_str(hi_nibble(ver_type), auto_rp_ver_vals, "Unknown"),
rp_count, plurality(rp_count, "", "s"));
if (tree) {
proto_item *ti, *tv;
proto_tree *auto_rp_tree, *ver_type_tree;
int i, offset;
guint16 holdtime;
offset = 0;
ti = proto_tree_add_item(tree, proto_auto_rp, tvb, offset, -1, FALSE);
auto_rp_tree = proto_item_add_subtree(ti, ett_auto_rp);
tv = proto_tree_add_text(auto_rp_tree, tvb, offset, 1, "Version: %s, Packet type: %s",
val_to_str(hi_nibble(ver_type), auto_rp_ver_vals, "Unknown"),
val_to_str(lo_nibble(ver_type), auto_rp_type_vals, "Unknown"));
ver_type_tree = proto_item_add_subtree(tv, ett_auto_rp_ver_type);
proto_tree_add_uint(ver_type_tree, hf_auto_rp_version, tvb, offset, 1, ver_type);
proto_tree_add_uint(ver_type_tree, hf_auto_rp_type, tvb, offset, 1, ver_type);
offset++;
proto_tree_add_uint(auto_rp_tree, hf_auto_rp_count, tvb, offset, 1, rp_count);
offset++;
holdtime = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint_format_value(auto_rp_tree, hf_auto_rp_holdtime, tvb, offset, 2, holdtime,
"%u second%s", holdtime, plurality(holdtime, "", "s"));
offset+=2;
proto_tree_add_text(auto_rp_tree, tvb, offset, 4, "Reserved: 0x%x", tvb_get_ntohs(tvb, offset));
offset+=4;
for (i = 0; i < rp_count; i++)
offset = do_auto_rp_map(tvb, offset, auto_rp_tree);
if (tvb_offset_exists(tvb, offset))
proto_tree_add_text(tree, tvb, offset, -1, "Trailing junk");
}
return;
}
static void dissect_auto_rp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint8 ver_type, rp_count;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Auto-RP");
col_clear(pinfo->cinfo, COL_INFO);
ver_type = tvb_get_guint8(tvb, 0);
rp_count = tvb_get_guint8(tvb, 1);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s (v%s) for %u RP%s",
val_to_str_const(lo_nibble(ver_type), auto_rp_type_vals, "Unknown"),
val_to_str_const(hi_nibble(ver_type), auto_rp_ver_vals, "Unknown"),
rp_count, plurality(rp_count, "", "s"));
if (tree) {
proto_item *ti;
proto_tree *auto_rp_tree, *ver_type_tree;
int i, offset;
guint16 holdtime;
offset = 0;
ti = proto_tree_add_item(tree, proto_auto_rp, tvb, offset, -1, ENC_NA);
auto_rp_tree = proto_item_add_subtree(ti, ett_auto_rp);
ver_type_tree = proto_tree_add_subtree_format(auto_rp_tree, tvb, offset, 1,
ett_auto_rp_ver_type, NULL, "Version: %s, Packet type: %s",
val_to_str_const(hi_nibble(ver_type), auto_rp_ver_vals, "Unknown"),
val_to_str_const(lo_nibble(ver_type), auto_rp_type_vals, "Unknown"));
proto_tree_add_uint(ver_type_tree, hf_auto_rp_version, tvb, offset, 1, ver_type);
proto_tree_add_uint(ver_type_tree, hf_auto_rp_type, tvb, offset, 1, ver_type);
offset++;
proto_tree_add_uint(auto_rp_tree, hf_auto_rp_count, tvb, offset, 1, rp_count);
offset++;
holdtime = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint_format_value(auto_rp_tree, hf_auto_rp_holdtime, tvb, offset, 2, holdtime,
"%u second%s", holdtime, plurality(holdtime, "", "s"));
offset+=2;
proto_tree_add_item(auto_rp_tree, hf_auto_rp_reserved, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
for (i = 0; i < rp_count; i++)
offset = do_auto_rp_map(tvb, offset, auto_rp_tree);
if (tvb_reported_length_remaining(tvb, offset) > 0)
proto_tree_add_item(tree, hf_auto_rp_trailing_junk, tvb, offset, -1, ENC_NA);
}
return;
}
/*
* 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_value(radio_tree, hf_data_rate, tvb, 0, 0,
(guint64)pinfo->pseudo_header->ieee_802_11.data_rate * 500000,
"%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_value(radio_tree, hf_signal_strength, tvb, 0, 0,
pinfo->pseudo_header->ieee_802_11.signal_level,
"%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 void
add_authval_str(proto_tree *tree, int type, int len, tvbuff_t *tvb, int offset)
{
int val;
switch (type)
{
case IAPP_AUTH_STATUS:
val = tvb_get_guint8(tvb, offset);
proto_tree_add_uint_format_value(tree, hf_iapp_auth_status, tvb, offset, 1, val, "%s", val ? "Authenticated" : "Not authenticated");
break;
case IAPP_AUTH_USERNAME:
case IAPP_AUTH_PROVNAME:
proto_tree_add_item(tree, hf_iapp_auth_string, tvb, offset, 1, ENC_ASCII|ENC_NA);
break;
case IAPP_AUTH_RXPKTS:
case IAPP_AUTH_TXPKTS:
case IAPP_AUTH_RXBYTES:
case IAPP_AUTH_TXBYTES:
case IAPP_AUTH_RXGWORDS:
case IAPP_AUTH_TXGWORDS:
case IAPP_AUTH_VOLLIMIT:
proto_tree_add_item(tree, hf_iapp_auth_uint, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
case IAPP_AUTH_LOGINTIME:
case IAPP_AUTH_TIMELIMIT:
case IAPP_AUTH_ACCCYCLE:
val = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint_format_value(tree, hf_iapp_auth_uint, tvb, offset, 4, val, "%d seconds", val);
break;
case IAPP_AUTH_IPADDR:
proto_tree_add_item(tree, hf_iapp_auth_ipaddr, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
case IAPP_AUTH_TRAILER:
proto_tree_add_item(tree, hf_iapp_auth_trailer, tvb, offset, len, ENC_NA);
break;
}
}
static void
dissect_tcp_tree(tvbuff_t *tvb, packet_info *pinfo, proto_tree *stt_tree)
{
int offset = 0;
proto_tree *tcp_tree;
proto_item *tcp_item, *data_offset_item;
int data_offset;
proto_tree_add_item(stt_tree, hf_stt_stream_id, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(stt_tree, hf_stt_dport, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(stt_tree, hf_stt_pkt_len, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(stt_tree, hf_stt_seg_off, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(stt_tree, hf_stt_pkt_id, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
tcp_item = proto_tree_add_item(stt_tree, hf_stt_tcp_data, tvb, offset,
8, ENC_NA);
tcp_tree = proto_item_add_subtree(tcp_item, ett_stt_tcp_data);
proto_item_set_text(tcp_item, "TCP Data");
data_offset = hi_nibble(tvb_get_guint8(tvb, offset)) * 4;
data_offset_item = proto_tree_add_uint_format_value(tcp_tree,
hf_stt_tcp_data_offset,
tvb, offset, 1,
data_offset,
"%u bytes", data_offset);
if (data_offset != STT_TCP_HDR_LEN) {
expert_add_info(pinfo, data_offset_item, &ei_stt_data_offset_bad);
}
offset = dissect_tcp_flags(tcp_tree, tvb, offset);
proto_tree_add_item(tcp_tree, hf_stt_tcp_window, tvb, offset, 2,
ENC_BIG_ENDIAN);
offset += 2;
dissect_stt_checksum(tvb, pinfo, stt_tree);
offset += 2;
proto_tree_add_item(tcp_tree, hf_stt_tcp_urg_ptr, tvb, offset, 2,
ENC_BIG_ENDIAN);
}
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;
}
void
DDS_Dissector::dissect_transport_header (proto_tree* ltree,
const DCPS::TransportHeader& header,
gint& offset)
{
gint len;
offset += sizeof(header.protocol_) - 2; // skip preamble
// hf_version
len = sizeof(header.protocol_) - offset;
const guint8 *data_ptr =
reinterpret_cast<const guint8*>(header.protocol_ + offset);
proto_tree_add_bytes_format_value (ltree, hf_version, tvb_,
offset, len, data_ptr,
"%d.%d",
header.protocol_[4],
header.protocol_[5]);
offset += len;
// hf_flags
len = sizeof(ACE_CDR::Octet);
proto_tree_add_bitmask(ltree, tvb_, offset, hf_flags, ett_trans_flags,
flags_fields, FALSE);
offset += len;
offset += sizeof(header.reserved_); // skip reserved
// hf_length
len = sizeof(header.length_);
proto_tree_add_uint_format_value(ltree, hf_length, tvb_, offset, len,
header.length_, "%d octets",
header.length_);
offset += len;
// hf_sequence
size_t size = 0, padding = 0;
gen_find_size(header.sequence_, size, padding);
len = static_cast<gint>(size);
proto_tree_add_uint64(ltree, hf_sequence, tvb_, offset, len,
gint64(header.sequence_.getValue()));
offset += len;
// hf_source
len = sizeof(header.source_);
proto_tree_add_uint(ltree, hf_source, tvb_, offset, len,
guint32(header.source_));
offset += len;
}
static int
dissect_cancel_segment(proto_tree * ltp_tree, tvbuff_t *tvb,int frame_offset){
guint8 reason_code;
proto_tree *ltp_cancel_tree;
/* The cancel segment has only one byte, which contains the reason code. */
reason_code = tvb_get_guint8(tvb,frame_offset);
/* Creating tree for the cancel segment */
ltp_cancel_tree = proto_tree_add_subtree(ltp_tree, tvb,frame_offset, 1, ett_session_mgmt, NULL, "Cancel Segment");
proto_tree_add_uint_format_value(ltp_cancel_tree, hf_ltp_cancel_code, tvb, frame_offset, 1, reason_code,
"%x (%s)", reason_code, val_to_str_const(reason_code,ltp_cancel_codes,"Reserved"));
return 1;
}
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_messageid is a utility function which
* calculates the ID of the message.
*
* @see dissect_packetid()
* @see dissect_reliable_message_index_base()
* @see dissect_content_length()
* @see dissect_reliable_message_number()
* @see dissect_payload()
* @param buffer the buffer to the data
* @param offset the offset where to start reading the data
* @param tree the parent tree where the dissected data is going to be inserted
* @return int returns the messageid
*
*/
static int
dissect_messageid(tvbuff_t *buffer, int *offset, proto_tree *tree, packet_info *pinfo, gboolean separator)
{
gint messageid_length;
guint8 messageid;
gboolean col_write;
messageid = tvb_get_guint8(buffer, (*offset));
switch(messageid)
{
case DISCONNECT:
case DISCONNECTACK:
case CONNECTSYN:
case CONNECTSYNACK:
case CONNECTACK:
messageid_length = 4;
break;
default:
messageid_length = 1;
break;
}
proto_tree_add_uint_format_value(tree, hf_knet_messageid, buffer, *offset, messageid_length, messageid,
"%s (%d)", val_to_str_const(messageid, packettypenames, "AppData or Malformed Message ID"), messageid);
/* XXX - TCP reassembly disables writing columns which prevents populating COL_INFO if multiple KNET messages
appear in a single packet that needed to be reassembled.
Force making columns writable.
*/
if (separator)
{
col_write = col_get_writable(pinfo->cinfo);
col_set_writable(pinfo->cinfo, TRUE);
col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ", "%s (%d)", val_to_str_const(messageid, packettypenames, "AppData"), messageid);
col_set_writable(pinfo->cinfo, col_write);
}
else
{
col_append_fstr(pinfo->cinfo, COL_INFO, "%s (%d)", val_to_str_const(messageid, packettypenames, "AppData"), messageid);
}
*offset += messageid_length;
return messageid;
}
static void
dissect_aodv_ext(tvbuff_t * tvb, packet_info *pinfo, int offset, proto_tree * tree)
{
proto_tree *ext_tree;
proto_item *len_item;
guint8 type, len;
again:
if ((int) tvb_reported_length(tvb) <= offset)
return; /* No more options left */
type = tvb_get_guint8(tvb, offset);
len = tvb_get_guint8(tvb, offset + 1);
ext_tree = proto_tree_add_subtree(tree, tvb, offset, 2 + len, ett_aodv_extensions, NULL, "Extensions");
proto_tree_add_item(ext_tree, hf_aodv_ext_type, tvb, offset, 1, ENC_NA);
len_item = proto_tree_add_uint_format_value(ext_tree, hf_aodv_ext_length, tvb, offset + 1, 1,
len, "%u bytes", len);
if (len == 0) {
expert_add_info(pinfo, len_item, &ei_aodv_ext_length);
return; /* we must not try to decode this */
}
offset += 2;
switch (type) {
case AODV_EXT_INT:
proto_tree_add_uint(ext_tree, hf_aodv_ext_interval,
tvb, offset, 4, tvb_get_ntohl(tvb, offset));
break;
case AODV_EXT_NTP:
proto_tree_add_item(ext_tree, hf_aodv_ext_timestamp,
tvb, offset, 8, ENC_BIG_ENDIAN);
break;
default:
break;
}
/* If multifield extensions appear, we need more
* sophisticated handler. For now, this is okay. */
offset += len;
goto again;
}
static void
dissect_status_type_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
guint16 status_type, status_id;
status_type = tvb_get_ntohs(parameter_tvb, STATUS_TYPE_OFFSET);
status_id = tvb_get_ntohs(parameter_tvb, STATUS_IDENT_OFFSET);
proto_tree_add_item(parameter_tree, hf_status_type,
parameter_tvb, STATUS_TYPE_OFFSET, STATUS_TYPE_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_uint_format_value(parameter_tree, hf_status_id, parameter_tvb, STATUS_IDENT_OFFSET, STATUS_IDENT_LENGTH,
status_id, "%u (%s)", status_id,
val_to_str_const(status_type * 256 * 256 + status_id, status_type_id_values, "unknown"));
proto_item_append_text(parameter_item, " (%s)",
val_to_str_const(status_type * 256 * 256 + status_id,
status_type_id_values,
"unknown status information"));
}
static void
esis_dissect_ish_pdu( guint8 len, tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo) {
int offset = 0;
int netl = 0;
proto_tree* network_tree;
offset += ESIS_HDR_FIXED_LENGTH;
netl = (int) tvb_get_guint8(tvb, offset);
network_tree = proto_tree_add_subtree( tree, tvb, offset, netl + 1, ett_esis_network, NULL,
"### Network Entity Title Section ###");
proto_tree_add_uint_format_value(network_tree, hf_esis_netl, tvb, offset++, 1, netl, "%2u Octets", netl);
proto_tree_add_string(network_tree, hf_esis_net, tvb, offset, netl, print_nsap_net( tvb, offset, netl ) );
offset += netl;
len -= ( netl + 1 );
dissect_osi_options( len, tvb, offset, network_tree, pinfo );
}
static void
dissect_trmac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *mac_tree = NULL;
proto_item *ti;
int mv_length, sv_offset, sv_additional;
guint8 mv_val;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TR MAC");
col_clear(pinfo->cinfo, COL_INFO);
mv_val = tvb_get_guint8(tvb, 3);
/* Interpret the major vector */
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(mv_val, major_vector_vs, "Unknown Major Vector: %u"));
if (tree) {
mv_length = tvb_get_ntohs(tvb, 0);
ti = proto_tree_add_item(tree, proto_trmac, tvb, 0, mv_length, ENC_NA);
mac_tree = proto_item_add_subtree(ti, ett_tr_mac);
proto_tree_add_uint(mac_tree, hf_trmac_mv, tvb, 3, 1, mv_val);
proto_tree_add_uint_format_value(mac_tree, hf_trmac_length, tvb, 0, 2, mv_length,
"%d bytes", mv_length);
proto_tree_add_uint(mac_tree, hf_trmac_srcclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) & 0x0f);
proto_tree_add_uint(mac_tree, hf_trmac_dstclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) >> 4 );
/* interpret the subvectors */
sv_offset = 4;
while (sv_offset < mv_length) {
sv_additional = sv_text(tvb, sv_offset, pinfo, mac_tree);
/* if this is a bad packet, we could get a 0-length added here,
* looping forever */
if (sv_additional > 0)
sv_offset += sv_additional;
else
break;
}
}
}
static void dissect_vektor_igrp (tvbuff_t *tvb, proto_tree *igrp_vektor_tree, guint8 network)
{
union {
guint8 addr_bytes[4];
guint32 addr_word;
} addr;
address ip_addr;
if (network != 0) {
/*
* Interior route; network is the high-order byte, and the three
* bytes in the vector are the lower 3 bytes.
*/
addr.addr_bytes[0]=network;
addr.addr_bytes[1]=tvb_get_guint8(tvb,0);
addr.addr_bytes[2]=tvb_get_guint8(tvb,1);
addr.addr_bytes[3]=tvb_get_guint8(tvb,2);
} else {
/*
* System or exterior route; the three bytes in the vector are
* the three high-order bytes, and the low-order byte is 0.
*/
addr.addr_bytes[0]=tvb_get_guint8(tvb,0);
addr.addr_bytes[1]=tvb_get_guint8(tvb,1);
addr.addr_bytes[2]=tvb_get_guint8(tvb,2);
addr.addr_bytes[3]=0;
}
set_address(&ip_addr, AT_IPv4, 4, &addr);
igrp_vektor_tree = proto_tree_add_subtree_format(igrp_vektor_tree, tvb, 0 ,14,
ett_igrp_net, NULL, "Entry for network %s", address_to_str(wmem_packet_scope(), &ip_addr));
proto_tree_add_ipv4(igrp_vektor_tree, hf_igrp_network, tvb, 0, 3, addr.addr_word);
proto_tree_add_item(igrp_vektor_tree, hf_igrp_delay, tvb, 3, 3, ENC_BIG_ENDIAN);
proto_tree_add_item(igrp_vektor_tree, hf_igrp_bandwidth, tvb, 6, 3, ENC_BIG_ENDIAN);
proto_tree_add_uint_format_value(igrp_vektor_tree, hf_igrp_mtu, tvb, 9, 2, tvb_get_ntohs(tvb,9), "%d bytes", tvb_get_ntohs(tvb,9));
proto_tree_add_item(igrp_vektor_tree, hf_igrp_reliability, tvb, 11, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(igrp_vektor_tree, hf_igrp_load, tvb, 12, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(igrp_vektor_tree, hf_igrp_hop_count, tvb, 13, 1, ENC_BIG_ENDIAN);
}
static void
esis_dissect_ish_pdu( guint8 len, tvbuff_t *tvb, proto_tree *tree) {
int offset = 0;
int netl = 0;
if (tree) {
offset += ESIS_HDR_FIXED_LENGTH;
netl = (int) tvb_get_guint8(tvb, offset);
proto_tree_add_text( tree, tvb, offset, netl + 1,
"### Network Entity Title Section ###");
proto_tree_add_uint_format_value(tree, hf_esis_netl, tvb, offset++, 1, netl, "%2u Octets", netl);
proto_tree_add_text( tree, tvb, offset, netl,
" NET: %s",
print_nsap_net( tvb_get_ptr(tvb, offset, netl), netl ) );
offset += netl;
len -= ( netl + 1 );
dissect_osi_options( len, tvb, offset, tree );
}
}
static int
display_LMNT_token(tvbuff_t *tvb, int offset, proto_tree *tree)
{
guint16 Token;
Token = tvb_get_letohs(tvb, offset);
if (Token == 0xffff) {
proto_tree_add_uint_format_value(tree, hf_lmnt_token, tvb, offset, 2,
Token,
"0x%04x (Windows NT Networking)", Token);
} else {
/*
* XXX - what is it if it's not 0xffff?
*/
proto_tree_add_uint_format(tree, hf_lm_token, tvb, offset, 2,
Token,
"LMNT Token: 0x%04x (Unknown)", Token);
}
offset += 2;
return offset;
}
/* dissects MPA FPDU */
static guint16
dissect_mpa_fpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
mpa_state_t *state, struct tcpinfo *tcpinfo, guint8 endpoint)
{
proto_item *mpa_item = NULL;
proto_item *mpa_header_item = NULL;
proto_tree *mpa_tree = NULL;
proto_tree *mpa_header_tree = NULL;
guint8 pad_length;
guint16 ulpdu_length, exp_ulpdu_length;
guint32 offset, total_length;
guint32 num_of_m = 0;
/*
* Initialize starting offset for this FPDU. Deals with the case that this
* FPDU may start with a Marker instead of the ULPDU_LENTH header field.
*/
if (state->minfo[endpoint].valid
&& get_first_marker_offset(state, tcpinfo, endpoint) == 0) {
offset = MPA_MARKER_LEN;
} else {
offset = 0;
}
/* get ULPDU length of this FPDU */
ulpdu_length = (guint16) tvb_get_ntohs(tvb, offset);
mpa_packetlist(pinfo, MPA_FPDU);
if (state->minfo[endpoint].valid) {
num_of_m = number_of_markers(state, tcpinfo, endpoint);
}
if (tree) {
/*
* Stop FPDU dissection if the read ULPDU_LENGTH field does NOT contain
* what is expected.
* Reasons for getting a wrong ULPDU_LENGTH can be lost packets (because
* libpcap was not able to capture every packet) or lost alignment (the
* MPA FPDU header does not start right after TCP header).
* We consider the above to be an error since we make the assumption
* that exactly one MPA FPDU is contained in one TCP segement and starts
* always either with a Marker or the ULPDU_LENGTH header field.
*/
exp_ulpdu_length = expected_ulpdu_length(state, tcpinfo, endpoint);
if (!exp_ulpdu_length || exp_ulpdu_length != ulpdu_length) {
proto_tree_add_expert_format(tree, pinfo, &ei_mpa_bad_length, tvb, offset,
MPA_ULPDU_LENGTH_LEN,
"[ULPDU length [%u] field does not contain the expected length[%u]]",
exp_ulpdu_length, ulpdu_length);
}
mpa_item = proto_tree_add_item(tree, proto_iwarp_mpa, tvb, 0,
-1, ENC_NA);
mpa_tree = proto_item_add_subtree(mpa_item, ett_mpa);
mpa_header_item = proto_tree_add_item(mpa_tree, hf_mpa_fpdu,
tvb, offset, -1, ENC_NA);
mpa_header_tree = proto_item_add_subtree(mpa_header_item,
ett_mpa);
/* ULPDU Length header field */
proto_tree_add_uint_format_value(mpa_header_tree,
hf_mpa_ulpdu_length, tvb, offset,
MPA_ULPDU_LENGTH_LEN, ulpdu_length, "%u bytes",
ulpdu_length);
pad_length = fpdu_pad_length(ulpdu_length);
/* Markers are present in this FPDU */
if (state->minfo[endpoint].valid && num_of_m > 0) {
total_length = fpdu_total_length(tcpinfo);
if (pad_length > 0) {
proto_tree_add_item(mpa_header_tree, hf_mpa_pad,
tvb, pad_offset(tcpinfo,
total_length,
pad_length),
pad_length, ENC_NA);
}
dissect_fpdu_crc(tvb, mpa_header_tree, state,
total_length-MPA_CRC_LEN, num_of_m * MPA_MARKER_LEN +
ulpdu_length + pad_length + MPA_ULPDU_LENGTH_LEN);
dissect_fpdu_markers(tvb, mpa_tree, state, tcpinfo, endpoint);
} else { /* Markers are not present or not enabled */
offset += MPA_ULPDU_LENGTH_LEN + ulpdu_length;
if (pad_length > 0) {
proto_tree_add_item(mpa_header_tree, hf_mpa_pad, tvb, offset,
pad_length, ENC_NA);
offset += pad_length;
}
dissect_fpdu_crc(tvb, mpa_header_tree, state, offset,
ulpdu_length+pad_length+MPA_ULPDU_LENGTH_LEN);
}
}
return ulpdu_length;
}
/* dissects MPA REQUEST or MPA REPLY */
static gboolean
dissect_mpa_req_rep(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
gint message_type)
{
proto_tree *mpa_tree = NULL;
proto_tree *mpa_header_tree = NULL;
proto_item *mpa_item = NULL;
proto_item *mpa_header_item = NULL;
guint16 pd_length;
guint32 offset = 0;
mpa_packetlist(pinfo, message_type);
if (tree) {
mpa_item = proto_tree_add_item(tree, proto_iwarp_mpa, tvb, 0,
-1, ENC_NA);
mpa_tree = proto_item_add_subtree(mpa_item, ett_mpa);
if (message_type == MPA_REQUEST_FRAME) {
mpa_header_item = proto_tree_add_item(mpa_tree,
hf_mpa_req, tvb, offset, -1, ENC_NA);
mpa_header_tree = proto_item_add_subtree(
mpa_header_item, ett_mpa);
proto_tree_add_item(mpa_header_tree, hf_mpa_key_req,
tvb, offset, MPA_REQ_REP_KEY_LEN, ENC_NA);
}
if (message_type == MPA_REPLY_FRAME) {
mpa_header_item = proto_tree_add_item(mpa_tree,
hf_mpa_rep, tvb, offset, -1, ENC_NA);
mpa_header_tree = proto_item_add_subtree(
mpa_header_item, ett_mpa);
proto_tree_add_item(mpa_header_tree, hf_mpa_key_rep,
tvb, offset, MPA_REQ_REP_KEY_LEN, ENC_NA);
}
offset += MPA_REQ_REP_KEY_LEN;
proto_tree_add_item(mpa_header_tree, hf_mpa_flag_m, tvb,
offset, MPA_REQ_REP_FLAG_LEN, ENC_BIG_ENDIAN);
proto_tree_add_item(mpa_header_tree, hf_mpa_flag_c, tvb,
offset, MPA_REQ_REP_FLAG_LEN, ENC_BIG_ENDIAN);
proto_tree_add_item(mpa_header_tree, hf_mpa_flag_r, tvb,
offset, MPA_REQ_REP_FLAG_LEN, ENC_BIG_ENDIAN);
proto_tree_add_item(mpa_header_tree, hf_mpa_flag_res, tvb,
offset, MPA_REQ_REP_FLAG_LEN, ENC_BIG_ENDIAN);
offset += MPA_REQ_REP_FLAG_LEN;
proto_tree_add_item(mpa_header_tree, hf_mpa_rev, tvb,
offset, MPA_REQ_REP_REV_LEN, ENC_BIG_ENDIAN);
offset += MPA_REQ_REP_REV_LEN;
/* check whether the Private Data Length conforms to RFC 5044 */
pd_length = tvb_get_ntohs(tvb, offset);
if (pd_length > MPA_MAX_PD_LENGTH) {
proto_tree_add_expert_format(tree, pinfo, &ei_mpa_bad_length, tvb, offset, 2,
"[PD length field indicates more 512 bytes of Private Data]");
return FALSE;
}
proto_tree_add_uint_format_value(mpa_header_tree,
hf_mpa_pd_length, tvb, offset,
MPA_REQ_REP_PDLENGTH_LEN, pd_length, "%u bytes",
pd_length);
offset += MPA_REQ_REP_PDLENGTH_LEN;
if (pd_length) {
proto_tree_add_item(mpa_header_tree,
hf_mpa_private_data, tvb, offset,
pd_length, ENC_NA);
}
}
return TRUE;
}
static void
dissect_v5dl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *v5dl_tree, *addr_tree;
proto_item *v5dl_ti, *addr_ti;
int direction;
guint v5dl_header_len;
guint16 control;
#if 0
proto_tree *checksum_tree;
proto_item *checksum_ti;
guint16 checksum, checksum_calculated;
guint checksum_offset;
#endif
guint16 addr, cr, eah, eal, v5addr;
gboolean is_response = 0;
#if 0
guint length, reported_length;
#endif
tvbuff_t *next_tvb;
const char *srcname = "?";
const char *dstname = "?";
col_set_str(pinfo->cinfo, COL_PROTOCOL, "V5DL");
col_clear(pinfo->cinfo, COL_INFO);
addr = tvb_get_ntohs(tvb, 0);
cr = addr & V5DL_CR;
eal = (addr & V5DL_EAL) >> V5DL_EAL_SHIFT;
eah = (addr & V5DL_EAH) >> V5DL_EAH_SHIFT;
v5addr = (eah << 7) + eal;
v5dl_header_len = 2; /* addr */
direction = pinfo->p2p_dir;
if (pinfo->p2p_dir == P2P_DIR_RECV) {
is_response = cr ? FALSE : TRUE;
srcname = "Network";
dstname = "User";
}
else if (pinfo->p2p_dir == P2P_DIR_SENT) {
is_response = cr ? TRUE : FALSE;
srcname = "User";
dstname = "Network";
}
col_set_str(pinfo->cinfo, COL_RES_DL_SRC, srcname);
col_set_str(pinfo->cinfo, COL_RES_DL_DST, dstname);
if (tree) {
proto_item *direction_ti;
v5dl_ti = proto_tree_add_item(tree, proto_v5dl, tvb, 0, -1,
ENC_NA);
v5dl_tree = proto_item_add_subtree(v5dl_ti, ett_v5dl);
/*
* Don't show the direction if we don't know it.
*/
if (direction != P2P_DIR_UNKNOWN) {
direction_ti = proto_tree_add_uint(v5dl_tree, hf_v5dl_direction,
tvb, 0, 0, pinfo->p2p_dir);
PROTO_ITEM_SET_GENERATED(direction_ti);
}
addr_ti = proto_tree_add_uint(v5dl_tree, hf_v5dl_ef, tvb,
0, 2, v5addr);
addr_tree = proto_item_add_subtree(addr_ti, ett_v5dl_address);
proto_tree_add_uint(addr_tree, hf_v5dl_eah, tvb, 0, 1, addr);
proto_tree_add_uint(addr_tree, hf_v5dl_cr, tvb, 0, 1, addr);
proto_tree_add_uint(addr_tree, hf_v5dl_ea1, tvb, 0, 1, addr);
proto_tree_add_uint(addr_tree, hf_v5dl_eal, tvb, 1, 1, addr);
proto_tree_add_uint(addr_tree, hf_v5dl_ea2, tvb, 1, 1, addr);
}
else {
v5dl_ti = NULL;
v5dl_tree = NULL;
}
control = dissect_xdlc_control(tvb, 2, pinfo, v5dl_tree, hf_v5dl_control,
ett_v5dl_control, &v5dl_cf_items, &v5dl_cf_items_ext, NULL, NULL,
is_response, TRUE, FALSE);
v5dl_header_len += XDLC_CONTROL_LEN(control, TRUE);
if (tree)
proto_item_set_len(v5dl_ti, v5dl_header_len);
/*
* XXX - the sample capture supplied with bug 7027 does not
* appear to include checksums in the packets.
*/
#if 0
/*
* Check the checksum, if available.
* The checksum is a CCITT CRC-16 at the end of the packet, so
* if we don't have the entire packet in the capture - i.e., if
* tvb_captured_length(tvb) != tvb_reported_length(tvb) we can't check it.
*/
length = tvb_captured_length(tvb);
reported_length = tvb_reported_length(tvb);
/*
* If the reported length isn't big enough for the V5DL header
* and 2 bytes of checksum, the packet is malformed, as the
* checksum overlaps the header.
*/
if (reported_length < v5dl_header_len + 2)
THROW(ReportedBoundsError);
if (length == reported_length) {
/*
* There's no snapshot length cutting off any of the
* packet.
*/
checksum_offset = reported_length - 2;
checksum = tvb_get_ntohs(tvb, checksum_offset);
checksum_calculated = crc16_ccitt_tvb(tvb, checksum_offset);
checksum_calculated = g_htons(checksum_calculated); /* Note: g_htons() macro may eval arg multiple times */
if (checksum == checksum_calculated) {
checksum_ti = proto_tree_add_uint_format_value(v5dl_tree, hf_v5dl_checksum, tvb, checksum_offset,
2, 0,
"0x%04x [correct]",
checksum);
checksum_tree = proto_item_add_subtree(checksum_ti, ett_v5dl_checksum);
proto_tree_add_boolean(checksum_tree, hf_v5dl_checksum_good, tvb, checksum_offset, 2, TRUE);
proto_tree_add_boolean(checksum_tree, hf_v5dl_checksum_bad, tvb, checksum_offset, 2, FALSE);
} else {
checksum_ti = proto_tree_add_uint_format_value(v5dl_tree, hf_v5dl_checksum, tvb, checksum_offset,
2, 0,
"0x%04x [incorrect, should be 0x%04x]",
checksum, checksum_calculated);
checksum_tree = proto_item_add_subtree(checksum_ti, ett_v5dl_checksum);
proto_tree_add_boolean(checksum_tree, hf_v5dl_checksum_good, tvb, checksum_offset, 2, FALSE);
proto_tree_add_boolean(checksum_tree, hf_v5dl_checksum_bad, tvb, checksum_offset, 2, TRUE);
}
/*
* Remove the V5DL header *and* the checksum.
*/
next_tvb = tvb_new_subset(tvb, v5dl_header_len,
tvb_captured_length_remaining(tvb, v5dl_header_len) - 2,
tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
} else {
/*
* Some or all of the packet is cut off by a snapshot
* length.
*/
if (length == reported_length - 1) {
/*
* One byte is cut off, so there's only one
* byte of checksum in the captured data.
* Remove that byte from the captured length
* and both bytes from the reported length.
*/
next_tvb = tvb_new_subset(tvb, v5dl_header_len,
tvb_captured_length_remaining(tvb, v5dl_header_len) - 1,
tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
} else {
/*
* Two or more bytes are cut off, so there are
* no bytes of checksum in the captured data.
* Just remove the checksum from the reported
* length.
*/
next_tvb = tvb_new_subset(tvb, v5dl_header_len,
tvb_captured_length_remaining(tvb, v5dl_header_len),
tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
}
}
#else
next_tvb = tvb_new_subset_remaining(tvb, v5dl_header_len);
#endif
if (XDLC_IS_INFORMATION(control)) {
/* call V5.2 dissector */
call_dissector(v52_handle, next_tvb, pinfo, tree);
}
}
static void dissect_msdp_notification(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int *offset, guint16 tlv_len)
{
guint8 error, error_sub;
const value_string *vals;
proto_tree_add_item(tree, hf_msdp_not_o, tvb, *offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_msdp_not_error, tvb, *offset, 1, ENC_BIG_ENDIAN);
error = tvb_get_guint8(tvb, *offset);
error &= 0x7F; /* Error is 7-bit field. O-bit is bit 8 */
*offset += 1;
/* Depending on the Error Code, we collect the correct
* value_strings for the Error subcode
*/
switch (error) {
case MESSAGE_HEADER_ERROR:
vals = hdr_error_vals;
break;
case SA_REQUEST_ERROR:
vals = sa_req_error_vals;
break;
case SA_MESSAGE_SA_RESPONSE_ERROR:
vals = sa_msg_error_vals;
break;
case FSM_ERROR:
vals = fsm_error_vals;
break;
case HOLD_TIMER_EXPIRED:
case NOTIFICATION:
case CEASE:
vals = sa_unspec_error_vals;
break;
default:
vals = sa_unspec_error_vals;
break;
}
error_sub = tvb_get_guint8(tvb, *offset);
proto_tree_add_uint_format_value(tree, hf_msdp_not_error_sub, tvb, *offset, 1,
error_sub, "%s (%u)",
val_to_str_const(error_sub, vals, "<Unknown Error subcode>"),
error_sub);
*offset += 1;
/* Do switch again, this time to dissect the data portion
* correctly. Ugly.
*/
switch (error) {
tvbuff_t *next_tvb;
case SA_REQUEST_ERROR:
add_notification_data_ipv4addr(tvb, tree, offset, hf_msdp_not_group_address);
break;
case SA_MESSAGE_SA_RESPONSE_ERROR:
if (error_sub == 0) {
break;
} else if (error_sub == 1) {
proto_tree_add_item(tree, hf_msdp_not_entry_count, tvb, *offset, 1, ENC_BIG_ENDIAN);
*offset += 1;
break;
} else if (error_sub == 2) {
add_notification_data_ipv4addr(tvb, tree, offset, hf_msdp_not_rp_address);
break;
} else if (error_sub == 3 || error_sub == 8) {
add_notification_data_ipv4addr(tvb, tree, offset, hf_msdp_not_group_address);
break;
} else if (error_sub == 4) {
add_notification_data_ipv4addr(tvb, tree, offset, hf_msdp_not_source_address);
break;
} else if (error_sub == 5) {
proto_tree_add_item(tree, hf_msdp_not_sprefix_len, tvb, *offset, 1, ENC_BIG_ENDIAN);
*offset += 1;
break;
} else if (error_sub == 6) {
/* No break, causes fall through to next label */
} else if (error_sub == 7) {
proto_tree_add_item(tree, hf_msdp_unknown_encap, tvb, *offset, tlv_len - 5, ENC_NA);
*offset += tlv_len - 5;
break;
} else {
proto_tree_add_item(tree, hf_msdp_unknown_data, tvb, *offset, tlv_len - 5, ENC_NA);
*offset += tlv_len - 5;
break;
}
/* Fall through */
case MESSAGE_HEADER_ERROR:
case NOTIFICATION:
/* Data contains the message that had an error. Even a
* broken Notification message causes a Notification
* message with Error Code set to Notification to be
* sent back.
*/
next_tvb = tvb_new_subset_remaining(tvb, *offset);
dissect_msdp(next_tvb, pinfo, tree);
break;
case FSM_ERROR:
case HOLD_TIMER_EXPIRED:
case CEASE:
/* Do nothing. These contain no data */
break;
default:
if (tlv_len - 5 > 0)
proto_tree_add_item(tree, hf_msdp_unknown_data, tvb, *offset, tlv_len - 5, ENC_NA);
*offset += tlv_len - 5;
break;
}
return;
}
static int
dissect_ltp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti = NULL;
proto_tree *ltp_tree = NULL;
int frame_offset;
int header_offset;
int segment_offset = 0;
int hdr_extn_offset = 0;
int trl_extn_offset = 0;
guint8 ltp_hdr;
gint ltp_type;
guint8 ltp_extn_cnt;
gint hdr_extn_cnt;
gint trl_extn_cnt;
guint64 engine_id;
guint64 session_num;
int engine_id_size;
int session_num_size;
proto_item *ltp_header_item = NULL;
proto_item *ltp_session_item = NULL;
proto_tree *ltp_header_tree = NULL;
proto_tree *ltp_session_tree = NULL;
/* Check that there's enough data */
if(tvb_length(tvb) < LTP_MIN_DATA_BUFFER){
return 0;
}
frame_offset = 0;
header_offset = 0;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LTP Segment");
/* Extract all the header info from the packet */
ltp_hdr = tvb_get_guint8(tvb, frame_offset);
header_offset++;
engine_id = evaluate_sdnv_64(tvb,frame_offset + header_offset,&engine_id_size);
header_offset += engine_id_size;
if((unsigned)header_offset >= tvb_length(tvb)){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
session_num = evaluate_sdnv_64(tvb,frame_offset + header_offset,&session_num_size);
header_offset += session_num_size;
if((unsigned)header_offset >= tvb_length(tvb)){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
ti = proto_tree_add_item(tree, proto_ltp, tvb, 0, -1, ENC_NA);
ltp_tree = proto_item_add_subtree(ti, ett_ltp);
/* Adding Header Subtree */
ltp_header_item = proto_tree_add_text(ltp_tree, tvb, frame_offset, header_offset+1, "LTP Header");
ltp_header_tree = proto_item_add_subtree(ltp_header_item, ett_ltp_hdr);
proto_tree_add_uint(ltp_header_tree,hf_ltp_version,tvb,frame_offset,1,hi_nibble(ltp_hdr));
ltp_type = lo_nibble(ltp_hdr);
proto_tree_add_uint_format_value(ltp_header_tree,hf_ltp_type,tvb,frame_offset,1,ltp_type,"%x (%s)",
ltp_type,val_to_str(ltp_type,ltp_type_codes,"Invalid"));
frame_offset++;
/* Adding the session id subtree */
ltp_session_item = proto_tree_add_item(ltp_header_item,hf_ltp_session_id,tvb,frame_offset, engine_id_size + session_num_size,ENC_NA);
ltp_session_tree = proto_item_add_subtree(ltp_session_item,ett_hdr_session);
proto_tree_add_uint64(ltp_session_tree,hf_ltp_session_orig,tvb,frame_offset,engine_id_size,engine_id);
frame_offset+=engine_id_size;
proto_tree_add_uint64(ltp_session_tree,hf_ltp_session_no, tvb, frame_offset,session_num_size,session_num);
frame_offset+=session_num_size;
/* Adding Extension count to the header tree */
ltp_extn_cnt = tvb_get_guint8(tvb,frame_offset);
hdr_extn_cnt = hi_nibble(ltp_extn_cnt);
trl_extn_cnt = lo_nibble(ltp_extn_cnt);
proto_tree_add_uint(ltp_header_tree,hf_ltp_hdr_extn_cnt,tvb,frame_offset,1,hdr_extn_cnt);
proto_tree_add_uint(ltp_header_tree,hf_ltp_trl_extn_cnt,tvb,frame_offset,1,trl_extn_cnt);
frame_offset++;
col_add_str(pinfo->cinfo, COL_INFO, val_to_str_const(ltp_type,ltp_type_col_info,"Protocol Error"));
if((unsigned)frame_offset >= tvb_length(tvb)){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
/* Check if there are any header extensions */
if(hdr_extn_cnt > 0){
hdr_extn_offset = dissect_header_extn(ltp_tree, tvb, frame_offset,hdr_extn_cnt);
if(hdr_extn_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
frame_offset += hdr_extn_offset;
}
if((unsigned)frame_offset >= tvb_length(tvb)){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
/* Call sub routines to handle the segment content*/
if((ltp_type >= 0) && (ltp_type < 8)){
segment_offset = dissect_data_segment(ltp_tree,tvb,pinfo,frame_offset,ltp_type,session_num);
if(segment_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
}
else if(ltp_type == 8){
segment_offset = dissect_report_segment(tvb, pinfo, ltp_tree,frame_offset);
if(segment_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
}
else if(ltp_type == 9){
segment_offset = dissect_report_ack_segment(ltp_tree,tvb,frame_offset);
if(segment_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
}
else if(ltp_type == 12 || ltp_type == 14){
segment_offset = dissect_cancel_segment(ltp_tree,tvb,frame_offset);
if(segment_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
}
frame_offset += segment_offset;
/* Check to see if there are any trailer extensions */
if(trl_extn_cnt > 0){
if((unsigned)frame_offset >= tvb_length(tvb)){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
trl_extn_offset = dissect_trailer_extn(ltp_tree, tvb, frame_offset,trl_extn_cnt);
if(trl_extn_offset == 0){
col_set_str(pinfo->cinfo, COL_INFO, "Protocol Error");
return 0;
}
}
/* Return the amount of data this dissector was able to dissect */
return tvb_length(tvb);
}
guint dissect_cbs_message_identifier(tvbuff_t *tvb, proto_tree *tree, guint offset)
{
guint16 msg_id;
const char *msg_id_string = NULL;
msg_id = tvb_get_ntohs(tvb, offset);
msg_id_string = try_val_to_str(msg_id, message_id_values);
if (msg_id_string == NULL)
{
if (msg_id < 1000)
{
msg_id_string = "Message ID to be allocated by GSMA";
}
else if (msg_id < 4096)
{
msg_id_string = "Message ID intended for standardization in future versions of 3GPP TS 23.041";
}
else if (msg_id < 4224)
{
msg_id_string = "Message ID reserved for Cell Broadcast Data Download (unsecured) to the SIM ";
}
else if (msg_id < 4352)
{
msg_id_string = "Message ID reserved for Cell Broadcast Data Download (secured) to the SIM ";
}
else if (msg_id < 4360)
{
msg_id_string = "ETWS CBS Message Identifier for future extension";
}
else if (msg_id < 4400)
{
msg_id_string = "CMAS CBS Message Identifier for future extension";
}
else if (msg_id < 6400)
{
msg_id_string = "CBS Message Identifier for future PWS use";
}
else if (msg_id < 40960)
{
msg_id_string = "Intended for standardization in future versions of 3GPP TS 23.041";
}
else if (msg_id < 43500)
{
msg_id_string = "Message ID in PLMN operator specific range";
}
else if (msg_id < 43530)
{
msg_id_string = "Traffic Information Traffic Master UK";
}
else if (msg_id < 43585)
{
msg_id_string = "Traffic information Mannesmann Telecommerce";
}
else if (msg_id < 45056)
{
msg_id_string = "Message ID in PLMN operator specific range";
}
else
{
msg_id_string = "Message ID intended as PLMN operator specific range in future versions of 3GPP TS 23.041";
}
}
proto_tree_add_uint_format_value(tree, hf_gsm_cbs_message_identifier, tvb, offset, 2, msg_id, "%s (%d)", msg_id_string, msg_id);
offset += 2;
return offset;
}
