From Michael Mann:

length bugfix + proto_tree_add_text() cleanup

Fixed the Web-Cache Identity Info dissection.  Also converted many of the
proto_tree_add_text() to "more filterable" APIs.

https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=5141

svn path=/trunk/; revision=43231

1 files changed, 655 insertions, 434 deletions

diff --git a/epan/dissectors/packet-wccp.c b/epan/dissectors/packet-wccp.c
index a22438f71d..4179555936 100644
--- a/epan/dissectors/packet-wccp.c
+++ b/epan/dissectors/packet-wccp.c
@@ -37,10 +37,91 @@
 static int proto_wccp = -1;
 static int hf_wccp_message_type = -1;	/* the message type */
 static int hf_wccp_version = -1;	/* protocol version */
+static int hf_wccp2_version = -1;
 static int hf_hash_revision = -1;	/* the version of the hash */
 static int hf_change_num = -1;		/* change number */
+static int hf_hash_flag = -1;
+static int hf_hash_flag_u = -1;
 static int hf_recvd_id = -1;
+static int hf_num_web_caches = -1;
 static int hf_cache_ip = -1;
+static int hf_item_header_length = -1;
+static int hf_item_type = -1;
+static int hf_item_length = -1;
+static int hf_item_data = -1;
+static int hf_security_option = -1;
+static int hf_security_md5_checksum = -1;
+static int hf_service_type = -1;
+static int hf_service_id = -1;
+static int hf_service_priority = -1;
+static int hf_service_protocol = -1;
+static int hf_service_flags = -1;
+static int hf_service_flags_src_ip_hash = -1;
+static int hf_service_flags_dest_ip_hash = -1;
+static int hf_service_flags_src_port_hash = -1;
+static int hf_service_flags_dest_port_hash = -1;
+static int hf_service_flags_ports_defined = -1;
+static int hf_service_flags_ports_source = -1;
+static int hf_service_flags_src_ip_alt_hash = -1;
+static int hf_service_flags_dest_ip_alt_hash = -1;
+static int hf_service_flags_src_port_alt_hash = -1;
+static int hf_service_flags_dest_port_alt_hash = -1;
+static int hf_service_port = -1;
+static int hf_router_identity_ip = -1;
+static int hf_router_identity_receive_id = -1;
+static int hf_router_send_to_ip = -1;
+static int hf_router_num_recv_ip = -1;
+static int hf_router_recv_ip = -1;
+static int hf_web_cache_identity_ip = -1;
+static int hf_web_cache_identity_hash_rev = -1;
+static int hf_web_cache_identity_flags = -1;
+static int hf_web_cache_identity_flag_hash_info = -1;
+static int hf_web_cache_identity_flag_assign_type = -1;
+static int hf_web_cache_identity_num_mask = -1;
+static int hf_web_cache_identity_assign_mask = -1;
+static int hf_web_cache_identity_assign_weight = -1;
+static int hf_web_cache_identity_status = -1;
+static int hf_assignment_key_ip = -1;
+static int hf_assignment_key_change_num = -1;
+static int hf_router_view_member_change_num = -1;
+static int hf_router_router_num = -1;
+static int hf_router_router_ip = -1;
+static int hf_wc_view_info_change_num = -1;
+static int hf_wc_view_router_num = -1;
+static int hf_wc_view_ip = -1;
+static int hf_router_assignment_element_ip = -1;
+static int hf_router_assignment_element_receive_id = -1;
+static int hf_router_assignment_element_change_num = -1;
+static int hf_wccp2_assignment_info_router_num = -1;
+static int hf_wccp2_assignment_info_ip = -1;
+static int hf_router_query_info_ip = -1;
+static int hf_router_query_info_receive_id = -1;
+static int hf_router_query_info_send_to_ip = -1;
+static int hf_router_query_info_target_ip = -1;
+static int hf_capability_info_type = -1;
+static int hf_capability_info_length = -1;
+static int hf_capability_info_bytes = -1;
+static int hf_capability_info_value = -1;
+static int hf_capability_forwarding_method_flag_gre = -1;
+static int hf_capability_forwarding_method_flag_l2 = -1;
+static int hf_capability_assignment_method_flag_hash = -1;
+static int hf_capability_assignment_method_flag_mask = -1;
+static int hf_capability_return_method_flag_gre = -1;
+static int hf_capability_return_method_flag_l2 = -1;
+static int hf_wccp2_value_element_src_ip = -1;
+static int hf_wccp2_value_element_dest_ip = -1;
+static int hf_wccp2_value_element_src_port = -1;
+static int hf_wccp2_value_element_dest_port = -1;
+static int hf_wccp2_value_element_web_cache_ip = -1;
+static int hf_wccp2_mask_value_set_element_src_ip = -1;
+static int hf_wccp2_mask_value_set_element_dest_ip = -1;
+static int hf_wccp2_mask_value_set_element_src_port = -1;
+static int hf_wccp2_mask_value_set_element_dest_port = -1;
+static int hf_wccp2_mask_value_set_element_num = -1;
+static int hf_alt_assignment_info_assignment_type = -1;
+static int hf_alt_assignment_info_assignment_length = -1;
+static int hf_alt_assignment_info_num_routers = -1;
+static int hf_alt_assignment_info_num_elements = -1;
 
 static gint ett_wccp = -1;
 static gint ett_cache_count = -1;
@@ -113,9 +194,15 @@ static const value_string wccp_version_val[] = {
 	{ 0, NULL}
 };
 
+const true_false_string tfs_defined_not_defined = { "Defined", "Not defined" };
+const true_false_string tfs_src_dest_port = { "Source port", "Destination port" };
+const true_false_string tfs_historical_current = { "Historical", "Current" };
+const true_false_string tfs_mask_hash = { "Mask", "Hash" };
+
 #define HASH_INFO_SIZE	(4*(1+8+1))
 
 #define	WCCP_U_FLAG	0x80000000
+#define	WCCP_T_FLAG	0x4000
 
 #define WCCP2_SECURITY_INFO		0
 #define WCCP2_SERVICE_INFO		1
@@ -154,14 +241,14 @@ const value_string service_id_vals[] = {
 typedef struct capability_flag {
 	guint32 value;
 	const char *short_name;
-	const char *long_name;
+	int* phf;
 } capability_flag;
 
 static void dissect_hash_data(tvbuff_t *tvb, int offset,
     proto_tree *wccp_tree);
 static void dissect_web_cache_list_entry(tvbuff_t *tvb, int offset,
     int idx, proto_tree *wccp_tree);
-static int wccp_bucket_info(guint8 bucket_info, proto_tree *bucket_tree,
+static guint32 wccp_bucket_info(guint8 bucket_info, proto_tree *bucket_tree,
     guint32 start, tvbuff_t *tvb, int offset);
 static gchar *bucket_name(guint8 bucket);
 static guint16 dissect_wccp2_header(tvbuff_t *tvb, int offset,
@@ -169,28 +256,28 @@ static guint16 dissect_wccp2_header(tvbuff_t *tvb, int offset,
 static void dissect_wccp2_info(tvbuff_t *tvb, int offset, guint16 length,
     packet_info *pinfo, proto_tree *wccp_tree);
 static gboolean dissect_wccp2_security_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_service_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_router_identity_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_wc_identity_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_router_view_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_wc_view_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_assignment_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_router_query_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static gboolean dissect_wccp2_capability_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo _U_, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 static void dissect_32_bit_capability_flags(tvbuff_t *tvb, int curr_offset,
-    guint16 capability_val_len, gint ett, const capability_flag *flags,
-    proto_tree *element_tree);
+    guint16 capability_val_len, packet_info *pinfo, gint ett, const capability_flag *flags,
+    proto_tree *element_tree, proto_item *element_item);
 static gboolean dissect_wccp2_alt_assignment_info(tvbuff_t *tvb, int offset,
-    int length, packet_info *pinfo, proto_tree *info_tree);
+    int length, packet_info *pinfo, proto_tree *info_tree, proto_item *info_item);
 
 static int
 dissect_wccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
@@ -225,14 +312,13 @@ dissect_wccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 		wccp_tree = proto_item_add_subtree(wccp_tree_item, ett_wccp);
 
 		proto_tree_add_uint(wccp_tree, hf_wccp_message_type, tvb, offset,
-		    sizeof(wccp_message_type), wccp_message_type);
-		offset += sizeof(wccp_message_type);
+		    4, wccp_message_type);
+		offset += 4;
 
 		switch (wccp_message_type) {
 
 		case WCCP_HERE_I_AM:
-			proto_tree_add_item(wccp_tree, hf_wccp_version, tvb,
-			    offset, 4, ENC_BIG_ENDIAN);
+			proto_tree_add_item(wccp_tree, hf_wccp_version, tvb, offset, 4, ENC_BIG_ENDIAN);
 			offset += 4;
 			dissect_hash_data(tvb, offset, wccp_tree);
 			offset += HASH_INFO_SIZE;
@@ -242,22 +328,17 @@ dissect_wccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 			break;
 
 		case WCCP_I_SEE_YOU:
-			proto_tree_add_item(wccp_tree, hf_wccp_version, tvb,
-			    offset, 4, ENC_BIG_ENDIAN);
+			proto_tree_add_item(wccp_tree, hf_wccp_version, tvb, offset, 4, ENC_BIG_ENDIAN);
 			offset += 4;
-			proto_tree_add_item(wccp_tree, hf_change_num, tvb, offset,
-			    4, ENC_BIG_ENDIAN);
+			proto_tree_add_item(wccp_tree, hf_change_num, tvb, offset, 4, ENC_BIG_ENDIAN);
 			offset += 4;
-			proto_tree_add_item(wccp_tree, hf_recvd_id, tvb, offset,
-			    4, ENC_BIG_ENDIAN);
+			proto_tree_add_item(wccp_tree, hf_recvd_id, tvb, offset, 4, ENC_BIG_ENDIAN);
 			offset += 4;
 			cache_count = tvb_get_ntohl(tvb, offset);
-			proto_tree_add_text(wccp_tree, tvb, offset, 4,
-			    "Number of Web Caches: %u", cache_count);
+			proto_tree_add_uint(wccp_tree, hf_num_web_caches, tvb, offset, 4, cache_count);
 			offset += 4;
 			for (i = 0; i < cache_count; i++) {
-				dissect_web_cache_list_entry(tvb, offset, i,
-				    wccp_tree);
+				dissect_web_cache_list_entry(tvb, offset, i, wccp_tree);
 				offset += 4 + HASH_INFO_SIZE;
 			}
 			break;
@@ -271,12 +352,10 @@ dissect_wccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 			 * have a Received ID field after the type,
 			 * rather than a Version field.
 			 */
-			proto_tree_add_item(wccp_tree, hf_recvd_id, tvb, offset,
-			    4, ENC_BIG_ENDIAN);
+			proto_tree_add_item(wccp_tree, hf_recvd_id, tvb, offset, 4, ENC_BIG_ENDIAN);
 			offset += 4;
 			cache_count = tvb_get_ntohl(tvb, offset);
-			proto_tree_add_text(wccp_tree, tvb, offset, 4,
-			    "Number of Web Caches: %u", cache_count);
+			proto_tree_add_uint(wccp_tree, hf_num_web_caches, tvb, offset, 4, cache_count);
 			offset += 4;
 			for (i = 0; i < cache_count; i++) {
 				ipaddr = tvb_get_ipv4(tvb, offset);
@@ -321,10 +400,8 @@ dissect_hash_data(tvbuff_t *tvb, int offset, proto_tree *wccp_tree)
 	proto_tree *bucket_tree;
 	proto_item *tf;
 	proto_tree *field_tree;
-	int i;
+	int i, n;
 	guint8 bucket_info;
-	int n;
-	guint32 flags;
 
 	proto_tree_add_item(wccp_tree, hf_hash_revision, tvb, offset, 4,
 	    ENC_BIG_ENDIAN);
@@ -339,18 +416,10 @@ dissect_hash_data(tvbuff_t *tvb, int offset, proto_tree *wccp_tree)
 		n = wccp_bucket_info(bucket_info, bucket_tree, n, tvb, offset);
 		offset += 1;
 	}
-	flags = tvb_get_ntohl(tvb, offset);
-	tf = proto_tree_add_text(wccp_tree, tvb, offset, 4,
-	    "Flags: 0x%08X (%s)", flags,
-	    ((flags & WCCP_U_FLAG) ?
-	      "Hash information is historical" :
-	      "Hash information is current"));
+
+	tf = proto_tree_add_item(wccp_tree, hf_hash_flag, tvb, offset, 4, ENC_BIG_ENDIAN);
 	field_tree = proto_item_add_subtree(tf, ett_flags);
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP_U_FLAG,
-	      sizeof (flags)*8,
-	      "Hash information is historical",
-	      "Hash information is current"));
+	proto_tree_add_item(field_tree, hf_hash_flag_u, tvb, offset, 4, ENC_BIG_ENDIAN);
 }
 
 static void
@@ -363,8 +432,7 @@ dissect_web_cache_list_entry(tvbuff_t *tvb, int offset, int idx,
 	tl = proto_tree_add_text(wccp_tree, tvb, offset, 4 + HASH_INFO_SIZE,
 	    "Web-Cache List Entry(%d)", idx);
 	list_entry_tree = proto_item_add_subtree(tl, ett_cache_info);
-	proto_tree_add_item(list_entry_tree, hf_cache_ip, tvb, offset, 4,
-	    ENC_BIG_ENDIAN);
+	proto_tree_add_item(list_entry_tree, hf_cache_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
 	dissect_hash_data(tvb, offset + 4, list_entry_tree);
 }
 
@@ -373,7 +441,7 @@ dissect_web_cache_list_entry(tvbuff_t *tvb, int offset, int idx,
  * takes an integer representing a "Hash Information" bitmap, and spits out
  * the corresponding proto_tree entries, returning the next bucket number.
  */
-static int
+static guint32
 wccp_bucket_info(guint8 bucket_info, proto_tree *bucket_tree, guint32 start,
     tvbuff_t *tvb, int offset)
 {
@@ -404,12 +472,10 @@ dissect_wccp2_header(tvbuff_t *tvb, int offset, proto_tree *wccp_tree)
 {
 	guint16 length;
 
-	proto_tree_add_item(wccp_tree, hf_wccp_version, tvb, offset, 2,
-	    ENC_BIG_ENDIAN);
+	proto_tree_add_item(wccp_tree, hf_wccp2_version, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
 	length = tvb_get_ntohs(tvb, offset);
-	proto_tree_add_text(wccp_tree, tvb, offset, 2, "Length: %u",
-	    length);
+	proto_tree_add_uint(wccp_tree, hf_item_header_length, tvb, offset, 2, length);
 	return length;
 }
 
@@ -422,7 +488,7 @@ dissect_wccp2_info(tvbuff_t *tvb, int offset, guint16 length,
 	proto_item *ti;
 	proto_tree *info_tree;
 	gint ett;
-	gboolean (*dissector)(tvbuff_t *, int, int, packet_info *, proto_tree *);
+	gboolean (*dissector)(tvbuff_t *, int, int, packet_info *, proto_tree *, proto_item *);
 
 	while (length != 0) {
 		type = tvb_get_ntohs(tvb, offset);
@@ -488,14 +554,12 @@ dissect_wccp2_info(tvbuff_t *tvb, int offset, guint16 length,
 			break;
 		}
 
-		ti = proto_tree_add_text(wccp_tree, tvb, offset, item_length + 4, "%s",
+		ti = proto_tree_add_text(wccp_tree, tvb, offset, item_length + 4, "Message Component (%s)",
 		    val_to_str(type, info_type_vals, "Unknown info type (%u)"));
 		info_tree = proto_item_add_subtree(ti, ett);
-		proto_tree_add_text(info_tree, tvb, offset, 2,
-		    "Type: %s",
-		    val_to_str(type, info_type_vals, "Unknown info type (%u)"));
-		proto_tree_add_text(info_tree, tvb, offset+2, 2,
-		    "Length: %u", item_length);
+		proto_tree_add_item(info_tree, hf_item_type, tvb, offset, 2, ENC_BIG_ENDIAN);
+		proto_tree_add_item(info_tree, hf_item_length, tvb, offset+2, 2, ENC_BIG_ENDIAN);
+
 		offset += 4;
 		length -= 4;
 
@@ -503,12 +567,10 @@ dissect_wccp2_info(tvbuff_t *tvb, int offset, guint16 length,
 		 * XXX - pass in "length" and check for that as well.
 		 */
 		if (dissector != NULL) {
-			if (!(*dissector)(tvb, offset, item_length, pinfo, info_tree))
+			if (!(*dissector)(tvb, offset, item_length, pinfo, info_tree, ti))
 				return;	/* ran out of data */
 		} else {
-			proto_tree_add_text(info_tree, tvb, offset, item_length,
-			    "Data: %u byte%s", item_length,
-			    plurality(item_length, "", "s"));
+			proto_tree_add_item(info_tree, hf_item_data, tvb, offset, item_length, ENC_NA);
 		}
 		offset += item_length;
 		length -= item_length;
@@ -520,43 +582,30 @@ dissect_wccp2_info(tvbuff_t *tvb, int offset, guint16 length,
 #define WCCP2_NO_SECURITY		0
 #define WCCP2_MD5_SECURITY		1
 
+const value_string security_option_vals[] = {
+	{ WCCP2_NO_SECURITY, "None" },
+	{ WCCP2_MD5_SECURITY, "MD5" },
+	{ 0,    NULL }
+};
+
 static gboolean
 dissect_wccp2_security_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint32 security_option;
 
 	if (length < SECURITY_INFO_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be %u", length,
-		    SECURITY_INFO_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+			    "Item length is %u, should be >= %u", length, SECURITY_INFO_LEN);
 		return TRUE;
 	}
 
 	security_option = tvb_get_ntohl(tvb, offset);
-	switch (security_option) {
-
-	case WCCP2_NO_SECURITY:
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Security Option: None");
-		break;
-
-	case WCCP2_MD5_SECURITY:
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Security Option: MD5");
-		offset += 4;
-		if (length > 4) {
-			proto_tree_add_text(info_tree, tvb, offset,
-			    length - 4, "MD5 checksum: %s",
-			    tvb_bytes_to_str(tvb, offset, length - 4));
-		}
-		break;
-
-	default:
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Security Option: Unknown (%u)", security_option);
-		break;
+	proto_tree_add_item(info_tree, hf_security_option, tvb, offset, 4, ENC_BIG_ENDIAN);
+	if (security_option == WCCP2_MD5_SECURITY) {
+		proto_tree_add_item(info_tree, hf_security_md5_checksum, tvb, offset+4, length-4, ENC_NA);
 	}
+
 	return TRUE;
 }
 
@@ -565,6 +614,12 @@ dissect_wccp2_security_info(tvbuff_t *tvb, int offset, int length,
 #define	WCCP2_SERVICE_STANDARD		0
 #define	WCCP2_SERVICE_DYNAMIC		1
 
+const value_string service_type_vals[] = {
+	{ WCCP2_SERVICE_STANDARD, "Well-known service" },
+	{ WCCP2_SERVICE_DYNAMIC, "Dynamic service" },
+	{ 0,    NULL }
+};
+
 /*
  * Service flags.
  */
@@ -581,7 +636,7 @@ dissect_wccp2_security_info(tvbuff_t *tvb, int offset, int length,
 
 static gboolean
 dissect_wccp2_service_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint8 service_type;
 	guint8 priority;
@@ -592,124 +647,63 @@ dissect_wccp2_service_info(tvbuff_t *tvb, int offset, int length,
 	int i;
 
 	if (length != SERVICE_INFO_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be %u", length,
-		    SERVICE_INFO_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+				"Item length is %u, should be %u", length, SERVICE_INFO_LEN);
 		return TRUE;
 	}
 
 	service_type = tvb_get_guint8(tvb, offset);
+    proto_tree_add_item(info_tree, hf_service_type, tvb, offset, 1, ENC_BIG_ENDIAN);
 	switch (service_type) {
 
 	case WCCP2_SERVICE_STANDARD:
-		proto_tree_add_text(info_tree, tvb, offset, 1,
-		    "Service Type: Well-known service");
-		proto_tree_add_text(info_tree, tvb, offset+1, 1,
-		    "Service ID: %s",
-		    val_to_str(tvb_get_guint8(tvb, offset+1), service_id_vals,
-			    "Unknown (0x%02X)"));
+		proto_tree_add_item(info_tree, hf_service_id, tvb, offset+1, 1, ENC_BIG_ENDIAN);
+		tf = proto_tree_add_item(info_tree, hf_service_priority, tvb, offset+2, 1, ENC_BIG_ENDIAN);
 		priority = tvb_get_guint8(tvb, offset+2);
-		tf = proto_tree_add_text(info_tree, tvb, offset+2, 1,
-		    "Priority: %u (unused, must be zero)", priority);
 		if (priority != 0)
-		    expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
-			    "The priority must be zero for well-known services.");
+			expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
+				"The priority must be zero for well-known services.");
+		tf = proto_tree_add_item(info_tree, hf_service_protocol, tvb, offset+3, 1, ENC_BIG_ENDIAN);
 		protocol = tvb_get_guint8(tvb, offset+3);
-		tf = proto_tree_add_text(info_tree, tvb, offset+3, 1,
-		    "Protocol: %u (unused, must be zero)", protocol);
 		if (protocol != 0)
-		    expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
-			    "The protocol must be zero for well-known services.");
+			expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
+				"The protocol must be zero for well-known services.");
 		break;
 
 	case WCCP2_SERVICE_DYNAMIC:
-		proto_tree_add_text(info_tree, tvb, offset, 1,
-		    "Service Type: Dynamic service");
-		proto_tree_add_text(info_tree, tvb, offset+1, 1,
-		    "Service ID: %s",
-		    val_to_str(tvb_get_guint8(tvb, offset+1), service_id_vals,
-			    "Unknown (0x%02X)"));
-		proto_tree_add_text(info_tree, tvb, offset+2, 1,
-		    "Priority: %u", tvb_get_guint8(tvb, offset+2));
+		proto_tree_add_item(info_tree, hf_service_id, tvb, offset+1, 1, ENC_BIG_ENDIAN);
+		proto_tree_add_item(info_tree, hf_service_priority, tvb, offset+2, 1, ENC_BIG_ENDIAN);
 		/*
 		 * XXX - does "IP protocol identifier" mean this is a
 		 * protocol type of the sort you get in IP headers?
 		 * If so, we should get a table of those from the
 		 * IP dissector, and use that.
 		 */
-		proto_tree_add_text(info_tree, tvb, offset+3, 1,
-		    "Protocol: %u", tvb_get_guint8(tvb, offset+3));	/* IP protocol identifier */
-		break;
-
-	default:
-		proto_tree_add_text(info_tree, tvb, offset, 1,
-		    "Service Type: Unknown (%u)", service_type);
+		proto_tree_add_item(info_tree, hf_service_protocol, tvb, offset+3, 1, ENC_BIG_ENDIAN);
 		break;
 	}
 	offset += 4;
 
 	flags = tvb_get_ntohl(tvb, offset);
-	tf = proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Flags: 0x%08X", flags);
+	tf = proto_tree_add_item(info_tree, hf_service_flags, tvb, offset, 4, ENC_BIG_ENDIAN);
 	field_tree = proto_item_add_subtree(tf, ett_service_flags);
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_SRC_IP_HASH,
-	      sizeof (flags)*8,
-	      "Use source IP address in primary hash",
-	      "Don't use source IP address in primary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_DST_IP_HASH,
-	      sizeof (flags)*8,
-	      "Use destination IP address in primary hash",
-	      "Don't use destination IP address in primary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_SRC_PORT_HASH,
-	      sizeof (flags)*8,
-	      "Use source port in primary hash",
-	      "Don't use source port in primary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_DST_PORT_HASH,
-	      sizeof (flags)*8,
-	      "Use destination port in primary hash",
-	      "Don't use destination port in primary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_PORTS_DEFINED,
-	      sizeof (flags)*8,
-	      "Ports defined",
-	      "Ports not defined"));
-	if (flags & WCCP2_SI_PORTS_DEFINED) {
-		proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-		    decode_boolean_bitfield(flags, WCCP2_SI_PORTS_SOURCE,
-		      sizeof (flags)*8,
-		      "Ports refer to source port",
-		      "Ports refer to destination port"));
-	}
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_SRC_IP_ALT_HASH,
-	      sizeof (flags)*8,
-	      "Use source IP address in secondary hash",
-	      "Don't use source IP address in secondary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_DST_IP_ALT_HASH,
-	      sizeof (flags)*8,
-	      "Use destination IP address in secondary hash",
-	      "Don't use destination IP address in secondary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_SRC_PORT_ALT_HASH,
-	      sizeof (flags)*8,
-	      "Use source port in secondary hash",
-	      "Don't use source port in secondary hash"));
-	proto_tree_add_text(field_tree, tvb, offset, 4, "%s",
-	    decode_boolean_bitfield(flags, WCCP2_SI_DST_PORT_ALT_HASH,
-	      sizeof (flags)*8,
-	      "Use destination port in secondary hash",
-	      "Don't use destination port in secondary hash"));
+
+	proto_tree_add_item(field_tree, hf_service_flags_src_ip_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_dest_ip_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_src_port_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_dest_port_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_ports_defined, tvb, offset, 4, ENC_BIG_ENDIAN);
+	if (flags & WCCP2_SI_PORTS_DEFINED)
+		proto_tree_add_item(field_tree, hf_service_flags_ports_source, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_src_ip_alt_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_dest_ip_alt_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_src_port_alt_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_service_flags_dest_port_alt_hash, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
 
 	if (flags & WCCP2_SI_PORTS_DEFINED) {
 		for (i = 0; i < 8; i++) {
-			proto_tree_add_text(info_tree, tvb, offset, 2,
-			    "Port %d: %u", i, tvb_get_ntohs(tvb, offset));
+			proto_tree_add_item(info_tree, hf_service_port, tvb, offset, 2, ENC_BIG_ENDIAN);
 			offset += 2;
 		}
 	}
@@ -723,15 +717,13 @@ static void
 dissect_wccp2_router_identity_element(tvbuff_t *tvb, int offset,
     proto_tree *tree)
 {
-	proto_tree_add_text(tree, tvb, offset, 4,
-	    "IP Address: %s", tvb_ip_to_str(tvb, offset));
-	proto_tree_add_text(tree, tvb, offset + 4, 4,
-	    "Receive ID: %u", tvb_get_ntohl(tvb, offset + 4));
+	proto_tree_add_item(tree, hf_router_identity_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_router_identity_receive_id, tvb, offset+4, 4, ENC_BIG_ENDIAN);
 }
 
 static gboolean
 dissect_wccp2_router_identity_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint32 n_received_from;
 	guint i;
@@ -739,33 +731,28 @@ dissect_wccp2_router_identity_info(tvbuff_t *tvb, int offset, int length,
 	proto_tree *element_tree;
 
 	if (length < ROUTER_ID_INFO_MIN_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be >= %u", length,
-		    ROUTER_ID_INFO_MIN_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+				"Item length is %u, should be >= %u", length, ROUTER_ID_INFO_MIN_LEN);
 		return TRUE;
 	}
 
 	te = proto_tree_add_text(info_tree, tvb, offset, 8,
 	    "Router Identity Element: IP address %s",
 	    tvb_ip_to_str(tvb, offset));
-	element_tree = proto_item_add_subtree(te,
-	    ett_router_identity_element);
+	element_tree = proto_item_add_subtree(te, ett_router_identity_element);
 	dissect_wccp2_router_identity_element(tvb, offset, element_tree);
 	offset += 8;
 
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Sent To IP Address: %s", tvb_ip_to_str(tvb, offset));
+	proto_tree_add_item(info_tree, hf_router_send_to_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
 
 	n_received_from = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Received From IP addresses: %u", n_received_from);
+	proto_tree_add_item(info_tree, hf_router_num_recv_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
-
 	for (i = 0; i < n_received_from; i++) {
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Received From IP Address %d: %s", i,
-		    tvb_ip_to_str(tvb, offset));
+		proto_tree_add_ipv4_format_value(info_tree, hf_router_recv_ip, tvb, offset, 4,
+			tvb_get_ipv4(tvb, offset), "Received From IP Address %d: %s", i,
+			tvb_ip_to_str(tvb, offset));
 		offset += 4;
 	}
 
@@ -775,78 +762,74 @@ dissect_wccp2_router_identity_info(tvbuff_t *tvb, int offset, int length,
 #define	WC_ID_INFO_LEN			(4+4+8*4+4)
 
 static gboolean
-dissect_wccp2_web_cache_identity_element(tvbuff_t *tvb, int offset,
-    proto_tree *tree)
+dissect_wccp2_web_cache_identity_element(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int length)
 {
 	proto_item *bucket_item;
 	proto_tree *bucket_tree;
 	proto_item *tf;
 	proto_tree *field_tree;
-	guint16 flags;
-	int i;
+    guint16 flags;
+	guint32 i, n, num_masks;
 	guint8 bucket_info;
-	int n;
 
-	proto_tree_add_text(tree, tvb, offset, 4,
-	    "Web-Cache IP Address: %s", tvb_ip_to_str(tvb, offset));
+	proto_tree_add_item(tree, hf_web_cache_identity_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
-
-	proto_tree_add_text(tree, tvb, offset, 2,
-	    "Hash Revision %u", tvb_get_ntohs(tvb, offset));
+	proto_tree_add_item(tree, hf_web_cache_identity_hash_rev, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
 
-	flags = tvb_get_ntohs(tvb, offset);
-	tf = proto_tree_add_text(tree, tvb, offset, 2,
-	    "Flags: 0x%04X (%s)", flags,
-	    ((flags & 0x8000) ?
-	      "Hash information is historical" :
-	      "Hash information is current"));
+    flags = tvb_get_ntohs(tvb, offset);
+	tf = proto_tree_add_uint(tree, hf_web_cache_identity_flags, tvb, offset, 2, flags);
 	field_tree = proto_item_add_subtree(tf, ett_flags);
-	proto_tree_add_text(field_tree, tvb, offset, 2, "%s",
-	    decode_boolean_bitfield(flags, 0x8000,
-	      sizeof (flags)*8,
-	      "Hash information is historical",
-	      "Hash information is current"));
+	proto_tree_add_item(field_tree, hf_web_cache_identity_flag_hash_info, tvb, offset, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(field_tree, hf_web_cache_identity_flag_assign_type, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
 
-	bucket_item = proto_tree_add_text(tree, tvb, offset, 8*4,
-	    "Hash information");
-	bucket_tree = proto_item_add_subtree(bucket_item, ett_buckets);
-	for (i = 0, n = 0; i < 32; i++) {
-		bucket_info = tvb_get_guint8(tvb, offset);
-		n = wccp_bucket_info(bucket_info, bucket_tree, n, tvb, offset);
-		offset += 1;
-	}
-
-	proto_tree_add_text(tree, tvb, offset, 2,
-	    "Assignment Weight: %u", tvb_get_ntohs(tvb, offset));
+    if (flags & WCCP_T_FLAG) {
+	    bucket_item = proto_tree_add_text(tree, tvb, offset, 8*4, "Mask Assignment information");
+	    bucket_tree = proto_item_add_subtree(bucket_item, ett_buckets);
+
+        num_masks = tvb_get_ntohl(tvb, offset);
+	    proto_tree_add_uint(bucket_tree, hf_web_cache_identity_num_mask, tvb, offset, 4, num_masks);
+        offset += 4;
+	    for (i = 0; i < num_masks; i++) {
+        	proto_tree_add_item(bucket_tree, hf_web_cache_identity_assign_mask, tvb, offset, 4, ENC_BIG_ENDIAN);
+		    offset += 4;
+        }
+    }
+    else {
+	    if (length != WC_ID_INFO_LEN) {
+		    expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
+				    "Item length is %u, should be %u", length, WC_ID_INFO_LEN);
+		    return TRUE;
+	    }
+
+	    bucket_item = proto_tree_add_text(tree, tvb, offset, 8*4, "Hash information");
+	    bucket_tree = proto_item_add_subtree(bucket_item, ett_buckets);
+	    for (i = 0, n = 0; i < 32; i++) {
+		    bucket_info = tvb_get_guint8(tvb, offset);
+		    n = wccp_bucket_info(bucket_info, bucket_tree, n, tvb, offset);
+		    offset += 1;
+        }
+    }
+
+	proto_tree_add_item(tree, hf_web_cache_identity_assign_weight, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
-
-	proto_tree_add_text(tree, tvb, offset, 2,
-	    "Status: 0x%04X", tvb_get_ntohs(tvb, offset));
-
+	proto_tree_add_item(tree, hf_web_cache_identity_status, tvb, offset, 2, ENC_BIG_ENDIAN);
 	return TRUE;
 }
 
 static gboolean
 dissect_wccp2_wc_identity_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	proto_item *te;
 	proto_tree *element_tree;
 
-	if (length != WC_ID_INFO_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be %u", length, WC_ID_INFO_LEN);
-		return TRUE;
-	}
-
-	te = proto_tree_add_text(info_tree, tvb, offset, 4+2+2+32+2+2,
+	te = proto_tree_add_text(info_tree, tvb, offset, length,
 	    "Web-Cache Identity Element: IP address %s",
 	    tvb_ip_to_str(tvb, offset));
 	element_tree = proto_item_add_subtree(te, ett_wc_identity_element);
-	if (!dissect_wccp2_web_cache_identity_element(tvb, offset,
-	    element_tree))
+	if (!dissect_wccp2_web_cache_identity_element(tvb, offset, pinfo, element_tree, length))
 		return FALSE;	/* ran out of data */
 
 	return TRUE;
@@ -858,16 +841,13 @@ static void
 dissect_wccp2_assignment_key(tvbuff_t *tvb, int offset,
     proto_tree *info_tree)
 {
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Assignment Key IP Address: %s",
-	    tvb_ip_to_str(tvb, offset));
-	proto_tree_add_text(info_tree, tvb, offset + 4, 4,
-	    "Assignment Key Change Number: %u", tvb_get_ntohl(tvb, offset + 4));
+	proto_tree_add_item(info_tree, hf_assignment_key_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(info_tree, hf_assignment_key_change_num, tvb, offset+4, 4, ENC_BIG_ENDIAN);
 }
 
 static gboolean
 dissect_wccp2_router_view_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint32 n_routers;
 	guint32 n_web_caches;
@@ -876,44 +856,38 @@ dissect_wccp2_router_view_info(tvbuff_t *tvb, int offset, int length,
 	proto_tree *element_tree;
 
 	if (length < ROUTER_VIEW_INFO_MIN_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be >= %u", length,
-		    ROUTER_VIEW_INFO_MIN_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+				"Item length is %u, should be >= %u", length, ROUTER_VIEW_INFO_MIN_LEN);
 		return TRUE;
 	}
 
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Member Change Number: %u", tvb_get_ntohl(tvb, offset));
+	proto_tree_add_item(info_tree, hf_router_view_member_change_num, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
 
 	dissect_wccp2_assignment_key(tvb, offset, info_tree);
 	offset += 8;
 
 	n_routers = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Routers: %u", n_routers);
+	proto_tree_add_uint(info_tree, hf_router_router_num, tvb, offset, 4, n_routers);
 	offset += 4;
 
 	for (i = 0; i < n_routers; i++) {
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Router %d IP Address: %s", i,
-		    tvb_ip_to_str(tvb, offset));
+		proto_tree_add_ipv4_format_value(info_tree, hf_router_router_ip, tvb, offset, 4,
+			tvb_get_ipv4(tvb, offset), "Router %d IP Address: %s", i,
+			tvb_ip_to_str(tvb, offset));
 		offset += 4;
 	}
 
 	n_web_caches = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Web Caches: %u", n_web_caches);
+	proto_tree_add_uint(info_tree, hf_num_web_caches, tvb, offset, 4, n_web_caches);
 	offset += 4;
 
 	for (i = 0; i < n_web_caches; i++) {
 		te = proto_tree_add_text(info_tree, tvb, offset, WC_ID_INFO_LEN,
 		    "Web-Cache Identity Element %d: IP address %s", i,
 		    tvb_ip_to_str(tvb, offset));
-		element_tree = proto_item_add_subtree(te,
-		    ett_wc_identity_element);
-		if (!dissect_wccp2_web_cache_identity_element(tvb,
-		    offset, element_tree))
+		element_tree = proto_item_add_subtree(te, ett_wc_identity_element);
+		if (!dissect_wccp2_web_cache_identity_element(tvb, offset, pinfo, element_tree, WC_ID_INFO_LEN))
 			return FALSE;	/* ran out of data */
 		offset += WC_ID_INFO_LEN;
 	}
@@ -925,7 +899,7 @@ dissect_wccp2_router_view_info(tvbuff_t *tvb, int offset, int length,
 
 static gboolean
 dissect_wccp2_wc_view_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint32 n_routers;
 	guint32 n_web_caches;
@@ -934,40 +908,35 @@ dissect_wccp2_wc_view_info(tvbuff_t *tvb, int offset, int length,
 	proto_tree *element_tree;
 
 	if (length < WC_VIEW_INFO_MIN_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be >= %u", length,
-		    WC_VIEW_INFO_MIN_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+			    "Item length is %u, should be >= %u", length, WC_VIEW_INFO_MIN_LEN);
 		return TRUE;
 	}
 
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Change Number: %u", tvb_get_ntohl(tvb, offset));
+	proto_tree_add_item(info_tree, hf_wc_view_info_change_num, tvb, offset, 4, ENC_BIG_ENDIAN);
 	offset += 4;
 
 	n_routers = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Routers: %u", n_routers);
+	proto_tree_add_uint(info_tree, hf_wc_view_router_num, tvb, offset, 4, n_routers);
 	offset += 4;
 
 	for (i = 0; i < n_routers; i++) {
 		te = proto_tree_add_text(info_tree, tvb, offset, 8,
 		    "Router %d Identity Element: IP address %s", i,
 		    tvb_ip_to_str(tvb, offset));
-		element_tree = proto_item_add_subtree(te,
-		    ett_router_identity_element);
+		element_tree = proto_item_add_subtree(te, ett_router_identity_element);
 		dissect_wccp2_router_identity_element(tvb, offset, element_tree);
 		offset += 8;
 	}
 
 	n_web_caches = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Web Caches: %u", n_web_caches);
+	proto_tree_add_uint(info_tree, hf_num_web_caches, tvb, offset, 4, n_web_caches);
 	offset += 4;
 
 	for (i = 0; i < n_web_caches; i++) {
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Web-Cache %d: IP address %s", i,
-		    tvb_ip_to_str(tvb, offset));
+		proto_tree_add_ipv4_format_value(info_tree, hf_wc_view_ip, tvb, offset, 4,
+			tvb_get_ipv4(tvb, offset), "Web-Cache %d IP Address: %s", i,
+			tvb_ip_to_str(tvb, offset));
 		offset += 4;
 	}
 
@@ -980,12 +949,9 @@ static void
 dissect_wccp2_router_assignment_element(tvbuff_t *tvb, int offset,
     proto_tree *tree)
 {
-	proto_tree_add_text(tree, tvb, offset, 4,
-	    "IP Address: %s", tvb_ip_to_str(tvb, offset));
-	proto_tree_add_text(tree, tvb, offset + 4, 4,
-	    "Receive ID: %u", tvb_get_ntohl(tvb, offset + 4));
-	proto_tree_add_text(tree, tvb, offset + 8, 4,
-	    "Change Number: %u", tvb_get_ntohl(tvb, offset + 8));
+	proto_tree_add_item(tree, hf_router_assignment_element_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_router_assignment_element_receive_id, tvb, offset+4, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_router_assignment_element_change_num, tvb, offset+8, 4, ENC_BIG_ENDIAN);
 }
 
 static gchar *
@@ -1004,7 +970,7 @@ assignment_bucket_name(guint8 bucket)
 
 static gboolean
 dissect_wccp2_assignment_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint32 n_routers;
 	guint32 n_web_caches;
@@ -1013,9 +979,8 @@ dissect_wccp2_assignment_info(tvbuff_t *tvb, int offset, int length,
 	proto_tree *element_tree;
 
 	if (length < ASSIGNMENT_INFO_MIN_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be >= %u", length,
-		    ASSIGNMENT_INFO_MIN_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+			    "Item length is %u, should be >= %u", length, ASSIGNMENT_INFO_MIN_LEN);
 		return TRUE;
 	}
 
@@ -1023,29 +988,25 @@ dissect_wccp2_assignment_info(tvbuff_t *tvb, int offset, int length,
 	offset += 8;
 
 	n_routers = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Routers: %u", n_routers);
+	proto_tree_add_uint(info_tree, hf_wccp2_assignment_info_router_num, tvb, offset, 4, n_routers);
 	offset += 4;
 
 	for (i = 0; i < n_routers; i++) {
 		te = proto_tree_add_text(info_tree, tvb, offset, 4,
 		    "Router %d Assignment Element: IP address %s", i,
 		    tvb_ip_to_str(tvb, offset));
-		element_tree = proto_item_add_subtree(te,
-		    ett_router_assignment_element);
-		dissect_wccp2_router_assignment_element(tvb, offset,
-		    element_tree);
+		element_tree = proto_item_add_subtree(te, ett_router_assignment_element);
+		dissect_wccp2_router_assignment_element(tvb, offset, element_tree);
 		offset += 12;
 	}
 
 	n_web_caches = tvb_get_ntohl(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Number of Web Caches: %u", n_web_caches);
+	proto_tree_add_uint(info_tree, hf_num_web_caches, tvb, offset, 4, n_web_caches);
 	offset += 4;
 
 	for (i = 0; i < n_web_caches; i++) {
-		proto_tree_add_text(info_tree, tvb, offset, 4,
-		    "Web-Cache %d: IP address %s", i,
+		proto_tree_add_ipv4_format_value(info_tree, hf_wccp2_assignment_info_ip, tvb, offset, 4,
+			tvb_get_ipv4(tvb, offset), "Web-Cache %d IP Address: %s", i,
 		    tvb_ip_to_str(tvb, offset));
 		offset += 4;
 	}
@@ -1068,28 +1029,18 @@ dissect_wccp2_assignment_info(tvbuff_t *tvb, int offset, int length,
 
 static gboolean
 dissect_wccp2_router_query_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	if (length != QUERY_INFO_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be %u", length, QUERY_INFO_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+				"Item length is %u, should be %u", length, QUERY_INFO_LEN);
 		return TRUE;
 	}
 
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Router IP Address: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Receive ID: %u", tvb_get_ntohl(tvb, offset));
-	offset += 4;
-
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Sent To IP Address: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-
-	proto_tree_add_text(info_tree, tvb, offset, 4,
-	    "Target IP Address: %s", tvb_ip_to_str(tvb, offset));
+	proto_tree_add_item(info_tree, hf_router_query_info_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(info_tree, hf_router_query_info_receive_id, tvb, offset+4, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(info_tree, hf_router_query_info_send_to_ip, tvb, offset+8, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(info_tree, hf_router_query_info_target_ip, tvb, offset+12, 4, ENC_BIG_ENDIAN);
 
 	return TRUE;
 }
@@ -1109,20 +1060,17 @@ static const value_string capability_type_vals[] = {
 #define WCCP2_FORWARDING_METHOD_L2	0x00000002
 
 static const capability_flag forwarding_method_flags[] = {
-	{ WCCP2_FORWARDING_METHOD_GRE,
-	  "IP-GRE", "GRE-encapsulated" },
-	{ WCCP2_FORWARDING_METHOD_L2,
-	  "L2", "L2 rewrite" },
-	{ 0,
-	  NULL, NULL }
+	{ WCCP2_FORWARDING_METHOD_GRE, "IP-GRE", &hf_capability_forwarding_method_flag_gre },
+	{ WCCP2_FORWARDING_METHOD_L2, "L2", &hf_capability_forwarding_method_flag_l2 },
+	{ 0, NULL, NULL }
 };
 
 #define WCCP2_ASSIGNMENT_METHOD_HASH    0x00000001
 #define WCCP2_ASSIGNMENT_METHOD_MASK    0x00000002
 
 static const capability_flag assignment_method_flags[] = {
-	{ WCCP2_ASSIGNMENT_METHOD_HASH, "Hash", "Hash" },
-	{ WCCP2_ASSIGNMENT_METHOD_MASK, "Mask", "Mask" },
+	{ WCCP2_ASSIGNMENT_METHOD_HASH, "Hash", &hf_capability_assignment_method_flag_hash },
+	{ WCCP2_ASSIGNMENT_METHOD_MASK, "Mask", &hf_capability_assignment_method_flag_mask },
 	{ 0,                            NULL,   NULL }
 };
 
@@ -1130,17 +1078,14 @@ static const capability_flag assignment_method_flags[] = {
 #define WCCP2_PACKET_RETURN_METHOD_L2   0x00000002
 
 static const capability_flag packet_return_method_flags[] = {
-	{ WCCP2_PACKET_RETURN_METHOD_GRE,
-	  "IP-GRE", "GRE-encapsulated" },
-	{ WCCP2_PACKET_RETURN_METHOD_L2,
-	  "L2", "L2 rewrite" },
-	{ 0,
-	  NULL, NULL }
+	{ WCCP2_PACKET_RETURN_METHOD_GRE, "IP-GRE", &hf_capability_return_method_flag_gre },
+	{ WCCP2_PACKET_RETURN_METHOD_L2, "L2", &hf_capability_return_method_flag_l2 },
+	{ 0, NULL, NULL }
 };
 
 static gboolean
 dissect_wccp2_capability_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo _U_, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint16 capability_type;
 	guint16 capability_val_len;
@@ -1149,59 +1094,45 @@ dissect_wccp2_capability_info(tvbuff_t *tvb, int offset, int length,
 	proto_tree *element_tree;
 
 	for (curr_offset = offset; curr_offset < (length + offset);
-	    curr_offset += (capability_val_len + 4)) {
+		curr_offset += (capability_val_len + 4)) {
 		capability_type = tvb_get_ntohs(tvb, curr_offset);
 		capability_val_len = tvb_get_ntohs(tvb, curr_offset + 2);
-		te = proto_tree_add_text(info_tree, tvb, curr_offset,
-		    capability_val_len + 4, "%s",
-		    val_to_str(capability_type,
-		      capability_type_vals, "Unknown Capability Element (0x%08X)"));
-		element_tree = proto_item_add_subtree(te,
-		    ett_capability_element);
-
-		proto_tree_add_text(element_tree, tvb, curr_offset, 2,
-		    "Type: %s",
-		    val_to_str(capability_type,
-		      capability_type_vals, "Unknown (0x%08X)"));
 
+		te = proto_tree_add_item(info_tree, hf_capability_info_type, tvb, curr_offset, 2, ENC_BIG_ENDIAN);
+		proto_item_set_len(te, capability_val_len + 4);
+		element_tree = proto_item_add_subtree(te, ett_capability_element);
 		if (capability_val_len < 4) {
-			proto_tree_add_text(element_tree, tvb, curr_offset+2, 2,
-			    "Value Length: %u (illegal, must be >= 4)",
-			    capability_val_len);
+			expert_add_info_format(pinfo, te, PI_PROTOCOL, PI_WARN,
+					"Value Length: %u (illegal, must be >= 4)", capability_val_len);
 			break;
 		}
-		proto_tree_add_text(element_tree, tvb, curr_offset+2, 2,
-		    "Value Length: %u", capability_val_len);
 
+		proto_tree_add_uint(element_tree, hf_capability_info_length, tvb, curr_offset+2, 2, capability_val_len);
 		switch (capability_type) {
 
 		case WCCP2_FORWARDING_METHOD:
 			dissect_32_bit_capability_flags(tvb, curr_offset,
-			    capability_val_len,
+			    capability_val_len, pinfo,
 			    ett_capability_forwarding_method,
-			    forwarding_method_flags, element_tree);
+			    forwarding_method_flags, element_tree, te);
 			break;
 
 		case WCCP2_ASSIGNMENT_METHOD:
 			dissect_32_bit_capability_flags(tvb, curr_offset,
-			    capability_val_len,
+			    capability_val_len, pinfo,
 			    ett_capability_assignment_method,
-			    assignment_method_flags, element_tree);
+			    assignment_method_flags, element_tree, te);
 			break;
 
 		case WCCP2_PACKET_RETURN_METHOD:
 			dissect_32_bit_capability_flags(tvb, curr_offset,
-			    capability_val_len,
+			    capability_val_len, pinfo,
 			    ett_capability_return_method,
-			    packet_return_method_flags, element_tree);
+			    packet_return_method_flags, element_tree, te);
 			break;
 
 		default:
-			proto_tree_add_text(element_tree, tvb,
-			    curr_offset+4, capability_val_len,
-			    "Value: %s",
-			    tvb_bytes_to_str(tvb, curr_offset+4,
-				    	     capability_val_len));
+			proto_tree_add_item(element_tree, hf_capability_info_bytes, tvb, curr_offset+4, capability_val_len, ENC_NA);
 			break;
 		}
 
@@ -1211,62 +1142,42 @@ dissect_wccp2_capability_info(tvbuff_t *tvb, int offset, int length,
 
 static void
 dissect_32_bit_capability_flags(tvbuff_t *tvb, int curr_offset,
-    guint16 capability_val_len, gint ett, const capability_flag *flags,
-    proto_tree *element_tree)
+    guint16 capability_val_len, packet_info *pinfo, gint ett, const capability_flag *flags,
+    proto_tree *element_tree, proto_item *element_item)
 {
 	guint32 capability_val;
 	proto_item *tm;
 	proto_tree *method_tree;
 	int i;
-	char *flags_string;
-	char *p;
-	gint returned_length, str_index = 0;
-	char *buf;
+	gboolean first = TRUE;
 
 	if (capability_val_len != 4) {
-		proto_tree_add_text(element_tree, tvb,
-		    curr_offset+4, capability_val_len,
-		    "Illegal length (must be 4)");
+		expert_add_info_format(pinfo, element_item, PI_PROTOCOL, PI_WARN,
+				"Value Length: %u (illegal, must be >= 4)", capability_val_len);
 		return;
 	}
 
 	capability_val = tvb_get_ntohl(tvb, curr_offset + 4);
-#define FLAGS_STRING_LEN (128+1)
-	flags_string=ep_alloc(FLAGS_STRING_LEN);
-	flags_string[0] = 0;
+	tm = proto_tree_add_uint(element_tree, hf_capability_info_value, tvb, curr_offset + 4, 4, capability_val);
+
 	for (i = 0; flags[i].short_name != NULL; i++) {
 		if (capability_val & flags[i].value) {
-			if (str_index != 0) {
-				returned_length = g_snprintf(&flags_string[str_index],
-					FLAGS_STRING_LEN-str_index, ",");
-				str_index += MIN(returned_length, FLAGS_STRING_LEN-str_index);
+			if (first) {
+				proto_item_append_text( tm, " (%s", flags[i].short_name);
+				first = FALSE;
+			} else {
+				proto_item_append_text( tm, ", %s", flags[i].short_name);
 			}
-			returned_length = g_snprintf(&flags_string[str_index],
-				FLAGS_STRING_LEN-str_index, "%s", flags[i].short_name);
-			str_index += MIN(returned_length, FLAGS_STRING_LEN-str_index);
 		}
 	}
-	tm = proto_tree_add_text(element_tree, tvb, curr_offset+4, 4,
-	    "Value: 0x%08X (%s)", capability_val, flags_string);
+
+	if (first == FALSE)
+		proto_item_append_text( tm, ")");
 
 	method_tree = proto_item_add_subtree(tm, ett);
-#define BUF_SIZE 1024
-	buf=ep_alloc(BUF_SIZE);
-	buf[0]=0;
-	for (i = 0; flags[i].long_name != NULL; i++) {
-		p = decode_bitfield_value(buf, capability_val,
-		      flags[i].value, 32);
-		str_index = MIN((gint)(p-buf), BUF_SIZE);
-		returned_length = g_snprintf(&flags_string[str_index], BUF_SIZE-str_index,
-			"%s: %s", flags[i].long_name,
-				(capability_val & flags[i].value)?
-					"Supported":
-					"Not supported"
-				);
-		str_index += MIN(returned_length, BUF_SIZE-str_index);
-		proto_tree_add_text(method_tree, tvb, curr_offset+4, 4,
-		    "%s", buf);
-	}
+	for (i = 0; flags[i].phf != NULL; i++)
+		proto_tree_add_item(method_tree, *(flags[i].phf), tvb, curr_offset+4, 4, ENC_BIG_ENDIAN);
+
 }
 
 #define ALT_ASSIGNMENT_INFO_MIN_LEN    (4+4)
@@ -1289,15 +1200,11 @@ dissect_wccp2_value_element(tvbuff_t *tvb, int offset, int idx, proto_tree *info
 	tl = proto_tree_add_text(info_tree, tvb, offset, 16, "Value Element(%u)", idx);
 	element_tree = proto_item_add_subtree(tl, ett_value_element);
 
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Source Address value: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Destination Address value: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-	proto_tree_add_text(element_tree, tvb, offset, 2, "Source Port value: %u", tvb_get_ntohs(tvb, offset));
-	offset += 2;
-	proto_tree_add_text(element_tree, tvb, offset, 2, "Source Port value: %u", tvb_get_ntohs(tvb, offset));
-	offset += 2;
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Web Cache Address: %s", tvb_ip_to_str(tvb, offset));
+	proto_tree_add_item(element_tree, hf_wccp2_value_element_src_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_value_element_dest_ip, tvb, offset+4, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_value_element_src_port, tvb, offset+8, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_value_element_dest_port, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_value_element_web_cache_ip, tvb, offset+12, 4, ENC_BIG_ENDIAN);
 }
 
 static guint
@@ -1308,22 +1215,16 @@ dissect_wccp2_mask_value_set_element(tvbuff_t *tvb, int offset, int idx, proto_t
 	guint num_of_val_elements;
 	guint i;
 
-	tl = proto_tree_add_text(info_tree, tvb, offset, 0,
-	    "Mask/Value Set Element(%d)", idx);
+	tl = proto_tree_add_text(info_tree, tvb, offset, 0, "Mask/Value Set Element(%d)", idx);
 	element_tree = proto_item_add_subtree(tl, ett_mv_set_element);
 
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Source Address Mask: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Destination Address Mask: %s", tvb_ip_to_str(tvb, offset));
-	offset += 4;
-	proto_tree_add_text(element_tree, tvb, offset, 2, "Source Port Mask: %04x", tvb_get_ntohs(tvb, offset));
-	offset += 2;
-	proto_tree_add_text(element_tree, tvb, offset, 2, "Destination Port Mask: %04x", tvb_get_ntohs(tvb, offset));
-	offset += 2;
-
-	proto_tree_add_text(element_tree, tvb, offset, 4, "Number of Value Elements: %u", tvb_get_ntohl(tvb, offset));
-	num_of_val_elements = tvb_get_ntohl(tvb, offset);
-	offset += 4;
+	proto_tree_add_item(element_tree, hf_wccp2_mask_value_set_element_src_ip, tvb, offset, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_mask_value_set_element_dest_ip, tvb, offset+4, 4, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_mask_value_set_element_src_port, tvb, offset+8, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_mask_value_set_element_dest_port, tvb, offset+10, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(element_tree, hf_wccp2_mask_value_set_element_num, tvb, offset+12, 4, ENC_BIG_ENDIAN);
+	num_of_val_elements = tvb_get_ntohl(tvb, offset+12);
+	offset += 16;
 
 	for (i = 0; i < num_of_val_elements; i++)
 	{
@@ -1338,33 +1239,28 @@ dissect_wccp2_mask_value_set_element(tvbuff_t *tvb, int offset, int idx, proto_t
 
 static gboolean
 dissect_wccp2_alt_assignment_info(tvbuff_t *tvb, int offset, int length,
-    packet_info *pinfo, proto_tree *info_tree)
+    packet_info *pinfo, proto_tree *info_tree, proto_item *info_item)
 {
 	guint16 assignment_type;
 	guint16 assignment_length;
 
 	if (length < ALT_ASSIGNMENT_INFO_MIN_LEN) {
-		proto_tree_add_text(info_tree, tvb, offset, 0,
-		    "Item length is %u, should be >= %u", length,
-		    ALT_ASSIGNMENT_INFO_MIN_LEN);
+		expert_add_info_format(pinfo, info_item, PI_PROTOCOL, PI_WARN,
+				"Item length is %u, should be >= %u", length, ALT_ASSIGNMENT_INFO_MIN_LEN);
 		return TRUE;
 	}
 
 	assignment_type = tvb_get_ntohs(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 2,
-	    "Assignment type: %s", val_to_str(assignment_type,
-	    assignment_type_vals, "Unknown assignment type (%u)"));
+	proto_tree_add_item(info_tree, hf_alt_assignment_info_assignment_type, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
 
 	assignment_length = tvb_get_ntohs(tvb, offset);
-	proto_tree_add_text(info_tree, tvb, offset, 2,
-	    "Assignment length: %u", assignment_length);
+	proto_tree_add_item(info_tree, hf_alt_assignment_info_assignment_length, tvb, offset, 2, ENC_BIG_ENDIAN);
 	offset += 2;
 
 	switch (assignment_type) {
 	case WCCP2_HASH_ASSIGNMENT_TYPE:
-		dissect_wccp2_assignment_info(tvb, offset, assignment_length,
-			pinfo, info_tree);
+		dissect_wccp2_assignment_info(tvb, offset, assignment_length, pinfo, info_tree, info_item);
 		break;
 
 	case WCCP2_MASK_ASSIGNMENT_TYPE:
@@ -1377,7 +1273,7 @@ dissect_wccp2_alt_assignment_info(tvbuff_t *tvb, int offset, int length,
 		offset += 8;
 
 		num_of_rtr = tvb_get_ntohl(tvb, offset);
-		proto_tree_add_text(info_tree, tvb, offset, 4, "Number of routers: %u", num_of_rtr);
+		proto_tree_add_uint(info_tree, hf_alt_assignment_info_num_routers, tvb, offset, 4, num_of_rtr);
 		offset += 4;
 		for (i = 0; i < num_of_rtr; i++)
 		{
@@ -1386,7 +1282,7 @@ dissect_wccp2_alt_assignment_info(tvbuff_t *tvb, int offset, int length,
 		}
 
 		num_of_elem = tvb_get_ntohl(tvb, offset);
-		proto_tree_add_text(info_tree, tvb, offset, 4, "Number of elements: %u", num_of_elem);
+		proto_tree_add_uint(info_tree, hf_alt_assignment_info_num_elements, tvb, offset, 4, num_of_elem);
 		offset += 4;
 		for (i = 0; i < num_of_elem; i++)
 		{
@@ -1414,6 +1310,10 @@ proto_register_wccp(void)
 			{ "WCCP Version", "wccp.version", FT_UINT32, BASE_HEX, VALS(wccp_version_val), 0x0,
 				"The WCCP version", HFILL }
 		},
+		{ &hf_wccp2_version,
+			{ "WCCP Version", "wccp.version", FT_UINT16, BASE_HEX, NULL, 0x0,
+				"The WCCP version", HFILL }
+		},
 		{ &hf_hash_revision,
 			{ "Hash Revision", "wccp.hash_revision", FT_UINT32, BASE_DEC, 0x0, 0x0,
 				"The cache hash revision", HFILL }
@@ -1422,15 +1322,336 @@ proto_register_wccp(void)
 			{ "Change Number", "wccp.change_num", FT_UINT32, BASE_DEC, 0x0, 0x0,
 				"The Web-Cache list entry change number", HFILL }
 		},
+		{ &hf_hash_flag,
+			{ "Flags", "wccp.hash_flag", FT_UINT32, BASE_HEX, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_hash_flag_u,
+			{ "Hash information", "wccp.hash_flag.u", FT_BOOLEAN, 32, TFS(&tfs_historical_current), WCCP_U_FLAG,
+				NULL, HFILL }
+		},
 		{ &hf_recvd_id,
 			{ "Received ID", "wccp.recvd_id", FT_UINT32, BASE_DEC, 0x0, 0x0,
 				"The number of I_SEE_YOU's that have been sent", HFILL }
 		},
+		{ &hf_num_web_caches,
+			{ "Number of Web Caches", "wccp.num_web_caches", FT_UINT32, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
 		{ &hf_cache_ip,
 			{ "Web Cache IP address", "wccp.cache_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
 				"The IP address of a Web cache", HFILL }
 		},
+		{ &hf_item_header_length,
+			{ "Length", "wccp.item_header_length", FT_UINT16, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_item_length,
+			{ "Length", "wccp.item_length", FT_UINT16, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_item_type,
+			{ "Type", "wccp.item_type", FT_UINT16, BASE_DEC, VALS(info_type_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_item_data,
+			{ "Data", "wccp.item_data", FT_BYTES, BASE_NONE, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_security_option,
+			{ "Security Option", "wccp.security_option", FT_UINT16, BASE_DEC, VALS(security_option_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_security_md5_checksum,
+			{ "MD5 checksum", "wccp.security_md5_checksum", FT_BYTES, BASE_NONE, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_type,
+			{ "Service Type", "wccp.service_type", FT_UINT8, BASE_DEC, VALS(service_type_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_id,
+			{ "Service ID", "wccp.service_id", FT_UINT8, BASE_DEC, VALS(service_id_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_priority,
+			{ "Priority", "wccp.service_priority", FT_UINT8, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_protocol,
+			{ "Protocol", "wccp.service_protocol", FT_UINT8, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags,
+			{ "Flags", "wccp.service_flags", FT_UINT32, BASE_HEX, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_src_ip_hash,
+			{ "Source IP address in primary hash", "wccp.service_flag.src_ip_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_SRC_IP_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_dest_ip_hash,
+			{ "Destination IP address in primary hash", "wccp.service_flag.dest_ip_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_DST_IP_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_src_port_hash,
+			{ "Source port in primary hash", "wccp.service_flag.src_port_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_SRC_PORT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_dest_port_hash,
+			{ "Destination port in primary hash", "wccp.service_flag.dest_port_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_DST_PORT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_ports_defined,
+			{ "Ports", "wccp.service_flag.ports_defined", FT_BOOLEAN, 32, TFS(&tfs_defined_not_defined), WCCP2_SI_PORTS_DEFINED,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_ports_source,
+			{ "Ports refer to", "wccp.service_flag.ports_source", FT_BOOLEAN, 32, TFS(&tfs_src_dest_port), WCCP2_SI_PORTS_SOURCE,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_src_ip_alt_hash,
+			{ "Source IP address in secondary hash", "wccp.service_flag.src_ip_alt_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_SRC_IP_ALT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_dest_ip_alt_hash,
+			{ "Destination IP address in secondary hash", "wccp.service_flag.dest_ip_alt_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_DST_IP_ALT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_src_port_alt_hash,
+			{ "Source port in secondary hash", "wccp.service_flag.src_port_alt_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_SRC_PORT_ALT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_flags_dest_port_alt_hash,
+			{ "Destination port in secondary hash", "wccp.service_flag.dest_port_alt_hash", FT_BOOLEAN, 32, TFS(&tfs_used_notused), WCCP2_SI_DST_PORT_ALT_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_service_port,
+			{ "Port", "wccp.service_port", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_identity_ip,
+			{ "IP Address", "wccp.router_identity.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_identity_receive_id,
+			{ "Received ID", "wccp.router_identity.receive_id", FT_UINT32, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_send_to_ip,
+			{ "Sent To IP Address", "wccp.router.send_to_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_num_recv_ip,
+			{ "Number of Received From IP addresses", "wccp.router.num_recv_ip", FT_UINT32, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_recv_ip,
+			{ "Received From IP Address", "wccp.router.recv_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_ip,
+			{ "Web-Cache IP Address", "wccp.web_cache_identity.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_hash_rev,
+			{ "Hash Revision", "wccp.web_cache_identity.hash_rev", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_flags,
+			{ "Flags", "wccp.web_cache_identity.flags", FT_UINT16, BASE_HEX, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_flag_hash_info,
+			{ "Hash information", "wccp.web_cache_identity.flags.hash_info", FT_BOOLEAN, 16, TFS(&tfs_historical_current), 0x8000,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_flag_assign_type,
+			{ "Assignment Type", "wccp.web_cache_identity.flags.assign_type", FT_BOOLEAN, 16, TFS(&tfs_mask_hash), 0x4000,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_num_mask,
+			{ "Number of Masks", "wccp.web_cache_identity.num_mask", FT_UINT32, BASE_DEC, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_assign_mask,
+			{ "Mask Element", "wccp.web_cache_identity.assign_mask", FT_UINT32, BASE_HEX, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_assign_weight,
+			{ "Assignment Weight", "wccp.web_cache_identity.assignment_weight", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_web_cache_identity_status,
+			{ "Status", "wccp.web_cache_identity.status", FT_UINT16, BASE_HEX, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_assignment_key_ip,
+			{ "Assignment Key IP Address", "wccp.assignment_key.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_assignment_key_change_num,
+			{ "Assignment Key Change Number", "wccp.assignment_key.change_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_view_member_change_num,
+			{ "Member Change Number", "wccp.router_view.member_change_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_router_num,
+			{ "Number of Routers", "wccp.router_view.router_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_router_ip,
+			{ "Router IP Address", "wccp.router_view.router_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wc_view_info_change_num,
+			{ "Change Number", "wccp.wc_view.change_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wc_view_router_num,
+			{ "Number of Routers", "wccp.wc_view.router_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wc_view_ip,
+			{ "Router IP Address", "wccp.wc_view.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_assignment_element_ip,
+			{ "IP Address", "wccp.router_assignment_element.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_assignment_element_receive_id,
+			{ "Receive ID", "wccp.router_assignment_element.receive_id", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_assignment_element_change_num,
+			{ "Change Number", "wccp.router_assignment_element.change_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_assignment_info_router_num,
+			{ "Number of Routers", "wccp.assignment_info.router_num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_assignment_info_ip,
+			{ "Router IP Address", "wccp.assignment_info.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_query_info_ip,
+			{ "Router IP Address", "wccp.router_query_info.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_query_info_receive_id,
+			{ "Receive ID", "wccp.router_query_info.receive_id", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_query_info_send_to_ip,
+			{ "Sent To IP Address", "wccp.router_query_info.send_to_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_router_query_info_target_ip,
+			{ "Target IP Address", "wccp.router_query_info.target_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_capability_info_type,
+			{ "Type", "wccp.capability_info.type", FT_UINT16, BASE_DEC, VALS(capability_type_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_capability_info_length,
+			{ "Value Length", "wccp.capability_info.length", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_capability_info_bytes,
+			{ "Value", "wccp.capability_info.bytes", FT_BYTES, BASE_NONE, 0x0, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_capability_info_value,
+			{ "Value", "wccp.capability_info.value", FT_UINT32, BASE_HEX, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_capability_forwarding_method_flag_gre,
+			{ "GRE-encapsulated", "wccp.capability_info.forwarding_method_flag.gre", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_FORWARDING_METHOD_GRE,
+				NULL, HFILL }
+		},
+		{ &hf_capability_forwarding_method_flag_l2,
+			{ "L2 rewrite", "wccp.capability_info.forwarding_method_flag.l2", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_FORWARDING_METHOD_L2,
+				NULL, HFILL }
+		},
+		{ &hf_capability_assignment_method_flag_hash,
+			{ "Hash", "wccp.capability_info.assignment_method_flag.hash", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_ASSIGNMENT_METHOD_HASH,
+				NULL, HFILL }
+		},
+		{ &hf_capability_assignment_method_flag_mask,
+			{ "Mask", "wccp.capability_info.assignment_method_flag.mask", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_ASSIGNMENT_METHOD_MASK,
+				NULL, HFILL }
+		},
+		{ &hf_capability_return_method_flag_gre,
+			{ "GRE-encapsulated", "wccp.capability_info.return_method_flag.gre", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_PACKET_RETURN_METHOD_GRE,
+				NULL, HFILL }
+		},
+		{ &hf_capability_return_method_flag_l2,
+			{ "L2 rewrite", "wccp.capability_info.return_method_flag.l2", FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), WCCP2_PACKET_RETURN_METHOD_L2,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_value_element_src_ip,
+			{ "Source Address", "wccp.value_element.src_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_value_element_dest_ip,
+			{ "Destination Address", "wccp.value_element.dest_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_value_element_src_port,
+			{ "Source Port", "wccp.value_element.src_port", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_value_element_dest_port,
+			{ "Destination Port", "wccp.value_element.dest_port", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_value_element_web_cache_ip,
+			{ "Web Cache Address", "wccp.value_element.web_cache_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_mask_value_set_element_src_ip,
+			{ "Source Address Mask", "wccp.mask_value_set_element.src_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_mask_value_set_element_dest_ip,
+			{ "Destination Address Mask", "wccp.mask_value_set_element.dest_ip", FT_IPv4, BASE_NONE, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_mask_value_set_element_src_port,
+			{ "Source Port Mask", "wccp.mask_value_set_element.src_port", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_mask_value_set_element_dest_port,
+			{ "Destination Port Mask", "wccp.mask_value_set_element.dest_port", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_wccp2_mask_value_set_element_num,
+			{ "Number of Value Elements", "wccp.mask_value_set_element.num", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_alt_assignment_info_assignment_type,
+			{ "Assignment type", "wccp.alt_assignment_info.assignment_type", FT_UINT16, BASE_DEC, VALS(assignment_type_vals), 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_alt_assignment_info_assignment_length,
+			{ "Assignment length", "wccp.alt_assignment_info.assignment_length", FT_UINT16, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_alt_assignment_info_num_routers,
+			{ "Number of routers", "wccp.alt_assignment_info.num_routers", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
+		{ &hf_alt_assignment_info_num_elements,
+			{ "Number of elements", "wccp.alt_assignment_info.num_elements", FT_UINT32, BASE_DEC, NULL, 0x0,
+				NULL, HFILL }
+		},
 	};
+
 	static gint *ett[] = {
 		&ett_wccp,
 		&ett_cache_count,