/* packet-wccp.c

 * Routines for Web Cache C* Protocol dissection

 * Jerry Talkington <jtalkington@users.sourceforge.net>

 *

 * https://datatracker.ietf.org/doc/html/draft-mclaggan-wccp-v2rev1-00

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/to_str.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <epan/iana-info.h>

#include <wsutil/array.h>

#include <wsutil/ws_roundup.h>

#include "packet-wccp.h"

void proto_register_wccp(void);

void proto_reg_handoff_wccp(void);

static dissector_handle_t wccp_handle;

static int proto_wccp;

static int hf_wccp_message_type;   /* the message type */

static int hf_wccp_version;        /* protocol version */

static int hf_bucket;

static int hf_bucket_bit;

static int hf_message_header_version;

static int hf_hash_revision;       /* the version of the hash */

static int hf_change_num;          /* change number */

static int hf_hash_flag;

static int hf_hash_flag_u;

static int hf_recvd_id;

static int hf_wc_num;

static int hf_wc_view_wc_num;

static int hf_cache_ip;

static int hf_message_header_length;

static int hf_item_type;

static int hf_item_length;

static int hf_item_data;

static int hf_security_info_option;

static int hf_security_info_md5_checksum;

static int hf_command_element_type;

static int hf_command_element_length;

static int hf_command_length;

static int hf_command_element_shutdown_ip_index;

static int hf_command_element_shutdown_ipv4;

static int hf_command_element_shutdown_ipv6;

static int hf_command_unknown;

static int hf_service_info_type;

static int hf_service_info_id_standard;

static int hf_service_info_id_dynamic;

static int hf_service_info_priority;

static int hf_service_info_protocol;

static int hf_service_info_flags;

static int hf_service_info_flags_src_ip_hash;

static int hf_service_info_flags_dest_ip_hash;

static int hf_service_info_flags_src_port_hash;

static int hf_service_info_flags_dest_port_hash;

static int hf_service_info_flags_ports_defined;

static int hf_service_info_flags_ports_source;

static int hf_service_info_flags_redirect_only_protocol_0;

static int hf_service_info_flags_src_ip_alt_hash;

static int hf_service_info_flags_dest_ip_alt_hash;

static int hf_service_info_flags_src_port_alt_hash;

static int hf_service_info_flags_dest_port_alt_hash;

static int hf_service_info_flags_reserved;

static int hf_service_info_source_port;

static int hf_service_info_destination_port;

static int hf_router_identity_ip_index;

static int hf_router_identity_ipv4;

static int hf_router_identity_ipv6;

static int hf_router_identity_receive_id;

static int hf_router_identity_send_to_ip_index;

static int hf_router_identity_send_to_ipv4;

static int hf_router_identity_send_to_ipv6;

static int hf_router_identity_received_from_num;

static int hf_web_cache_identity_index;

static int hf_web_cache_identity_ipv4;

static int hf_web_cache_identity_ipv6;

static int hf_web_cache_identity_hash_rev;

static int hf_web_cache_identity_flags;

static int hf_web_cache_identity_flag_hash_info;

static int hf_web_cache_identity_flag_assign_type;

static int hf_web_cache_identity_flag_version_request;

static int hf_web_cache_identity_flag_reserved;

static int hf_mask_value_set_element_value_element_num;

static int hf_assignment_weight;

static int hf_assignment_status;

static int hf_assignment_key_ip_index;

static int hf_assignment_key_ipv4;

static int hf_assignment_key_ipv6;

static int hf_assignment_key_change_num;

static int hf_assignment_no_data;

static int hf_router_view_member_change_num;

static int hf_router_router_num;

static int hf_router_identity_router_ip_index;

static int hf_router_identity_router_ipv4;

static int hf_router_identity_router_ipv6;

static int hf_wc_view_info_change_num;

static int hf_wc_view_info_router_ip_index;

static int hf_wc_view_info_router_ipv4;

static int hf_wc_view_info_router_ipv6;

static int hf_wc_view_info_wc_ip_index;

static int hf_wc_view_info_wc_ipv4;

static int hf_wc_view_info_wc_ipv6;

static int hf_wc_view_router_num;

static int hf_wc_identity_ip_address_index;

static int hf_wc_identity_ip_address_ipv4;

static int hf_wc_identity_ip_address_ipv6;

static int hf_router_identity_received_from_ip_index;

static int hf_router_identity_received_from_ipv4;

static int hf_router_identity_received_from_ipv6;

static int hf_router_assignment_element_change_num;

static int hf_assignment_info_router_num;

static int hf_hash_buckets_assignment_wc_num;

static int hf_hash_buckets_assignment_wc_ip_index;

static int hf_hash_buckets_assignment_wc_ipv4;

static int hf_hash_buckets_assignment_wc_ipv6;

static int hf_assignment_info_router_ip_index;

static int hf_assignment_info_router_ipv4;

static int hf_assignment_info_router_ipv6;

static int hf_router_view_ip_index;

static int hf_router_view_ipv4;

static int hf_router_view_ipv6;

static int hf_router_query_info_ip_index;

static int hf_router_query_info_ipv4;

static int hf_router_query_info_ipv6;

static int hf_router_query_info_send_to_ip_index;

static int hf_router_query_info_send_to_ipv4;

static int hf_router_query_info_send_to_ipv6;

static int hf_router_query_info_target_ip_index;

static int hf_router_query_info_target_ipv4;

static int hf_router_query_info_target_ipv6;

static int hf_capability_element_type;

static int hf_capability_element_length;

static int hf_capability_info_value;

static int hf_capability_forwarding_method_flag_gre;

static int hf_capability_forwarding_method_flag_l2;

static int hf_capability_assignment_method_flag_hash;

static int hf_capability_assignment_method_flag_mask;

static int hf_capability_return_method_flag_gre;

static int hf_capability_return_method_flag_l2;

static int hf_capability_transmit_t;

static int hf_capability_transmit_t_upper_limit;

static int hf_capability_transmit_t_lower_limit;

static int hf_capability_timer_scale_timeout_scale;

static int hf_capability_timer_scale_ra_timer_scale;

static int hf_capability_timer_scale_timeout_scale_upper_limit;

static int hf_capability_timer_scale_timeout_scale_lower_limit;

static int hf_capability_timer_scale_ra_scale_upper_limit;

static int hf_capability_timer_scale_ra_scale_lower_limit;

static int hf_capability_value;

static int hf_reserved_zero;

static int hf_value_element_src_ip_index;

static int hf_value_element_src_ipv4;

static int hf_value_element_src_ipv6;

static int hf_value_element_dest_ip_index;

static int hf_value_element_dest_ipv4;

static int hf_value_element_dest_ipv6;

static int hf_value_element_src_port;

static int hf_value_element_dest_port;

static int hf_value_element_web_cache_ip_index;

static int hf_value_element_web_cache_ipv4;

static int hf_value_element_web_cache_ipv6;

static int hf_mask_value_set_list_num_elements;

static int hf_mask_element_src_ip;

static int hf_mask_element_dest_ip;

static int hf_mask_element_src_port;

static int hf_mask_element_dest_port;

static int hf_alt_assignment_info_assignment_type;

static int hf_extended_assignment_data_type;

static int hf_alt_assignment_info_assignment_length;

static int hf_alt_assignment_map_assignment_type;

static int hf_alt_assignment_map_assignment_length;

static int hf_extended_assignment_data_length;

static int hf_alt_assignment_info_num_routers;

static int hf_alt_assignment_mask_value_set_element_num_wc_value_elements;

static int hf_web_cache_value_element_wc_address_index;

static int hf_web_cache_value_element_wc_address_ipv4;

static int hf_web_cache_value_element_wc_address_ipv6;

static int hf_web_cache_value_element_num_values;

static int hf_web_cache_value_seq_num;

static int hf_alt_assignment_mask_value_set_list_num_elements;

static int hf_address_table_family;

static int hf_address_table_address_length;

static int hf_address_table_length;

static int hf_address_table_element;

static int ett_wccp;

static int ett_buckets;

static int ett_hash_assignment_buckets;

static int ett_mask_assignment_data_element;

static int ett_alternate_mask_assignment_data_element;

static int ett_extended_assigment_data_element;

static int ett_table_element;

static int ett_hash_flags;

static int ett_wc_identity_flags;

static int ett_cache_info;

static int ett_security_info;

static int ett_service_info;

static int ett_service_flags;

static int ett_service_info_ports;

static int ett_wc_view_info_router_element;

static int ett_router_identity_info;

static int ett_wc_identity_element;

static int ett_wc_identity_info;

static int ett_router_view_info;

static int ett_wc_view_info;

static int ett_router_assignment_element;

static int ett_hash_buckets_assignment_wc_element;

static int ett_hash_buckets_assignment_buckets;

static int ett_router_alt_assignment_element;

static int ett_router_assignment_info;

static int ett_query_info;

static int ett_capabilities_info;

static int ett_capability_element;

static int ett_capability_forwarding_method;

static int ett_capability_assignment_method;

static int ett_capability_return_method;

static int ett_capability_transmit_t;

static int ett_capability_timer_scale;

static int ett_alt_assignment_info;

static int ett_alt_assignment_map;

static int ett_address_table;

static int ett_assignment_map;

static int ett_command_extension;

static int ett_alternate_mask_value_set;

static int ett_alternate_mask_value_set_element;

static int ett_mv_set_list;

static int ett_mv_set_element;

static int ett_mv_set_value_list;

static int ett_alternate_mv_set_element_list;

static int ett_web_cache_value_element_list;

static int ett_alternate_mv_set_element;

static int ett_value_element;

static int ett_unknown_info;

static expert_field ei_wccp_missing_security_info;

static expert_field ei_wccp_missing_service_info;

static expert_field ei_wccp_missing_wc_id_info;

static expert_field ei_wccp_missing_router_id_info;

static expert_field ei_wccp_missing_query_info;

static expert_field ei_wccp_missing_wc_view_info;

static expert_field ei_wccp_missing_rtr_view_info;

static expert_field ei_wccp_contains_redirect_assignment;

static expert_field ei_wccp_contains_router_id_info;

static expert_field ei_wccp_contains_rtr_view_info;

static expert_field ei_wccp_contains_query_info;

static expert_field ei_wccp_contains_alt_assignment;

static expert_field ei_wccp_contains_assign_map;

static expert_field ei_wccp_contains_alt_assignment_map;

static expert_field ei_wccp_contains_wc_id_info;

static expert_field ei_wccp_contains_wc_view_info;

static expert_field ei_wccp_contains_capabilities_info;

static expert_field ei_wccp_contains_command_extension;

static expert_field ei_wccp_missing_assignment;

static expert_field ei_wccp_assignment_length_bad;

static expert_field ei_wccp_length_bad;

static expert_field ei_wccp_service_info_priority_nonzero;

static expert_field ei_wccp_service_info_protocol_nonzero;

static expert_field ei_wccp_router_identity_receive_id_zero;

static expert_field ei_wccp_web_cache_identity_hash_rev_zero;

static expert_field ei_wccp_address_table_family_unknown;

static expert_field ei_wccp_capability_element_length;

static expert_field ei_wccp_port_fields_not_used;

static expert_field ei_wccp_a_zero_not_c;

/* static expert_field ei_wccp_c_zero_not_a; */

/*

 * At

 *

 *      https://datatracker.ietf.org/doc/html/draft-forster-wrec-wccp-v1-00

 *

 * is the now-expired Internet-Draft for WCCP 1.0 (Web Cache Coordination

 * Protocol V1.0).

 *

 * At

 *

 *      https://datatracker.ietf.org/doc/html/draft-wilson-wrec-wccp-v2-01

 *

 * is the now-expired Internet-Draft for WCCP 2.0 (Web Cache Communication

 * Protocol V2.0).

 *

 *      https://datatracker.ietf.org/doc/html/draft-param-wccp-v2rev1-01

 *

 * is the now-expired Internet-Draft for WCCP 2.01 (Web Cache Communication

 * Protocol V2, Revision 1).

 */

/* This is NOT IANA assigned */

#define UDP_PORT_WCCP           2048

#define WCCPv1                  4

#define WCCPv2                  0x0200

#define WCCPv2r1                0x0201

#define WCCP_HERE_I_AM          7

#define WCCP_I_SEE_YOU          8

#define WCCP_ASSIGN_BUCKET      9

#define WCCP2_HERE_I_AM         10

#define WCCP2_I_SEE_YOU         11

#define WCCP2_REDIRECT_ASSIGN   12

#define WCCP2_REMOVAL_QUERY     13

static const value_string wccp_type_vals[] = {

  { WCCP_HERE_I_AM,        "1.0 Here I am" },

  { WCCP_I_SEE_YOU,        "1.0 I see you" },

  { WCCP_ASSIGN_BUCKET,    "1.0 Assign bucket" },

  { WCCP2_HERE_I_AM,       "2.0 Here I am" },

  { WCCP2_I_SEE_YOU,       "2.0 I see you" },

  { WCCP2_REDIRECT_ASSIGN, "2.0 Redirect assign" },

  { WCCP2_REMOVAL_QUERY,   "2.0 Removal query" },

  { 0,                     NULL }

};

static const value_string wccp_version_val[] = {

  { WCCPv1, "1"},

  { WCCPv2, "2"},

  { WCCPv2r1, "2.01"},

  { 0, NULL}

};

static const true_false_string tfs_src_dest_port = { "Source port", "Destination port" };

static const true_false_string tfs_redirect_protocol0 = { "Redirect only protocol 0 (IP)", "Redirect all traffic" };

static const true_false_string tfs_historical_current = { "Historical", "Current" };

static const true_false_string tfs_version_min_max = {"WCCP version set is maximum supported by CE", "WCCP version set is minimum supported by CE"};

static const value_string wccp_address_family_val[] = {

  { 0, "Reserved" },

  { 1, "IPv4" },

  { 2, "IPv6" },

  { 0, NULL }

};

#define WCCP2_HASH_ASSIGNMENT_TYPE         0

#define WCCP2_MASK_ASSIGNMENT_TYPE         1

#define WCCP2r1_ALT_MASK_ASSIGNMENT_TYPE   2

#define WCCP2r1_ASSIGNMENT_WEIGHT_STATUS   3

static const value_string assignment_type_vals[] = {

  { WCCP2_HASH_ASSIGNMENT_TYPE, "Hash" },

  { WCCP2_MASK_ASSIGNMENT_TYPE, "Mask" },

  { WCCP2r1_ALT_MASK_ASSIGNMENT_TYPE, "WCCP2r1 Alternate Mask"},

  { WCCP2r1_ASSIGNMENT_WEIGHT_STATUS, "WCCP2r1 Assignment Weight Status"},

  { 0,                          NULL }

};

#define HASH_INFO_SIZE          (4*(1+8+1))

#define WCCP2_SECURITY_INFO             0

#define WCCP2_SERVICE_INFO              1

#define WCCP2_ROUTER_ID_INFO            2

#define WCCP2_WC_ID_INFO                3

#define WCCP2_RTR_VIEW_INFO             4

#define WCCP2_WC_VIEW_INFO              5

#define WCCP2_REDIRECT_ASSIGNMENT       6

#define WCCP2_QUERY_INFO                7

#define WCCP2_CAPABILITIES_INFO         8

#define WCCP2_ALT_ASSIGNMENT            13

#define WCCP2_ASSIGN_MAP                14

#define WCCP2_COMMAND_EXTENSION         15

/* WCCP 2 r1 additions: */

#define WCCP2r1_ALT_ASSIGNMENT_MAP      16

#define WCCP2r1_ADDRESS_TABLE           17

  static const value_string info_type_vals[] = {

    { WCCP2_SECURITY_INFO,       "Security Info" },

    { WCCP2_SERVICE_INFO,        "Service Info" },

    { WCCP2_ROUTER_ID_INFO,      "Router Identity Info" },

    { WCCP2_WC_ID_INFO,          "Web-Cache Identity Info" },

    { WCCP2_RTR_VIEW_INFO,       "Router View Info" },

    { WCCP2_WC_VIEW_INFO,        "Web-Cache View Info" },

    { WCCP2_REDIRECT_ASSIGNMENT, "Assignment Info" },

    { WCCP2_QUERY_INFO,          "Router Query Info" },

    { WCCP2_CAPABILITIES_INFO,   "Capabilities Info" },

    { WCCP2_ALT_ASSIGNMENT,      "Alternate Assignment" },

    { WCCP2_ASSIGN_MAP,          "Assignment Map" },

    { WCCP2_COMMAND_EXTENSION,   "Command Extension" },

    { WCCP2r1_ALT_ASSIGNMENT_MAP, "Alternative Assignment Map" },

    { WCCP2r1_ADDRESS_TABLE,      "Address Table" },

    { 0,                         NULL }

  };

const value_string service_id_vals[] = {

  { 0x00, "HTTP" },

  { 0,    NULL }

};

typedef struct capability_flag {

  uint32_t value;

  const char *short_name;

  int* phf;

} capability_flag;

#define WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_HASH        0

#define WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_MASK        1

#define WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_NOT_PRESENT 2

#define WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_EXTENDED    3

static const value_string wccp_web_cache_assignment_data_type_val[] = {

  { WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_HASH        , "Hash Assignment Data Element"},

  { WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_MASK        , "Mask Assignment Data Element"},

  { WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_NOT_PRESENT , "Assignment Data Element Not Present"},

  { WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_EXTENDED    , "Extended Assignment Data Element"},

  { 0,                          NULL }

};

#define WCCP2_FORWARDING_METHOD         0x01

#define WCCP2_ASSIGNMENT_METHOD         0x02

#define WCCP2_PACKET_RETURN_METHOD      0x03

#define WCCP2_TRANSMIT_T                0x04

#define WCCP2_TIMER_SCALE               0x05

static const value_string capability_type_vals[] = {

  { WCCP2_FORWARDING_METHOD,    "Forwarding Method" },

  { WCCP2_ASSIGNMENT_METHOD,    "Assignment Method" },

  { WCCP2_PACKET_RETURN_METHOD, "Packet Return Method" },

  { WCCP2_TRANSMIT_T,           "Transmit_t Message interval values"},

  { WCCP2_TIMER_SCALE,          "Timer_scale Timeout scale values"},

  { 0, NULL }

};

/* with version 2.01 we now have a address table which is possibly present */

typedef struct wccp_address_table {

  bool in_use;

  int16_t family;

  int16_t version;

  uint16_t table_length;

  ws_in4_addr *table_ipv4;

  ws_in6_addr *table_ipv6;

} wccp_address_table;

static int wccp_bucket_info(uint8_t bucket_info, proto_tree *bucket_tree,

                            uint32_t start, tvbuff_t *tvb, int offset);

/* The V2 dissectors will return the remaining length of the packet

   and a negative number if there are missing bytes to finish the

   dissection */

static int dissect_wccp2_mask_assignment_data_element(tvbuff_t *tvb, int offset, int length, packet_info *pinfo,

                                                       proto_tree *info_tree, wccp_address_table* addr_table);

static int dissect_wccp2_hash_buckets_assignment_element(tvbuff_t *tvb, int offset, int length,

                                                          packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table);

static int   dissect_wccp2r1_address_table_info(tvbuff_t *tvb, int offset,

                                                int length, packet_info *pinfo, proto_tree *info_tree,

                                                wccp_address_table* wccp_wccp_address_table);

static int dissect_wccp2_hash_assignment_data_element(tvbuff_t *tvb, int offset, int length, packet_info *pinfo,

                                                       proto_tree *info_tree);

static int dissect_wccp2_assignment_weight_and_status_element(tvbuff_t *tvb, int offset, int length, packet_info *pinfo,

                                                               proto_tree *info_tree);

static int dissect_wccp2_extended_assignment_data_element(tvbuff_t *tvb, int offset, int length, packet_info *pinfo,

                                                           proto_tree *info_tree, wccp_address_table* addr_table);

static int dissect_wccp2_capability_element(tvbuff_t *tvb, int offset, int length,

                                             packet_info *pinfo _U_, proto_tree *info_tree);

static int   dissect_wccp2_mask_value_set_list(tvbuff_t *tvb, int offset,

                                               int length, packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table);

/* Utility functions */

static int dissect_wccp2_mask_value_set_element(tvbuff_t *tvb, int offset,

                                                 int length, int idx, packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table);

static int dissect_wccp2_alternate_mask_value_set_list(tvbuff_t *tvb, int offset,

                                                        int length, packet_info *pinfo _U_, proto_tree *info_tree, wccp_address_table* addr_table);

static int dissect_wccp2_alternate_mask_value_set_element(tvbuff_t *tvb, int offset, int length, unsigned el_index, packet_info *pinfo,

                                                    proto_tree *info_tree, wccp_address_table* addr_table);

static int dissect_wccp2_web_cache_value_element(tvbuff_t *tvb, int offset,

                                                  int length,  packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table);

static void dissect_32_bit_capability_flags(tvbuff_t *tvb, int curr_offset,

                                            uint16_t capability_val_len, int ett, const capability_flag *flags,

                                            proto_tree *element_tree, proto_item *header,

                                            proto_item *length_item, packet_info *pinfo);

static void dissect_transmit_t_capability(tvbuff_t *tvb, proto_item *te, int curr_offset,

                                          uint16_t capability_val_len, int ett, proto_tree *element_tree,

                                          proto_item *length_item, packet_info *pinfo);

static void dissect_timer_scale_capability(tvbuff_t *tvb, int curr_offset,

                                           uint16_t capability_val_len, int ett, proto_tree *element_tree,

                                           proto_item *length_item, packet_info *pinfo);

/*

 * In WCCP 2.01 addresses are encoded to support IPv6 with 32 bit fields

 *

 * handle the decoding

 */

static void

find_wccp_address_table(tvbuff_t *tvb, int offset,

                        packet_info *pinfo, proto_tree *wccp_tree _U_, wccp_address_table* wccp_wccp_address_table)

{

  uint16_t type;

  uint16_t item_length;

  for (;;) {

    if (4 > tvb_reported_length_remaining(tvb, offset)) {

      /* We've run out of packet data without finding an address table,

         so there's no address table in the packet. */

      return;

    }

    type = tvb_get_ntohs(tvb, offset);

    item_length = tvb_get_ntohs(tvb, offset+2);

    if ((item_length + 4U) > tvb_reported_length_remaining(tvb, offset)) {

      /* We've run out of packet data without finding an address table,

         so there's no address table in the packet. */

      return;

    }

    if (type == WCCP2r1_ADDRESS_TABLE)

      {

        dissect_wccp2r1_address_table_info(tvb, offset+4, item_length, pinfo, NULL, wccp_wccp_address_table);

        /* no need to decode the rest */

        return;

      }

    offset = offset + (item_length + 4);

  }

}

/* This function prints the IP or the encoded IP if the table exists */

/* at most an IPv6 IP: see

   http://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address

   39 = 8 groups of 4 digits with 7 : characters

   or

   45 = IPv4 tunnel features: 0000:0000:0000:0000:0000:0000:192.168.0.1

*/

/* problem here is that the IP is in network byte order for IPv4

   we need to fix that

*/

static const char * decode_wccp_encoded_address(tvbuff_t *tvb, int offset, packet_info *pinfo,

                        proto_tree *info_tree _U_, wccp_address_table* addr_table)

{

  uint32_t host_addr;

  char *buffer;

  /* are we using an address table? */

  if (!addr_table->in_use)

    {

      /* no; return the IPv4 IP */

      host_addr = tvb_get_ipv4(tvb,offset);

      buffer = (char *) wmem_alloc(pinfo->pool, WS_INET_ADDRSTRLEN);

      ip_addr_to_str_buf(&host_addr, buffer, WS_INET_ADDRSTRLEN);

    }

  else

    {

      /* yes; we need to decode the encoded address */

      uint16_t reserv;

      uint16_t addr_index;

      host_addr = tvb_get_ntohl(tvb,offset);

      reserv = (host_addr & 0xFFFF0000) >> 16;

      addr_index = (host_addr & 0x0000FFFF);

      if (reserv != 0) {

        buffer = wmem_strdup(pinfo->pool, "INVALID: reserved part non zero");

      }

      else {

        /* now check if it's IPv4 or IPv6 we need to print */

        switch (addr_table->family) {

        case 1:

          /* IPv4 */

          /* special case: index 0 -> undefined IP */

          if (addr_index == 0) {

            buffer = wmem_strdup(pinfo->pool, "0.0.0.0");

            break;

          }

          /* are we be beyond the end of the table? */

          if (addr_index > addr_table->table_length) {

            buffer = wmem_strdup_printf(pinfo->pool, "INVALID IPv4 index: %d > %d",

                       addr_index, addr_table->table_length);

            break;

          }

          /* ok get the IP */

          if (addr_table->table_ipv4 != NULL) {

            buffer = (char *) wmem_alloc(pinfo->pool, WS_INET_ADDRSTRLEN);

            ip_addr_to_str_buf(&addr_table->table_ipv4[addr_index-1], buffer, WS_INET_ADDRSTRLEN);

          }

          else {

            buffer = wmem_strdup(pinfo->pool, "INVALID IPv4 table empty!");

          }

          break;

        case 2:

          /* IPv6 */

          /* special case: index 0 -> undefined IP */

          if (addr_index == 0) {

            buffer = wmem_strdup(pinfo->pool, "::");

            break;

          }

          /* are we be beyond the end of the table? */

          if (addr_index > addr_table->table_length) {

            buffer = wmem_strdup_printf(pinfo->pool, "INVALID IPv6 index: %d > %d",

                       addr_index, addr_table->table_length);

            break;

          }

          /* ok get the IP */

          if (addr_table->table_ipv6 != NULL) {

            buffer = (char *) wmem_alloc(pinfo->pool, WS_INET6_ADDRSTRLEN);

            ip6_to_str_buf(&(addr_table->table_ipv6[addr_index-1]), buffer, WS_INET6_ADDRSTRLEN);

          }

          else {

            buffer = wmem_strdup(pinfo->pool, "INVALID IPv6 table empty!");

          }

          break;

        default:

          buffer = wmem_strdup(pinfo->pool, "INVALID IP family");

          break;

        }

      }

    }

  return buffer;

}

static proto_item* wccp_add_ipaddress_item(proto_tree* tree, int hf_index, int hf_ipv4, int hf_ipv6, tvbuff_t *tvb,

                                    int offset, int length, wccp_address_table* addr_table)

{

    uint32_t host_addr;

    ws_in6_addr ipv6_zero;

    uint16_t reserv, addr_index;

    /* are we using an address table? */

    if (! addr_table->in_use)

      return proto_tree_add_item(tree, hf_ipv4, tvb, offset, length, ENC_BIG_ENDIAN);

    host_addr = tvb_get_ntohl(tvb, offset);

    /* we need to decode the encoded address: */

    reserv = (host_addr & 0xFFFF0000) >> 16;

    addr_index  = (host_addr & 0x0000FFFF);

    memset(&ipv6_zero, 0, sizeof(ipv6_zero));

    if (reserv != 0)

      return proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, length, host_addr, "INVALID: reserved part non zero");

    /* now check if it's IPv4 or IPv6 we need to print */

    switch (addr_table->family) {

    case 1:

    /* IPv4 */

        /* special case: index 0 -> undefined IP */

        if (addr_index == 0) {

          return proto_tree_add_item(tree, hf_ipv4, tvb, offset, length, ENC_LITTLE_ENDIAN);

        }

        /* are we be beyond the end of the table? */

        if (addr_index > addr_table->table_length) {

          return proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, length, host_addr,

                     "INVALID IPv4 index: %d > %d", addr_index, addr_table->table_length);

        }

        /* ok get the IP */

        if (addr_table->table_ipv4 != NULL) {

          return proto_tree_add_ipv4(tree, hf_ipv4, tvb, offset, length, addr_table->table_ipv4[addr_index-1]);

        }

        return proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, length, host_addr, "INVALID: IPv4 table empty!");

    case 2:

        /* IPv6 */

        /* special case: index 0 -> undefined IP */

        if (addr_index == 0) {

          return proto_tree_add_ipv6(tree, hf_ipv6, tvb, offset, length, &ipv6_zero);

        }

        /* are we be beyond the end of the table? */

        if (addr_index > addr_table->table_length) {

          return proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, length, host_addr,

                        "INVALID IPv6 index: %d > %d", addr_index, addr_table->table_length);

        }

        /* ok get the IP */

        if (addr_table->table_ipv6 != NULL) {

          return proto_tree_add_ipv6(tree, hf_ipv6, tvb, offset, length, &(addr_table->table_ipv6[addr_index-1]));

        }

        return proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, length, host_addr,

                        "INVALID IPv6 table empty!");

    }

    return proto_tree_add_uint_format(tree, hf_index, tvb, offset, length, host_addr, "INVALID IP family");

}

#define WCCP_IP_MAX_LENGTH (WS_INET_ADDRSTRLEN > 46 ? WS_INET_ADDRSTRLEN : 46)

static unsigned

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;

  uint8_t bucket_info;

  int n;

  proto_tree_add_item(wccp_tree, hf_hash_revision, tvb, offset, 4,

                      ENC_BIG_ENDIAN);

  offset += 4;

  bucket_tree = proto_tree_add_subtree(wccp_tree, tvb, offset, 32,

                                    ett_buckets, NULL, "Hash information");

  for (i = 0, n = 0; i < 32; i++) {

    bucket_info = tvb_get_uint8(tvb, offset);

    n = wccp_bucket_info(bucket_info, bucket_tree, n, tvb, offset);

    offset += 1;

  }

  tf = proto_tree_add_item(wccp_tree, hf_hash_flag, tvb, offset, 4, ENC_BIG_ENDIAN);

  field_tree = proto_item_add_subtree(tf, ett_hash_flags);

  proto_tree_add_item(field_tree, hf_hash_flag_u, tvb, offset, 4, ENC_BIG_ENDIAN);

  offset += 4;

  return offset;

}

static unsigned

dissect_web_cache_list_entry(tvbuff_t *tvb, int offset, int idx,

                             proto_tree *wccp_tree)

{

  proto_tree *list_entry_tree;

  list_entry_tree = proto_tree_add_subtree_format(wccp_tree, tvb, offset, 4 + HASH_INFO_SIZE,

                           ett_cache_info, NULL, "Web-Cache List Entry(%d)", idx);

  proto_tree_add_item(list_entry_tree, hf_cache_ip, tvb, offset, 4,

                      ENC_BIG_ENDIAN);

  offset += 4;

  offset = dissect_hash_data(tvb, offset, list_entry_tree);

  return offset;

}

/*

 * wccp_bucket_info()

 * takes an integer representing a "Hash Information" bitmap, and spits out

 * the corresponding proto_tree entries, returning the next bucket number.

 */

static int

wccp_bucket_info(uint8_t bucket_info, proto_tree *bucket_tree, uint32_t start,

                 tvbuff_t *tvb, int offset)

{

  uint32_t i;

  for(i = 0; i < 8; i++) {

    proto_tree_add_uint_format(bucket_tree, hf_bucket_bit, tvb, offset, 1, bucket_info & 1<<i,

                    "Bucket %3d: %s", start, (bucket_info & 1<<i ? "Assigned" : "Not Assigned") );

    start++;

  }

  return start;

}

/* the following functions all need to check the length and the offset

   so we have a few macros to use

*/

#define EAT(x) {length -= x; offset += x;}

#define EAT_AND_CHECK(x,next) {length -= x; offset += x; if (length < next) return length - next;}

#define CHECK_LENGTH_ADVANCE_OFFSET(new_length) { \

  int old_offset = offset; \

  if (new_length<0) return new_length; \

  offset += length-new_length; \

  if (old_offset >= offset) return offset - old_offset; \

  length = new_length; \

  }

/* 5.1.1 Security Info Component */

/* Security options */

#define WCCP2_NO_SECURITY               0

#define WCCP2_MD5_SECURITY              1

#define SECURITY_INFO_LEN               4

static const value_string security_option_vals[] = {

  { WCCP2_NO_SECURITY, "None" },

  { WCCP2_MD5_SECURITY, "MD5" },

  { 0,    NULL }

};

static int

dissect_wccp2_security_info(tvbuff_t *tvb, int offset, int length,

                            packet_info *pinfo _U_, proto_tree *info_tree, wccp_address_table* addr_table _U_)

{

  uint32_t security_option;

  if (length < SECURITY_INFO_LEN)

    return (length-SECURITY_INFO_LEN);

  security_option = tvb_get_ntohl(tvb, offset);

  proto_tree_add_item(info_tree, hf_security_info_option, tvb, offset, 4, ENC_BIG_ENDIAN);

  if (security_option == WCCP2_MD5_SECURITY) {

    offset += 4;

    proto_tree_add_item(info_tree, hf_security_info_md5_checksum, tvb, offset, length-4, ENC_NA);

    return length-4-16;

  }

  return length-4;

}

/* 5.1.2 Service Info Component */

#define SERVICE_INFO_LEN                (4+4+8*2)

#define WCCP2_SERVICE_STANDARD          0

#define WCCP2_SERVICE_DYNAMIC           1

static const value_string service_type_vals[] = {

  { WCCP2_SERVICE_STANDARD, "Standard predefined service"},

  { WCCP2_SERVICE_DYNAMIC, "Dynamic CE defined service" },

  { 0,    NULL }

};

/*

 * Service flags.

 */

#define WCCP2_SI_SRC_IP_HASH                    0x00000001

#define WCCP2_SI_DST_IP_HASH                    0x00000002

#define WCCP2_SI_SRC_PORT_HASH                  0x00000004

#define WCCP2_SI_DST_PORT_HASH                  0x00000008

#define WCCP2_SI_PORTS_DEFINED                  0x00000010

#define WCCP2_SI_PORTS_SOURCE                   0x00000020

#define WCCP2r1_SI_REDIRECT_ONLY_PROTOCOL_0     0x00000040

#define WCCP2_SI_SRC_IP_ALT_HASH                0x00000100

#define WCCP2_SI_DST_IP_ALT_HASH                0x00000200

#define WCCP2_SI_SRC_PORT_ALT_HASH              0x00000400

#define WCCP2_SI_DST_PORT_ALT_HASH              0x00000800

static int

dissect_wccp2_service_info(tvbuff_t *tvb, int offset, int length,

                           packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table _U_)

{

  uint8_t service_type;

  uint32_t flags;

  proto_item *tf;

  proto_tree *ports_tree;

  int i;

  int max_offset = offset+length;

  static int * const flag_fields[] = {

    &hf_service_info_flags_src_ip_hash,

    &hf_service_info_flags_dest_ip_hash,

    &hf_service_info_flags_src_port_hash,

    &hf_service_info_flags_dest_port_hash,

    &hf_service_info_flags_ports_defined,

    &hf_service_info_flags_ports_source,

    &hf_service_info_flags_redirect_only_protocol_0,

    &hf_service_info_flags_src_ip_alt_hash,

    &hf_service_info_flags_dest_ip_alt_hash,

    &hf_service_info_flags_src_port_alt_hash,

    &hf_service_info_flags_dest_port_alt_hash,

    &hf_service_info_flags_reserved,

    NULL

  };

  if (length != SERVICE_INFO_LEN)

    return length - SERVICE_INFO_LEN;

  service_type = tvb_get_uint8(tvb, offset);

  proto_tree_add_item(info_tree, hf_service_info_type, tvb,

                      offset, 1, ENC_BIG_ENDIAN);

  switch (service_type) {

  case WCCP2_SERVICE_STANDARD:

    proto_tree_add_item(info_tree, hf_service_info_id_standard, tvb,

                        offset +1 , 1, ENC_BIG_ENDIAN);

    tf = proto_tree_add_item(info_tree, hf_service_info_priority, tvb, offset+2, 1, ENC_BIG_ENDIAN);

    if (tvb_get_uint8(tvb, offset+2) != 0)

      expert_add_info(pinfo, tf, &ei_wccp_service_info_priority_nonzero);

    tf = proto_tree_add_item(info_tree, hf_service_info_protocol, tvb,

                        offset+3, 1, ENC_BIG_ENDIAN);

    if (tvb_get_uint8(tvb, offset+3) != 0)

      expert_add_info(pinfo, tf, &ei_wccp_service_info_protocol_nonzero);

    break;

  case WCCP2_SERVICE_DYNAMIC:

    proto_tree_add_item(info_tree, hf_service_info_id_dynamic, tvb,

                        offset +1 , 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(info_tree, hf_service_info_priority, tvb,

                        offset+2, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(info_tree, hf_service_info_protocol, tvb,

                        offset+3, 1, ENC_BIG_ENDIAN);

    break;

  }

  offset += 4;

  flags = tvb_get_ntohl(tvb, offset);

  proto_tree_add_bitmask(info_tree, tvb, offset, hf_service_info_flags, ett_service_flags, flag_fields, ENC_BIG_ENDIAN);

  offset += 4;

  if (flags & WCCP2_SI_PORTS_DEFINED) {

    ports_tree = proto_tree_add_subtree(info_tree, tvb, offset, 2*8,

                             ett_service_info_ports, &tf, "Ports list: ");

    for (i = 0; i < 8; i++) {

      uint16_t port = tvb_get_ntohs(tvb, offset);

      if (port) {

        if (flags & WCCP2_SI_SRC_PORT_HASH)

          proto_tree_add_item(ports_tree, hf_service_info_source_port, tvb, offset, 2, ENC_BIG_ENDIAN);

        else

          proto_tree_add_item(ports_tree, hf_service_info_destination_port, tvb, offset, 2, ENC_BIG_ENDIAN);

        proto_item_append_text(tf, " %d", port);

      }

      offset += 2;

      DISSECTOR_ASSERT(offset <= max_offset);

    }

  }

  else {

    /* just use up the space if there is */

    if (offset + 8 * 2 <= max_offset)  {

      proto_tree_add_expert(info_tree, pinfo, &ei_wccp_port_fields_not_used, tvb, offset, 8*2);

      /*offset += 8*2;*/

    }

  }

  return length - SERVICE_INFO_LEN;

}

/* 6.1 Router Identity Element */

static void

dissect_wccp2_router_identity_element(tvbuff_t *tvb, int offset, packet_info *pinfo,

                                      proto_tree *tree, wccp_address_table* addr_table)

{

  proto_item *tf;

  wccp_add_ipaddress_item(tree, hf_router_identity_ip_index, hf_router_identity_ipv4, hf_router_identity_ipv6, tvb, offset, 4, addr_table);

  tf = proto_tree_add_item(tree, hf_router_identity_receive_id, tvb, offset+4, 4, ENC_BIG_ENDIAN);

  if (tvb_get_ntohl(tvb, offset + 4) == 0)

    expert_add_info(pinfo, tf, &ei_wccp_router_identity_receive_id_zero);

}

#define ROUTER_ID_INFO_MIN_LEN          (8+4+4)

/* 5.3.1 Router Identity Info Component */

static int

dissect_wccp2_router_identity_info(tvbuff_t *tvb, int offset, int length,

                                   packet_info *pinfo, proto_tree *info_tree, wccp_address_table* addr_table)

{

  uint32_t n_received_from;

  unsigned i;

  proto_item *te;

  proto_tree *element_tree;

  if (length < 8)

    return length -  ROUTER_ID_INFO_MIN_LEN;

  te = wccp_add_ipaddress_item(info_tree, hf_router_identity_router_ip_index, hf_router_identity_router_ipv4, hf_router_identity_router_ipv6, tvb, offset, 4, addr_table);

  element_tree = proto_item_add_subtree(te,ett_wc_view_info_router_element);

  dissect_wccp2_router_identity_element(tvb,offset,pinfo,element_tree, addr_table);

  EAT_AND_CHECK(8,4);

  wccp_add_ipaddress_item(info_tree, hf_router_identity_send_to_ip_index, hf_router_identity_send_to_ipv4, hf_router_identity_send_to_ipv6, tvb, offset, 4, addr_table);

  EAT_AND_CHECK(4,4);

  n_received_from = tvb_get_ntohl(tvb, offset);

  proto_tree_add_item(info_tree, hf_router_identity_received_from_num, tvb, offset, 4, ENC_BIG_ENDIAN);

  EAT(4);

  for (i = 0; i < n_received_from; i++) {

    if (length < 4)

      return length-4*(i-n_received_from);

    wccp_add_ipaddress_item(info_tree, hf_router_identity_received_from_ip_index, hf_router_identity_received_from_ipv4, hf_router_identity_received_from_ipv6, tvb, offset, 4, addr_table);

    EAT(4);

  }

  return length;

}

#define ROUTER_WC_ID_ELEMENT_MIN_LEN (4+2+2)

/* 6.4 Web-Cache Identity Element */

static int

dissect_wccp2_web_cache_identity_element(tvbuff_t *tvb, int offset, int length, packet_info *pinfo,

                                         proto_tree *info_tree, wccp_address_table* addr_table)

{

  proto_item *tf;

  uint16_t flags;

  unsigned data_element_type;

  static int * const flag_fields[] = {

    &hf_web_cache_identity_flag_hash_info,

    &hf_web_cache_identity_flag_assign_type,

    &hf_web_cache_identity_flag_version_request,

    &hf_web_cache_identity_flag_reserved,

    NULL

  };

  if (length < ROUTER_WC_ID_ELEMENT_MIN_LEN)

    return length - ROUTER_WC_ID_ELEMENT_MIN_LEN;

  wccp_add_ipaddress_item(info_tree, hf_web_cache_identity_index, hf_web_cache_identity_ipv4, hf_web_cache_identity_ipv6, tvb, offset, 4, addr_table);

  EAT_AND_CHECK(4,2);

  tf = proto_tree_add_item(info_tree, hf_web_cache_identity_hash_rev, tvb, offset, 2, ENC_BIG_ENDIAN);

  if (tvb_get_ntohs(tvb, offset) != 0)

    expert_add_info(pinfo, tf, &ei_wccp_web_cache_identity_hash_rev_zero);

  EAT_AND_CHECK(2,2);

  flags = tvb_get_ntohs(tvb, offset);

  data_element_type = (flags & 0x6) >> 1;

  proto_tree_add_bitmask(info_tree, tvb, offset, hf_web_cache_identity_flags, ett_wc_identity_flags, flag_fields, ENC_BIG_ENDIAN);

  EAT(2);

  switch (data_element_type) {

  case WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_HASH:

    return dissect_wccp2_hash_assignment_data_element(tvb,offset,length,pinfo,info_tree);

  case WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_MASK:

    return dissect_wccp2_mask_assignment_data_element(tvb,offset,length,pinfo,info_tree, addr_table);

  case WCCP2_WEB_CACHE_ASSIGNMENT_DATA_TYPE_NOT_PRESENT: