/* * Handles one Auto-RP map entry. Returns the new offset. */ static int do_auto_rp_map(tvbuff_t *tvb, int offset, proto_tree *auto_rp_tree) { proto_item *ti; proto_tree *map_tree; guint8 group_count; guint32 rp_addr; /* In network byte order */ int i; rp_addr = tvb_get_ipv4(tvb, offset); group_count = tvb_get_guint8(tvb, offset + 5); /* sizeof map header + n * sizeof encoded group addresses */ ti = proto_tree_add_text(auto_rp_tree, tvb, offset, 6 + group_count * 6, "RP %s: %u group%s", ip_to_str((void *)&rp_addr), group_count, plurality(group_count, "", "s")); map_tree = proto_item_add_subtree(ti, ett_auto_rp_map); proto_tree_add_ipv4(map_tree, hf_auto_rp_rp_addr, tvb, offset, 4, rp_addr); offset += 4; proto_tree_add_uint(map_tree, hf_auto_rp_pim_ver, tvb, offset, 1, tvb_get_guint8(tvb, offset)); offset++; proto_tree_add_text(map_tree, tvb, offset, 1, "Number of groups this RP maps to: %u", group_count); offset++; for (i = 0; i < group_count; i++) { proto_item *gi; proto_tree *grp_tree; guint8 sign, mask_len; guint32 group_addr; /* In network byte order */ sign = tvb_get_guint8(tvb, offset); mask_len = tvb_get_guint8(tvb, offset + 1); group_addr = tvb_get_ipv4(tvb, offset + 2); gi = proto_tree_add_text(map_tree, tvb, offset, 6, "Group %s/%u (%s)", ip_to_str((void *)&group_addr), mask_len, val_to_str(sign&AUTO_RP_SIGN_MASK, auto_rp_mask_sign_vals, "")); grp_tree = proto_item_add_subtree(gi, ett_auto_rp_group); proto_tree_add_uint(grp_tree, hf_auto_rp_prefix_sgn, tvb, offset, 1, sign); offset++; proto_tree_add_uint(grp_tree, hf_auto_rp_mask_len, tvb, offset, 1, mask_len); offset++; proto_tree_add_ipv4(grp_tree, hf_auto_rp_group_prefix, tvb, offset, 4, group_addr); offset += 4; } return offset; }
static int dissect_bp_address(tvbuff_t *tvb, int offset, proto_tree *tree, int hfindex) { guint32 type; guint32 ipaddr; type = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_bootparams_addresstype, offset); switch(type){ case 1: ipaddr = ((tvb_get_guint8(tvb, offset+3 )&0xff)<<24) |((tvb_get_guint8(tvb, offset+7 )&0xff)<<16) |((tvb_get_guint8(tvb, offset+11)&0xff)<<8 ) |((tvb_get_guint8(tvb, offset+15)&0xff) ); proto_tree_add_ipv4(tree, hfindex, tvb, offset, 16, g_ntohl(ipaddr)); offset += 16; break; default: break; } return offset; }
static void msproxy_sub_dissector( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { /* Conversation dissector called from TCP or UDP dissector. Decode and */ /* display the msproxy header, the pass the rest of the data to the tcp */ /* or udp port decode routine to handle the payload. */ guint32 *ptr; redirect_entry_t *redirect_info; conversation_t *conversation; proto_tree *msp_tree; proto_item *ti; conversation = find_conversation( pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, pinfo->srcport, pinfo->destport, 0); DISSECTOR_ASSERT( conversation); /* should always find a conversation */ redirect_info = conversation_get_proto_data(conversation, proto_msproxy); col_set_str(pinfo->cinfo, COL_PROTOCOL, "MS Proxy"); if (check_col(pinfo->cinfo, COL_INFO)) col_set_str(pinfo->cinfo, COL_INFO, (( redirect_info->proto == PT_TCP) ? "TCP stream" : "UDP packets")); if ( tree) { ti = proto_tree_add_item( tree, proto_msproxy, tvb, 0, 0, FALSE ); msp_tree = proto_item_add_subtree(ti, ett_msproxy); proto_tree_add_uint( msp_tree, hf_msproxy_dstport, tvb, 0, 0, redirect_info->remote_port); proto_tree_add_ipv4( msp_tree, hf_msproxy_dstaddr, tvb, 0, 0, redirect_info->remote_addr); } /* set pinfo->{src/dst port} and call the UDP sub-dissector lookup */ if ( pinfo->srcport == redirect_info->clnt_port) ptr = &pinfo->destport; else ptr = &pinfo->srcport; *ptr = redirect_info->remote_port; if ( redirect_info->proto == PT_TCP) decode_tcp_ports( tvb, 0, pinfo, tree, pinfo->srcport, pinfo->destport, NULL); else decode_udp_ports( tvb, 0, pinfo, tree, pinfo->srcport, pinfo->destport, -1); *ptr = redirect_info->server_int_port; }
static void decode_iei_ip_address(nsip_ie_t *ie, build_info_t *bi, int ie_start_offset) { guint8 addr_type; guint32 ip4_addr; struct e_in6_addr ip6_addr; addr_type = tvb_get_guint8(bi->tvb, bi->offset); proto_tree_add_item(bi->nsip_tree, hf_nsip_ip_address_type, bi->tvb, bi->offset, 1, ENC_BIG_ENDIAN); switch (addr_type) { case NSIP_IP_ADDRESS_TYPE_IPV4: ie->total_length = 2 + ipv4_element.address_length; ip4_addr = tvb_get_ipv4(bi->tvb, bi->offset+1); proto_tree_add_ipv4(bi->nsip_tree, hf_nsip_ip_address_ipv4, bi->tvb, ie_start_offset, ie->total_length, ip4_addr); break; case NSIP_IP_ADDRESS_TYPE_IPV6: ie->total_length = 2 + ipv6_element.address_length; tvb_get_ipv6(bi->tvb, bi->offset+1, &ip6_addr); proto_tree_add_ipv6(bi->nsip_tree, hf_nsip_ip_address_ipv4, bi->tvb, ie_start_offset, ie->total_length, (guint8 *)&ip6_addr); break; default: return; /* error */ } bi->offset += ie->value_length; }
static void dissect_vektor_igrp (tvbuff_t *tvb, proto_tree *igrp_vektor_tree, guint8 network) { guint8 *ptr_addr,addr[5]; address ip_addr; addr[0]=network; addr[1]=tvb_get_guint8(tvb,0); addr[2]=tvb_get_guint8(tvb,1); addr[3]=tvb_get_guint8(tvb,2); addr[4]=0; ptr_addr=addr; if (network==0) ptr_addr=&addr[1]; SET_ADDRESS(&ip_addr, AT_IPv4, 4, ptr_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, *((guint32*)ptr_addr)); 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 int zebra_route(proto_tree *tree, tvbuff_t *tvb, int offset, guint16 len, guint8 family) { guint32 prefix4; guint8 message, prefixlen, buffer6[16]; proto_tree_add_item(tree, hf_zebra_type, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_zebra_rtflags, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; message = tvb_get_guint8(tvb, offset); offset = zebra_route_message(tree, tvb, offset, message); prefixlen = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_prefixlen, tvb, offset, 1, prefixlen); offset += 1; if (family == ZEBRA_FAMILY_IPV6) { memset(buffer6, '\0', sizeof buffer6); tvb_memcpy(tvb, buffer6, offset, MIN((unsigned) PSIZE(prefixlen), sizeof buffer6)); proto_tree_add_ipv6(tree, hf_zebra_prefix6, tvb, offset, PSIZE(prefixlen), buffer6); }else { prefix4 = 0; tvb_memcpy(tvb, (guint8 *)&prefix4, offset, MIN((unsigned) PSIZE(prefixlen), sizeof prefix4)); proto_tree_add_ipv4(tree, hf_zebra_prefix4, tvb, offset, PSIZE(prefixlen), prefix4); } offset += PSIZE(prefixlen); if (message & ZEBRA_ZAPI_MESSAGE_NEXTHOP) { offset = zebra_route_nexthop(tree, tvb, offset, len); } if (message & ZEBRA_ZAPI_MESSAGE_IFINDEX) { offset = zebra_route_ifindex(tree, tvb, offset, len); } if (message & ZEBRA_ZAPI_MESSAGE_DISTANCE) { proto_tree_add_item(tree, hf_zebra_distance, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; } if (message & ZEBRA_ZAPI_MESSAGE_METRIC) { proto_tree_add_item(tree, hf_zebra_metric, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } return offset; }
static void decode_ipv4_attribute(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_item *item, int* hfValue, int offset, int length) { guint32 ip_address; if (length < 8) { expert_add_info(pinfo, item, &ei_opsi_short_attribute); return; } ip_address = tvb_get_ipv4(tvb, offset+4); proto_tree_add_ipv4(tree, *hfValue, tvb, offset+4, 4, ip_address); }
static int dissect_msnip_gm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset) { guint8 count; /* group count */ count = tvb_get_guint8(tvb, offset); proto_tree_add_uint(parent_tree, hf_count, tvb, offset, 1, count); offset += 1; /* checksum */ igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); offset += 2; /* holdtime */ proto_tree_add_uint(parent_tree, hf_holdtime, tvb, offset, 4, count); offset += 4; while (count--) { proto_tree *tree; proto_item *item; guint32 maddr; guint8 masklen; int old_offset = offset; item = proto_tree_add_item(parent_tree, hf_groups, tvb, offset, -1, ENC_NA); tree = proto_item_add_subtree(item, ett_groups); /* multicast group */ maddr = tvb_get_ipv4(tvb, offset); proto_tree_add_ipv4(tree, hf_maddr, tvb, offset, 4, maddr); offset += 4; /* mask length */ masklen = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_mask, tvb, offset, 1, masklen); offset += 1; /* skip 3 unused bytes */ offset += 3; if (item) { proto_item_set_text(item,"Group: %s/%d", ip_to_str((guint8 *)&maddr), masklen); proto_item_set_len(item, offset-old_offset); } } return offset; }
static int dissect_msnip_rmr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset) { guint8 count; /* group count */ count = tvb_get_guint8(tvb, offset); proto_tree_add_uint(parent_tree, hf_count, tvb, offset, 1, count); offset += 1; /* checksum */ igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); offset += 2; while (count--) { proto_tree *tree; proto_item *item; guint8 rec_type; guint32 maddr; int old_offset = offset; item = proto_tree_add_item(parent_tree, hf_groups, tvb, offset, -1, ENC_NA); tree = proto_item_add_subtree(item, ett_groups); /* record type */ rec_type = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_rec_type, tvb, offset, 1, rec_type); offset += 1; /* skip 3 unused bytes */ offset += 3; /* multicast group */ maddr = tvb_get_ipv4(tvb, offset); proto_tree_add_ipv4(tree, hf_maddr, tvb, offset, 4, maddr); offset += 4; if (item) { proto_item_set_text(item,"Group: %s %s", ip_to_str((guint8 *)&maddr), val_to_str(rec_type, msnip_rec_types, "Unknown Type:0x%02x")); proto_item_set_len(item, offset-old_offset); } } return offset; }
/* * dissect the description of link in roofnet */ static void dissect_roofnet_link(proto_tree *tree, tvbuff_t *tvb, guint *offset, guint link) { proto_item *it= NULL; proto_tree *subtree= NULL; ptvcursor_t *cursor= NULL; guint32 addr_src= 0; guint32 addr_dst= 0; addr_src= tvb_get_ipv4(tvb, *offset + ROOFNET_LINK_OFFSET_SRC); addr_dst= tvb_get_ipv4(tvb, *offset + ROOFNET_LINK_OFFSET_DST); it = proto_tree_add_text(tree, tvb, *offset, ROOFNET_LINK_LEN, "link: %u, src: %s, dst: %s", link, (char*)get_hostname(addr_src), (char*)get_hostname(addr_dst)); subtree= proto_item_add_subtree(it, ett_roofnet_link); proto_tree_add_ipv4(subtree, hf_roofnet_link_src, tvb, *offset, 4, addr_src); *offset += 4; cursor = ptvcursor_new(subtree, tvb, *offset); ptvcursor_add(cursor, hf_roofnet_link_forward, 4, FALSE); ptvcursor_add(cursor, hf_roofnet_link_rev, 4, FALSE); ptvcursor_add(cursor, hf_roofnet_link_seq, 4, FALSE); ptvcursor_add(cursor, hf_roofnet_link_age, 4, FALSE); ptvcursor_free(cursor); *offset = ptvcursor_current_offset(cursor); proto_tree_add_ipv4(subtree, hf_roofnet_link_dst, tvb, *offset, 4, addr_dst); /* don't increment offset here because the dst of this link is the src of the next one */ }
static int parse_teredo_orig(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, e_teredohdr *teredoh) { proto_item *ti = NULL; col_append_sep_str (pinfo->cinfo, COL_INFO, ", ", "Origin indication"); if (tree) { ti = proto_tree_add_item(tree, hf_teredo_orig, tvb, offset, 8, ENC_NA); tree = proto_item_add_subtree(ti, ett_teredo_orig); } offset += 2; teredoh->th_orgport = tvb_get_ntohs(tvb, offset); if (tree) { /* * The "usual arithmetic conversions" will convert * "teredoh->th_orgport" to an "int" (because all * "unsigned short" values will fit in an "int"), * which will zero-extend it. This means that * complementing it will turn all the zeroes in * the upper 16 bits into ones; we just want the * lower 16 bits (containing the port number) * complemented, with the result zero-extended. * * That's what the cast is for. */ proto_tree_add_uint(tree, hf_teredo_orig_port, tvb, offset, 2, (guint16)~teredoh->th_orgport); } offset += 2; teredoh->th_iporgaddr = tvb_get_ipv4(tvb, offset); if (tree) { proto_tree_add_ipv4(tree, hf_teredo_orig_addr, tvb, offset, 4, ~teredoh->th_iporgaddr); } offset += 4; return offset; }
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 guint dissect_s5066_address(tvbuff_t *tvb, guint offset, proto_tree *tree, gint source) { proto_item *ti = NULL; proto_tree *s5066_tree_address = NULL; guint32 addr; if (source) { ti = proto_tree_add_text(tree, tvb, offset, 4, "Source Address"); } else { ti = proto_tree_add_text(tree, tvb, offset, 4, "Destination Address"); } s5066_tree_address = proto_item_add_subtree(ti, ett_s5066_address); proto_tree_add_item(s5066_tree_address, hf_s5066_ad_size, tvb, offset, 1, FALSE); proto_tree_add_item(s5066_tree_address, hf_s5066_ad_group, tvb, offset, 1, FALSE); addr = tvb_get_ntohl(tvb, offset); addr = addr & 0x1FFFFFFF; proto_tree_add_ipv4(s5066_tree_address, hf_s5066_ad_address, tvb, offset, 4, g_htonl(addr)); return offset + 4; }
static void dissect_tpcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { tpcpdu_t tpcph; proto_tree *tpcp_tree = NULL, *field_tree = NULL; proto_item *ti, *tf; guint8 length = TPCP_VER_1_LENGTH; col_set_str(pinfo->cinfo, COL_PROTOCOL, "TPCP"); col_clear(pinfo->cinfo, COL_INFO); /* need to find out which version!! */ tpcph.version = tvb_get_guint8(tvb, 0); /* as version 1 and 2 are so similar use the same structure, just don't use as much for version 1*/ if (tpcph.version == TPCP_VER_1) { length = TPCP_VER_1_LENGTH; tvb_memcpy(tvb, (guint8 *) &tpcph, 0, length); } else if (tpcph.version == TPCP_VER_2){ length = TPCP_VER_2_LENGTH; tvb_memcpy(tvb, (guint8 *) &tpcph, 0, length); } tpcph.id = g_ntohs(tpcph.id); tpcph.flags = g_ntohs(tpcph.flags); tpcph.cport = g_ntohs(tpcph.cport); if (check_col(pinfo->cinfo, COL_INFO)) col_add_fstr(pinfo->cinfo, COL_INFO,"%s id %d CPort %s CIP %s SIP %s", val_to_str(tpcph.type, type_vals, "Unknown"), tpcph.id, get_udp_port(tpcph.cport), ip_to_str((guint8 *)&tpcph.caddr), ip_to_str((guint8 *)&tpcph.saddr)); if (tree) { ti = proto_tree_add_protocol_format(tree, proto_tpcp, tvb, 0, length, "Alteon WebSystems - Transparent Proxy Cache Protocol"); tpcp_tree = proto_item_add_subtree(ti, ett_tpcp); proto_tree_add_item(tpcp_tree, hf_tpcp_version, tvb, 0, 1, tpcph.version); proto_tree_add_uint_format(tpcp_tree, hf_tpcp_type, tvb, 1, 1, tpcph.type, "Type: %s (%d)", val_to_str(tpcph.type, type_vals, "Unknown"), tpcph.type); /* flags next , i'll do that when I can work out how to do it :-( */ tf = proto_tree_add_text(tpcp_tree, tvb, 2, 2, "Flags: 0x%04x",tpcph.flags); field_tree = proto_item_add_subtree(tf, ett_tpcp_flags); proto_tree_add_boolean(field_tree, hf_tpcp_flags_tcp, tvb, 2, 2, tpcph.flags); proto_tree_add_boolean(field_tree, hf_tpcp_flags_redir, tvb, 2,2, tpcph.flags); proto_tree_add_boolean(field_tree, hf_tpcp_flags_xon, tvb, 2, 2, tpcph.flags); proto_tree_add_boolean(field_tree, hf_tpcp_flags_xoff, tvb, 2, 2, tpcph.flags); proto_tree_add_uint(tpcp_tree, hf_tpcp_id, tvb, 4, 2, tpcph.id); proto_tree_add_uint_format(tpcp_tree, hf_tpcp_cport, tvb, 6, 2, tpcph.cport, "Client Source port: %s", get_udp_port(tpcph.cport)); proto_tree_add_ipv4(tpcp_tree, hf_tpcp_caddr, tvb, 8, 4, tpcph.caddr); proto_tree_add_ipv4(tpcp_tree, hf_tpcp_saddr, tvb, 12, 4, tpcph.saddr); if (tpcph.version == TPCP_VER_2) { proto_tree_add_ipv4(tpcp_tree, hf_tpcp_vaddr, tvb, 16, 4, tpcph.vaddr); proto_tree_add_ipv4(tpcp_tree, hf_tpcp_rasaddr, tvb, 20, 4, tpcph.rasaddr); proto_tree_add_text(tpcp_tree, tvb, 24, 4, "Signature: %u", tpcph.signature); } } }
static int dissect_zebra_request(proto_tree *tree, gboolean request, tvbuff_t *tvb, int offset, guint16 len, guint8 command) { guint32 prefix4; guint16 i; guint8 buffer6[16], prefixlen, message; proto_item *ti; proto_tree *msg_tree; proto_tree_add_uint(tree, hf_zebra_len, tvb, offset, 2, len); offset += 2; proto_tree_add_uint(tree, hf_zebra_command, tvb, offset, 1, command); offset += 1; switch(command) { case ZEBRA_INTERFACE_ADD: case ZEBRA_INTERFACE_UP: case ZEBRA_INTERFACE_DOWN: if (request) break; /* Request just subscribes to messages */ proto_tree_add_item(tree, hf_zebra_interface, tvb, offset, INTERFACE_NAMSIZ, ENC_ASCII|ENC_NA); offset += INTERFACE_NAMSIZ; proto_tree_add_item(tree, hf_zebra_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_intflags, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_metric, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_mtu, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_bandwidth, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case ZEBRA_INTERFACE_DELETE: proto_tree_add_item(tree, hf_zebra_interface, tvb, offset, INTERFACE_NAMSIZ, ENC_ASCII|ENC_NA); offset += INTERFACE_NAMSIZ; proto_tree_add_item(tree, hf_zebra_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case ZEBRA_INTERFACE_ADDRESS_ADD: case ZEBRA_INTERFACE_ADDRESS_DELETE: proto_tree_add_item(tree, hf_zebra_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_family, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; /* XXX - switch on the address family here, instead? */ if (len == 17) { /* IPv4 */ proto_tree_add_item(tree, hf_zebra_prefix4, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } else if (len == 41) { /* IPv6 */ proto_tree_add_item(tree, hf_zebra_prefix6, tvb, offset, 16, ENC_NA); offset += 16; } else break; proto_tree_add_item(tree, hf_zebra_prefixlen, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; if (len == 17) { /* IPv4 */ proto_tree_add_item(tree, hf_zebra_dest4, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } else if (len == 41) { /* IPv6 */ proto_tree_add_item(tree, hf_zebra_dest6, tvb, offset, 16, ENC_NA); offset += 16; } break; case ZEBRA_IPV4_ROUTE_ADD: case ZEBRA_IPV4_ROUTE_DELETE: proto_tree_add_item(tree, hf_zebra_type, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_zebra_rtflags, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; message = tvb_get_guint8(tvb, offset); ti = proto_tree_add_uint(tree, hf_zebra_message, tvb, offset, 1, message); msg_tree = proto_item_add_subtree(ti, ett_message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_nexthop, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_index, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_distance, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_metric, tvb, offset, 1, message); offset += 1; prefixlen = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_prefixlen, tvb, offset, 1, prefixlen); offset += 1; prefix4 = 0; tvb_memcpy(tvb, (guint8 *)&prefix4, offset, MIN((unsigned) PSIZE(prefixlen), sizeof prefix4)); proto_tree_add_ipv4(tree, hf_zebra_prefix4, tvb, offset, PSIZE(prefixlen), prefix4); offset += PSIZE(prefixlen); if (message & ZEBRA_ZAPI_MESSAGE_NEXTHOP) { i = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_nexthopnum, tvb, offset, 1, i); offset += 1; if (i>len) break; /* Sanity */ while (i--) { proto_tree_add_item(tree, hf_zebra_nexthop4, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } } if (message & ZEBRA_ZAPI_MESSAGE_IFINDEX) { i = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_indexnum, tvb, offset, 1, i); offset += 1; if (i>len) break; /* Sanity */ while (i--) { proto_tree_add_item(tree, hf_zebra_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } } if (message & ZEBRA_ZAPI_MESSAGE_DISTANCE) { proto_tree_add_item(tree, hf_zebra_distance, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; } if (message & ZEBRA_ZAPI_MESSAGE_METRIC) { proto_tree_add_item(tree, hf_zebra_metric, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } break; case ZEBRA_IPV6_ROUTE_ADD: case ZEBRA_IPV6_ROUTE_DELETE: proto_tree_add_item(tree, hf_zebra_type, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_zebra_rtflags, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; message = tvb_get_guint8(tvb, offset); ti = proto_tree_add_uint(tree, hf_zebra_message, tvb, offset, 1, message); msg_tree = proto_item_add_subtree(ti, ett_message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_nexthop, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_index, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_distance, tvb, offset, 1, message); proto_tree_add_boolean(msg_tree, hf_zebra_msg_metric, tvb, offset, 1, message); offset += 1; prefixlen = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_prefixlen, tvb, offset, 1, prefixlen); offset += 1; memset(buffer6, '\0', sizeof buffer6); tvb_memcpy(tvb, buffer6, offset, MIN((unsigned) PSIZE(prefixlen), sizeof buffer6)); proto_tree_add_ipv6(tree, hf_zebra_prefix6, tvb, offset, PSIZE(prefixlen), buffer6); offset += PSIZE(prefixlen); if (message & ZEBRA_ZAPI_MESSAGE_NEXTHOP) { i = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_nexthopnum, tvb, offset, 1, i); offset += 1; if (i>len) break; /* Sanity */ while (i--) { proto_tree_add_item(tree, hf_zebra_nexthop6, tvb, offset, 16, ENC_NA); offset += 16; } } if (message & ZEBRA_ZAPI_MESSAGE_IFINDEX) { i = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_zebra_indexnum, tvb, offset, 1, i); offset += 1; if (i>len) break; /* Sanity */ while (i--) { proto_tree_add_item(tree, hf_zebra_index, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } } if (message & ZEBRA_ZAPI_MESSAGE_DISTANCE) { proto_tree_add_item(tree, hf_zebra_distance, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; } if (message & ZEBRA_ZAPI_MESSAGE_METRIC) { proto_tree_add_item(tree, hf_zebra_metric, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } break; case ZEBRA_REDISTRIBUTE_ADD: case ZEBRA_REDISTRIBUTE_DELETE: proto_tree_add_item(tree, hf_zebra_type, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; break; case ZEBRA_REDISTRIBUTE_DEFAULT_ADD: case ZEBRA_REDISTRIBUTE_DEFAULT_DELETE: break; case ZEBRA_IPV4_NEXTHOP_LOOKUP: proto_tree_add_item(tree, hf_zebra_nexthop4, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_zebra_metric, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case ZEBRA_IPV6_NEXTHOP_LOOKUP: /* Not yet implemeted in ZEBRA */ break; } return offset; }
static void dissect_aodv_rreq(tvbuff_t *tvb, packet_info *pinfo, proto_tree *aodv_tree, proto_item *ti, gboolean is_ipv6) { int offset = 1; proto_item *tj; proto_tree *aodv_flags_tree; guint8 flags; guint8 hop_count; guint32 rreq_id; guint32 dest_addr_v4; struct e_in6_addr dest_addr_v6; guint32 dest_seqno; guint32 orig_addr_v4; struct e_in6_addr orig_addr_v6; guint32 orig_seqno; int extlen; flags = tvb_get_guint8(tvb, offset); if (aodv_tree) { tj = proto_tree_add_text(aodv_tree, tvb, offset, 1, "Flags:"); aodv_flags_tree = proto_item_add_subtree(tj, ett_aodv_flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_join, tvb, offset, 1, flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_repair, tvb, offset, 1, flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_gratuitous, tvb, offset, 1, flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_destinationonly, tvb, offset, 1, flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_unknown, tvb, offset, 1, flags); if (flags & RREQ_JOIN) proto_item_append_text(tj, " J"); if (flags & RREQ_REP) proto_item_append_text(tj, " R"); if (flags & RREQ_GRATRREP) proto_item_append_text(tj, " G"); if (flags & RREQ_DESTONLY) proto_item_append_text(tj, " D"); if (flags & RREQ_UNKNSEQ) proto_item_append_text(tj, " U"); } offset += 2; /* skip reserved byte */ hop_count = tvb_get_guint8(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_hopcount, tvb, offset, 1, hop_count); offset += 1; rreq_id = tvb_get_ntohl(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_rreq_id, tvb, offset, 4, rreq_id); offset += 4; if (is_ipv6) { tvb_get_ipv6(tvb, offset, &dest_addr_v6); if (aodv_tree) { proto_tree_add_ipv6(aodv_tree, hf_aodv_dest_ipv6, tvb, offset, INET6_ADDRLEN, (guint8 *)&dest_addr_v6); proto_item_append_text(ti, ", Dest IP: %s", ip6_to_str(&dest_addr_v6)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s", ip6_to_str(&dest_addr_v6)); offset += INET6_ADDRLEN; } else { dest_addr_v4 = tvb_get_ipv4(tvb, offset); if (aodv_tree) { proto_tree_add_ipv4(aodv_tree, hf_aodv_dest_ip, tvb, offset, 4, dest_addr_v4); proto_item_append_text(ti, ", Dest IP: %s", ip_to_str((guint8 *)&dest_addr_v4)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s", ip_to_str((guint8 *)&dest_addr_v4)); offset += 4; } dest_seqno = tvb_get_ntohl(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_dest_seqno, tvb, offset, 4, dest_seqno); offset += 4; if (is_ipv6) { tvb_get_ipv6(tvb, offset, &orig_addr_v6); if (aodv_tree) { proto_tree_add_ipv6(aodv_tree, hf_aodv_orig_ipv6, tvb, offset, INET6_ADDRLEN, (guint8 *)&orig_addr_v6); proto_item_append_text(ti, ", Orig IP: %s", ip6_to_str(&orig_addr_v6)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", O: %s", ip6_to_str(&orig_addr_v6)); offset += INET6_ADDRLEN; } else { orig_addr_v4 = tvb_get_ipv4(tvb, offset); if (aodv_tree) { proto_tree_add_ipv4(aodv_tree, hf_aodv_orig_ip, tvb, offset, 4, orig_addr_v4); proto_item_append_text(ti, ", Orig IP: %s", ip_to_str((guint8 *)&orig_addr_v4)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", O: %s", ip_to_str((guint8 *)&orig_addr_v4)); offset += 4; } orig_seqno = tvb_get_ntohl(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_orig_seqno, tvb, offset, 4, orig_seqno); col_append_fstr(pinfo->cinfo, COL_INFO, " Id=%u Hcnt=%u DSN=%u OSN=%u", rreq_id, hop_count, dest_seqno, orig_seqno); offset += 4; if (aodv_tree) { extlen = tvb_reported_length_remaining(tvb, offset); if (extlen > 0) dissect_aodv_ext(tvb, offset, aodv_tree); } }
static int dissect_dtpt_sockaddr(tvbuff_t *tvb, guint offset, proto_tree *tree, int hfindex, int sockaddr_type) { guint32 sockaddr_length = 0; proto_item *sockaddr_item = NULL; proto_tree *sockaddr_tree = NULL; guint32 sockaddr_len1 = 0; guint32 sockaddr_len2 = 0; switch (sockaddr_type) { case SOCKADDR_WITH_LEN: sockaddr_len1=4; sockaddr_len2=16; break; case SOCKADDR_CONNECT: sockaddr_len1=0; sockaddr_len2=30; break; } if (sockaddr_type == SOCKADDR_WITH_LEN) sockaddr_length = tvb_get_letohl(tvb, offset + 0); if (tree) { sockaddr_item = proto_tree_add_text(tree, tvb, offset, sockaddr_len1+sockaddr_len2, "%s", proto_registrar_get_name(hfindex)); if (sockaddr_item) sockaddr_tree = proto_item_add_subtree(sockaddr_item, ett_dtpt_sockaddr); if (sockaddr_tree) { if (sockaddr_type == SOCKADDR_WITH_LEN) proto_tree_add_uint(sockaddr_tree, hf_dtpt_sockaddr_length, tvb, offset+0, 4, sockaddr_length); } } offset += sockaddr_len1; if (sockaddr_tree) { switch (sockaddr_type) { case SOCKADDR_WITH_LEN: { guint16 family; family = tvb_get_letohs(tvb, offset); proto_tree_add_uint(sockaddr_tree, hf_dtpt_sockaddr_family, tvb, offset, 2, family); switch (family) { case WINSOCK_AF_INET: { guint16 port; guint32 addr; port = tvb_get_ntohs(tvb,offset+2); proto_tree_add_uint(sockaddr_tree, hf_dtpt_sockaddr_port, tvb, offset+2,2,port); addr = tvb_get_ipv4(tvb,offset+4); proto_tree_add_ipv4(sockaddr_tree, hf_dtpt_sockaddr_address, tvb, offset+4,4,addr); proto_tree_add_text(sockaddr_tree, tvb, offset+8, 8, "Padding"); proto_item_append_text(sockaddr_item, ": %s:%d", ip_to_str((guint8*)&addr), port); } break; } } break; case SOCKADDR_CONNECT: { guint32 family; family = tvb_get_letohl(tvb, offset+0); proto_tree_add_uint(sockaddr_tree, hf_dtpt_sockaddr_family, tvb, offset+0, 4, family); switch (family) { case WINSOCK_AF_INET: { guint16 port; guint32 addr; proto_tree_add_text(sockaddr_tree, tvb, offset+4, 4, "Padding"); port = tvb_get_ntohs(tvb,offset+8); proto_tree_add_uint(sockaddr_tree, hf_dtpt_sockaddr_port, tvb, offset+8,2,port); addr = tvb_get_ipv4(tvb,offset+10); proto_tree_add_ipv4(sockaddr_tree, hf_dtpt_sockaddr_address, tvb, offset+10,4,addr); proto_tree_add_text(sockaddr_tree, tvb, offset+14, 16, "Padding"); proto_item_append_text(sockaddr_item, ": %s:%d", ip_to_str((guint8*)&addr), port); } break; } } break; } } offset += sockaddr_len2; return offset; }
/* dissector of each payload */ static int dissect_xtp_aseg(tvbuff_t *tvb, proto_tree *tree, guint32 offset) { guint32 len = tvb_length_remaining(tvb, offset); guint32 start = offset; proto_item *ti, *ti2, *top_ti; proto_tree *xtp_subtree; struct xtp_ip_addr_seg aseg[1]; int error = 0; top_ti = proto_tree_add_text(tree, tvb, offset, len, "Address Segment"); xtp_subtree = proto_item_add_subtree(top_ti, ett_xtp_aseg); if (len < XTP_NULL_ADDR_SEG_LEN) { proto_item_append_text(top_ti, ", bogus length(%u, must be at least %u)", len, XTP_NULL_ADDR_SEG_LEN); return 0; } /** parse common fields **/ /* alen(2) */ aseg->alen = tvb_get_ntohs(tvb, offset); offset += 2; /* adomain(1) */ aseg->adomain = tvb_get_guint8(tvb, offset); offset++; /* aformat(1) */ aseg->aformat = tvb_get_guint8(tvb, offset); /** display common fields **/ offset = start; /* alen(2) */ ti = proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_alen, tvb, offset, 2, aseg->alen); offset += 2; if (aseg->alen > len) { proto_item_append_text(ti, ", bogus length(%u, must be at most %u)", aseg->alen, len); error = 1; } /* adomain(1) */ proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_adomain, tvb, offset, 1, aseg->adomain); offset++; /* aformat(1) */ ti2 = proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_aformat, tvb, offset, 1, aseg->aformat); offset++; switch (aseg->aformat) { case 0: if (aseg->alen != XTP_NULL_ADDR_SEG_LEN) { proto_item_append_text(ti, ", bogus length(%u, must be %u)", aseg->alen, XTP_NULL_ADDR_SEG_LEN); error = 1; } break; case 1: if (aseg->alen != XTP_IP_ADDR_SEG_LEN) { proto_item_append_text(ti, ", bogus length(%u, must be %u)", aseg->alen, XTP_IP_ADDR_SEG_LEN); error = 1; } break; default: if (aseg->aformat < 128) { proto_item_append_text(ti2, ", Unsupported aformat(%u)", aseg->aformat); error = 1; } break; } if (error) return (offset - start); /** parse and display each address fileds */ switch (aseg->aformat) { case 0: /* address(4) */ aseg->dsthost = tvb_get_ntohl(tvb, offset); proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_address, tvb, offset, 4, aseg->dsthost); offset += 4; break; case 1: /* dsthost(4) */ aseg->dsthost = tvb_get_ipv4(tvb, offset); proto_tree_add_ipv4(xtp_subtree, hf_xtp_aseg_dsthost, tvb, offset, 4, aseg->dsthost); offset += 4; /* srchost(4) */ aseg->srchost = tvb_get_ipv4(tvb, offset); proto_tree_add_ipv4(xtp_subtree, hf_xtp_aseg_srchost, tvb, offset, 4, aseg->srchost); offset += 4; /* dstport(2) */ aseg->dstport = tvb_get_ntohs(tvb, offset); proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_dstport, tvb, offset, 2, aseg->dstport); offset += 2; /* srcport(2) */ aseg->srcport = tvb_get_ntohs(tvb, offset); proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_srcport, tvb, offset, 2, aseg->srcport); offset += 2; /** add summary **/ proto_item_append_text(top_ti, ", Dst Port: %u", aseg->dstport); proto_item_append_text(top_ti, ", Src Port: %u", aseg->srcport); break; default: break; } return (offset - start); }
static int dissect_ppcap_source_address(tvbuff_t *tvb, packet_info *pinfo, proto_tree * ppcap_tree1, int offset) { int key1; guint16 msg_len; msg_len = tvb_get_ntohs(tvb, offset); proto_tree_add_item( ppcap_tree1, hf_ppcap_length, tvb, offset, 2, ENC_BIG_ENDIAN); offset = offset + 2; proto_tree_add_item(ppcap_tree1, hf_ppcap_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; key1 = tvb_get_ntohs(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_address_type, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; if (key1 == 1) { proto_tree_add_item(ppcap_tree1, hf_ppcap_ssn, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(ppcap_tree1, hf_ppcap_spc, tvb, offset, 3, ENC_BIG_ENDIAN); /*src_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_opc = wmem_new0(wmem_packet_scope(), mtp3_addr_pc_t); mtp3_addr_opc->pc = (guint32 )tvb_get_ntoh24(tvb, offset); mtp3_addr_opc->type = ITU_STANDARD; mtp3_addr_opc->ni = 0; /*SET_ADDRESS(&pinfo->net_src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc);*/ SET_ADDRESS(&pinfo->src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc); if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len-1; return offset; } else if (key1 == 2) { proto_tree_add_item(ppcap_tree1, hf_ppcap_opc, tvb, offset, msg_len, ENC_BIG_ENDIAN); /*src_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_opc = wmem_new0(wmem_packet_scope(), mtp3_addr_pc_t); mtp3_addr_opc->pc = tvb_get_ntohl(tvb, offset); mtp3_addr_opc->type = ITU_STANDARD; mtp3_addr_opc->ni = 0; SET_ADDRESS(&pinfo->src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc); } else if (key1 == 3) { if (msg_len%16 != 0) { proto_tree_add_ipv4(ppcap_tree1, hf_ppcap_source_ip_address1, tvb, offset, msg_len, tvb_get_ipv4(tvb, offset)); TVB_SET_ADDRESS(&pinfo->net_src, AT_IPv4, tvb, offset, 4); COPY_ADDRESS_SHALLOW(&pinfo->src, &pinfo->net_src); } else { struct e_in6_addr value; tvb_get_ipv6(tvb, offset, &value); proto_tree_add_ipv6(ppcap_tree1, hf_ppcap_source_ip_address2, tvb, offset, msg_len, &value); TVB_SET_ADDRESS(&pinfo->net_src, AT_IPv6, tvb, offset, 6); COPY_ADDRESS_SHALLOW(&pinfo->src, &pinfo->net_src); } } else if (key1 == 4) { proto_tree_add_item(ppcap_tree1, hf_ppcap_source_nodeid, tvb, offset, msg_len, ENC_ASCII|ENC_NA); TVB_SET_ADDRESS(&pinfo->net_src, AT_STRINGZ, tvb, offset, msg_len); COPY_ADDRESS_SHALLOW(&pinfo->src, &pinfo->net_src); } if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len; return offset; }
static int dissect_ppcap_destination_address(tvbuff_t *tvb, packet_info * pinfo, proto_tree * ppcap_tree1, int offset) { int key2; guint16 msg_len; msg_len = tvb_get_ntohs(tvb, offset); proto_tree_add_item( ppcap_tree1, hf_ppcap_length, tvb, offset, 2, ENC_BIG_ENDIAN); offset = offset + 2; proto_tree_add_item(ppcap_tree1, hf_ppcap_destreserved, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; key2 = tvb_get_ntohs(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_address_type, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; if (key2 == 1) { ssn = tvb_get_guint8(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_ssn1, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(ppcap_tree1, hf_ppcap_spc1, tvb, offset, 3, ENC_BIG_ENDIAN); /*dst_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_dpc = wmem_new0(wmem_packet_scope(), mtp3_addr_pc_t); mtp3_addr_dpc->pc = (guint32)tvb_get_ntoh24(tvb, offset); mtp3_addr_dpc->type = ITU_STANDARD; mtp3_addr_dpc->ni = 0; SET_ADDRESS(&pinfo->dst, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_dpc); if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len-1; return offset; } else if (key2 == 2) { proto_tree_add_item(ppcap_tree1, hf_ppcap_dpc, tvb, offset, 4, ENC_BIG_ENDIAN); /*dst_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_dpc = wmem_new0(wmem_packet_scope(), mtp3_addr_pc_t); mtp3_addr_dpc->pc = tvb_get_ntohl(tvb, offset); mtp3_addr_dpc->type = ITU_STANDARD; mtp3_addr_dpc->ni = 0; SET_ADDRESS(&pinfo->dst, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_dpc); } else if (key2 == 3) { if (msg_len%16 != 0) { proto_tree_add_ipv4(ppcap_tree1, hf_ppcap_destination_ip_address1, tvb, offset, msg_len, tvb_get_ipv4(tvb, offset)); TVB_SET_ADDRESS(&pinfo->net_dst, AT_IPv4, tvb, offset, 4); COPY_ADDRESS_SHALLOW(&pinfo->dst, &pinfo->net_dst); } else { struct e_in6_addr value; tvb_get_ipv6(tvb, offset,&value); proto_tree_add_ipv6(ppcap_tree1, hf_ppcap_destination_ip_address2, tvb, offset, msg_len, &value); TVB_SET_ADDRESS(&pinfo->net_dst, AT_IPv6, tvb, offset, 6); COPY_ADDRESS_SHALLOW(&pinfo->dst, &pinfo->net_dst); } } else if (key2 == 4) { char *string; string = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, msg_len, ENC_UTF_8|ENC_NA); proto_tree_add_string(ppcap_tree1, hf_ppcap_destination_nodeid, tvb, offset, msg_len, string); TVB_SET_ADDRESS(&pinfo->net_dst, AT_STRINGZ, tvb, offset, msg_len); COPY_ADDRESS_SHALLOW(&pinfo->dst, &pinfo->net_dst); } if (msg_len%4) msg_len = msg_len+(4-(msg_len%4)); offset += msg_len; return offset; }
static int dissect_ppcap_source_address(tvbuff_t *tvb, packet_info *pinfo, proto_tree * ppcap_tree1, int offset, guint16 msg_len) { int key1; const guchar *src_addr; /*guint32 src_addr1;*/ proto_tree_add_item(ppcap_tree1, hf_ppcap_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; key1 = tvb_get_ntohs(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_address_type, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; if (key1 == 1) { proto_tree_add_item(ppcap_tree1, hf_ppcap_ssn, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(ppcap_tree1, hf_ppcap_spc, tvb, offset, 3, ENC_BIG_ENDIAN); /*src_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_opc = ep_alloc0(sizeof(mtp3_addr_pc_t)); mtp3_addr_opc->pc = (guint32 )tvb_get_ntoh24(tvb, offset); mtp3_addr_opc->type = 1; /* ITU_STANDARD */ mtp3_addr_opc->ni = 0; /*SET_ADDRESS(&pinfo->net_src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc);*/ SET_ADDRESS(&pinfo->src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc); if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len-1; return offset; } else if (key1 == 2) { proto_tree_add_item(ppcap_tree1, hf_ppcap_opc, tvb, offset, msg_len, ENC_BIG_ENDIAN); /*src_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_opc = ep_alloc0(sizeof(mtp3_addr_pc_t)); mtp3_addr_opc->pc = tvb_get_ntohl(tvb, offset); mtp3_addr_opc->type = 1; /* ITU_STANDARD */ mtp3_addr_opc->ni = 0; SET_ADDRESS(&pinfo->src, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_opc); /*src_addr = tvb_get_ptr(tvb, offset, 4);*/ /*SET_ADDRESS(&pinfo->net_src, AT_SS7PC, 4, src_addr);*/ /*SET_ADDRESS(&pinfo->src, AT_SS7PC, 4, src_addr);*/ } else if (key1 == 3) { if (msg_len%4 == 0) { proto_tree_add_ipv4(ppcap_tree1, hf_ppcap_source_ip_address1, tvb, offset, msg_len, tvb_get_ipv4(tvb, offset)); src_addr = tvb_get_ptr(tvb, offset, 4); SET_ADDRESS(&pinfo->net_src, AT_IPv4, 4, src_addr); SET_ADDRESS(&pinfo->src, AT_IPv4, 4, src_addr); } else { struct e_in6_addr value; tvb_get_ipv6(tvb, offset, &value); proto_tree_add_ipv6(ppcap_tree1, hf_ppcap_source_ip_address2, tvb, offset, msg_len, (guint8*)&value); src_addr = tvb_get_ptr(tvb, offset, 6); SET_ADDRESS(&pinfo->net_src, AT_IPv6, 6, src_addr); SET_ADDRESS(&pinfo->src, AT_IPv6, 6, src_addr); } } else if (key1 == 4) { proto_tree_add_item(ppcap_tree1, hf_ppcap_source_nodeid, tvb, offset, msg_len, ENC_BIG_ENDIAN|ENC_ASCII); src_addr = tvb_get_ptr(tvb, offset, msg_len); SET_ADDRESS(&pinfo->net_src, AT_STRINGZ, msg_len, src_addr); SET_ADDRESS(&pinfo->src, AT_STRINGZ, msg_len, src_addr); } if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len; return offset; }
static void dissect_bat_batman_v5(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { struct batman_packet_v5 *batman_packeth; const guint8 *old_orig_addr, *orig_addr; guint32 old_orig, orig; gint i; tvbuff_t *next_tvb; guint length_remaining; int offset = 0; batman_packeth = ep_alloc(sizeof(struct batman_packet_v5)); batman_packeth->version = tvb_get_guint8(tvb, 0); batman_packeth->flags = tvb_get_guint8(tvb, 1); batman_packeth->ttl = tvb_get_guint8(tvb, 2); batman_packeth->gwflags = tvb_get_guint8(tvb, 3); batman_packeth->seqno = tvb_get_ntohs(tvb, 4); batman_packeth->gwport = tvb_get_ntohs(tvb, 6); orig_addr = tvb_get_ptr(tvb, 8, 4); orig = tvb_get_ipv4(tvb, 8); SET_ADDRESS(&batman_packeth->orig, AT_IPv4, 4, orig_addr); old_orig_addr = tvb_get_ptr(tvb, 12, 4); old_orig = tvb_get_ipv4(tvb, 12); SET_ADDRESS(&batman_packeth->old_orig, AT_IPv4, 4, old_orig_addr); batman_packeth->tq = tvb_get_guint8(tvb, 16); batman_packeth->hna_len = tvb_get_guint8(tvb, 17); /* Set info column */ if (check_col(pinfo->cinfo, COL_INFO)) col_add_fstr(pinfo->cinfo, COL_INFO, "Seq=%u", batman_packeth->seqno); /* Set tree info */ if (tree) { proto_item *ti = NULL, *tf, *tgw; proto_tree *bat_batman_tree = NULL, *flag_tree = NULL; if (PTREE_DATA(tree)->visible) { ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, 0, BATMAN_PACKET_V5_SIZE, "B.A.T.M.A.N., Orig: %s (%s)", get_hostname(orig), ip_to_str(batman_packeth->orig.data)); } else { ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, BATMAN_PACKET_V5_SIZE, FALSE); } bat_batman_tree = proto_item_add_subtree(ti, ett_bat_batman); /* items */ proto_tree_add_item(bat_batman_tree, hf_bat_batman_version, tvb, offset, 1, FALSE); offset += 1; tf = proto_tree_add_item(bat_batman_tree, hf_bat_batman_flags, tvb, offset, 1, FALSE); /* <flags> */ flag_tree = proto_item_add_subtree(tf, ett_bat_batman_flags); proto_tree_add_boolean(flag_tree, hf_bat_batman_flags_unidirectional, tvb, offset, 1, batman_packeth->flags); proto_tree_add_boolean(flag_tree, hf_bat_batman_flags_directlink, tvb, offset, 1, batman_packeth->flags); /* </flags> */ offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_ttl, tvb, offset, 1, FALSE); offset += 1; tgw = proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwflags, tvb, offset, 1, FALSE); dissect_bat_gwflags(tvb, batman_packeth->gwflags, offset, tgw); offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_seqno, tvb, offset, 2, FALSE); offset += 2; proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwport, tvb, offset, 2, FALSE); offset += 2; proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_orig, tvb, offset, 4, orig); offset += 4; proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_old_orig, tvb, offset, 4, old_orig); offset += 4; proto_tree_add_item(bat_batman_tree, hf_bat_batman_tq, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_hna_len, tvb, offset, 1, FALSE); offset += 1; tap_queue_packet(bat_tap, pinfo, batman_packeth); for (i = 0; i < batman_packeth->hna_len; i++) { next_tvb = tvb_new_subset(tvb, offset, 5, 5); if (have_tap_listener(bat_follow_tap)) { tap_queue_packet(bat_follow_tap, pinfo, next_tvb); } dissect_bat_hna(next_tvb, pinfo, bat_batman_tree); offset += 5; } } length_remaining = tvb_reported_length_remaining(tvb, offset); if (length_remaining != 0) { next_tvb = tvb_new_subset_remaining(tvb, offset); if (have_tap_listener(bat_follow_tap)) { tap_queue_packet(bat_follow_tap, pinfo, next_tvb); } dissect_bat_batman(next_tvb, pinfo, tree); } }
static void dissect_aodv_rrep(tvbuff_t *tvb, packet_info *pinfo, proto_tree *aodv_tree, proto_item *ti, gboolean is_ipv6) { int offset = 1; proto_item *tj; proto_tree *aodv_flags_tree; guint8 flags; guint8 prefix_sz; guint8 hop_count; guint32 dest_addr_v4; struct e_in6_addr dest_addr_v6; guint32 dest_seqno; guint32 orig_addr_v4; struct e_in6_addr orig_addr_v6; guint32 lifetime; int extlen; flags = tvb_get_guint8(tvb, offset); if (aodv_tree) { tj = proto_tree_add_text(aodv_tree, tvb, offset, 1, "Flags:"); aodv_flags_tree = proto_item_add_subtree(tj, ett_aodv_flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rrep_repair, tvb, offset, 1, flags); proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rrep_ack, tvb, offset, 1, flags); if (flags & RREP_REP) proto_item_append_text(tj, " R"); if (flags & RREP_ACK_REQ) proto_item_append_text(tj, " A"); } offset += 1; prefix_sz = tvb_get_guint8(tvb, offset) & 0x1F; if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_prefix_sz, tvb, offset, 1, prefix_sz); offset += 1; hop_count = tvb_get_guint8(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_hopcount, tvb, offset, 1, hop_count); offset += 1; if (is_ipv6) { tvb_get_ipv6(tvb, offset, &dest_addr_v6); if (aodv_tree) { proto_tree_add_ipv6(aodv_tree, hf_aodv_dest_ipv6, tvb, offset, INET6_ADDRLEN, (guint8 *)&dest_addr_v6); proto_item_append_text(ti, ", Dest IP: %s", ip6_to_str(&dest_addr_v6)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s", ip6_to_str(&dest_addr_v6)); offset += INET6_ADDRLEN; } else { dest_addr_v4 = tvb_get_ipv4(tvb, offset); if (aodv_tree) { proto_tree_add_ipv4(aodv_tree, hf_aodv_dest_ip, tvb, offset, 4, dest_addr_v4); proto_item_append_text(ti, ", Dest IP: %s", ip_to_str((guint8 *)&dest_addr_v4)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s", ip_to_str((guint8 *)&dest_addr_v4)); offset += 4; } dest_seqno = tvb_get_ntohl(tvb, offset); if (aodv_tree) proto_tree_add_uint(aodv_tree, hf_aodv_dest_seqno, tvb, offset, 4, dest_seqno); offset += 4; if (is_ipv6) { tvb_get_ipv6(tvb, offset, &orig_addr_v6); if (aodv_tree) { proto_tree_add_ipv6(aodv_tree, hf_aodv_orig_ipv6, tvb, offset, INET6_ADDRLEN, (guint8 *)&orig_addr_v6); proto_item_append_text(ti, ", Orig IP: %s", ip6_to_str(&orig_addr_v6)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", O: %s", ip6_to_str(&orig_addr_v6)); offset += INET6_ADDRLEN; } else { orig_addr_v4 = tvb_get_ipv4(tvb, offset); if (aodv_tree) { proto_tree_add_ipv4(aodv_tree, hf_aodv_orig_ip, tvb, offset, 4, orig_addr_v4); proto_item_append_text(ti, ", Orig IP: %s", ip_to_str((guint8 *)&orig_addr_v4)); } col_append_fstr(pinfo->cinfo, COL_INFO, ", O: %s", ip_to_str((guint8 *)&orig_addr_v4)); offset += 4; } lifetime = tvb_get_ntohl(tvb, offset); if (aodv_tree) { proto_tree_add_uint(aodv_tree, hf_aodv_lifetime, tvb, offset, 4, lifetime); proto_item_append_text(ti, ", Lifetime=%u", lifetime); } col_append_fstr(pinfo->cinfo, COL_INFO, " Hcnt=%u DSN=%u Lifetime=%u", hop_count, dest_seqno, lifetime); offset += 4; if (aodv_tree) { extlen = tvb_reported_length_remaining(tvb, offset); if (extlen > 0) dissect_aodv_ext(tvb, offset, aodv_tree); } }
static int dissect_pbb_addressblock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset, guint maxoffset, guint8 addressType, guint8 addressSize) { guint8 addr[MAX_ADDR_SIZE]; guint8 numAddr; guint8 address_flags; guint8 head_length = 0, tail_length = 0; guint block_length = 0, midSize = 0; guint block_index = 0, head_index = 0, tail_index = 0, mid_index = 0, prefix_index = 0; proto_tree *addr_tree = NULL; proto_tree *addrFlags_tree = NULL; proto_tree *addrValue_tree = NULL; proto_item *addr_item = NULL; proto_item *addrFlags_item = NULL; proto_item *addrValue_item = NULL; int i = 0; if (maxoffset - offset < 2) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for minimal addressblock header"); return tvb_reported_length(tvb); } DISSECTOR_ASSERT(addressSize <= MAX_ADDR_SIZE); memset(addr, 0, addressSize); block_length = 2; block_index = offset; midSize = addressSize; numAddr = tvb_get_guint8(tvb, offset++); address_flags = tvb_get_guint8(tvb, offset++); if ((address_flags & ADDR_HASHEAD) != 0) { head_index = offset; if (maxoffset - offset <= 0) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for addressblock head"); return tvb_reported_length(tvb); } head_length = tvb_get_guint8(tvb, offset++); if (head_length > addressSize-1) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "address head length is too long"); return tvb_reported_length(tvb); } if (maxoffset - offset < head_length) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for addressblock head"); return tvb_reported_length(tvb); } tvb_memcpy(tvb, addr, offset, head_length); midSize -= head_length; block_length += (head_length+1); offset += head_length; } if ((address_flags & ADDR_HASZEROTAIL) != 0) { tail_index = offset; if (maxoffset - offset <= 0) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for addressblock tail"); return tvb_reported_length(tvb); } tail_length = tvb_get_guint8(tvb, offset++); if (tail_length > addressSize-1-head_length) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "address tail length is too long"); return tvb_reported_length(tvb); } midSize -= tail_length; block_length++; } else if ((address_flags & ADDR_HASFULLTAIL) != 0) { tail_index = offset; if (maxoffset - offset <= 0) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for addressblock tail"); return tvb_reported_length(tvb); } tail_length = tvb_get_guint8(tvb, offset++); if (tail_length > addressSize-1-head_length) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "address tail length is too long"); return tvb_reported_length(tvb); } if (maxoffset - offset < tail_length) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for addressblock tail"); return tvb_reported_length(tvb); } tvb_memcpy(tvb, &addr[addressSize - tail_length], offset, tail_length); midSize -= tail_length; block_length += (tail_length+1); offset += tail_length; } mid_index = offset; block_length += numAddr * midSize; offset += numAddr * midSize; if ((address_flags & ADDR_HASSINGLEPRELEN) != 0) { prefix_index = offset; block_length++; } else if ((address_flags & ADDR_HASMULTIPRELEN) != 0) { prefix_index = offset; block_length += numAddr; } if (maxoffset < block_index + block_length) { proto_tree_add_expert_format(tree, pinfo, &ei_packetbb_error, tvb, offset, maxoffset - offset, "Not enough octets for address block"); return maxoffset; } /* add address tree */ addr_item = proto_tree_add_item(tree, hf_packetbb_addr, tvb, block_index, block_length, ENC_NA); addr_tree = proto_item_add_subtree(addr_item, ett_packetbb_addr); proto_item_append_text(addr_item, " (%d addresses)", numAddr); /* add num-addr */ proto_tree_add_item(addr_tree, hf_packetbb_addr_num, tvb, block_index, 1, ENC_BIG_ENDIAN); /* add flags */ addrFlags_item = proto_tree_add_item(addr_tree, hf_packetbb_addr_flags, tvb, block_index+1, 1, ENC_BIG_ENDIAN); addrFlags_tree = proto_item_add_subtree(addrFlags_item, ett_packetbb_addr_flags); proto_tree_add_item(addrFlags_tree, hf_packetbb_addr_flags_hashead, tvb, block_index+1, 1, ENC_BIG_ENDIAN); proto_tree_add_item(addrFlags_tree, hf_packetbb_addr_flags_hasfulltail, tvb, block_index+1, 1, ENC_BIG_ENDIAN); proto_tree_add_item(addrFlags_tree, hf_packetbb_addr_flags_haszerotail, tvb, block_index+1, 1, ENC_BIG_ENDIAN); proto_tree_add_item(addrFlags_tree, hf_packetbb_addr_flags_hassingleprelen, tvb, block_index+1, 1, ENC_BIG_ENDIAN); proto_tree_add_item(addrFlags_tree, hf_packetbb_addr_flags_hasmultiprelen, tvb, block_index+1, 1, ENC_BIG_ENDIAN); if ((address_flags & ADDR_HASHEAD) != 0) { /* add head */ proto_tree_add_item(addr_tree, hf_packetbb_addr_head, tvb, head_index, head_length+1, ENC_NA); } if ((address_flags & ADDR_HASFULLTAIL) != 0) { /* add full tail */ proto_tree_add_item(addr_tree, hf_packetbb_addr_tail, tvb, tail_index, tail_length+1, ENC_NA); } else if ((address_flags & ADDR_HASZEROTAIL) != 0) { /* add zero tail */ proto_tree_add_item(addr_tree, hf_packetbb_addr_tail, tvb, tail_index, 1, ENC_NA); } for (i=0; i<numAddr; i++) { guint32 ipv4 = 0; guint8 prefix = addressSize * 8; tvb_memcpy(tvb, &addr[head_length], mid_index + midSize*i, midSize); ipv4 = (addr[3] << 24) + (addr[2] << 16) + (addr[1] << 8) + addr[0]; switch (addressType) { case 0: addrValue_item = proto_tree_add_ipv4(addr_tree, hf_packetbb_addr_value[addressType], tvb, mid_index, block_index + block_length - mid_index, ipv4); break; case 1: addrValue_item = proto_tree_add_ipv6(addr_tree, hf_packetbb_addr_value[addressType], tvb, mid_index, block_index + block_length - mid_index, (struct e_in6_addr *)addr); break; case 2: addrValue_item = proto_tree_add_ether(addr_tree, hf_packetbb_addr_value[addressType], tvb, mid_index, block_index + block_length - mid_index, addr); break; case 3: addrValue_item = proto_tree_add_bytes(addr_tree, hf_packetbb_addr_value[addressType], tvb, mid_index, block_index + block_length - mid_index, addr); break; default: break; } addrValue_tree = proto_item_add_subtree(addrValue_item, ett_packetbb_addr_value); proto_tree_add_item(addrValue_tree, hf_packetbb_addr_value_mid, tvb, mid_index + midSize*i, midSize, ENC_NA); if ((address_flags & ADDR_HASSINGLEPRELEN) != 0) { prefix = tvb_get_guint8(tvb, prefix_index); proto_tree_add_item(addrValue_tree, hf_packetbb_addr_value_prefix, tvb, prefix_index, 1, ENC_BIG_ENDIAN); } else if ((address_flags & ADDR_HASMULTIPRELEN) != 0) { prefix = tvb_get_guint8(tvb, prefix_index + i); proto_tree_add_item(addrValue_tree, hf_packetbb_addr_value_prefix, tvb, prefix_index + i, 1, ENC_BIG_ENDIAN); } proto_item_append_text(addrValue_item, "/%d", prefix); } offset = dissect_pbb_tlvblock(tvb, pinfo, addr_tree, block_index + block_length, maxoffset, numAddr); return offset; }
static int dissect_bat_batman_v5(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree) { proto_item *tf, *tgw; proto_tree *bat_batman_tree = NULL, *flag_tree; struct batman_packet_v5 *batman_packeth; const guint8 *old_orig_addr, *orig_addr; guint32 old_orig, orig; gint i; tvbuff_t *next_tvb; batman_packeth = wmem_new(wmem_packet_scope(), struct batman_packet_v5); batman_packeth->version = tvb_get_guint8(tvb, offset+0); batman_packeth->flags = tvb_get_guint8(tvb, offset+1); batman_packeth->ttl = tvb_get_guint8(tvb, offset+2); batman_packeth->gwflags = tvb_get_guint8(tvb, offset+3); batman_packeth->seqno = tvb_get_ntohs(tvb, offset+4); batman_packeth->gwport = tvb_get_ntohs(tvb, offset+6); orig_addr = tvb_get_ptr(tvb, offset+8, 4); orig = tvb_get_ipv4(tvb, offset+8); SET_ADDRESS(&batman_packeth->orig, AT_IPv4, 4, orig_addr); old_orig_addr = tvb_get_ptr(tvb, offset+12, 4); old_orig = tvb_get_ipv4(tvb, offset+12); SET_ADDRESS(&batman_packeth->old_orig, AT_IPv4, 4, old_orig_addr); batman_packeth->tq = tvb_get_guint8(tvb, offset+16); batman_packeth->hna_len = tvb_get_guint8(tvb, offset+17); /* Set info column */ col_add_fstr(pinfo->cinfo, COL_INFO, "Seq=%u", batman_packeth->seqno); /* Set tree info */ if (tree) { proto_item *ti; if (PTREE_DATA(tree)->visible) { ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, "B.A.T.M.A.N., Orig: %s (%s)", get_hostname(orig), ip_to_str((const guint8 *)batman_packeth->orig.data)); } else { ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, ENC_NA); } bat_batman_tree = proto_item_add_subtree(ti, ett_bat_batman); } /* items */ proto_tree_add_item(bat_batman_tree, hf_bat_batman_version, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; tf = proto_tree_add_item(bat_batman_tree, hf_bat_batman_flags, tvb, offset, 1, ENC_BIG_ENDIAN); /* <flags> */ flag_tree = proto_item_add_subtree(tf, ett_bat_batman_flags); proto_tree_add_boolean(flag_tree, hf_bat_batman_flags_unidirectional, tvb, offset, 1, batman_packeth->flags); proto_tree_add_boolean(flag_tree, hf_bat_batman_flags_directlink, tvb, offset, 1, batman_packeth->flags); /* </flags> */ offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_ttl, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; tgw = proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwflags, tvb, offset, 1, ENC_BIG_ENDIAN); dissect_bat_gwflags(tvb, batman_packeth->gwflags, offset, tgw); offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_seqno, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwport, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_orig, tvb, offset, 4, orig); offset += 4; proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_old_orig, tvb, offset, 4, old_orig); offset += 4; proto_tree_add_item(bat_batman_tree, hf_bat_batman_tq, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(bat_batman_tree, hf_bat_batman_hna_len, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; tap_queue_packet(bat_tap, pinfo, batman_packeth); for (i = 0; i < batman_packeth->hna_len; i++) { next_tvb = tvb_new_subset(tvb, offset, 5, 5); if (have_tap_listener(bat_follow_tap)) { tap_queue_packet(bat_follow_tap, pinfo, next_tvb); } dissect_bat_hna(next_tvb, pinfo, bat_batman_tree); offset += 5; } return offset; }
static int dissect_ppcap_destination_address(tvbuff_t *tvb, packet_info * pinfo, proto_tree * ppcap_tree1, int offset, guint16 msg_len ) { int key2; const guchar *dst_addr; /*guint32 dst_addr1;*/ proto_tree_add_item(ppcap_tree1, hf_ppcap_destreserved, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; key2 = tvb_get_ntohs(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_address_type, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; if (key2 == 1) { ssn = tvb_get_guint8(tvb, offset); proto_tree_add_item(ppcap_tree1, hf_ppcap_ssn1, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(ppcap_tree1, hf_ppcap_spc1, tvb, offset, 3, ENC_BIG_ENDIAN); /*dst_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_dpc = ep_alloc0(sizeof(mtp3_addr_pc_t)); mtp3_addr_dpc->pc = (guint32)tvb_get_ntoh24(tvb, offset); mtp3_addr_dpc->type = 1; /* ITU_STANDARD */ mtp3_addr_dpc->ni = 0; SET_ADDRESS(&pinfo->dst, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_dpc); /*dst_addr = tvb_get_ptr(tvb, offset, msg_len-1); SET_ADDRESS(&pinfo->net_dst, AT_SS7PC, msg_len-1, dst_addr); SET_ADDRESS(&pinfo->dst, AT_SS7PC, msg_len-1, dst_addr);*/ if (msg_len%4) msg_len = msg_len + (4 - (msg_len%4)); offset += msg_len-1; return offset; } else if (key2 == 2) { proto_tree_add_item(ppcap_tree1, hf_ppcap_dpc, tvb, offset, 4, ENC_BIG_ENDIAN); /*dst_addr1 = (guint32 )tvb_get_ntoh24(tvb, offset);*/ mtp3_addr_dpc = ep_alloc0(sizeof(mtp3_addr_pc_t)); mtp3_addr_dpc->pc = tvb_get_ntohl(tvb, offset); mtp3_addr_dpc->type = 1; /* ITU_STANDARD */ mtp3_addr_dpc->ni = 0; SET_ADDRESS(&pinfo->dst, AT_SS7PC, sizeof(mtp3_addr_pc_t), (guint8 *) mtp3_addr_dpc); } else if (key2 == 3) { if (msg_len%4 == 0) { proto_tree_add_ipv4(ppcap_tree1, hf_ppcap_destination_ip_address1, tvb, offset, msg_len, tvb_get_ipv4(tvb, offset)); dst_addr = tvb_get_ptr(tvb, offset, 4); SET_ADDRESS(&pinfo->net_dst, AT_IPv4, 4, dst_addr); SET_ADDRESS(&pinfo->dst, AT_IPv4, 4, dst_addr); } else { struct e_in6_addr value; tvb_get_ipv6(tvb, offset,&value); proto_tree_add_ipv6(ppcap_tree1, hf_ppcap_destination_ip_address2, tvb, offset, msg_len, (guint8*)&value); dst_addr = tvb_get_ptr(tvb, offset, 6); SET_ADDRESS(&pinfo->net_dst, AT_IPv6, 6, dst_addr); SET_ADDRESS(&pinfo->dst, AT_IPv6, 6, dst_addr); } } else if (key2 == 4) { char *string; string = tvb_get_string(tvb, offset, msg_len); proto_tree_add_string(ppcap_tree1, hf_ppcap_destination_nodeid, tvb, offset, msg_len, string); dst_addr = tvb_get_ptr(tvb, offset, msg_len); SET_ADDRESS(&pinfo->net_dst, AT_STRINGZ, msg_len, dst_addr); SET_ADDRESS(&pinfo->dst, AT_STRINGZ, msg_len, dst_addr); /*g_free(string);*/ } if (msg_len%4) msg_len = msg_len+(4-(msg_len%4)); offset += msg_len; return offset; }
static void dissect_ftp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { gboolean is_request; proto_tree *ftp_tree = NULL; proto_tree *reqresp_tree = NULL; proto_item *ti, *hidden_item; gint offset = 0; const guchar *line; guint32 code; gchar code_str[4]; gboolean is_port_request = FALSE; gboolean is_pasv_response = FALSE; gboolean is_epasv_response = FALSE; gint next_offset; int linelen; int tokenlen; const guchar *next_token; guint32 pasv_ip; guint32 ftp_ip; guint16 ftp_port; address ftp_ip_address; gboolean ftp_nat; conversation_t *conversation; ftp_ip_address = pinfo->src; if (pinfo->match_uint == pinfo->destport) is_request = TRUE; else is_request = FALSE; col_set_str(pinfo->cinfo, COL_PROTOCOL, "FTP"); /* * Find the end of the first line. * * Note that "tvb_find_line_end()" will return a value that is * not longer than what's in the buffer, so the "tvb_get_ptr()" * call won't throw an exception. */ linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE); line = tvb_get_ptr(tvb, offset, linelen); /* * Put the first line from the buffer into the summary * (but leave out the line terminator). */ col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s", is_request ? "Request" : "Response", format_text(line, linelen)); if (tree) { ti = proto_tree_add_item(tree, proto_ftp, tvb, offset, -1, ENC_NA); ftp_tree = proto_item_add_subtree(ti, ett_ftp); if (is_request) { hidden_item = proto_tree_add_boolean(ftp_tree, hf_ftp_request, tvb, 0, 0, TRUE); PROTO_ITEM_SET_HIDDEN(hidden_item); hidden_item = proto_tree_add_boolean(ftp_tree, hf_ftp_response, tvb, 0, 0, FALSE); PROTO_ITEM_SET_HIDDEN(hidden_item); } else { hidden_item = proto_tree_add_boolean(ftp_tree, hf_ftp_request, tvb, 0, 0, FALSE); PROTO_ITEM_SET_HIDDEN(hidden_item); hidden_item = proto_tree_add_boolean(ftp_tree, hf_ftp_response, tvb, 0, 0, TRUE); PROTO_ITEM_SET_HIDDEN(hidden_item); } /* * Put the line into the protocol tree. */ ti = proto_tree_add_text(ftp_tree, tvb, offset, next_offset - offset, "%s", tvb_format_text(tvb, offset, next_offset - offset)); reqresp_tree = proto_item_add_subtree(ti, ett_ftp_reqresp); } if (is_request) { /* * Extract the first token, and, if there is a first * token, add it as the request. */ tokenlen = get_token_len(line, line + linelen, &next_token); if (tokenlen != 0) { if (tree) { proto_tree_add_item(reqresp_tree, hf_ftp_request_command, tvb, offset, tokenlen, ENC_ASCII|ENC_NA); } if (strncmp(line, "PORT", tokenlen) == 0) is_port_request = TRUE; } } else { /* * This is a response; the response code is 3 digits, * followed by a space or hyphen, possibly followed by * text. * * If the line doesn't start with 3 digits, it's part of * a continuation. * * XXX - keep track of state in the first pass, and * treat non-continuation lines not beginning with digits * as errors? */ if (linelen >= 3 && isdigit(line[0]) && isdigit(line[1]) && isdigit(line[2])) { /* * One-line reply, or first or last line * of a multi-line reply. */ tvb_get_nstringz0(tvb, offset, sizeof(code_str), code_str); code = strtoul(code_str, NULL, 10); if (tree) { proto_tree_add_uint(reqresp_tree, hf_ftp_response_code, tvb, offset, 3, code); } /* * See if it's a passive-mode response. * * XXX - does anybody do FOOBAR, as per RFC * 1639, or has that been supplanted by RFC 2428? */ if (code == 227) is_pasv_response = TRUE; /* * Responses to EPSV command, as per RFC 2428 * XXX - handle IPv6? */ if (code == 229) is_epasv_response = TRUE; /* * Skip the 3 digits and, if present, the * space or hyphen. */ if (linelen >= 4) next_token = line + 4; else next_token = line + linelen; } else { /* * Line doesn't start with 3 digits; assume it's * a line in the middle of a multi-line reply. */ next_token = line; } } offset += (gint) (next_token - line); linelen -= (int) (next_token - line); line = next_token; if (tree) { /* * Add the rest of the first line as request or * reply data. */ if (linelen != 0) { if (is_request) { proto_tree_add_item(reqresp_tree, hf_ftp_request_arg, tvb, offset, linelen, ENC_ASCII|ENC_NA); } else { proto_tree_add_item(reqresp_tree, hf_ftp_response_arg, tvb, offset, linelen, ENC_ASCII|ENC_NA); } } offset = next_offset; } /* * If this is a PORT request or a PASV response, handle it. */ if (is_port_request) { if (parse_port_pasv(line, linelen, &ftp_ip, &ftp_port)) { if (tree) { proto_tree_add_ipv4(reqresp_tree, hf_ftp_active_ip, tvb, 0, 0, ftp_ip); proto_tree_add_uint(reqresp_tree, hf_ftp_active_port, tvb, 0, 0, ftp_port); } SET_ADDRESS(&ftp_ip_address, AT_IPv4, 4, (const guint8 *)&ftp_ip); ftp_nat = !ADDRESSES_EQUAL(&pinfo->src, &ftp_ip_address); if (ftp_nat) { if (tree) { proto_tree_add_boolean( reqresp_tree, hf_ftp_active_nat, tvb, 0, 0, ftp_nat); } } } } if (is_pasv_response) { if (linelen != 0) { /* * This frame contains a PASV response; set up a * conversation for the data. */ if (parse_port_pasv(line, linelen, &pasv_ip, &ftp_port)) { if (tree) { proto_tree_add_ipv4(reqresp_tree, hf_ftp_pasv_ip, tvb, 0, 0, pasv_ip); proto_tree_add_uint(reqresp_tree, hf_ftp_pasv_port, tvb, 0, 0, ftp_port); } SET_ADDRESS(&ftp_ip_address, AT_IPv4, 4, (const guint8 *)&pasv_ip); ftp_nat = !ADDRESSES_EQUAL(&pinfo->src, &ftp_ip_address); if (ftp_nat) { if (tree) { proto_tree_add_boolean(reqresp_tree, hf_ftp_pasv_nat, tvb, 0, 0, ftp_nat); } } /* * We use "ftp_ip_address", so that if * we're NAT'd we look for the un-NAT'd * connection. * * XXX - should this call to * "find_conversation()" just use * "ftp_ip_address" and "server_port", and * wildcard everything else? */ conversation = find_conversation(pinfo->fd->num, &ftp_ip_address, &pinfo->dst, PT_TCP, ftp_port, 0, NO_PORT_B); if (conversation == NULL) { /* * XXX - should this call to "conversation_new()" * just use "ftp_ip_address" and "server_port", * and wildcard everything else? * * XXX - what if we did find a conversation? As * we create it only on the first pass through the * packets, if we find one, it's presumably an * unrelated conversation. Should we remove the * old one from the hash table and put this one in * its place? Can the conversation code handle * conversations not in the hash table? Or should * we make conversations support start and end * frames, as circuits do, and treat this as an * indication that one conversation was closed and * a new one was opened? */ conversation = conversation_new( pinfo->fd->num, &ftp_ip_address, &pinfo->dst, PT_TCP, ftp_port, 0, NO_PORT2); conversation_set_dissector(conversation, ftpdata_handle); } } } } if (is_epasv_response) { if (linelen != 0) { /* * This frame contains an EPSV response; set up a * conversation for the data. */ if (parse_extended_pasv_response(line, linelen, &ftp_port)) { /* Add port number to tree */ if (tree) { proto_tree_add_uint(reqresp_tree, hf_ftp_pasv_port, tvb, 0, 0, ftp_port); } /* Find/create conversation for data */ conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, PT_TCP, ftp_port, 0, NO_PORT_B); if (conversation == NULL) { conversation = conversation_new( pinfo->fd->num, &pinfo->src, &pinfo->dst, PT_TCP, ftp_port, 0, NO_PORT2); conversation_set_dissector(conversation, ftpdata_handle); } } } } if (tree) { /* * Show the rest of the request or response as text, * a line at a time. * XXX - only if there's a continuation indicator? */ while (tvb_offset_exists(tvb, offset)) { /* * Find the end of the line. */ tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE); /* * Put this line. */ proto_tree_add_text(ftp_tree, tvb, offset, next_offset - offset, "%s", tvb_format_text(tvb, offset, next_offset - offset)); offset = next_offset; } } }
static int dissect_v3_report(tvbuff_t *tvb, proto_tree *parent_tree, int offset) { guint8 m0,m1,m2,m3; guint8 s0,s1,s2,s3; guint8 metric; guint32 ip; while (tvb_reported_length_remaining(tvb, offset) > 0) { proto_tree *tree; proto_item *item; int old_offset_a = offset; item = proto_tree_add_item(parent_tree, hf_route, tvb, offset, -1, ENC_NA); tree = proto_item_add_subtree(item, ett_route); m0 = 0xff; /* read the mask */ m1 = tvb_get_guint8(tvb, offset); m2 = tvb_get_guint8(tvb, offset+1); m3 = tvb_get_guint8(tvb, offset+2); ip = m3; ip = (ip<<8)|m2; ip = (ip<<8)|m1; ip = (ip<<8)|m0; proto_tree_add_ipv4(tree, hf_netmask, tvb, offset, 3, ip); offset += 3; /* read every srcnet, metric pairs */ do { int old_offset_b = offset; m0 = 0xff; s1 = 0; s2 = 0; s3 = 0; s0 = tvb_get_guint8(tvb, offset); offset += 1; if (m1) { s1 = tvb_get_guint8(tvb, offset); offset += 1; } if (m2) { s2 = tvb_get_guint8(tvb, offset); offset += 1; } if (m3) { s3 = tvb_get_guint8(tvb, offset); offset += 1; } /* handle special case for default route V3/3.4.3 */ if ((!m1)&&(!m2)&&(!m3)&&(!s0)) { m0 = 0; } ip = s3; ip = (ip<<8)|s2; ip = (ip<<8)|s1; ip = (ip<<8)|s0; proto_tree_add_ipv4_format(tree, hf_saddr, tvb, old_offset_b, offset-old_offset_b, ip, "%s %d.%d.%d.%d (netmask %d.%d.%d.%d)", m0?"Source Network":"Default Route", s0,s1,s2,s3,m0,m1,m2,m3); metric = tvb_get_guint8(tvb, offset); proto_tree_add_uint(tree, hf_metric, tvb, offset, 1, metric&0x7f); offset += 1; } while (!(metric&0x80)); proto_item_set_len(item, offset-old_offset_a); } return offset; }
void dissect_cie_list(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint offset, gint cieEnd, e_nhrp_hdr *hdr, gint isReq, gboolean codeinfo) { proto_item *cli_addr_tree_item = NULL; proto_tree *cli_addr_tree = NULL; proto_item *cli_saddr_tree_item = NULL; proto_tree *cli_saddr_tree = NULL; guint8 val; while ((offset + 12) <= cieEnd) { guint cli_addr_len = tvb_get_guint8(tvb, offset + 8); guint cli_saddr_len = tvb_get_guint8(tvb, offset + 9); guint cli_prot_len = tvb_get_guint8(tvb, offset + 10); guint cie_len = 12 + cli_addr_len + cli_saddr_len + cli_prot_len; proto_item *cie_tree_item = proto_tree_add_text(tree, tvb, offset, cie_len, "Client Information Entry"); proto_tree *cie_tree = proto_item_add_subtree(cie_tree_item, ett_nhrp_cie); if (isReq) { proto_tree_add_item(cie_tree, hf_nhrp_code, tvb, offset, 1, FALSE); } else { guint8 code = tvb_get_guint8(tvb, offset); if ( codeinfo ) { col_append_fstr(pinfo->cinfo, COL_INFO, ", Code=%s", val_to_str(code, nhrp_cie_code_vals, "Unknown (%u)")); } proto_tree_add_text(cie_tree, tvb, offset, 1, "Code: %s", val_to_str(code, nhrp_cie_code_vals, "Unknown (%u)")); } offset += 1; proto_tree_add_item(cie_tree, hf_nhrp_prefix_len, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(cie_tree, hf_nhrp_unused, tvb, offset, 2, FALSE); offset += 2; proto_tree_add_item(cie_tree, hf_nhrp_mtu, tvb, offset, 2, FALSE); offset += 2; proto_tree_add_item(cie_tree, hf_nhrp_holding_time, tvb, offset, 2, FALSE); offset += 2; val = tvb_get_guint8(tvb, offset); cli_addr_tree_item = proto_tree_add_uint_format(cie_tree, hf_nhrp_cli_addr_tl, tvb, offset, 1, val, "Client Address Type/Len: %s/%u", val_to_str(NHRP_SHTL_TYPE(val), nhrp_shtl_type_vals, "Unknown Type"), NHRP_SHTL_LEN(val)); cli_addr_tree = proto_item_add_subtree(cli_addr_tree_item, ett_nhrp_cie_cli_addr_tl); proto_tree_add_item(cli_addr_tree, hf_nhrp_cli_addr_tl_type, tvb, offset, 1, FALSE); proto_tree_add_item(cli_addr_tree, hf_nhrp_cli_addr_tl_len, tvb, offset, 1, FALSE); offset += 1; val = tvb_get_guint8(tvb, offset); cli_saddr_tree_item = proto_tree_add_uint_format(cie_tree, hf_nhrp_cli_saddr_tl, tvb, offset, 1, val, "Client Sub Address Type/Len: %s/%u", val_to_str(NHRP_SHTL_TYPE(val), nhrp_shtl_type_vals, "Unknown Type"), NHRP_SHTL_LEN(val)); cli_saddr_tree = proto_item_add_subtree(cli_saddr_tree_item, ett_nhrp_cie_cli_saddr_tl); proto_tree_add_item(cli_saddr_tree, hf_nhrp_cli_saddr_tl_type, tvb, offset, 1, FALSE); proto_tree_add_item(cli_saddr_tree, hf_nhrp_cli_saddr_tl_len, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(cie_tree, hf_nhrp_cli_prot_len, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(cie_tree, hf_nhrp_pref, tvb, offset, 1, FALSE); offset += 1; if (cli_addr_len) { switch (hdr->ar_afn) { case AFNUM_INET: if (cli_addr_len == 4) proto_tree_add_item(cie_tree, hf_nhrp_client_nbma_addr, tvb, offset, 4, FALSE); else { proto_tree_add_text(cie_tree, tvb, offset, cli_addr_len, "Client NBMA Address: %s", tvb_bytes_to_str(tvb, offset, cli_addr_len)); } break; default: proto_tree_add_text(cie_tree, tvb, offset, cli_addr_len, "Client NBMA Address: %s", tvb_bytes_to_str(tvb, offset, cli_addr_len)); break; } offset += cli_addr_len; } if (cli_saddr_len) { proto_tree_add_text(cie_tree, tvb, offset, cli_saddr_len, "Client NBMA Sub Address: %s", tvb_bytes_to_str(tvb, offset, cli_saddr_len)); } if (cli_prot_len) { if (cli_prot_len == 4) proto_tree_add_ipv4(cie_tree, hf_nhrp_client_prot_addr, tvb, offset, 4, FALSE); else { proto_tree_add_text(cie_tree, tvb, offset, cli_prot_len, "Client Protocol Address: %s", tvb_bytes_to_str(tvb, offset, cli_prot_len)); } offset += cli_prot_len; } } }