const gchar *
tvb_arphrdaddr_to_str(tvbuff_t *tvb, gint offset, int ad_len, guint16 type)
{
if (ad_len == 0)
return "<No address>";
if (ARP_HW_IS_ETHER(type, ad_len)) {
/* Ethernet address (or IEEE 802.x address, which is the same type of
address). */
return tvb_ether_to_str(tvb, offset);
}
return tvb_bytes_to_str(tvb, offset, ad_len);
}
/*
* Name: nlsp_dissect_nlsp_psnp()
*
* Description:
* Tear apart a L1 PSNP header and then call into payload dissect
* to pull apart the lsp id payload.
*
* Input:
* tvbuff_t * : tvbuffer for packet data
* proto_tree * : protocol display tree to add to. May be NULL.
* int offset : our offset into packet data.
* int : header length of packet.
*
* Output:
* void, but we will add to proto tree if !NULL.
*/
static void
nlsp_dissect_nlsp_psnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, int header_length)
{
guint16 packet_length;
int len;
packet_length = tvb_get_ntohs(tvb, offset);
if (tree) {
proto_tree_add_uint(tree, hf_nlsp_packet_length, tvb,
offset, 2, packet_length);
}
offset += 2;
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_fstr(pinfo->cinfo, COL_INFO, ", Source ID: %s",
tvb_ether_to_str(tvb, offset));
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Source ID system ID: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
/* XXX - add the pseudonode ID */
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"Source ID pseudonode ID: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
len = packet_length - header_length;
if (len < 0) {
return;
}
/* Call into payload dissector */
nlsp_dissect_clvs(tvb, tree, offset,
clv_l1_psnp_opts, len, ett_nlsp_psnp_clv_unknown);
}
/*
* Name: dissect_neighbor_clv()
*
* Description:
* Decode an neighbor clv.
*
* Input:
* tvbuff_t * : tvbuffer for packet data
* proto_tree * : protocol display tree to fill out. May be NULL
* int : offset into packet data where we are.
* int : length of clv we are decoding
*
* Output:
* void, but we will add to proto tree if !NULL.
*/
static void
dissect_neighbor_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
int length)
{
while (length > 0) {
if (length < 6) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short neighbor entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Neighbor: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
length -= 6;
}
}
static void
dissect_dtp_tlv(packet_info *pinfo, tvbuff_t *tvb, int offset, int length,
proto_tree *tree, proto_item *ti, proto_item *tlv_length_item, guint8 type)
{
switch (type) {
case DTP_TLV_DOMAIN:
if (length <= 33) { /* VTP domain name is at most 32 bytes long and is null-terminated */
proto_item_append_text(ti, ": %s", tvb_format_text(tvb, offset, length - 1));
proto_tree_add_item(tree, hf_dtp_domain, tvb, offset, length, ENC_NA);
}
else
expert_add_info(pinfo, tlv_length_item, &ei_dtp_tlv_length_invalid);
break;
case DTP_TLV_TRSTATUS:
if (length == 1) { /* Value field length must be 1 byte */
proto_item * value_item = NULL;
proto_tree * field_tree = NULL;
guint8 trunk_status = tvb_get_guint8(tvb, offset);
proto_item_append_text(ti,
" (Operating/Administrative): %s/%s (0x%02x)",
val_to_str_const(DTP_TOSVALUE(trunk_status), dtp_tos_vals, "Unknown operating status"),
val_to_str_const(DTP_TASVALUE(trunk_status), dtp_tas_vals, "Unknown administrative status"),
trunk_status);
value_item = proto_tree_add_text(tree, tvb, offset, length, "Value: %s/%s (0x%02x)",
val_to_str_const(DTP_TOSVALUE(trunk_status), dtp_tos_vals, "Unknown operating status"),
val_to_str_const(DTP_TASVALUE(trunk_status), dtp_tas_vals, "Unknown administrative status"),
trunk_status);
field_tree = proto_item_add_subtree(value_item, ett_dtp_status);
proto_tree_add_item(field_tree, hf_dtp_tos, tvb, offset, length, ENC_NA);
proto_tree_add_item(field_tree, hf_dtp_tas, tvb, offset, length, ENC_NA);
}
else
expert_add_info(pinfo, tlv_length_item, &ei_dtp_tlv_length_invalid);
break;
case DTP_TLV_TRTYPE:
if (length == 1) { /* Value field length must be 1 byte */
proto_item * value_item = NULL;
proto_tree * field_tree = NULL;
guint8 trunk_type = tvb_get_guint8(tvb, offset);
proto_item_append_text(ti,
" (Operating/Administrative): %s/%s (0x%02x)",
val_to_str_const(DTP_TOTVALUE(trunk_type), dtp_tot_vals, "Unknown operating type"),
val_to_str_const(DTP_TATVALUE(trunk_type), dtp_tat_vals, "Unknown administrative type"),
trunk_type);
value_item = proto_tree_add_text(tree, tvb, offset, length, "Value: %s/%s (0x%02x)",
val_to_str_const(DTP_TOTVALUE(trunk_type), dtp_tot_vals, "Unknown operating type"),
val_to_str_const(DTP_TATVALUE(trunk_type), dtp_tat_vals, "Unknown administrative type"),
trunk_type);
field_tree = proto_item_add_subtree(value_item, ett_dtp_type);
proto_tree_add_item(field_tree, hf_dtp_tot, tvb, offset, length, ENC_NA);
proto_tree_add_item(field_tree, hf_dtp_tat, tvb, offset, length, ENC_NA);
}
else
expert_add_info(pinfo, tlv_length_item, &ei_dtp_tlv_length_invalid);
break;
case DTP_TLV_SENDERID:
if (length == 6) { /* Value length must be 6 bytes for a MAC address */
proto_item_append_text(ti, ": %s",
tvb_ether_to_str(tvb, offset)); /* XXX - resolve? */
proto_tree_add_item(tree, hf_dtp_senderid, tvb, offset, length, ENC_NA);
}
else
expert_add_info(pinfo, tlv_length_item, &ei_dtp_tlv_length_invalid);
break;
default:
proto_tree_add_text(tree, tvb, offset, length, "Data");
break;
}
}
static void
nlsp_dissect_nlsp_lsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, int header_length)
{
guint16 packet_length;
guint16 remaining_lifetime;
guint32 sequence_number;
int len;
packet_length = tvb_get_ntohs(tvb, offset);
if (tree) {
proto_tree_add_uint(tree, hf_nlsp_packet_length, tvb,
offset, 2, packet_length);
}
offset += 2;
remaining_lifetime = tvb_get_ntohs(tvb, offset);
if (tree) {
proto_tree_add_text(tree, tvb, offset, 2,
"Remaining Lifetime: %us",
remaining_lifetime);
}
offset += 2;
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_fstr(pinfo->cinfo, COL_INFO, ", LSP ID: %s",
tvb_ether_to_str(tvb, offset));
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"LSP ID system ID: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
/* XXX - append the pseudonode ID */
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"LSP ID pseudonode ID: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"LSP ID LSP number: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
sequence_number = tvb_get_ntohl(tvb, offset);
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_fstr(pinfo->cinfo, COL_INFO,
", Sequence: 0x%08x, Lifetime: %us",
sequence_number, remaining_lifetime);
}
if (tree) {
proto_tree_add_uint(tree, hf_nlsp_lsp_sequence_number, tvb,
offset, 4, sequence_number);
}
offset += 4;
if (tree) {
/* XXX -> we could validate the cksum here! */
proto_tree_add_item(tree, hf_nlsp_lsp_checksum, tvb,
offset, 2, ENC_BIG_ENDIAN );
}
offset += 2;
if (tree) {
proto_tree_add_item(tree, hf_nlsp_lsp_p, tvb,
offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_nlsp_lsp_attached_flag, tvb,
offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_nlsp_lsp_lspdbol, tvb,
offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_nlsp_lsp_router_type, tvb,
offset, 1, ENC_BIG_ENDIAN);
}
offset += 1;
len = packet_length - header_length;
if (len < 0) {
nlsp_dissect_unknown(tvb, tree, offset,
"packet header length %d went beyond packet",
header_length);
return;
}
/*
* Now, we need to decode our CLVs. We need to pass in
* our list of valid ones!
*/
nlsp_dissect_clvs(tvb, tree, offset,
clv_l1_lsp_opts, len, ett_nlsp_lsp_clv_unknown);
}
static void
dissect_dvb_data_mpe(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint offset = 0, tot_len = 0;
guint8 llc_snap_flag;
int i;
proto_item *ti;
proto_tree *dvb_data_mpe_tree;
tvbuff_t *mac_tvb;
tvbuff_t *mac_bytes_tvb[6];
tvbuff_t *data_tvb;
/* The TVB should start right after the section_length in the Section packet */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DVB-DATA");
col_set_str(pinfo->cinfo, COL_INFO, "MultiProtocol Encapsulation");
ti = proto_tree_add_item(tree, proto_dvb_data_mpe, tvb, offset, -1, ENC_NA);
dvb_data_mpe_tree = proto_item_add_subtree(ti, ett_dvb_data_mpe);
offset += packet_mpeg_sect_header(tvb, offset, dvb_data_mpe_tree, &tot_len, NULL);
/* Parse the DMC-CC private section header */
mac_bytes_tvb[5] = tvb_new_subset(tvb, offset, 1, 1);
offset += 1;
mac_bytes_tvb[4] = tvb_new_subset(tvb, offset, 1, 1);
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_payload_scrambling_control, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_address_scrambling_control, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_llc_snap_flag, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_current_next_indicator, tvb, offset, 1, ENC_BIG_ENDIAN);
llc_snap_flag = tvb_get_guint8(tvb, offset) & DVB_DATA_MPE_LLC_SNAP_FLAG_MASK;
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_last_section_number, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
for (i = 3; i >= 0; i--) {
mac_bytes_tvb[i] = tvb_new_subset(tvb, offset, 1, 1);
offset += 1;
}
mac_tvb = tvb_new_composite();
for (i = 0; i < 6; i++)
tvb_composite_append(mac_tvb, mac_bytes_tvb[i]);
tvb_composite_finalize(mac_tvb);
proto_tree_add_item(dvb_data_mpe_tree, hf_dvb_data_mpe_dst_mac, mac_tvb, 0 , 6, ENC_NA);
col_add_str(pinfo->cinfo, COL_RES_DL_DST, tvb_ether_to_str(mac_tvb, 0));
data_tvb = tvb_new_subset_remaining(tvb, offset);
if (llc_snap_flag) {
call_dissector(llc_handle, data_tvb, pinfo, tree);
} else {
call_dissector(ip_handle, data_tvb, pinfo, tree);
}
packet_mpeg_sect_crc(tvb, pinfo, dvb_data_mpe_tree, 0, tot_len - 1);
return;
}
static void
dissect_lsp_link_info_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
int length)
{
guint8 flags_cost;
if (length < 1) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
flags_cost = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_nlsp_lsp_link_info_clv_flags_cost_present, tvb, offset, 1, ENC_BIG_ENDIAN);
if (!(flags_cost & 0x80)) {
/*
* 0x80 clear => cost present.
*/
proto_tree_add_item(tree, hf_nlsp_lsp_link_info_clv_flags_cost_metric, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_nlsp_lsp_link_info_clv_flags_cost, tvb, offset, 1, ENC_BIG_ENDIAN);
}
}
offset += 1;
length -= 1;
if (length < 3) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
offset += 3; /* Reserved */
length -= 3;
if (length < 7) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Router System ID: %s",
tvb_ether_to_str(tvb, offset));
proto_tree_add_text(tree, tvb, offset+6, 1,
"Router Pseudonode ID: %u",
tvb_get_guint8(tvb, offset+6));
}
offset += 7;
length -= 7;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"MTU Size: %u",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Delay: %uus",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Throughput: %u bits/s",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 2) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 2,
"Media type: %s",
val_to_str(tvb_get_ntohs(tvb, offset), media_type_vals,
"Unknown (0x%04x)"));
}
offset += 2;
length -= 2;
}
/*
* Name: dissect_lsp_svcs_info_clv()
*
* Description:
* Decode for a lsp packet's services information clv.
*
* Input:
* tvbuff_t * : tvbuffer for packet data
* proto_tree * : protocol display tree to fill out. May be NULL
* int : offset into packet data where we are.
* int : length of clv we are decoding
*
* Output:
* void, but we will add to proto tree if !NULL.
*/
static void
dissect_lsp_svcs_info_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
int length)
{
if (length < 1) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short services info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"Hops to reach the service: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
length -= 1;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short services info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Network number: 0x%08x",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 6) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short services info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Node number: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
length -= 6;
if (length < 2) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short services info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 2,
"Socket: %s",
val_to_str_ext(tvb_get_ntohs(tvb, offset), &ipx_socket_vals_ext,
"Unknown (0x%04x)"));
}
offset += 2;
length -= 2;
if (length < 2) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short services info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 2,
"Type: %s",
val_to_str_ext(tvb_get_ntohs(tvb, offset), &novell_server_vals_ext,
"Unknown (0x%04x)"));
}
offset += 2;
length -= 2;
if (length > 0) {
if (tree) {
proto_tree_add_text(tree, tvb, offset, length,
"Service Name: %s",
tvb_format_text(tvb, offset, length));
}
}
}
/* Code to actually dissect the packets */
static int
dissect_wol(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint len;
gint offset;
guint8 sync[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
guint8 *mac;
const guint8 *passwd;
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti;
proto_item *mti;
proto_tree *wol_tree;
proto_tree *mac_tree;
/* First, if at all possible, do some heuristics to check if the packet cannot
* possibly belong to your protocol. This is especially important for
* protocols directly on top of TCP or UDP where port collisions are
* common place (e.g., even though your protocol uses a well known port,
* someone else may set up, for example, a web server on that port which,
* if someone analyzed that web server's traffic in Wireshark, would result
* in Wireshark handing an HTTP packet to your dissector). For example:
*/
/* Check that there's enough data */
len = tvb_length(tvb);
if ( len < 102 ) /* wol's smallest packet size is 102 */
return (0);
/* Get some values from the packet header, probably using tvb_get_*() */
/* Regardless of what the AMD white paper states, don't search the entire
* tvb for the synchronization stream. My feeling is that this could be
* quite expensive and seriously hinder Wireshark performance. For now,
* unless we need to change it later, just compare the 1st 6 bytes. */
if ( tvb_memeql(tvb, 0, sync, 6) != 0 )
return (0);
/* So far so good. Now get the next 6 bytes, which we'll assume is the
* target's MAC address, and do 15 memory chunk comparisons, since if this
* is a real MagicPacket, the target's MAC will be duplicated 16 times. */
mac = ep_tvb_memdup(tvb, 6, 6);
for ( offset = 12; offset < 102; offset += 6 )
if ( tvb_memeql(tvb, offset, mac, 6) != 0 )
return (0);
/* OK, we're going to assume it's a MagicPacket. If there's a password,
* grab it now, and in case there's any extra bytes after the only 3 valid
* and expected lengths, truncate the length so the extra byte(s) aren't
* included as being part of the WOL payload. */
if ( len >= 106 && len < 108 )
{
len = 106;
passwd = tvb_ip_to_str(tvb, 102);
}
else if ( len >= 108 )
{
len = 108;
passwd = tvb_ether_to_str(tvb, 102);
}
else
{
len = 102;
passwd = NULL;
}
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "WOL");
/* This field shows up as the "Info" column in the display; you should use
it, if possible, to summarize what's in the packet, so that a user looking
at the list of packets can tell what type of packet it is. See section 1.5
for more information.
Before changing the contents of a column you should make sure the column is
active by calling "check_col(pinfo->cinfo, COL_*)". If it is not active
don't bother setting it.
If you are setting the column to a constant string, use "col_set_str()",
as it's more efficient than the other "col_set_XXX()" calls.
If you're setting it to a string you've constructed, or will be
appending to the column later, use "col_add_str()".
"col_add_fstr()" can be used instead of "col_add_str()"; it takes
"printf()"-like arguments. Don't use "col_add_fstr()" with a format
string of "%s" - just use "col_add_str()" or "col_set_str()", as it's
more efficient than "col_add_fstr()".
If you will be fetching any data from the packet before filling in
the Info column, clear that column first, in case the calls to fetch
data from the packet throw an exception because they're fetching data
past the end of the packet, so that the Info column doesn't have data
left over from the previous dissector; do
col_clear(pinfo->cinfo, COL_INFO);
*/
if ( check_col(pinfo->cinfo, COL_INFO) )
{
col_add_fstr(pinfo->cinfo, COL_INFO, "MagicPacket for %s (%s)",
get_ether_name(mac), ether_to_str(mac));
/* NOTE: ether-wake uses a dotted-decimal format for specifying a
* 4-byte password or an Ethernet mac address format for specifying
* a 6-byte password, so display them in that format, even if the
* password isn't really an IP or MAC address. */
if ( passwd )
col_append_fstr(pinfo->cinfo, COL_INFO, ", password %s", passwd);
}
/* A protocol dissector can be called in 2 different ways:
(a) Operational dissection
In this mode, Wireshark is only interested in the way protocols
interact, protocol conversations are created, packets are
reassembled and handed over to higher-level protocol dissectors.
In this mode Wireshark does not build a so-called "protocol
tree".
(b) Detailed dissection
In this mode, Wireshark is also interested in all details of
a given protocol, so a "protocol tree" is created.
Wireshark distinguishes between the 2 modes with the proto_tree pointer:
(a) <=> tree == NULL
(b) <=> tree != NULL
In the interest of speed, if "tree" is NULL, avoid building a
protocol tree and adding stuff to it, or even looking at any packet
data needed only if you're building the protocol tree, if possible.
Note, however, that you must fill in column information, create
conversations, reassemble packets, build any other persistent state
needed for dissection, and call subdissectors regardless of whether
"tree" is NULL or not. This might be inconvenient to do without
doing most of the dissection work; the routines for adding items to
the protocol tree can be passed a null protocol tree pointer, in
which case they'll return a null item pointer, and
"proto_item_add_subtree()" returns a null tree pointer if passed a
null item pointer, so, if you're careful not to dereference any null
tree or item pointers, you can accomplish this by doing all the
dissection work. This might not be as efficient as skipping that
work if you're not building a protocol tree, but if the code would
have a lot of tests whether "tree" is null if you skipped that work,
you might still be better off just doing all that work regardless of
whether "tree" is null or not. */
if (tree) {
/* NOTE: The offset and length values in the call to
"proto_tree_add_item()" define what data bytes to highlight in the hex
display window when the line in the protocol tree display
corresponding to that item is selected.
Supplying a length of -1 is the way to highlight all data from the
offset to the end of the packet. */
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_wol, tvb, 0, len, ENC_NA);
proto_item_append_text(ti, ", MAC: %s (%s)", get_ether_name(mac),
ether_to_str(mac));
if ( passwd )
proto_item_append_text(ti, ", password: %s", passwd);
wol_tree = proto_item_add_subtree(ti, ett_wol);
/* add an item to the subtree, see section 1.6 for more information */
proto_tree_add_item(wol_tree, hf_wol_sync, tvb, 0, 6, ENC_NA);
/* Continue adding tree items to process the packet here */
mti = proto_tree_add_text(wol_tree, tvb, 6, 96, "MAC: %s (%s)",
get_ether_name(mac), ether_to_str(mac));
mac_tree = proto_item_add_subtree(mti, ett_wol_macblock);
for ( offset = 6; offset < 102; offset += 6 )
proto_tree_add_ether(mac_tree, hf_wol_mac, tvb, offset, 6, mac);
if ( len == 106 )
proto_tree_add_bytes_format(wol_tree, hf_wol_passwd, tvb, offset,
4, passwd, "Password: %s", passwd);
else if ( len == 108 )
proto_tree_add_bytes_format(wol_tree, hf_wol_passwd, tvb, offset,
6, passwd, "Password: %s", passwd);
}
/* If this protocol has a sub-dissector call it here, see section 1.8 */
/* Return the amount of data this dissector was able to dissect */
if ( pinfo->ethertype == ETHERTYPE_WOL )
return (len);
/* Heuristic dissectors return TRUE/FALSE. */
return (TRUE);
}
/*
* Name: dissect_lsp_mgt_info_clv()
*
* Description:
* Decode for a lsp packet's management information clv.
*
* Input:
* tvbuff_t * : tvbuffer for packet data
* proto_tree * : protocol display tree to fill out. May be NULL
* int : offset into packet data where we are.
* int : length of clv we are decoding
*
* Output:
* void, but we will add to proto tree if !NULL.
*/
static void
dissect_lsp_mgt_info_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
int length)
{
guint8 name_length;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short management info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Network number: 0x%08x",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 6) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short management info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Node number: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
length -= 6;
if (length < 1) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short management info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"IPX version number: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
length -= 1;
if (length < 1) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short management info entry");
return;
}
name_length = tvb_get_guint8(tvb, offset);
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"Name length: %u", name_length);
}
offset += 1;
length -= 1;
if (name_length != 0) {
if (length < name_length) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short management info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, name_length,
"Name: %s",
tvb_format_text(tvb, offset, name_length));
}
offset += name_length;
length -= name_length;
}
}
/* Code to actually dissect the packets */
static int
dissect_ans(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
proto_item *ti;
proto_tree *ans_tree = NULL;
guint16 sender_id;
guint32 seq_num;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Intel ANS probe");
seq_num = tvb_get_ntohl(tvb, 4);
sender_id = tvb_get_ntohs(tvb, 8);
col_add_fstr(pinfo->cinfo, COL_INFO, "Sequence: %u, Sender ID %u, Team ID %s",
seq_num, sender_id, tvb_ether_to_str(tvb, 10));
if (tree) {
ti = proto_tree_add_item(tree, proto_ans, tvb, 0, -1, ENC_NA);
ans_tree = proto_item_add_subtree(ti, ett_ans);
proto_tree_add_item(ans_tree, hf_ans_app_id, tvb, 0, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(ans_tree, hf_ans_rev_id, tvb, 2, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(ans_tree, hf_ans_seq_num, tvb, 4, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ans_tree, hf_ans_sender_id, tvb, 8, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(ans_tree, hf_ans_team_id, tvb, 10, 6, ENC_NA);
}
return tvb_captured_length(tvb);
}
static void
dissect_hpsw_tlv(tvbuff_t *tvb, int offset, int length,
proto_tree *tree, proto_item *ti, guint8 type)
{
switch (type) {
case HPFOO_DEVICE_NAME:
if (length > 0) {
proto_item_set_text(ti, "Device Name: %s", tvb_format_text(tvb, offset, length - 1));
proto_tree_add_text(tree, tvb, offset, length, "Device Name: %s", tvb_format_text(tvb, offset, length - 1));
} else {
proto_item_set_text(ti, "Device Name: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Device Name: Bad length %u", length);
}
break;
case HPFOO_DEVICE_VERSION:
if (length > 0) {
proto_item_set_text(ti, "Version: %s", tvb_format_text(tvb, offset, length - 1));
proto_tree_add_text(tree, tvb, offset, length, "Version: %s", tvb_format_text(tvb, offset, length - 1));
} else {
proto_item_set_text(ti, "Version: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Version: Bad length %u", length);
}
break;
case HPFOO_CONFIG_NAME:
if (length > 0) {
proto_item_set_text(ti, "Config: %s", tvb_format_text(tvb, offset, length - 1));
proto_tree_add_text(tree, tvb, offset, length, "Config: %s", tvb_format_text(tvb, offset, length - 1));
} else {
proto_item_set_text(ti, "Config: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Config: Bad length %u", length);
}
break;
case HPFOO_IP_ADDR:
if (length == 4) {
const char *ipstr = tvb_ip_to_str(tvb, offset);
proto_item_set_text(ti, "IP Addr: %s", ipstr);
proto_tree_add_text(tree, tvb, offset, length, "IP Addr: %s", ipstr);
} else {
proto_item_set_text(ti, "IP Addr: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "IP Addr: Bad length %u", length);
}
break;
case HPFOO_FIELD_7:
if (length == 1) {
proto_item_set_text(ti, "Field 7: 0x%02x", tvb_get_guint8(tvb,offset));
proto_tree_add_text(tree, tvb, offset, length, "Field 7: 0x%02x", tvb_get_guint8(tvb,offset));
} else {
proto_item_set_text(ti, "Field 7: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Field 7: Bad length %u", length);
}
break;
case HPFOO_FIELD_8:
if (length == 2) {
proto_item_set_text(ti, "Field 8: 0x%04x", tvb_get_ntohs(tvb,offset));
proto_tree_add_text(tree, tvb, offset, length, "Field 8: 0x%04x", tvb_get_ntohs(tvb,offset));
} else {
proto_item_set_text(ti, "Field 8: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Field 8: Bad length %u", length);
}
break;
case HPFOO_FIELD_9:
if (length == 2) {
proto_item_set_text(ti, "Field 9: 0x%04x", tvb_get_ntohs(tvb,offset));
proto_tree_add_text(tree, tvb, offset, length, "Field 9: 0x%04x", tvb_get_ntohs(tvb,offset));
} else {
proto_item_set_text(ti, "Field 9: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Field 9: Bad length %u", length);
}
break;
case HPFOO_FIELD_10:
if (length == 4) {
proto_item_set_text(ti, "Field 10: 0x%08x", tvb_get_ntohl(tvb,offset));
proto_tree_add_text(tree, tvb, offset, length, "Field 10: 0x%08x", tvb_get_ntohl(tvb,offset));
} else {
proto_item_set_text(ti, "Field 10: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Field 10: Bad length %u", length);
}
break;
case HPFOO_FIELD_12:
if (length == 1) {
proto_item_set_text(ti, "Field 12: 0x%02x", tvb_get_guint8(tvb,offset));
proto_tree_add_text(tree, tvb, offset, length, "Field 12: 0x%02x", tvb_get_guint8(tvb,offset));
} else {
proto_item_set_text(ti, "Field 12: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Field 12: Bad length %u", length);
}
break;
case HPFOO_DEVICE_ID:
if (length == 10) {
const gchar *macstr = tvb_ether_to_str(tvb, offset);
guint32 id=tvb_get_ntohl(tvb, offset+6);
proto_item_set_text(ti, "Device ID: %s / %u", macstr, id);
proto_tree_add_text(tree, tvb, offset, 10, "Device ID: %s / %u", macstr, id);
} else {
proto_item_set_text(ti, "Device ID: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Device ID: Bad length %u", length);
}
break;
case HPFOO_MAC_ADDR:
if (length == 6) {
const gchar *macstr = tvb_ether_to_str(tvb, offset);
proto_item_set_text(ti, "MAC Addr: %s", macstr);
proto_tree_add_text(tree, tvb, offset, length, "MAC Addr: %s", macstr);
} else {
proto_item_set_text(ti, "MAC Addr: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "MAC Addr: Bad length %u", length);
}
break;
default:
proto_tree_add_text(tree, tvb, offset, length, "Data");
break;
}
}
static void
dissect_lsp_link_info_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
int length)
{
guint8 flags_cost;
if (length < 1) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
flags_cost = tvb_get_guint8(tvb, offset);
proto_tree_add_text(tree, tvb, offset, 1, "%s",
decode_boolean_bitfield(flags_cost, 0x80, 1*8,
"Cost not present", "Cost present"));
if (!(flags_cost & 0x80)) {
/*
* 0x80 clear => cost present.
*/
proto_tree_add_text(tree, tvb, offset, 1, "%s",
decode_boolean_bitfield(flags_cost, 0x40, 1*8,
"Cost is internal metric",
"Cost is external metric"));
proto_tree_add_text(tree, tvb, offset, 1, "%s",
decode_numeric_bitfield(flags_cost, 0x3F, 1*8,
"Cost = %u"));
}
}
offset += 1;
length -= 1;
if (length < 3) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
offset += 3; /* Reserved */
length -= 3;
if (length < 7) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Router System ID: %s",
tvb_ether_to_str(tvb, offset));
proto_tree_add_text(tree, tvb, offset+6, 1,
"Router Pseudonode ID: %u",
tvb_get_guint8(tvb, offset+6));
}
offset += 7;
length -= 7;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"MTU Size: %u",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Delay: %uus",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 4) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 4,
"Throughput: %u bits/s",
tvb_get_ntohl(tvb, offset));
}
offset += 4;
length -= 4;
if (length < 2) {
nlsp_dissect_unknown(tvb, tree, offset,
"Short link info entry");
return;
}
if (tree) {
proto_tree_add_text(tree, tvb, offset, 2,
"Media type: %s",
val_to_str(tvb_get_ntohs(tvb, offset), media_type_vals,
"Unknown (0x%04x)"));
}
offset += 2;
length -= 2;
}
static int
dissect_mactelnet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *mactelnet_item;
proto_tree *mactelnet_tree;
proto_item *mactelnet_control_item;
proto_tree *mactelnet_control_tree;
int foundping = -1;
int foundclient = -1;
int foundserver = -1;
guint16 type;
/* Check that there's enough data */
if (tvb_length(tvb) < 18)
return 0;
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_MACTELNET);
/* Get the type byte */
type = tvb_get_guint8(tvb, 1);
if ((type == 4 || type == 5)) { /* Ping */
foundping = 1;
} else {
int i = 0;
while (clienttypenames[i].strptr != NULL) {
if (tvb_get_ntohs(tvb, 14) == clienttypenames[i].value) {
foundserver = i;
break;
}
if (tvb_get_ntohs(tvb, 16) == clienttypenames[i].value) {
foundclient = i;
break;
}
i++;
}
}
/* Not a mactelnet packet */
if (foundping < 0 && foundclient < 0 && foundserver < 0) {
return 0;
}
col_add_fstr(pinfo->cinfo, COL_INFO, "%s > %s Direction: %s Type: %s",
tvb_ether_to_str(tvb, 2),
tvb_ether_to_str(tvb, 8),
(foundclient >= 0 || type == 4 ? "Client->Server" : "Server->Client" ),
val_to_str(type, packettypenames, "Unknown Type:0x%02x")
);
if (tree) {
guint32 offset = 0;
/* create display subtree for the protocol */
mactelnet_item = proto_tree_add_item(tree, proto_mactelnet, tvb, 0, -1, ENC_NA);
mactelnet_tree = proto_item_add_subtree(mactelnet_item, ett_mactelnet);
/* ver(1) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_protocolver, tvb, offset, 1, ENC_NA);
offset++;
/* ptype(1) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_type, tvb, offset, 1, ENC_NA);
offset++;
/* saddr(6) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_source_mac, tvb, offset, 6, ENC_NA);
offset += 6;
/* dstaddr(6) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_destination_mac, tvb, offset, 6, ENC_NA);
offset += 6;
if (foundserver >= 0) {
/* Server to client */
/* sessionid(2) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_session_id, tvb, offset+2, 2, ENC_BIG_ENDIAN);
offset += 2;
/* clienttype(2) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_client_type, tvb, offset-2, 2, ENC_BIG_ENDIAN);
offset += 2;
} else if (foundclient >= 0) {
/* Client to server */
/* sessionid(2) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_session_id, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
/* clienttype(2) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_client_type, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
} else if (foundping >= 0) {
/* Skip empty data */
offset += 4;
}
if (foundping < 0) {
/* counter(4) */
proto_tree_add_item(mactelnet_tree, hf_mactelnet_databytes, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
}
/* Data packets only */
if (type == 1) {
while(tvb_reported_length_remaining(tvb, offset) > 0) {
if (tvb_reported_length_remaining(tvb, offset) > 4 && tvb_get_ntohl(tvb, offset) == control_packet) {
guint8 datatype;
guint32 datalength;
/* Add subtree for control packet */
mactelnet_control_item = proto_tree_add_item(mactelnet_tree, hf_mactelnet_control, tvb, offset, -1, ENC_NA);
mactelnet_control_tree = proto_item_add_subtree(mactelnet_control_item, ett_mactelnet);
/* Control packet magic number (4) */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_packet, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
/* Control packet type (1) */
datatype = tvb_get_guint8(tvb, offset);
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_datatype, tvb, offset, 1, ENC_NA);
offset++;
/* Control packet length (4) */
datalength = tvb_get_ntohl(tvb, offset);
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_length, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
switch (datatype) {
case 1: /* Encryption Key */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_encryption_key, tvb, offset, datalength, ENC_NA);
break;
case 2: /* Password */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_password, tvb, offset, datalength, ENC_NA);
break;
case 3: /* Username */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_username, tvb, offset, datalength, ENC_NA);
break;
case 4: /* Terminal type */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_terminal, tvb, offset, datalength, ENC_NA);
break;
case 5: /* Terminal width */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_width, tvb, offset, 2, ENC_LITTLE_ENDIAN);
break;
case 6: /* Terminal height */
proto_tree_add_item(mactelnet_control_tree, hf_mactelnet_control_height, tvb, offset, 2, ENC_LITTLE_ENDIAN);
break;
case 9: /* End authentication (no data) */
break;
}
proto_item_set_len (mactelnet_control_item, datalength + 9);
offset += datalength;
} else {
/* Data packet, let wireshark handle it */
tvbuff_t *next_client = tvb_new_subset(tvb, offset, -1, -1);
return call_dissector(data_handle, next_client, pinfo, mactelnet_tree);
}
}
} else if (type == 4 || type == 5) {
/* Data packet, let wireshark handle it */
tvbuff_t *next_client = tvb_new_subset(tvb, offset, -1, -1);
return call_dissector(data_handle, next_client, pinfo, mactelnet_tree);
}
}
return tvb_reported_length(tvb);
}
static void
dissect_dtp_tlv(tvbuff_t *tvb, int offset, int length,
proto_tree *tree, proto_item *ti, guint8 type)
{
switch (type) {
case TYPE_DOMAIN:
if (length > 0) {
proto_item_set_text(ti, "Domain: %s", tvb_format_text(tvb, offset, length - 1));
proto_tree_add_text(tree, tvb, offset, length, "Domain: %s", tvb_format_text(tvb, offset, length - 1));
} else {
proto_item_set_text(ti, "Domain: Bad length %u", length);
proto_tree_add_text(tree, tvb, offset, length, "Domain: Bad length %u", length);
}
break;
case TYPE_STATUS:
if (length > 0) {
proto_item_set_text(ti,
"Status: 0x%02x",
tvb_get_guint8(tvb, offset));
proto_tree_add_text(tree, tvb, offset, 1,
"Status: 0x%02x",
tvb_get_guint8(tvb, offset));
} else {
proto_item_set_text(ti,
"Status: Bad length %u",
length);
proto_tree_add_text(tree, tvb, offset, length,
"Status: Bad length %u",
length);
}
break;
case TYPE_DTPTYPE:
if (length > 0) {
proto_item_set_text(ti,
"Dtptype: 0x%02x",
tvb_get_guint8(tvb, offset));
proto_tree_add_text(tree, tvb, offset, 1,
"Dtptype: 0x%02x",
tvb_get_guint8(tvb, offset));
} else {
proto_item_set_text(ti,
"Dtptype: Bad length %u",
length);
proto_tree_add_text(tree, tvb, offset, length,
"Dtptype: Bad length %u",
length);
}
break;
case TYPE_NEIGHBOR:
if (length == 6) {
proto_item_set_text(ti, "Neighbor: %s",
tvb_ether_to_str(tvb, offset)); /* XXX - resolve? */
proto_tree_add_item(tree, hf_dtp_some_mac, tvb, offset, length, ENC_NA);
} else {
proto_item_set_text(ti,
"Neighbor: Bad length %u",
length);
proto_tree_add_text(tree, tvb, offset, length,
"Neighbor: Bad length %u",
length);
}
break;
default:
proto_tree_add_text(tree, tvb, offset, length, "Data");
break;
}
}
/* Code to actually dissect the PAGP packets */
static void
dissect_pagp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint32 raw_word;
guint16 raw_half_word;
guint16 num_tlvs;
guint16 tlv;
guint16 len;
guint16 ii;
guint16 offset = PAGP_FIRST_TLV;
guint8 raw_octet;
guint8 flags;
guchar *ch;
proto_tree *pagp_tree = NULL;
proto_item *pagp_item;
proto_tree *flags_tree;
proto_item *flags_item;
proto_tree *tlv_tree;
proto_item *tlv_item;
const char *sep;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PAGP"); /* PAGP Protocol */
col_clear(pinfo->cinfo, COL_INFO);
pinfo->current_proto = "PAGP";
raw_octet = tvb_get_guint8(tvb, PAGP_VERSION_NUMBER);
if (tree) {
pagp_item = proto_tree_add_protocol_format(tree, proto_pagp, tvb,
0, -1, "Port Aggregation Protocol");
pagp_tree = proto_item_add_subtree(pagp_item, ett_pagp);
proto_tree_add_uint(pagp_tree, hf_pagp_version_number, tvb,
PAGP_VERSION_NUMBER, 1, raw_octet);
}
col_append_str(pinfo->cinfo, COL_INFO,
val_to_str_const(raw_octet, pdu_vers, "Unknown PDU version"));
if (raw_octet == PAGP_FLUSH_PDU) {
col_append_fstr(pinfo->cinfo, COL_INFO, "; Local DevID: %s",
tvb_ether_to_str(tvb, PAGP_FLUSH_LOCAL_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_flush_local_device_id, tvb,
PAGP_FLUSH_LOCAL_DEVICE_ID, 6, ENC_NA);
col_append_fstr(pinfo->cinfo, COL_INFO, ", Partner DevID: %s",
tvb_ether_to_str(tvb, PAGP_FLUSH_PARTNER_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_flush_partner_device_id, tvb,
PAGP_FLUSH_PARTNER_DEVICE_ID, 6, ENC_NA);
raw_word = tvb_get_ntohl(tvb, PAGP_FLUSH_TRANSACTION_ID);
col_append_fstr(pinfo->cinfo, COL_INFO, "; Transaction ID: 0x%x ", raw_word);
proto_tree_add_uint(pagp_tree, hf_pagp_flush_transaction_id, tvb,
PAGP_FLUSH_TRANSACTION_ID, 4, raw_word);
return;
}
/* Info PDU */
flags = tvb_get_guint8(tvb, PAGP_FLAGS);
col_append_fstr(pinfo->cinfo, COL_INFO, "; Flags 0x%x", flags);
if (tree) {
flags_item = proto_tree_add_uint(pagp_tree, hf_pagp_flags, tvb,
PAGP_FLAGS, 1, flags);
flags_tree = proto_item_add_subtree(flags_item, ett_pagp_flags);
sep = initial_sep;
APPEND_BOOLEAN_FLAG(flags & PAGP_FLAGS_SLOW_HELLO, flags_item, "%sSlow Hello");
proto_tree_add_boolean(flags_tree, hf_pagp_flags_slow_hello, tvb,
PAGP_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & PAGP_FLAGS_AUTO_MODE, flags_item, "%sAuto Mode");
proto_tree_add_boolean(flags_tree, hf_pagp_flags_auto_mode, tvb,
PAGP_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & PAGP_FLAGS_CONSISTENT_STATE, flags_item,
"%sConsistent State");
proto_tree_add_boolean(flags_tree, hf_pagp_flags_consistent_state, tvb,
PAGP_FLAGS, 1, flags);
sep = cont_sep;
if (sep != initial_sep) {
/* We put something in; put in the terminating ")" */
proto_item_append_text(flags_item, ")");
}
}
col_append_fstr(pinfo->cinfo, COL_INFO, "; Local DevID: %s",
tvb_ether_to_str(tvb, PAGP_LOCAL_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_local_device_id, tvb,
PAGP_LOCAL_DEVICE_ID, 6, ENC_NA);
if (tree) {
raw_octet = tvb_get_guint8(tvb, PAGP_LOCAL_LEARN_CAP);
proto_tree_add_uint(pagp_tree, hf_pagp_local_learn_cap, tvb,
PAGP_LOCAL_LEARN_CAP, 1, raw_octet);
raw_octet = tvb_get_guint8(tvb, PAGP_LOCAL_PORT_PRIORITY);
proto_tree_add_uint(pagp_tree, hf_pagp_local_port_priority, tvb,
PAGP_LOCAL_PORT_PRIORITY, 1, raw_octet);
raw_word = tvb_get_ntohl(tvb, PAGP_LOCAL_SENT_PORT_IFINDEX);
proto_tree_add_uint(pagp_tree, hf_pagp_local_sent_port_ifindex, tvb,
PAGP_LOCAL_SENT_PORT_IFINDEX, 4, raw_word);
raw_word = tvb_get_ntohl(tvb, PAGP_LOCAL_GROUP_CAPABILITY);
proto_tree_add_uint(pagp_tree, hf_pagp_local_group_capability, tvb,
PAGP_LOCAL_GROUP_CAPABILITY, 4, raw_word);
raw_word = tvb_get_ntohl(tvb, PAGP_LOCAL_GROUP_IFINDEX);
proto_tree_add_uint(pagp_tree, hf_pagp_local_group_ifindex, tvb,
PAGP_LOCAL_GROUP_IFINDEX, 4, raw_word);
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", Partner DevID: %s",
tvb_ether_to_str(tvb, PAGP_PARTNER_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_partner_device_id, tvb,
PAGP_PARTNER_DEVICE_ID, 6, ENC_NA);
if (tree) {
raw_octet = tvb_get_guint8(tvb, PAGP_PARTNER_LEARN_CAP);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_learn_cap, tvb,
PAGP_PARTNER_LEARN_CAP, 1, raw_octet);
raw_octet = tvb_get_guint8(tvb, PAGP_PARTNER_PORT_PRIORITY);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_port_priority, tvb,
PAGP_PARTNER_PORT_PRIORITY, 1, raw_octet);
raw_word = tvb_get_ntohl(tvb, PAGP_PARTNER_SENT_PORT_IFINDEX);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_sent_port_ifindex, tvb,
PAGP_PARTNER_SENT_PORT_IFINDEX, 4, raw_word);
raw_word = tvb_get_ntohl(tvb, PAGP_PARTNER_GROUP_CAPABILITY);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_group_capability, tvb,
PAGP_PARTNER_GROUP_CAPABILITY, 4, raw_word);
raw_word = tvb_get_ntohl(tvb, PAGP_PARTNER_GROUP_IFINDEX);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_group_ifindex, tvb,
PAGP_PARTNER_GROUP_IFINDEX, 4, raw_word);
raw_half_word = tvb_get_ntohs(tvb, PAGP_PARTNER_COUNT);
proto_tree_add_uint(pagp_tree, hf_pagp_partner_count, tvb,
PAGP_PARTNER_COUNT, 2, raw_half_word);
num_tlvs = tvb_get_ntohs(tvb, PAGP_NUM_TLVS);
proto_tree_add_uint(pagp_tree, hf_pagp_num_tlvs, tvb,
PAGP_NUM_TLVS, 2, num_tlvs);
/* dump TLV entries */
for ( ii = 0; ii < num_tlvs; ii++ ) {
tlv = tvb_get_ntohs(tvb, offset);
len = tvb_get_ntohs(tvb, offset + 2);
if ( len == 0 ) {
proto_tree_add_text(pagp_tree, tvb, offset, -1,
"Unknown data - TLV len=0");
return;
}
tlv_item = proto_tree_add_text (pagp_tree, tvb, offset, len,
"TLV Entry #%d", ii+1);
tlv_tree = proto_item_add_subtree (tlv_item, ett_pagp_tlvs);
proto_tree_add_uint_format (tlv_tree, hf_pagp_tlv, tvb,
offset,2,tlv,"Type = %d (%s)", tlv,
val_to_str_const(tlv,tlv_types, "Unknown")) ;
proto_tree_add_text (tlv_tree, tvb, offset+2, 2,
"Length = %u bytes (includes Type and Length)", len) ;
if ( tvb_reported_length_remaining(tvb, offset) < len ) {
proto_tree_add_text(tlv_tree, tvb, offset, -1,
"TLV length too large");
return;
}
switch (tlv) {
case PAGP_TLV_DEVICE_NAME:
ch = tvb_get_string(wmem_packet_scope(), tvb, offset+4, len-4);
proto_tree_add_string(tlv_tree, hf_pagp_tlv_device_name,
tvb, offset+4, len-4, ch);
break;
case PAGP_TLV_PORT_NAME:
ch = tvb_get_string(wmem_packet_scope(), tvb, offset+4, len-4);
proto_tree_add_string(tlv_tree, hf_pagp_tlv_port_name,
tvb, offset+4, len-4, ch);
break;
case PAGP_TLV_AGPORT_MAC:
proto_tree_add_item(tlv_tree, hf_pagp_tlv_agport_mac,
tvb, offset+4, 6, ENC_NA);
break;
case PAGP_TLV_RESERVED:
break;
}
offset += len;
}
}
}
/* Sub-vectors */
static int
sv_text(tvbuff_t *tvb, int svoff, packet_info *pinfo, proto_tree *tree)
{
guint sv_length, sv_id;
guint16 beacon_type, ring;
const char *beacon[] = {
"Recovery mode set", "Signal loss error",
"Streaming signal not Claim Token MAC frame",
"Streaming signal, Claim Token MAC frame"
};
proto_tree *sv_tree, *sv_subtree;
proto_item *sv_item, *len_item, *ti;
guchar errors[6]; /* isolating or non-isolating */
sv_length = tvb_get_guint8(tvb, svoff+0);
/* Check the SV length; it must be at least 2, to include
the subvector length and indicator. */
if (sv_length < 2) {
ti = proto_tree_add_text(tree, tvb, svoff+0, 1,
"Invalid subvector: length < 2");
sv_tree = proto_item_add_subtree(ti, ett_tr_sv);
len_item = proto_tree_add_uint(sv_tree, hf_trmac_sv_len, tvb, svoff+0, 1, sv_length);
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is zero");
return 0; /* tells our caller to give up */
}
sv_item = proto_tree_add_text(tree, tvb, svoff+0, sv_length,
"Subvector: length %u", sv_length);
sv_tree = proto_item_add_subtree(sv_item, ett_tr_sv);
len_item = proto_tree_add_uint(sv_tree, hf_trmac_sv_len, tvb, svoff+0, 1, sv_length);
sv_id = tvb_get_guint8(tvb, svoff+1);
proto_tree_add_uint(sv_tree, hf_trmac_sv_id, tvb, svoff+1, 1, sv_id);
proto_item_set_text(sv_item, "%s", val_to_str(sv_id, subvector_vs, "Unknown subvector ID 0x%02X"));
switch(sv_id) {
case 0x01: /* Beacon Type */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
beacon_type = tvb_get_ntohs(tvb, svoff+2);
if (beacon_type < array_length(beacon)) {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Beacon Type: %s", beacon[beacon_type] );
proto_item_append_text(sv_item,
": %s", beacon[beacon_type] );
} else {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Beacon Type: Illegal value: %d", beacon_type );
proto_item_append_text(sv_item,
": Illegal value: %d", beacon_type );
}
break;
case 0x02: /* Upstream Neighbor's Address */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 8");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_naun, tvb, svoff+2, sv_length-2, ENC_NA);
proto_item_append_text(sv_item, ": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x03: /* Local Ring Number */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
ring = tvb_get_ntohs(tvb, svoff+2);
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Local Ring Number: 0x%04X (%d)", ring, ring);
proto_item_append_text(sv_item,
": 0x%04X (%d)", ring, ring);
break;
case 0x04: /* Assign Physical Drop Number */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 6");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Assign Physical Drop Number: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
proto_item_append_text(sv_item,
": 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x05: /* Error Report Timer Value */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Error Report Timer Value: %d ms", 10 * tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %d ms", 10 * tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x06: /* Authorized Function Classes */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Authorized Function Classes: %04X", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x07: /* Authorized Access Priority */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Authorized Access Priority: %04X", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x09: /* Correlator */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Correlator: %04X", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x0A: /* SA of Last AMP or SMP Frame */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 8");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"SA of Last AMP or SMP Frame: %s",
tvb_ether_to_str(tvb, svoff+2));
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x0B: /* Physical Drop Number */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 6");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Physical Drop Number: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
proto_item_append_text(sv_item,
": 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x20: /* Response Code */
if (sv_length != 4 && sv_length != 6) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4 and != 6");
break;
}
if (sv_length == 4) {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Response Code: 0x%04X 0x%02X 0x%02x",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_guint8(tvb, svoff+5));
proto_item_append_text(sv_item,
": 0x%04X 0x%02X 0x%02x",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_guint8(tvb, svoff+5));
} else {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Response Code: 0x%04X 0x%02X 0x%06X",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_ntoh24(tvb, svoff+5));
proto_item_append_text(sv_item,
": 0x%04X 0x%02X 0x%06X",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_ntoh24(tvb, svoff+5));
}
break;
case 0x21: /* Individual Address Count */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Individual Address Count: %u", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %u", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x22: /* Product Instance ID */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Product Instance ID: ...");
break;
case 0x23: /* Ring Station Version Number */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Ring Station Version Number: ...");
break;
case 0x26: /* Wrap data */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Wrap Data: ... (%u bytes)", sv_length - 2);
break;
case 0x27: /* Frame Forward */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Frame Forward: ... (%d bytes)", sv_length - 2);
break;
case 0x28: /* Station Identifier */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 8");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Station Identifier: %s",
tvb_ether_to_str(tvb, svoff+2));
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x29: /* Ring Station Status */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Ring Station Status: ...");
break;
case 0x2A: /* Transmit Status Code */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Transmit Status Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x2B: /* Group Address */
if (sv_length != 6 && sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 6 and != 8");
break;
}
if (sv_length == 6) {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Group Address: %08X", tvb_get_ntohl(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %08X", tvb_get_ntohl(tvb, svoff+2) );
} else {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Group Address: %s",
tvb_ether_to_str(tvb, svoff+2));
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
}
break;
case 0x2C: /* Functional Addresses */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 6");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Functional Addresses: %08X", tvb_get_ntohl(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x2D: /* Isolating Error Counts */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 8");
break;
}
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(sv_tree, hf_trmac_errors_iso, tvb, svoff+2, sv_length-2,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_subtree = proto_item_add_subtree(ti, ett_tr_ierr_cnt);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_line, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_internal, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_burst, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_ac, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_abort, tvb, svoff+6, 1, errors[4]);
break;
case 0x2E: /* Non-Isolating Error Counts */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 8");
break;
}
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(sv_tree, hf_trmac_errors_noniso, tvb, svoff+2, sv_length-2,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_subtree = proto_item_add_subtree(ti, ett_tr_nerr_cnt);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_lost, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_congestion, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_fc, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_freq, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_token, tvb, svoff+6, 1, errors[4]);
break;
case 0x30: /* Error Code */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, PI_MALFORMED, PI_ERROR,
"Subvector length is != 4");
break;
}
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Error Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
default: /* Unknown */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Unknown Subvector");
break;
}
return sv_length;
}
/* Sub-vectors */
static int
sv_text(tvbuff_t *tvb, int svoff, packet_info *pinfo, proto_tree *tree)
{
guint sv_length, sv_id;
guint16 beacon_type, ring;
guint32 error_report_timer_value;
proto_tree *sv_tree, *sv_subtree;
proto_item *sv_item, *len_item, *ti;
guchar errors[6]; /* isolating or non-isolating */
sv_item = proto_tree_add_text(tree, tvb, svoff+0, 1, "Subvector");
sv_tree = proto_item_add_subtree(sv_item, ett_tr_sv);
sv_length = tvb_get_guint8(tvb, svoff+0);
len_item = proto_tree_add_item(sv_tree, hf_trmac_sv_len, tvb, svoff+0, 1, ENC_NA);
/* Check the SV length; it must be at least 2, to include
the subvector length and indicator. */
if (sv_length < 2) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Invalid subvector: length < 2");
return 0; /* tells our caller to give up */
}
sv_id = tvb_get_guint8(tvb, svoff+1);
proto_tree_add_item(sv_tree, hf_trmac_sv_id, tvb, svoff+1, 1, ENC_NA);
proto_item_append_text(sv_item, " (%s)", val_to_str(sv_id, subvector_vs, "Unknown subvector ID 0x%02X"));
switch(sv_id) {
case 0x01: /* Beacon Type */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
beacon_type = tvb_get_ntohs(tvb, svoff+2);
proto_tree_add_uint_format_value(sv_tree, hf_trmac_beacon_type, tvb, svoff+2, sv_length-2,
beacon_type, "%s", val_to_str(beacon_type, beacon_vs, "Illegal value: %d"));
proto_item_append_text(sv_item,
": %s", val_to_str(beacon_type, beacon_vs, "Illegal value: %d"));
break;
case 0x02: /* Upstream Neighbor's Address */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 8");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_naun, tvb, svoff+2, sv_length-2, ENC_NA);
proto_item_append_text(sv_item, ": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x03: /* Local Ring Number */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
ring = tvb_get_ntohs(tvb, svoff+2);
proto_tree_add_item(sv_tree, hf_trmac_local_ring_number, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": 0x%04X (%d)", ring, ring);
break;
case 0x04: /* Assign Physical Drop Number */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 6");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_assign_physical_drop_number, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x05: /* Error Report Timer Value */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
error_report_timer_value = 10 * tvb_get_ntohs(tvb, svoff+2);
proto_tree_add_uint_format_value(sv_tree, hf_trmac_error_report_timer_value, tvb, svoff+2, sv_length-2,
error_report_timer_value, "%d ms", error_report_timer_value );
proto_item_append_text(sv_item,
": %d ms", error_report_timer_value );
break;
case 0x06: /* Authorized Function Classes */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_authorized_function_classes, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x07: /* Authorized Access Priority */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_authorized_access_priority, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x09: /* Correlator */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_correlator, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x0A: /* SA of Last AMP or SMP Frame */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 8");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_sa_of_last_amp_or_smp_frame, tvb, svoff+2, sv_length-2, ENC_NA);
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x0B: /* Physical Drop Number */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 6");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_physical_drop_number, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x20: /* Response Code */
if (sv_length != 4 && sv_length != 6) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4 and != 6");
break;
}
if (sv_length == 4) {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Response Code: 0x%04X 0x%02X 0x%02x",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_guint8(tvb, svoff+5));
proto_item_append_text(sv_item,
": 0x%04X 0x%02X 0x%02x",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_guint8(tvb, svoff+5));
} else {
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Response Code: 0x%04X 0x%02X 0x%06X",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_ntoh24(tvb, svoff+5));
proto_item_append_text(sv_item,
": 0x%04X 0x%02X 0x%06X",
tvb_get_ntohs(tvb, svoff+2),
tvb_get_guint8(tvb, svoff+4),
tvb_get_ntoh24(tvb, svoff+5));
}
break;
case 0x21: /* Individual Address Count */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_individual_address_count, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %u", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x22: /* Product Instance ID */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Product Instance ID: ...");
break;
case 0x23: /* Ring Station Version Number */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Ring Station Version Number: ...");
break;
case 0x26: /* Wrap data */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Wrap Data: ... (%u bytes)", sv_length - 2);
break;
case 0x27: /* Frame Forward */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Frame Forward: ... (%d bytes)", sv_length - 2);
break;
case 0x28: /* Station Identifier */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 8");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_station_identifier, tvb, svoff+2, sv_length-2, ENC_NA);
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x29: /* Ring Station Status */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Ring Station Status: ...");
break;
case 0x2A: /* Transmit Status Code */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_transmit_status_code, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x2B: /* Group Address */
if (sv_length != 6 && sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 6 and != 8");
break;
}
if (sv_length == 6) {
proto_tree_add_item(sv_tree, hf_trmac_group_address32, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %08X", tvb_get_ntohl(tvb, svoff+2) );
} else {
proto_tree_add_item(sv_tree, hf_trmac_group_address_ether, tvb, svoff+2, sv_length-2, ENC_NA);
proto_item_append_text(sv_item,
": %s",
tvb_ether_to_str(tvb, svoff+2));
}
break;
case 0x2C: /* Functional Addresses */
if (sv_length != 6) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 6");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_functional_addresses, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x2D: /* Isolating Error Counts */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 8");
break;
}
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(sv_tree, hf_trmac_errors_iso, tvb, svoff+2, sv_length-2,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_subtree = proto_item_add_subtree(ti, ett_tr_ierr_cnt);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_line, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_internal, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_burst, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_ac, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_abort, tvb, svoff+6, 1, errors[4]);
break;
case 0x2E: /* Non-Isolating Error Counts */
if (sv_length != 8) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 8");
break;
}
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(sv_tree, hf_trmac_errors_noniso, tvb, svoff+2, sv_length-2,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_subtree = proto_item_add_subtree(ti, ett_tr_nerr_cnt);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_lost, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_congestion, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_fc, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_freq, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_subtree, hf_trmac_errors_token, tvb, svoff+6, 1, errors[4]);
break;
case 0x30: /* Error Code */
if (sv_length != 4) {
expert_add_info_format(pinfo, len_item, &ei_trmac_sv_len,
"Subvector length is != 4");
break;
}
proto_tree_add_item(sv_tree, hf_trmac_error_code, tvb, svoff+2, sv_length-2, ENC_BIG_ENDIAN);
proto_item_append_text(sv_item,
": %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
default: /* Unknown */
proto_tree_add_text(sv_tree, tvb, svoff+2, sv_length-2,
"Unknown Subvector");
break;
}
return sv_length;
}
static void
nlsp_dissect_nlsp_hello(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, int hello_type, int header_length)
{
guint16 packet_length;
int len;
guint16 holding_timer;
if (tree) {
if (hello_type == NLSP_TYPE_WAN_HELLO) {
proto_tree_add_item(tree, hf_nlsp_hello_state, tvb,
offset, 1, ENC_BIG_ENDIAN);
} else {
proto_tree_add_item(tree, hf_nlsp_hello_multicast, tvb,
offset, 1, ENC_BIG_ENDIAN);
}
proto_tree_add_item(tree, hf_nlsp_hello_circuit_type, tvb,
offset, 1, ENC_BIG_ENDIAN);
}
offset += 1;
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Sending Router System ID: %s",
tvb_ether_to_str(tvb, offset));
}
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_fstr(pinfo->cinfo, COL_INFO, ", System ID: %s",
tvb_ether_to_str(tvb, offset));
}
offset += 6;
if (tree) {
holding_timer = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint_format(tree, hf_nlsp_hello_holding_timer,
tvb, offset, 2, holding_timer,
"Holding Timer: %us", holding_timer);
}
offset += 2;
packet_length = tvb_get_ntohs(tvb, offset);
if (tree) {
proto_tree_add_uint(tree, hf_nlsp_packet_length, tvb,
offset, 2, packet_length);
}
offset += 2;
if (tree) {
proto_tree_add_item(tree, hf_nlsp_hello_priority, tvb,
offset, 1, ENC_BIG_ENDIAN);
}
offset += 1;
if (hello_type == NLSP_TYPE_WAN_HELLO) {
if (tree) {
proto_tree_add_text(tree, tvb, offset, 1,
"Local WAN Circuit ID: %u",
tvb_get_guint8(tvb, offset));
}
offset += 1;
} else {
if (tree) {
proto_tree_add_text(tree, tvb, offset, 6,
"Designated Router System ID: %s",
tvb_ether_to_str(tvb, offset));
proto_tree_add_text(tree, tvb, offset+6, 1,
"Designated Router Pseudonode ID: %u",
tvb_get_guint8(tvb, offset+6));
}
offset += 7;
}
len = packet_length - header_length;
if (len < 0) {
nlsp_dissect_unknown(tvb, tree, offset,
"packet header length %d went beyond packet",
header_length);
return;
}
/*
* Now, we need to decode our CLVs. We need to pass in
* our list of valid ones!
*/
nlsp_dissect_clvs(tvb, tree, offset,
clv_hello_opts, len, ett_nlsp_hello_clv_unknown);
}
static void
dissect_ipxsap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *sap_tree, *s_tree;
proto_item *ti, *hidden_item;
int cursor;
struct sap_query query;
guint16 server_type;
gchar *server_name;
guint16 server_port;
guint16 intermediate_network;
static const char *sap_type[4] = { "General Query", "General Response",
"Nearest Query", "Nearest Response" };
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPX SAP");
col_clear(pinfo->cinfo, COL_INFO);
query.query_type = tvb_get_ntohs(tvb, 0);
query.server_type = tvb_get_ntohs(tvb, 2);
if (check_col(pinfo->cinfo, COL_INFO)) {
if (query.query_type >= 1 && query.query_type <= 4) {
col_set_str(pinfo->cinfo, COL_INFO, sap_type[query.query_type - 1]);
}
else {
col_set_str(pinfo->cinfo, COL_INFO, "Unknown Packet Type");
}
}
if (tree) {
ti = proto_tree_add_item(tree, proto_sap, tvb, 0, -1, ENC_NA);
sap_tree = proto_item_add_subtree(ti, ett_ipxsap);
if (query.query_type >= 1 && query.query_type <= 4) {
proto_tree_add_text(sap_tree, tvb, 0, 2, "%s", sap_type[query.query_type - 1]);
if ((query.query_type - 1) % 2) {
hidden_item = proto_tree_add_boolean(sap_tree,
hf_sap_response,
tvb, 0, 2, 1);
} else {
hidden_item = proto_tree_add_boolean(sap_tree,
hf_sap_request,
tvb, 0, 2, 1);
}
PROTO_ITEM_SET_HIDDEN(hidden_item);
}
else {
proto_tree_add_text(sap_tree, tvb, 0, 2,
"Unknown SAP Packet Type %d", query.query_type);
}
if (query.query_type == IPX_SAP_GENERAL_RESPONSE ||
query.query_type == IPX_SAP_NEAREST_RESPONSE) { /* responses */
int available_length = tvb_reported_length(tvb);
for (cursor = 2; (cursor + 64) <= available_length; cursor += 64) {
server_type = tvb_get_ntohs(tvb, cursor);
server_name = tvb_format_stringzpad(tvb, cursor+2, 48);
ti = proto_tree_add_text(sap_tree, tvb, cursor+2, 48,
"Server Name: %s", server_name);
s_tree = proto_item_add_subtree(ti, ett_ipxsap_server);
proto_tree_add_text(s_tree, tvb, cursor, 2, "Server Type: %s (0x%04X)",
val_to_str_ext_const(server_type, &novell_server_vals_ext, "Unknown"),
server_type);
proto_tree_add_text(s_tree, tvb, cursor+50, 4, "Network: %s",
ipxnet_to_string(tvb_get_ptr(tvb, cursor+50, 4)));
proto_tree_add_text(s_tree, tvb, cursor+54, 6, "Node: %s",
tvb_ether_to_str(tvb, cursor+54));
server_port = tvb_get_ntohs(tvb, cursor+60);
proto_tree_add_text(s_tree, tvb, cursor+60, 2, "Socket: %s (0x%04x)",
socket_text(server_port),
server_port);
intermediate_network = tvb_get_ntohs(tvb, cursor+62);
proto_tree_add_text(s_tree, tvb, cursor+62, 2,
"Intermediate Networks: %d",
intermediate_network);
}
}
else { /* queries */
proto_tree_add_text(sap_tree, tvb, 2, 2, "Server Type: %s (0x%04X)",
val_to_str_ext_const(query.server_type, &novell_server_vals_ext, "Unknown"),
query.server_type);
}
}
}
/* Sub-vectors */
static int
sv_text(tvbuff_t *tvb, int svoff, proto_tree *tree)
{
int sv_length = tvb_get_guint8(tvb, svoff+0);
guint16 beacon_type, ring;
const char *beacon[] = {
"Recovery mode set", "Signal loss error",
"Streaming signal not Claim Token MAC frame",
"Streaming signal, Claim Token MAC frame"
};
proto_tree *sv_tree;
proto_item *ti, *hidden_item;
guchar errors[6]; /* isolating or non-isolating */
/* Check the SV length.
XXX - Should we do this in each case statement below, e.g. to force
an SV length of 6 for the NAUN address? */
if (sv_length < 1) {
proto_tree_add_protocol_format(tree, proto_malformed, tvb, svoff+0, 1,
"Invalid subvector length: %d bytes", sv_length);
return sv_length;
}
/* this just adds to the clutter on the screen...
proto_tree_add_text(tree, tvb, svoff, 1,
"Subvector Length: %d bytes", sv_length);*/
hidden_item = proto_tree_add_uint(tree, hf_trmac_sv, tvb, svoff+1, 1, tvb_get_guint8(tvb, svoff+1));
PROTO_ITEM_SET_HIDDEN(hidden_item);
switch(tvb_get_guint8(tvb, svoff+1)) {
case 0x01: /* Beacon Type */
beacon_type = tvb_get_ntohs(tvb, svoff+2);
if (beacon_type < array_length(beacon)) {
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Beacon Type: %s", beacon[beacon_type] );
} else {
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Beacon Type: Illegal value: %d", beacon_type );
}
break;
case 0x02: /* NAUN */
proto_tree_add_ether(tree, hf_trmac_naun, tvb, svoff+1, sv_length-1,
tvb_get_ptr(tvb, svoff+2, 6));
break;
case 0x03: /* Local Ring Number */
ring = tvb_get_ntohs(tvb, svoff+2);
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Local Ring Number: 0x%04X (%d)", ring, ring);
break;
case 0x04: /* Assign Physical Location */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Assign Physical Location: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x05: /* Soft Error Report Value */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Soft Error Report Value: %d ms", 10 * tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x06: /* Enabled Function Classes */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Enabled Function Classes: %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x07: /* Allowed Access Priority */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Allowed Access Priority: %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x09: /* Correlator */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Correlator: %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x0A: /* Address of last neighbor notification */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Address of Last Neighbor Notification: %s",
tvb_ether_to_str(tvb, svoff+2));
break;
case 0x0B: /* Physical Location */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Physical Location: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x20: /* Response Code */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Response Code: 0x%04X 0x%04X", tvb_get_ntohl(tvb, svoff+2),
tvb_get_ntohl(tvb, svoff+4) );
break;
case 0x21: /* Reserved */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Reserved: 0x%04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x22: /* Product Instance ID */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Product Instance ID: ...");
break;
case 0x23: /* Ring Station Microcode Level */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Ring Station Microcode Level: ...");
break;
case 0x26: /* Wrap data */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Wrap Data: ... (%d bytes)", sv_length - 2);
break;
case 0x27: /* Frame Forward */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Frame Forward: ... (%d bytes)", sv_length - 2);
break;
case 0x29: /* Ring Station Status Subvector */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Ring Station Status Subvector: ...");
break;
case 0x2A: /* Transmit Status Code */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Transmit Status Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
case 0x2B: /* Group Address */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Group Address: %08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x2C: /* Functional Address */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Functional Address: %08X", tvb_get_ntohl(tvb, svoff+2) );
break;
case 0x2D: /* Isolating Error Counts */
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(tree, hf_trmac_errors_iso, tvb, svoff+1, sv_length-1,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_tree = proto_item_add_subtree(ti, ett_tr_ierr_cnt);
proto_tree_add_uint(sv_tree, hf_trmac_errors_line, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_internal, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_burst, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_ac, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_abort, tvb, svoff+6, 1, errors[4]);
break;
case 0x2E: /* Non-Isolating Error Counts */
tvb_memcpy(tvb, errors, svoff+2, 6);
ti = proto_tree_add_uint(tree, hf_trmac_errors_noniso, tvb, svoff+1, sv_length-1,
errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
sv_tree = proto_item_add_subtree(ti, ett_tr_nerr_cnt);
proto_tree_add_uint(sv_tree, hf_trmac_errors_lost, tvb, svoff+2, 1, errors[0]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_congestion, tvb, svoff+3, 1, errors[1]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_fc, tvb, svoff+4, 1, errors[2]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_freq, tvb, svoff+5, 1, errors[3]);
proto_tree_add_uint(sv_tree, hf_trmac_errors_token, tvb, svoff+6, 1, errors[4]);
break;
case 0x30: /* Error Code */
proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
"Error Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
break;
default: /* Unknown */
proto_tree_add_text(tree, tvb, svoff+1, 1,
"Unknown Sub-Vector: 0x%02X", tvb_get_guint8(tvb, svoff+1));
}
return sv_length;
}
static void
dissect_wfd_subelem_session_info(packet_info *pinfo, proto_tree *tree,
tvbuff_t *tvb, int offset, guint16 len)
{
int end = offset + len, next;
proto_item *item;
proto_tree *descr;
while (offset < end) {
guint8 dlen = tvb_get_guint8(tvb, offset);
next = offset + 1 + dlen;
item = proto_tree_add_text(tree, tvb, offset, 1 + dlen,
"WFD Device Info Descriptor");
descr = proto_item_add_subtree(item, ett_wfd_dev_info_descr);
if (offset + 1 + dlen > end || dlen < 23) {
expert_add_info(pinfo, item, &ei_wfd_subelem_session_descr_invalid);
break;
}
proto_tree_add_item(descr, hf_wfd_subelem_session_descr_len,
tvb, offset, 1, ENC_BIG_ENDIAN);
offset++;
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_addr, tvb, offset, 6,
ENC_NA);
proto_item_append_text(descr, ": %s", tvb_ether_to_str(tvb, offset));
offset += 6;
proto_tree_add_item(descr, hf_wfd_subelem_session_assoc_bssid,
tvb, offset, 6, ENC_NA);
offset += 6;
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_type,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr,
hf_wfd_subelem_session_dev_info_coupled_sink_source,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr,
hf_wfd_subelem_session_dev_info_coupled_sink_sink,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_available,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_wsd,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_pc,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr,
hf_wfd_subelem_session_dev_info_content_protection,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_time_sync,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree,
hf_wfd_subelem_session_dev_info_audio_unsupp_pri_sink,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree,
hf_wfd_subelem_session_dev_info_audio_only_supp_source,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree,
hf_wfd_subelem_session_dev_info_tdls_persistent_group,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree,
hf_wfd_subelem_session_dev_info_tdls_persistent_group_reinvoke,
tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tree,
hf_wfd_subelem_session_dev_info_reserved,
tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(descr, hf_wfd_subelem_session_dev_info_max_throughput,
tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(descr,
hf_wfd_subelem_session_coupled_sink_status_bitmap,
tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(descr,
hf_wfd_subelem_session_coupled_sink_reserved,
tvb, offset, 1, ENC_BIG_ENDIAN);
offset++;
proto_tree_add_item(descr, hf_wfd_subelem_session_coupled_sink_addr,
tvb, offset, 6, ENC_NA);
offset += 6;
if (offset < next) {
proto_tree_add_text(descr, tvb, offset, next - offset,
"Extra info in the end of descriptor");
}
offset = next;
}
}
/* Code to actually dissect the PAGP packets */
static void
dissect_pagp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint32 raw_word;
guint16 num_tlvs;
guint16 tlv;
guint16 len;
guint16 ii;
guint16 offset = PAGP_FIRST_TLV;
guint8 raw_octet;
guint8 flags;
proto_tree *pagp_tree = NULL;
proto_item *pagp_item, *len_item;
proto_tree *tlv_tree;
static const int * pagp_flags[] = {
&hf_pagp_flags_slow_hello,
&hf_pagp_flags_auto_mode,
&hf_pagp_flags_consistent_state,
NULL,
};
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PAGP"); /* PAGP Protocol */
col_clear(pinfo->cinfo, COL_INFO);
pinfo->current_proto = "PAGP";
raw_octet = tvb_get_guint8(tvb, PAGP_VERSION_NUMBER);
if (tree) {
pagp_item = proto_tree_add_protocol_format(tree, proto_pagp, tvb,
0, -1, "Port Aggregation Protocol");
pagp_tree = proto_item_add_subtree(pagp_item, ett_pagp);
proto_tree_add_uint(pagp_tree, hf_pagp_version_number, tvb,
PAGP_VERSION_NUMBER, 1, raw_octet);
}
col_append_str(pinfo->cinfo, COL_INFO,
val_to_str_const(raw_octet, pdu_vers, "Unknown PDU version"));
if (raw_octet == PAGP_FLUSH_PDU) {
col_append_fstr(pinfo->cinfo, COL_INFO, "; Local DevID: %s",
tvb_ether_to_str(tvb, PAGP_FLUSH_LOCAL_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_flush_local_device_id, tvb,
PAGP_FLUSH_LOCAL_DEVICE_ID, 6, ENC_NA);
col_append_fstr(pinfo->cinfo, COL_INFO, ", Partner DevID: %s",
tvb_ether_to_str(tvb, PAGP_FLUSH_PARTNER_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_flush_partner_device_id, tvb,
PAGP_FLUSH_PARTNER_DEVICE_ID, 6, ENC_NA);
raw_word = tvb_get_ntohl(tvb, PAGP_FLUSH_TRANSACTION_ID);
col_append_fstr(pinfo->cinfo, COL_INFO, "; Transaction ID: 0x%x ", raw_word);
proto_tree_add_uint(pagp_tree, hf_pagp_flush_transaction_id, tvb,
PAGP_FLUSH_TRANSACTION_ID, 4, raw_word);
return;
}
/* Info PDU */
flags = tvb_get_guint8(tvb, PAGP_FLAGS);
col_append_fstr(pinfo->cinfo, COL_INFO, "; Flags 0x%x", flags);
proto_tree_add_bitmask(pagp_tree, tvb, PAGP_FLAGS, hf_pagp_flags, ett_pagp_flags, pagp_flags, ENC_NA);
col_append_fstr(pinfo->cinfo, COL_INFO, "; Local DevID: %s",
tvb_ether_to_str(tvb, PAGP_LOCAL_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_local_device_id, tvb,
PAGP_LOCAL_DEVICE_ID, 6, ENC_NA);
if (tree) {
proto_tree_add_item(pagp_tree, hf_pagp_local_learn_cap, tvb,
PAGP_LOCAL_LEARN_CAP, 1, ENC_NA);
proto_tree_add_item(pagp_tree, hf_pagp_local_port_priority, tvb,
PAGP_LOCAL_PORT_PRIORITY, 1, ENC_NA);
proto_tree_add_item(pagp_tree, hf_pagp_local_sent_port_ifindex, tvb,
PAGP_LOCAL_SENT_PORT_IFINDEX, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(pagp_tree, hf_pagp_local_group_capability, tvb,
PAGP_LOCAL_GROUP_CAPABILITY, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(pagp_tree, hf_pagp_local_group_ifindex, tvb,
PAGP_LOCAL_GROUP_IFINDEX, 4, ENC_BIG_ENDIAN);
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", Partner DevID: %s",
tvb_ether_to_str(tvb, PAGP_PARTNER_DEVICE_ID));
proto_tree_add_item(pagp_tree, hf_pagp_partner_device_id, tvb,
PAGP_PARTNER_DEVICE_ID, 6, ENC_NA);
proto_tree_add_item(pagp_tree, hf_pagp_partner_learn_cap, tvb,
PAGP_PARTNER_LEARN_CAP, 1, ENC_NA);
proto_tree_add_item(pagp_tree, hf_pagp_partner_port_priority, tvb,
PAGP_PARTNER_PORT_PRIORITY, 1, ENC_NA);
proto_tree_add_item(pagp_tree, hf_pagp_partner_sent_port_ifindex, tvb,
PAGP_PARTNER_SENT_PORT_IFINDEX, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(pagp_tree, hf_pagp_partner_group_capability, tvb,
PAGP_PARTNER_GROUP_CAPABILITY, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(pagp_tree, hf_pagp_partner_group_ifindex, tvb,
PAGP_PARTNER_GROUP_IFINDEX, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(pagp_tree, hf_pagp_partner_count, tvb,
PAGP_PARTNER_COUNT, 2, ENC_BIG_ENDIAN);
num_tlvs = tvb_get_ntohs(tvb, PAGP_NUM_TLVS);
proto_tree_add_uint(pagp_tree, hf_pagp_num_tlvs, tvb,
PAGP_NUM_TLVS, 2, num_tlvs);
/* dump TLV entries */
for ( ii = 0; ii < num_tlvs; ii++ ) {
tlv = tvb_get_ntohs(tvb, offset);
len = tvb_get_ntohs(tvb, offset + 2);
tlv_tree = proto_tree_add_subtree_format(pagp_tree, tvb, offset, len,
ett_pagp_tlvs, NULL, "TLV Entry #%d", ii+1);
proto_tree_add_uint(tlv_tree, hf_pagp_tlv, tvb, offset, 2, tlv);
len_item = proto_tree_add_uint(tlv_tree, hf_pagp_tlv_length, tvb, offset+2, 2, len);
if ( len == 0 ) {
expert_add_info_format(pinfo, len_item, &ei_pagp_tlv_length,
"Unknown data - TLV len=0");
return;
}
if ( tvb_reported_length_remaining(tvb, offset) < len ) {
expert_add_info_format(pinfo, len_item, &ei_pagp_tlv_length,
"TLV length too large");
return;
}
switch (tlv) {
case PAGP_TLV_DEVICE_NAME:
proto_tree_add_item(tlv_tree, hf_pagp_tlv_device_name,
tvb, offset+4, len-4, ENC_NA|ENC_ASCII);
break;
case PAGP_TLV_PORT_NAME:
proto_tree_add_item(tlv_tree, hf_pagp_tlv_port_name,
tvb, offset+4, len-4, ENC_NA|ENC_ASCII);
break;
case PAGP_TLV_AGPORT_MAC:
proto_tree_add_item(tlv_tree, hf_pagp_tlv_agport_mac,
tvb, offset+4, 6, ENC_NA);
break;
case PAGP_TLV_RESERVED:
break;
}
offset += len;
}
}
