/* packet-zbee-zdp.c

 * Dissector routines for the ZigBee Device Profile (ZDP)

 * By Owen Kirby <osk@exegin.com>

 * Copyright 2009 Exegin Technologies Limited

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/*  Include Files */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <wsutil/bits_ctz.h>

#include <wsutil/str_util.h>

#include "packet-zbee.h"

#include "packet-zbee-aps.h"

#include "packet-zbee-nwk.h"

#include "packet-zbee-zdp.h"

#include "packet-zbee-zdp.h"

void proto_reg_handoff_zbee_zdp(void);

void proto_register_zbee_zdp(void);

/*************************/

/* Function Declarations */

/*************************/

/* Local Helper routines. */

static uint16_t zdp_convert_2003cluster     (uint8_t cluster);

/**************************************

 * Field indices

 **************************************

 */

/* Global field indices. */

static int proto_zbee_zdp;

static int hf_zbee_zdp_seqno;

#if 0

static int hf_zbee_zdp_length; /* Deprecates since ZigBee 2006. */

#endif

/* General indices. */

       int hf_zbee_zdp_ext_addr;

       int hf_zbee_zdp_nwk_addr;

       int hf_zbee_zdp_req_type;

       int hf_zbee_zdp_index;

static int hf_zbee_zdp_status;

       int hf_zbee_zdp_ep_count;

       int hf_zbee_zdp_endpoint;

       int hf_zbee_zdp_profile;

       int hf_zbee_zdp_cluster;

       int hf_zbee_zdp_addr_mode;

       int hf_zbee_zdp_table_size;

       int hf_zbee_zdp_table_count;

       int hf_zbee_zdp_in_count;

       int hf_zbee_zdp_out_count;

       int hf_zbee_zdp_in_cluster;

       int hf_zbee_zdp_out_cluster;

       int hf_zbee_zdp_assoc_device_count;

       int hf_zbee_zdp_assoc_device;

       int hf_zbee_zdp_cache_address;

/* Capability information indices. */

static int hf_zbee_zdp_cinfo;

static int hf_zbee_zdp_cinfo_alloc;

static int hf_zbee_zdp_cinfo_security;

static int hf_zbee_zdp_cinfo_idle_rx;

static int hf_zbee_zdp_cinfo_power;

static int hf_zbee_zdp_cinfo_ffd;

static int hf_zbee_zdp_cinfo_alt_coord;

/* Server mode flag indices. */

static int hf_zbee_zdp_server;

static int hf_zbee_zdp_server_pri_trust;

static int hf_zbee_zdp_server_bak_trust;

static int hf_zbee_zdp_server_pri_bind;

static int hf_zbee_zdp_server_bak_bind;

static int hf_zbee_zdp_server_pri_disc;

static int hf_zbee_zdp_server_bak_disc;

static int hf_zbee_zdp_server_network_manager;

static int hf_zbee_zdp_server_stk_compl_rev;

/* Node descriptor indices. */

static int hf_zbee_zdp_node_type;

static int hf_zbee_zdp_node_complex;

static int hf_zbee_zdp_node_user;

static int hf_zbee_zdp_node_frag_support;

static int hf_zbee_zdp_node_freq_868;

static int hf_zbee_zdp_node_freq_900;

static int hf_zbee_zdp_node_freq_2400;

static int hf_zbee_zdp_node_freq_eu_sub_ghz;

static int hf_zbee_zdp_node_manufacturer;

static int hf_zbee_zdp_node_max_buffer;

static int hf_zbee_zdp_node_max_incoming_transfer;

static int hf_zbee_zdp_node_max_outgoing_transfer;

static int hf_zbee_zdp_dcf;

static int hf_zbee_zdp_dcf_eaela;

static int hf_zbee_zdp_dcf_esdla;

/* Power descriptor indices. */

static int hf_zbee_zdp_power;

static int hf_zbee_zdp_power_mode;

static int hf_zbee_zdp_power_avail_ac;

static int hf_zbee_zdp_power_avail_recharge;

static int hf_zbee_zdp_power_avail_dispose;

static int hf_zbee_zdp_power_source_ac;

static int hf_zbee_zdp_power_source_recharge;

static int hf_zbee_zdp_power_source_dispose;

static int hf_zbee_zdp_power_level;

/* Simple descriptor indices. */

static int hf_zbee_zdp_simple_app_device;

static int hf_zbee_zdp_simple_zll_app_device;

static int hf_zbee_zdp_simple_ha_app_device;

static int hf_zbee_zdp_simple_app_version;

       int hf_zbee_zdp_simple_length;

/* Complex descriptor indices. */

       int hf_zbee_zdp_complex_length;

static int hf_zbee_zdp_complex;

/* User descriptor indices. */

       int hf_zbee_zdp_user;

       int hf_zbee_zdp_user_length;

/* Discovery indices. */

       int hf_zbee_zdp_cache;

       int hf_zbee_zdp_disc_node_size;

       int hf_zbee_zdp_disc_power_size;

       int hf_zbee_zdp_disc_ep_count;

       int hf_zbee_zdp_disc_simple_count;

       int hf_zbee_zdp_disc_simple_size;

/* Binding indices. */

       int hf_zbee_zdp_target;

       int hf_zbee_zdp_replacement;

       int hf_zbee_zdp_replacement_ep;

       int hf_zbee_zdp_bind_src;

       int hf_zbee_zdp_bind_src64;

       int hf_zbee_zdp_bind_src_ep;

       int hf_zbee_zdp_bind_dst;

       int hf_zbee_zdp_bind_dst64;

       int hf_zbee_zdp_bind_dst_ep;

/* Network Management indices. */

       int hf_zbee_zdp_duration;

       int hf_zbee_zdp_leave_children;

       int hf_zbee_zdp_leave_rejoin;

       int hf_zbee_zdp_significance;

       int hf_zbee_zdp_scan_count;

       int hf_zbee_zdp_update_id;

       int hf_zbee_zdp_manager;

       int hf_zbee_zdp_tx_total;

       int hf_zbee_zdp_tx_fail;

       int hf_zbee_zdp_tx_retries;

       int hf_zbee_zdp_period_time_results;

       int hf_zbee_zdp_channel_count;

       int hf_zbee_zdp_channel_mask;

       int hf_zbee_zdp_channel_page;

       int hf_zbee_zdp_channel_page_count;

       int hf_zbee_zdp_channel_energy;

       int hf_zbee_zdp_pan_eui64;

       int hf_zbee_zdp_pan_uint;

       int hf_zbee_zdp_channel;

       int hf_zbee_zdp_nwk_desc_profile;

       int hf_zbee_zdp_profile_version;

       int hf_zbee_zdp_beacon;

       int hf_zbee_zdp_superframe;

       int hf_zbee_zdp_permit_joining;

       int hf_zbee_zdp_extended_pan;

       int hf_zbee_zdp_addr;

       int hf_zbee_zdp_table_entry_type;

       int hf_zbee_zdp_table_entry_idle_rx_0c;

       int hf_zbee_zdp_table_entry_relationship_70;

       int hf_zbee_zdp_table_entry_idle_rx_04;

       int hf_zbee_zdp_table_entry_relationship_18;

       int hf_zbee_zdp_depth;

       int hf_zbee_zdp_permit_joining_03;

       int hf_zbee_zdp_lqi;

static int hf_zbee_zdp_scan_channel;

       int hf_zbee_zdp_ieee_join_start_index;

       int hf_zbee_zdp_ieee_join_update_id;

       int hf_zbee_zdp_ieee_join_policy;

       int hf_zbee_zdp_ieee_join_list_total;

       int hf_zbee_zdp_ieee_join_list_start;

       int hf_zbee_zdp_ieee_join_list_count;

       int hf_zbee_zdp_ieee_join_list_ieee;

       int hf_zbee_zdp_number_of_children;

       int hf_zbee_zdp_beacon_survey_scan_mask;

       int hf_zbee_zdp_beacon_survey_scan_mask_cnt;

       int hf_zbee_zdp_beacon_survey_conf_mask;

       int hf_zbee_zdp_beacon_survey_total;

       int hf_zbee_zdp_beacon_survey_cur_zbn;

       int hf_zbee_zdp_beacon_survey_cur_zbn_potent_parents;

       int hf_zbee_zdp_beacon_survey_other_zbn;

       int hf_zbee_zdp_beacon_survey_current_parent;

       int hf_zbee_zdp_beacon_survey_cnt_parents;

       int hf_zbee_zdp_beacon_survey_parent;

       int hf_zbee_zdp_tlv_count;

       int hf_zbee_zdp_tlv_id;

/* Routing Table */

       int hf_zbee_zdp_rtg;

       int hf_zbee_zdp_rtg_entry;

       int hf_zbee_zdp_rtg_destination;

       int hf_zbee_zdp_rtg_next_hop;

       int hf_zbee_zdp_rtg_status;

       int hf_zbee_zdp_rtg_mem_constrained_flag;

       int hf_zbee_zdp_rtg_mto_flag;

       int hf_zbee_zdp_rtg_rrec_req_flag;

/* Subtree indices. */

static int ett_zbee_zdp;

       int ett_zbee_zdp_endpoint;

       int ett_zbee_zdp_match_in;

       int ett_zbee_zdp_match_out;

       int ett_zbee_zdp_node;

static int ett_zbee_zdp_node_in;

static int ett_zbee_zdp_node_out;

       int ett_zbee_zdp_power;

       int ett_zbee_zdp_simple;

       int ett_zbee_zdp_cinfo;

       int ett_zbee_zdp_server;

       int ett_zbee_zdp_simple_sizes;

       int ett_zbee_zdp_bind;

       int ett_zbee_zdp_bind_entry;

       int ett_zbee_zdp_bind_end_in;

       int ett_zbee_zdp_bind_end_out;

static int ett_zbee_zdp_bind_table;

       int ett_zbee_zdp_bind_source;

       int ett_zbee_zdp_assoc_device;

       int ett_zbee_zdp_nwk;

       int ett_zbee_zdp_perm_join_fc;

       int ett_zbee_zdp_lqi;

       int ett_zbee_zdp_rtg;

       int ett_zbee_zdp_cache;

       int ett_zbee_zdp_nwk_desc;

       int ett_zbee_zdp_table_entry;

       int ett_zbee_zdp_rtg_status_set;

static int ett_zbee_zdp_descriptor_capability_field;

/* Expert Info */

static expert_field ei_deprecated_command;

/**************************************

 * Value Strings

 **************************************

 */

static const value_string zbee_zdp_req_types[] = {

    { ZBEE_ZDP_REQ_TYPE_SINGLE,     "Single Device Response" },

    { ZBEE_ZDP_REQ_TYPE_EXTENDED,   "Extended Response" },

    { 0, NULL }

};

const value_string zbee_zdp_cluster_names[] = {

    { ZBEE_ZDP_REQ_NWK_ADDR,                      "Network Address Request" },

    { ZBEE_ZDP_REQ_IEEE_ADDR,                     "Extended Address Request" },

    { ZBEE_ZDP_REQ_NODE_DESC,                     "Node Descriptor Request" },

    { ZBEE_ZDP_REQ_POWER_DESC,                    "Power Descriptor Request" },

    { ZBEE_ZDP_REQ_SIMPLE_DESC,                   "Simple Descriptor Request" },

    { ZBEE_ZDP_REQ_ACTIVE_EP,                     "Active Endpoint Request" },

    { ZBEE_ZDP_REQ_MATCH_DESC,                    "Match Descriptor Request" },

    { ZBEE_ZDP_REQ_COMPLEX_DESC,                  "Complex Descriptor Request" },

    { ZBEE_ZDP_REQ_USER_DESC,                     "User Descriptor Request" },

    { ZBEE_ZDP_REQ_DISCOVERY_CACHE,               "Discovery Cache Request" },

    { ZBEE_ZDP_REQ_DEVICE_ANNCE,                  "Device Announcement" },

    { ZBEE_ZDP_REQ_PARENT_ANNCE,                  "Parent Announce" },

    { ZBEE_ZDP_REQ_SET_USER_DESC,                 "Set User Descriptor Request" },

    { ZBEE_ZDP_REQ_SYSTEM_SERVER_DISC,            "Server Discovery Request" },

    { ZBEE_ZDP_REQ_STORE_DISCOVERY,               "Store Discovery Request" },

    { ZBEE_ZDP_REQ_STORE_NODE_DESC,               "Store Node Descriptor Request" },

    { ZBEE_ZDP_REQ_STORE_POWER_DESC,              "Store Power Descriptor Request" },

    { ZBEE_ZDP_REQ_STORE_ACTIVE_EP,               "Store Active Endpoints Request" },

    { ZBEE_ZDP_REQ_STORE_SIMPLE_DESC,             "Store Simple Descriptor Request" },

    { ZBEE_ZDP_REQ_REMOVE_NODE_CACHE,             "Remove Node Cache Request" },

    { ZBEE_ZDP_REQ_FIND_NODE_CACHE,               "Find Node Cache Request" },

    { ZBEE_ZDP_REQ_EXT_SIMPLE_DESC,               "Extended Simple Descriptor Request" },

    { ZBEE_ZDP_REQ_EXT_ACTIVE_EP,                 "Extended Active Endpoint Request" },

    { ZBEE_ZDP_REQ_END_DEVICE_BIND,               "End Device Bind Request" },

    { ZBEE_ZDP_REQ_BIND,                          "Bind Request" },

    { ZBEE_ZDP_REQ_UNBIND,                        "Unbind Request" },

    { ZBEE_ZDP_REQ_BIND_REGISTER,                 "Bind Register Request" },

    { ZBEE_ZDP_REQ_REPLACE_DEVICE,                "Replace Device Request" },

    { ZBEE_ZDP_REQ_STORE_BAK_BIND_ENTRY,          "Store Backup Binding Request" },

    { ZBEE_ZDP_REQ_REMOVE_BAK_BIND_ENTRY,         "Remove Backup Binding Request" },

    { ZBEE_ZDP_REQ_BACKUP_BIND_TABLE,             "Backup Binding Table Request" },

    { ZBEE_ZDP_REQ_RECOVER_BIND_TABLE,            "Recover Binding Table Request" },

    { ZBEE_ZDP_REQ_BACKUP_SOURCE_BIND,            "Backup Source Binding Request" },

    { ZBEE_ZDP_REQ_RECOVER_SOURCE_BIND,           "Recover Source Binding Request" },

    { ZBEE_ZDP_REQ_CLEAR_ALL_BINDINGS,            "Clear All Bindings Request" },

    { ZBEE_ZDP_REQ_MGMT_NWK_DISC,                 "Network Discovery Request" },

    { ZBEE_ZDP_REQ_MGMT_LQI,                      "Link Quality Request" },

    { ZBEE_ZDP_REQ_MGMT_RTG,                      "Routing Table Request" },

    { ZBEE_ZDP_REQ_MGMT_BIND,                     "Binding Table Request" },

    { ZBEE_ZDP_REQ_MGMT_LEAVE,                    "Leave Request" },

    { ZBEE_ZDP_REQ_MGMT_DIRECT_JOIN,              "Direct Join Request" },

    { ZBEE_ZDP_REQ_MGMT_PERMIT_JOIN,              "Permit Join Request" },

    { ZBEE_ZDP_REQ_MGMT_CACHE,                    "Cache Request" },

    { ZBEE_ZDP_REQ_MGMT_NWKUPDATE,                "Network Update Request" },

    { ZBEE_ZDP_REQ_MGMT_NWKUPDATE_ENH,            "Network Update Enhanced Request" },

    { ZBEE_ZDP_REQ_MGMT_IEEE_JOIN_LIST,           "IEEE Joining List Request" },

    { ZBEE_ZDP_REQ_MGMT_NWK_BEACON_SURVEY,        "Beacon Survey Request"},

    { ZBEE_ZDP_REQ_SECURITY_START_KEY_NEGOTIATION,"Security Start Key Negotiation Request" },

    { ZBEE_ZDP_REQ_SECURITY_GET_AUTH_TOKEN,       "Security Get Authentication Token Request"},

    { ZBEE_ZDP_REQ_SECURITY_GET_AUTH_LEVEL,       "Security Get Authentication Level Request"},

    { ZBEE_ZDP_REQ_SECURITY_SET_CONFIGURATION,    "Security Set Configuration Request"},

    { ZBEE_ZDP_REQ_SECURITY_GET_CONFIGURATION,    "Security Get Configuration Request"},

    { ZBEE_ZDP_REQ_SECURITY_START_KEY_UPDATE,     "Security Start Key Update Request"},

    { ZBEE_ZDP_REQ_SECURITY_DECOMMISSION,         "Security Decommission Request"},

    { ZBEE_ZDP_REQ_SECURITY_CHALLENGE,            "Security Challenge Request"},

    { ZBEE_ZDP_RSP_NWK_ADDR,                      "Network Address Response" },

    { ZBEE_ZDP_RSP_IEEE_ADDR,                     "Extended Address Response" },

    { ZBEE_ZDP_RSP_NODE_DESC,                     "Node Descriptor Response" },

    { ZBEE_ZDP_RSP_POWER_DESC,                    "Power Descriptor Response" },

    { ZBEE_ZDP_RSP_SIMPLE_DESC,                   "Simple Descriptor Response" },

    { ZBEE_ZDP_RSP_ACTIVE_EP,                     "Active Endpoint Response" },

    { ZBEE_ZDP_RSP_MATCH_DESC,                    "Match Descriptor Response" },

    { ZBEE_ZDP_RSP_COMPLEX_DESC,                  "Complex Descriptor Response" },

    { ZBEE_ZDP_RSP_USER_DESC,                     "User Descriptor Response" },

    { ZBEE_ZDP_RSP_DISCOVERY_CACHE,               "Discovery Cache Response" },

    { ZBEE_ZDP_RSP_CONF_USER_DESC,                "Set User Descriptor Confirm" },

    { ZBEE_ZDP_RSP_SYSTEM_SERVER_DISC,            "Server Discovery Response" },

    { ZBEE_ZDP_RSP_STORE_DISCOVERY,               "Store Discovery Response" },

    { ZBEE_ZDP_RSP_STORE_NODE_DESC,               "Store Node Descriptor Response" },

    { ZBEE_ZDP_RSP_STORE_POWER_DESC,              "Store Power Descriptor Response" },

    { ZBEE_ZDP_RSP_STORE_ACTIVE_EP,               "Store Active Endpoints Response" },

    { ZBEE_ZDP_RSP_STORE_SIMPLE_DESC,             "Store Simple Descriptor Response" },

    { ZBEE_ZDP_RSP_REMOVE_NODE_CACHE,             "Remove Node Cache Response" },

    { ZBEE_ZDP_RSP_FIND_NODE_CACHE,               "Find Node Cache Response" },

    { ZBEE_ZDP_RSP_EXT_SIMPLE_DESC,               "Extended Simple Descriptor Response" },

    { ZBEE_ZDP_RSP_EXT_ACTIVE_EP,                 "Extended Active Endpoint Response" },

    { ZBEE_ZDP_RSP_PARENT_ANNCE,                  "Parent Announce Response" },

    { ZBEE_ZDP_RSP_END_DEVICE_BIND,               "End Device Bind Response" },

    { ZBEE_ZDP_RSP_BIND,                          "Bind Response" },

    { ZBEE_ZDP_RSP_UNBIND,                        "Unbind Response" },

    { ZBEE_ZDP_RSP_BIND_REGISTER,                 "Bind Register Response" },

    { ZBEE_ZDP_RSP_REPLACE_DEVICE,                "Replace Device Response" },

    { ZBEE_ZDP_RSP_STORE_BAK_BIND_ENTRY,          "Store Backup Binding Response" },

    { ZBEE_ZDP_RSP_REMOVE_BAK_BIND_ENTRY,         "Remove Backup Binding Response" },

    { ZBEE_ZDP_RSP_BACKUP_BIND_TABLE,             "Backup Binding Table Response" },

    { ZBEE_ZDP_RSP_RECOVER_BIND_TABLE,            "Recover Binding Table Response" },

    { ZBEE_ZDP_RSP_BACKUP_SOURCE_BIND,            "Backup Source Binding Response" },

    { ZBEE_ZDP_RSP_RECOVER_SOURCE_BIND,           "Recover Source Binding Response" },

    { ZBEE_ZDP_RSP_CLEAR_ALL_BINDINGS,            "Clear All Bindings Response" },

    { ZBEE_ZDP_RSP_MGMT_NWK_DISC,                 "Network Discovery Response" },

    { ZBEE_ZDP_RSP_MGMT_LQI,                      "Link Quality Response" },

    { ZBEE_ZDP_RSP_MGMT_RTG,                      "Routing Table Response" },

    { ZBEE_ZDP_RSP_MGMT_BIND,                     "Binding Table Response" },

    { ZBEE_ZDP_RSP_MGMT_LEAVE,                    "Leave Response" },

    { ZBEE_ZDP_RSP_MGMT_DIRECT_JOIN,              "Direct Join Response" },

    { ZBEE_ZDP_RSP_MGMT_PERMIT_JOIN,              "Permit Join Response" },

    { ZBEE_ZDP_RSP_MGMT_CACHE,                    "Cache Response" },

    { ZBEE_ZDP_NOT_MGMT_NWKUPDATE,                "Network Update Notify" },

    { ZBEE_ZDP_NOT_MGMT_NWKUPDATE_ENH,            "Network Enhanced Update Notify" },

    { ZBEE_ZDP_RSP_MGMT_IEEE_JOIN_LIST,           "IEEE Joining List Response" },

    { ZBEE_ZDP_NOT_MGMT_UNSOLICITED_NWKUPDATE,    "Unsolicited Enhanced Network Update Notify" },

    { ZBEE_ZDP_RSP_MGMT_NWK_BEACON_SURVEY,        "Beacon Survey Response"},

    { ZBEE_ZDP_RSP_SECURITY_START_KEY_NEGOTIATION,"Security Start Key Negotiation Response" },

    { ZBEE_ZDP_RSP_SECURITY_GET_AUTH_TOKEN,       "Security Get Authentication Token Response"},

    { ZBEE_ZDP_RSP_SECURITY_GET_AUTH_LEVEL,       "Security Get Authentication Level Response"},

    { ZBEE_ZDP_RSP_SECURITY_SET_CONFIGURATION,    "Security Set Configuration Response"},

    { ZBEE_ZDP_RSP_SECURITY_GET_CONFIGURATION,    "Security Get Configuration Response"},

    { ZBEE_ZDP_RSP_SECURITY_START_KEY_UPDATE,     "Security Start Key Update Response"},

    { ZBEE_ZDP_RSP_SECURITY_DECOMMISSION,         "Security Decommission Response"},

    { ZBEE_ZDP_RSP_SECURITY_CHALLENGE,            "Security Challenge Response"},

    { 0, NULL }

};

static const value_string zbee_zdp_status_names[] = {

    { ZBEE_ZDP_STATUS_SUCCESS,                    "Success" },

    { ZBEE_ZDP_STATUS_INV_REQUESTTYPE,            "Invalid Request Type" },

    { ZBEE_ZDP_STATUS_DEVICE_NOT_FOUND,           "Device Not Found" },

    { ZBEE_ZDP_STATUS_INVALID_EP,                 "Invalid Endpoint" },

    { ZBEE_ZDP_STATUS_NOT_ACTIVE,                 "Not Active" },

    { ZBEE_ZDP_STATUS_NOT_SUPPORTED,              "Not Supported" },

    { ZBEE_ZDP_STATUS_TIMEOUT,                    "Timeout" },

    { ZBEE_ZDP_STATUS_NO_MATCH,                   "No Match" },

    { ZBEE_ZDP_STATUS_NO_ENTRY,                   "No Entry" },

    { ZBEE_ZDP_STATUS_NO_DESCRIPTOR,              "No Descriptor" },

    { ZBEE_ZDP_STATUS_INSUFFICIENT_SPACE,         "Insufficient Space" },

    { ZBEE_ZDP_STATUS_NOT_PERMITTED,              "Not Permitted" },

    { ZBEE_ZDP_STATUS_TABLE_FULL,                 "Table Full" },

    { ZBEE_ZDP_STATUS_NOT_AUTHORIZED,             "Not Authorized" },

    { ZBEE_ZDP_STATUS_DEVICE_BINDING_TABLE_FULL,  "Device Binding Table Full" },

    { ZBEE_ZDP_STATUS_INVALID_INDEX,              "Invalid Index" },

    { ZBEE_ZDP_STATUS_RESPONSE_TOO_LARGE,         "Response Too Large" },

    { ZBEE_ZDP_STATUS_MISSING_TLV,                "Missing TLV" },

    { 0, NULL }

};

static const value_string zbee_zll_device_names[] = {

    { ZBEE_ZLL_DEVICE_ON_OFF_LIGHT,               "On/Off light" },

    { ZBEE_ZLL_DEVICE_ON_OFF_PLUG_IN_UNIT,        "On/Off plug-in unit" },

    { ZBEE_ZLL_DEVICE_DIMMABLE_LIGHT,             "Dimmable light" },

    { ZBEE_ZLL_DEVICE_DIMMABLE_PLUG_IN_UNIT,      "Dimmable plug-in unit" },

    { ZBEE_ZLL_DEVICE_COLOR_LIGHT,                "Color light" },

    { ZBEE_ZLL_DEVICE_EXTENDED_COLOR_LIGHT,       "Extended color light" },

    { ZBEE_ZLL_DEVICE_COLOR_TEMPERATURE_LIGHT,    "Color temperature light" },

    { ZBEE_ZLL_DEVICE_COLOR_CONTROLLER,           "Color controller" },

    { ZBEE_ZLL_DEVICE_COLOR_SCENE_CONTROLLER,     "Color scene controller" },

    { ZBEE_ZLL_DEVICE_NON_COLOR_CONTROLLER,       "Non-color controller" },

    { ZBEE_ZLL_DEVICE_NON_COLOR_SCENE_CONTROLLER, "Non-color scene controller" },

    { ZBEE_ZLL_DEVICE_CONTROL_BRIDGE,             "Control Bridge" },

    { ZBEE_ZLL_DEVICE_ON_OFF_SENSOR,              "On/Off sensor" },

    { 0, NULL }

};

static const value_string zbee_ha_device_names[] = {

    { ZBEE_HA_DEVICE_ON_OFF_LIGHT,               "On/Off light" },

    { ZBEE_HA_DEVICE_DIMMABLE_LIGHT,             "Dimmable light" },

    { ZBEE_HA_DEVICE_COLOR_DIMMABLE_LIGHT,       "Color dimmable light" },

    { ZBEE_HA_DEVICE_ON_OFF_LIGHT_SWITCH,        "On/Off light switch" },

    { ZBEE_HA_DEVICE_DIMMER_SWITCH,              "Dimmer switch" },

    { ZBEE_HA_DEVICE_COLOR_DIMMER_SWITCH,        "Color dimmer switch" },

    { ZBEE_HA_DEVICE_LIGHT_SENSOR,               "Light sensor" },

    { ZBEE_HA_DEVICE_OCCUPANCY_SENSOR,           "Occupancy sensor" },

    { ZBEE_HA_DEVICE_ON_OFF_BALLAST,             "On/Off ballast" },

    { ZBEE_HA_DEVICE_DIMMABLE_BALLAST,           "Dimmable ballast" },

    { ZBEE_HA_DEVICE_ON_OFF_PLUG_IN_UNIT,        "On/Off plug-in unit" },

    { ZBEE_HA_DEVICE_DIMMABLE_PLUG_IN_UNIT,      "Dimmable plug-in unit" },

    { ZBEE_HA_DEVICE_COLOR_TEMPERATURE_LIGHT,    "Color temperature light" },

    { ZBEE_HA_DEVICE_EXTENDED_COLOR_LIGHT,       "Extended color light" },

    { ZBEE_HA_DEVICE_LIGHT_LEVEL_SENSOR,         "Light level sensor" },

    { ZBEE_HA_DEVICE_COLOR_CONTROLLER,           "Color controller" },

    { ZBEE_HA_DEVICE_COLOR_SCENE_CONTROLLER,     "Color scene controller" },

    { ZBEE_HA_DEVICE_NON_COLOR_CONTROLLER,       "Non-color controller" },

    { ZBEE_HA_DEVICE_NON_COLOR_SCENE_CONTROLLER, "Non-color scene controller" },

    { ZBEE_HA_DEVICE_CONTROL_BRIDGE,             "Control Bridge" },

    { ZBEE_HA_DEVICE_ON_OFF_SENSOR,              "On/Off sensor" },

    { 0, NULL }

};

const value_string zbee_zdp_rtg_status_vals[] = {

    { 0x00,  "Active" },

    { 0x01,  "Discovery Underway" },

    { 0x02,  "Discovery Failed" },

    { 0x03,  "Inactive" },

    { 0, NULL }

};

static const value_string zbee_zdp_ieee_join_policy_vals[] = {

    { 0x00,  "All Join" },

    { 0x01,  "IEEE Join" },

    { 0x02,  "No Join" },

    { 0, NULL }

};

/* The reason this has it's own value_string and doesn't use

   tfs_get_string(), is that some hf_ fields use bitmasks larger

   than 0x01, and it's intentional that those other values be

   "Unknown" (which is what value_string will give us)

 */

static const value_string zbee_zdp_true_false_plus_vals[] = {

    { 0x00,  "False" },

    { 0x01,  "True" },

    { 0, NULL }

};

static const value_string zbee_zdp_table_entry_type_vals[] = {

    { 0x00,  "Coordinator" },

    { 0x01,  "Router" },

    { 0x02,  "End Device" },

    { 0, NULL }

};

static const value_string zbee_zdp_relationship_vals[] = {

    { 0x00,  "Parent" },

    { 0x01,  "Child" },

    { 0x02,  "Sibling" },

    { 0x03,  "None" },

    { 0x04,  "Previous Child" },

    { 0, NULL }

};

static const range_string zbee_zcl_zdp_address_modes[] = {

    { 0x0, 0x0, "Reserved" },

    { ZBEE_ZDP_ADDR_MODE_GROUP, ZBEE_ZDP_ADDR_MODE_GROUP, "Group" },

    { 0x02, 0x02, "Reserved" },

    { ZBEE_ZDP_ADDR_MODE_UNICAST, ZBEE_ZDP_ADDR_MODE_UNICAST, "Unicast" },

    { 0x03, 0xFF, "Reserved" },

    { 0, 0, NULL }

};

/*

    if (tree) {

        if (type == 0x00)       proto_item_append_text(ti, ", Type: Coordinator");

        else if (type == 0x01)  proto_item_append_text(ti, ", Type: Router");

        else if (type == 0x02)  proto_item_append_text(ti, ", Type: End Device");

        else                    proto_item_append_text(ti, ", Type: Unknown");

        if (idle_rx == 0x00)    proto_item_append_text(ti, ", Idle Rx: False");

        else if (idle_rx==0x01) proto_item_append_text(ti, ", Idle Rx: True");

        else                    proto_item_append_text(ti, ", Idle Rx: Unknown");

        if (rel == 0x00)        proto_item_append_text(ti, ", Relationship: Parent");

        else if (rel == 0x01)   proto_item_append_text(ti, ", Relationship: Child");

        else if (rel == 0x02)   proto_item_append_text(ti, ", Relationship: Sibling");

        else if (rel == 0x03)   proto_item_append_text(ti, ", Relationship: None");

        else if (rel == 0x04)   proto_item_append_text(ti, ", Relationship: Previous Child");

        else                    proto_item_append_text(ti, ", Relationship: Unknown");

    }

*/

/**

 *Returns a status name for a given status value.

 *

*/

const char *

zdp_status_name(uint8_t status)

{

    return val_to_str_const(status, zbee_zdp_status_names, "Reserved");

} /* zdp_status_name */

/**

 *Converts a ZigBee 2003 & earlier cluster ID to a 2006

 *

*/

static uint16_t

zdp_convert_2003cluster(uint8_t cluster)

{

    uint16_t cluster16 = (uint16_t)cluster;

    if (cluster16 & ZBEE_ZDP_MSG_RESPONSE_BIT_2003) {

        /* Clear the 2003 request bit. */

        cluster16 &= ~(ZBEE_ZDP_MSG_RESPONSE_BIT_2003);

        /* Set the 2006 request bit. */

        cluster16 |= (ZBEE_ZDP_MSG_RESPONSE_BIT);

    }

    return cluster16;

} /* zdp_convert_2003cluster */

/**

 *Helper functions dumps any excess data into the data dissector.

 *

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset after parsing last item.

 *@param pinfo packet information structure.

 *@param tree pointer to data tree Wireshark uses to display packet.

*/

void

zdp_dump_excess(tvbuff_t *tvb, unsigned offset, packet_info *pinfo, proto_tree *tree)

{

    proto_tree  *root = proto_tree_get_root(tree);

    unsigned    length = tvb_captured_length_remaining(tvb, offset);

    tvbuff_t    *excess;

    if (length > 0) {

        excess = tvb_new_subset_remaining(tvb, offset);

        call_data_dissector(excess, pinfo, root);

    }

} /* zdp_dump_excess */

/**

 *ZigBee helper function. Appends the info to the info column

 *

 *@param item item to display info on.

 *@param pinfo packet info struct.

 *@param format format string.

*/

void

zbee_append_info(proto_item *item, packet_info *pinfo, const char *format, ...)

{

    static char     buffer[512];

    va_list         ap;

    va_start(ap, format);

    vsnprintf(buffer, 512, format, ap);

    va_end(ap);

    proto_item_append_text(item, "%s", buffer);

    col_append_str(pinfo->cinfo, COL_INFO, buffer);

} /* zbee_add_info */

/**

 *ZigBee helper function. extracts an EUI64 address and displays

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param hfindex index to field information.

 *@param tvb pointer to buffer containing raw packet.

 *@param offset pointer to value of offset.

 *@param length length of the value to extract.

 *@param ti optional pointer to get the created proto item.

 *@return the value read out of the tvbuff and added to the tree.

*/

uint64_t

zbee_parse_eui64(proto_tree *tree, int hfindex, tvbuff_t *tvb, unsigned *offset, unsigned length, proto_item **ti)

{

    proto_item          *item = NULL;

    uint64_t            value;

    /* Get the value. */

    value = tvb_get_letoh64(tvb, *offset);

    /* Display it. */

    item = proto_tree_add_eui64(tree, hfindex, tvb, *offset, length, value);

    /* Increment the offset. */

    *offset += (int)sizeof(uint64_t);

    /* return the item if requested. */

    if (ti) *ti = item;

    /* return the value. */

    return value;

} /* zbee_parse_eui64 */

/**

 *Parses and displays the status value.

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the status value.

*/

uint8_t

zdp_parse_status(proto_tree *tree, tvbuff_t *tvb, unsigned *offset)

{

    uint8_t     status;

    /* Get and display the flags. */

    status = tvb_get_uint8(tvb, *offset);

    proto_tree_add_uint(tree, hf_zbee_zdp_status, tvb, *offset, (int)sizeof(uint8_t), status);

    *offset += (int)sizeof(uint8_t);

    return status;

} /* zdp_parse_status */

/**

 *Parses and displays the a channel mask.

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the status value.

*/

uint32_t

zdp_parse_chanmask(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, int hf_page, int hf_channel)

{

    int         i;

    uint32_t    mask;

    uint8_t     page;

    proto_item  *ti;

    /* Get and display the channel mask. */

    mask = tvb_get_letohl(tvb, *offset);

    page = (uint8_t)((mask & ZBEE_ZDP_NWKUPDATE_PAGE) >> 27);

    mask &= ZBEE_ZDP_NWKUPDATE_CHANNEL;

    proto_tree_add_uint(tree, hf_page, tvb, *offset, 4, page);

    ti = proto_tree_add_uint_format(tree, hf_channel, tvb, *offset, 4, mask, "Channels: ");

    /* Check if there are any channels to display. */

    if (mask==0) {

        proto_item_append_text(ti, "None");

    }

    /* Display the first channel #. */

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

        if ((1<<i) & mask) {

            proto_item_append_text(ti, "%d", i++);

            break;

        }

    } /* for */

    /* Display the rest of the channels. */

    for (;i<32; i++) {

        if (!((1<<i) & mask)) {

            /* This channel isn't selected. */

            continue;

        }

        /* If the previous channel wasn't selected, then display the

         * channel number.

         */

        if ( ! ((1<<(i-1)) & mask) ) {

            proto_item_append_text(ti, ", %d", i);

        }

        /*

         * If the next channel is selected too, skip past it and display

         * a range of values instead.

         */

        if ((2<<i) & mask) {

            while ((2<<i) & mask) i++;

            proto_item_append_text(ti, "-%d", i);

        }

    } /* for */

    *offset += (int)sizeof(uint32_t);

    return mask;

} /* zdp_parse_chanmask */

/**

 *Parses and displays MAC capability info flags.

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

*/

uint8_t

zdp_parse_cinfo(proto_tree *tree, int ettindex, tvbuff_t *tvb, unsigned *offset)

{

    uint8_t     flags;

    static int * const cinfo[] = {

        &hf_zbee_zdp_cinfo_alt_coord,

        &hf_zbee_zdp_cinfo_ffd,

        &hf_zbee_zdp_cinfo_power,

        &hf_zbee_zdp_cinfo_idle_rx,

        &hf_zbee_zdp_cinfo_security,

        &hf_zbee_zdp_cinfo_alloc,

        NULL

    };

    /* Get and display the flags. */

    proto_tree_add_bitmask_with_flags(tree, tvb, *offset, hf_zbee_zdp_cinfo, ettindex, cinfo, ENC_NA, BMT_NO_APPEND);

    flags = tvb_get_uint8(tvb, *offset);

    *offset += 1;

    return flags;

} /* zdp_parse_cinfo */

/**

 *Parses and displays server mode flags.

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

*/

uint16_t

zdp_parse_server_flags(proto_tree *tree, int ettindex, tvbuff_t *tvb, unsigned *offset)

{

    uint16_t     flags;

    static int * const server_flags[] = {

        &hf_zbee_zdp_server_pri_trust,

        &hf_zbee_zdp_server_bak_trust,

        &hf_zbee_zdp_server_pri_bind,

        &hf_zbee_zdp_server_bak_bind,

        &hf_zbee_zdp_server_pri_disc,

        &hf_zbee_zdp_server_bak_disc,

        &hf_zbee_zdp_server_network_manager,

        &hf_zbee_zdp_server_stk_compl_rev,

        NULL

    };

    /* Get and display the flags. */

    flags = tvb_get_letohs(tvb, *offset);

    proto_tree_add_bitmask_with_flags(tree, tvb, *offset, hf_zbee_zdp_server, ettindex, server_flags, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);

    *offset += 2;

    return flags;

} /* zdp_parse_server_flags */

/**

 *Parses and displays a node descriptor to the specified

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

*/

void

zdp_parse_node_desc(proto_tree *tree, packet_info *pinfo, bool show_ver_flags, int ettindex, tvbuff_t *tvb, unsigned *offset, uint8_t version)

{

    proto_item  *ti;

    proto_item  *field_root = NULL;

    proto_tree  *field_tree = NULL;

    uint16_t    flags;

    /*uint8_t     capability;*/

    /*uint16_t    mfr_code;*/

    /*uint8_t     max_buff;*/

    /*uint16_t    max_transfer;*/

    static int * const nodes[] = {

        &hf_zbee_zdp_node_complex,

        &hf_zbee_zdp_node_user,

        &hf_zbee_zdp_node_frag_support,

        &hf_zbee_zdp_node_freq_868,

        &hf_zbee_zdp_node_freq_900,

        &hf_zbee_zdp_node_freq_2400,

        &hf_zbee_zdp_node_freq_eu_sub_ghz,

        NULL

    };

    if ((tree) && (ettindex != -1)) {

        field_tree = proto_tree_add_subtree(tree, tvb, *offset, -1, ettindex, &field_root, "Node Descriptor");

    }

    else

        field_tree = tree;

    /* Get and display the flags. */

    flags = tvb_get_letohs(tvb, *offset);

    if (tree) {

        uint16_t type = flags & ZBEE_ZDP_NODE_TYPE;

        ti = proto_tree_add_uint(field_tree, hf_zbee_zdp_node_type, tvb, *offset, 2, type);

        /* XXX - should probably be converted to proto_tree_add_bitmask */

        proto_tree_add_bitmask_list(field_tree, tvb, *offset, 2, nodes, ENC_LITTLE_ENDIAN);

        /* Enumerate the type field. */

        if (type == ZBEE_ZDP_NODE_TYPE_COORD)    proto_item_append_text(ti, " (Coordinator)");

        else if (type == ZBEE_ZDP_NODE_TYPE_FFD) proto_item_append_text(ti, " (Router)");

        else if (type == ZBEE_ZDP_NODE_TYPE_RFD) proto_item_append_text(ti, " (End Device)");

        else proto_item_append_text(ti, " (Reserved)");

    }

    *offset += 2;

    /* Get and display the capability flags. */

    /*capability      =*/ zdp_parse_cinfo(field_tree, ett_zbee_zdp_cinfo, tvb, offset);

    proto_tree_add_item(field_tree, hf_zbee_zdp_node_manufacturer, tvb, *offset, 2, ENC_LITTLE_ENDIAN);

    *offset += 2;

    proto_tree_add_item(field_tree, hf_zbee_zdp_node_max_buffer, tvb, *offset, 1, ENC_LITTLE_ENDIAN);

    *offset += 1;

    proto_tree_add_item(field_tree, hf_zbee_zdp_node_max_incoming_transfer, tvb, *offset, 2, ENC_LITTLE_ENDIAN);

    *offset += 2;

    /* Get and display the server flags. */

    if (version >= ZBEE_VERSION_2007) {

        uint16_t ver_flags;

        static int * const descriptors[] = {

            &hf_zbee_zdp_dcf_eaela,

            &hf_zbee_zdp_dcf_esdla,

            NULL

        };

        ver_flags = zdp_parse_server_flags(field_tree, ett_zbee_zdp_server, tvb, offset) & ZBEE_ZDP_NODE_SERVER_STACK_COMPL_REV;

        if (show_ver_flags && ver_flags) {

            zbee_append_info(tree, pinfo, ", Rev: %d",

                             (ver_flags >> ws_ctz(ZBEE_ZDP_NODE_SERVER_STACK_COMPL_REV)));

        }

        proto_tree_add_item(field_tree, hf_zbee_zdp_node_max_outgoing_transfer, tvb, *offset, 2, ENC_LITTLE_ENDIAN);

        *offset += 2;

        proto_tree_add_bitmask_with_flags(field_tree, tvb, *offset, hf_zbee_zdp_dcf, ett_zbee_zdp_descriptor_capability_field, descriptors, ENC_NA, BMT_NO_APPEND);

        *offset += 1;

    }

    /* Correct the length of the subtree. */

    if (tree && (ettindex != -1)) {

        proto_item_set_len(field_root, *offset);

    }

} /* zdp_parse_node_desc */

static const value_string zbee_zdp_power_mode_vals[] = {

   { ZBEE_ZDP_POWER_MODE_RX_ON,              "Receiver Always On"          },

   { ZBEE_ZDP_POWER_MODE_RX_PERIODIC,        "Receiver Periodically On"    },

   { ZBEE_ZDP_POWER_MODE_RX_STIMULATE,       "Receiver On When Stimulated" },

   { 0,                    NULL }

};

static const value_string zbee_zdp_power_level_vals[] = {

   { ZBEE_ZDP_POWER_LEVEL_FULL,      "Full"          },

   { ZBEE_ZDP_POWER_LEVEL_OK,        "OK"    },

   { ZBEE_ZDP_POWER_LEVEL_LOW,       "Low" },

   { ZBEE_ZDP_POWER_LEVEL_CRITICAL,  "Critical" },

   { 0,                    NULL }

};

/**

 *Parses and displays a node descriptor to the specified

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

*/

void

zdp_parse_power_desc(proto_tree *tree, int ettindex, tvbuff_t *tvb, unsigned *offset)

{

    static int * const power_desc[] = {

        &hf_zbee_zdp_power_mode,

        &hf_zbee_zdp_power_avail_ac,

        &hf_zbee_zdp_power_avail_recharge,

        &hf_zbee_zdp_power_avail_dispose,

        &hf_zbee_zdp_power_source_ac,

        &hf_zbee_zdp_power_source_recharge,

        &hf_zbee_zdp_power_source_dispose,

        &hf_zbee_zdp_power_level,

        NULL

    };

    proto_tree_add_bitmask_with_flags(tree, tvb, *offset, hf_zbee_zdp_power, ettindex, power_desc, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);

    *offset += 2;

} /* zdp_parse_power_desc */

/**

 *Parses and displays a simple descriptor to the specified

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

*/

void

zdp_parse_simple_desc(proto_tree *tree, int ettindex, tvbuff_t *tvb, unsigned *offset, uint8_t version)

{

    proto_item  *field_root = NULL;

    proto_tree  *field_tree = NULL, *cluster_tree = NULL;

    unsigned    i, sizeof_cluster;

    int         hf_app_device;

    uint32_t    profile;

    uint32_t    in_count, out_count;

    if ((tree) && (ettindex != -1)) {

        field_tree = proto_tree_add_subtree(tree, tvb, *offset, -1, ettindex, &field_root, "Simple Descriptor");

    }

    else field_tree = tree;

    proto_tree_add_item(field_tree, hf_zbee_zdp_endpoint, tvb, *offset, 1, ENC_LITTLE_ENDIAN);

    *offset += 1;

    proto_tree_add_item_ret_uint(field_tree, hf_zbee_zdp_profile, tvb, *offset, 2, ENC_LITTLE_ENDIAN, &profile);

    *offset += 2;

    switch (profile)

    {

    case ZBEE_PROFILE_ZLL: hf_app_device = hf_zbee_zdp_simple_zll_app_device; break;

    case ZBEE_PROFILE_HA:  hf_app_device = hf_zbee_zdp_simple_ha_app_device;  break;

    default:               hf_app_device = hf_zbee_zdp_simple_app_device;     break;

    }

    proto_tree_add_item(field_tree, hf_app_device, tvb, *offset, 2, ENC_LITTLE_ENDIAN);

    *offset += 2;

    proto_tree_add_item(field_tree, hf_zbee_zdp_simple_app_version, tvb, *offset, 1, ENC_LITTLE_ENDIAN);

    *offset += 1;

    sizeof_cluster = (version >= ZBEE_VERSION_2007)?(int)sizeof(uint16_t):(int)sizeof(uint8_t);

    proto_tree_add_item_ret_uint(field_tree, hf_zbee_zdp_in_count, tvb, *offset, 1, ENC_LITTLE_ENDIAN, &in_count);

    *offset += 1;

    if ((tree) && (in_count)) {

        cluster_tree = proto_tree_add_subtree(field_tree, tvb, *offset, in_count*sizeof_cluster,

                                                ett_zbee_zdp_node_in, NULL, "Input Cluster List");

    }

    for (i=0; i<in_count && tvb_bytes_exist(tvb, *offset, sizeof_cluster); i++) {

        proto_tree_add_item(cluster_tree, hf_zbee_zdp_in_cluster, tvb, *offset, sizeof_cluster, ENC_LITTLE_ENDIAN);

        *offset += sizeof_cluster;

    }

    proto_tree_add_item_ret_uint(field_tree, hf_zbee_zdp_out_count, tvb, *offset, 1, ENC_LITTLE_ENDIAN, &out_count);

    *offset += 1;

    if ((tree) && (out_count)) {

        cluster_tree = proto_tree_add_subtree(field_tree, tvb, *offset, out_count*sizeof_cluster,

                                                ett_zbee_zdp_node_out, NULL, "Output Cluster List");

    }

    for (i=0; (i<out_count) && tvb_bytes_exist(tvb, *offset, sizeof_cluster); i++) {

        proto_tree_add_item(cluster_tree, hf_zbee_zdp_out_cluster, tvb, *offset, sizeof_cluster, ENC_LITTLE_ENDIAN);

        *offset += sizeof_cluster;

    }

    if (tree && (ettindex != -1)) {

        proto_item_set_len(field_root, *offset);

    }

} /* zdp_parse_simple_desc */

/**

 *Parses and displays a simple descriptor to the specified

 *

 *@param tree pointer to data tree Wireshark uses to display packet.

 *@param ettindex subtree index to create the node descriptor in, or -1

 *@param tvb pointer to buffer containing raw packet.

 *@param offset offset into the tvb to find the node descriptor.

 *@param length length of the complex descriptor.

*/

void

zdp_parse_complex_desc(packet_info *pinfo, proto_tree *tree, int ettindex, tvbuff_t *tvb, unsigned *offset, unsigned length)

{

    enum {

        tag_charset = 1,

        tag_mfr_name = 2,

        tag_model_name = 3,

        tag_serial_no = 4,

        tag_url = 5,

        tag_icon = 6,

        tag_icon_url = 7

    };

    static const char *tag_name[] = {

        "Reserved Tag",

        "languageChar",

        "manufacturerName",

        "modelName",

        "serialNumber",

        "deviceURL",

        "icon",

        "outliner"

    };

    proto_tree  *field_tree;

    char    *complex;

    uint8_t tag;

    if ((tree) && (ettindex != -1)) {

        field_tree = proto_tree_add_subtree(tree, tvb, *offset, length, ettindex, NULL, "Complex Descriptor");

    }

    else

        field_tree = tree;

    tag = tvb_get_uint8(tvb, *offset);

    if (tag == tag_charset) {

        char    *lang_str[2];

        uint8_t ch;

        uint8_t charset  = tvb_get_uint8(tvb, *offset + 3);

        const char *charset_str;

        if (charset == 0x00) charset_str = "ASCII";

        else                 charset_str = "Unknown Character Set";

        ch = tvb_get_uint8(tvb, *offset + 1);

        lang_str[0] = format_char(pinfo->pool, ch);

        ch = tvb_get_uint8(tvb, *offset + 2);

        lang_str[1] = format_char(pinfo->pool, ch);

        complex = wmem_strdup_printf(pinfo->pool, "<%s>%s%s, %s</%s>", tag_name[tag_charset], lang_str[0], lang_str[1], charset_str, tag_name[tag_charset]);

    }

    else if (tag == tag_icon) {

        /* TODO: */

        complex = wmem_strdup_printf(pinfo->pool, "<%s>FixMe</%s>", tag_name[tag_icon], tag_name[tag_icon]);

    }

    else {

        char *str;

        str = (char *) tvb_get_string_enc(pinfo->pool, tvb, *offset+1, length-1, ENC_ASCII);

        /* Handles all string type XML tags. */

        if (tag <= tag_icon_url) {

            complex = wmem_strdup_printf(pinfo->pool, "<%s>%s</%s>", tag_name[tag], str, tag_name[tag]);

        }

        else {

            complex = wmem_strdup_printf(pinfo->pool, "<%s>%s</%s>", tag_name[0], str, tag_name[0]);

        }

    }

    proto_tree_add_string(field_tree, hf_zbee_zdp_complex, tvb, *offset, length, complex);

    *offset += (length);

} /* zdp_parse_complex_desc */

/**

 *ZigBee Device Profile dissector for wireshark.

 *

 *@param tvb pointer to buffer containing raw packet.

 *@param pinfo pointer to packet information fields

 *@param tree pointer to data tree Wireshark uses to display packet.

*/

static int

dissect_zbee_zdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)

{

    proto_tree      *zdp_tree;

    proto_item      *proto_root;

    tvbuff_t        *zdp_tvb;

    uint8_t         seqno;

    uint16_t        cluster;

    unsigned        offset = 0;

    zbee_nwk_packet *nwk;

    /* Reject the packet if data is NULL */

    if (data == NULL)

        return 0;

    nwk = (zbee_nwk_packet *)data;

    /* Create the protocol tree. */

    proto_root = proto_tree_add_protocol_format(tree, proto_zbee_zdp, tvb, offset, tvb_captured_length(tvb), "ZigBee Device Profile");

    zdp_tree = proto_item_add_subtree(proto_root, ett_zbee_zdp);

#if 0

    /* Overwrite the protocol column */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "ZigBee ZDP");

#endif

    /* Get and display the sequence number. */

    seqno = tvb_get_uint8(tvb, offset);

    proto_tree_add_uint(zdp_tree, hf_zbee_zdp_seqno, tvb, offset, (int)sizeof(uint8_t), seqno);

    offset += (int)sizeof(uint8_t);

    if (nwk->version <= ZBEE_VERSION_2004) {

        /* ZigBee 2004 and earlier had different cluster identifiers, need to convert

         * them into the ZigBee 2006 & later values. */

        cluster = zdp_convert_2003cluster((uint8_t)nwk->cluster_id);

    }

    else {