From 10f59319373e9346fccaaeac38a4a08343dfe2db Mon Sep 17 00:00:00 2001 From: Aditya Jain Date: Mon, 21 Dec 2015 14:53:04 +0530 Subject: Adding Shade Configuration and Door Lock Clusters for Zigbee Change-Id: Ifc99c47e4bf8c03355f60ab508cd7f9b2fb249e4 Reviewed-on: https://code.wireshark.org/review/12776 Petri-Dish: Alexis La Goutte Tested-by: Petri Dish Buildbot Reviewed-by: Alexis La Goutte Reviewed-by: Michael Mann --- epan/CMakeLists.txt | 1 + epan/dissectors/Makefile.common | 1 + epan/dissectors/packet-zbee-zcl-closures.c | 611 +++++++++++++++++++++++++++++ epan/dissectors/packet-zbee.h | 2 + 4 files changed, 615 insertions(+) create mode 100644 epan/dissectors/packet-zbee-zcl-closures.c (limited to 'epan') diff --git a/epan/CMakeLists.txt b/epan/CMakeLists.txt index 1976ce197e..43ea761d66 100644 --- a/epan/CMakeLists.txt +++ b/epan/CMakeLists.txt @@ -1458,6 +1458,7 @@ set(DISSECTOR_SRC dissectors/packet-zbee-nwk-gp.c dissectors/packet-zbee-security.c dissectors/packet-zbee-zcl.c + dissectors/packet-zbee-zcl-closures.c dissectors/packet-zbee-zcl-general.c dissectors/packet-zbee-zcl-ha.c dissectors/packet-zbee-zcl-meas-sensing.c diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common index f896402e27..f88dbb3b05 100644 --- a/epan/dissectors/Makefile.common +++ b/epan/dissectors/Makefile.common @@ -1375,6 +1375,7 @@ DISSECTOR_SRC = \ packet-zbee-nwk-gp.c \ packet-zbee-security.c \ packet-zbee-zcl.c \ + packet-zbee-zcl-closures.c \ packet-zbee-zcl-general.c \ packet-zbee-zcl-ha.c \ packet-zbee-zcl-meas-sensing.c \ diff --git a/epan/dissectors/packet-zbee-zcl-closures.c b/epan/dissectors/packet-zbee-zcl-closures.c new file mode 100644 index 0000000000..83b71f8dbc --- /dev/null +++ b/epan/dissectors/packet-zbee-zcl-closures.c @@ -0,0 +1,611 @@ +/* packet-zbee-zcl-closures.c + * Dissector routines for the ZigBee ZCL Closures clusters + * Shade configuration, Door Lock + * By + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/* Include Files */ +#include "config.h" + +#include +#include + +#include "packet-zbee.h" +#include "packet-zbee-aps.h" +#include "packet-zbee-zcl.h" + + +/* ########################################################################## */ +/* #### (0x0100) SHADE CONFIGURATION CLUSTER ################################ */ +/* ########################################################################## */ + +/*************************/ +/* Defines */ +/*************************/ + +#define ZBEE_ZCL_SHADE_CONFIGURATION_NUM_ETT 2 + +/*Attributes*/ +#define ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT 0x0000 /* Physical Closed Limit */ +#define ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE 0x0001 /* Motor Step Size */ +#define ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_STATUS 0x0002 /* Status */ +#define ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_CLOSED_LIMIT 0x0010 /* Closed Limit */ +#define ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MODE 0x0011 /* Mode */ + +/*Server commands received - none*/ + +/*Server commands generated - none*/ + +/*Status Mask Value*/ +#define ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_OPERATIONAL 0x01 /* Shade Operational */ +#define ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_ADJUSTING 0x02 /* Shade Adjusting */ +#define ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_DIRECTION 0x04 /* Shade Direction */ +#define ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_MOTOR_FORWARD_DIRECTION 0x08 /* Motor Forward Direction */ + +/*************************/ +/* Function Declarations */ +/*************************/ + +void proto_register_zbee_zcl_shade_configuration(void); +void proto_reg_handoff_zbee_zcl_shade_configuration(void); + +/* Command Dissector Helpers */ +static void dissect_zcl_shade_configuration_attr_data (proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 attr_id, guint data_type); + +/* Private functions prototype */ + +/*************************/ +/* Global Variables */ +/*************************/ +/* Initialize the protocol and registered fields */ +static int proto_zbee_zcl_shade_configuration = -1; + +static int hf_zbee_zcl_shade_configuration_attr_id = -1; +static int hf_zbee_zcl_shade_configuration_status = -1; +static int hf_zbee_zcl_shade_configuration_status_shade_operational = -1; +static int hf_zbee_zcl_shade_configuration_status_shade_adjusting = -1; +static int hf_zbee_zcl_shade_configuration_status_shade_direction = -1; +static int hf_zbee_zcl_shade_configuration_status_motor_forward_direction = -1; +static int hf_zbee_zcl_shade_configuration_mode = -1; + +/* Initialize the subtree pointers */ +static gint ett_zbee_zcl_shade_configuration = -1; +static gint ett_zbee_zcl_shade_configuration_status = -1; + +/* Attributes */ +static const value_string zbee_zcl_shade_configuration_attr_names[] = { + { ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT, "Physical Closed Limit" }, + { ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE, "Motor Step Size" }, + { ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_STATUS, "Status" }, + { ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_CLOSED_LIMIT, "Closed Limit" }, + { ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MODE, "Mode" }, + { 0, NULL } +}; + +/*Shade and motor direction values*/ +static const value_string zbee_zcl_shade_configuration_shade_motor_direction_names[] = { + {0, "Closing"}, + {1, "Opening"}, + {0, NULL} +}; + +/*Mode Values*/ +static const value_string zbee_zcl_shade_configuration_mode_names[] = { + {0, "Normal"}, + {1, "Configure"}, + {0, NULL} +}; + + +/*************************/ +/* Function Bodies */ +/*************************/ + +/** + *ZigBee ZCL Shade Configuration cluster 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_zcl_shade_configuration(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_) +{ + return tvb_captured_length(tvb); +} /*dissect_zbee_zcl_shade_configuration*/ + + +/** + *This function is called by ZCL foundation dissector in order to decode + * + *@param tree pointer to data tree Wireshark uses to display packet. + *@param tvb pointer to buffer containing raw packet. + *@param offset pointer to buffer offset + *@param attr_id attribute identifier + *@param data_type attribute data type +*/ +void +dissect_zcl_shade_configuration_attr_data(proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 attr_id, guint data_type) +{ + static const int * shade_config_status[] = { + &hf_zbee_zcl_shade_configuration_status_shade_operational, + &hf_zbee_zcl_shade_configuration_status_shade_adjusting, + &hf_zbee_zcl_shade_configuration_status_shade_direction, + &hf_zbee_zcl_shade_configuration_status_motor_forward_direction, + NULL + }; + + /* Dissect attribute data type and data */ + switch (attr_id) { + + case ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_STATUS: + proto_tree_add_bitmask(tree, tvb, *offset, hf_zbee_zcl_shade_configuration_status, ett_zbee_zcl_shade_configuration_status, shade_config_status, ENC_LITTLE_ENDIAN); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MODE: + proto_tree_add_item(tree, hf_zbee_zcl_shade_configuration_mode, tvb, *offset, 1, ENC_NA); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT: + case ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE: + case ZBEE_ZCL_ATTR_ID_SHADE_CONFIGURATION_CLOSED_LIMIT: + default: + dissect_zcl_attr_data(tvb, tree, offset, data_type); + break; + } + +} /*dissect_zcl_shade_configuration_attr_data*/ + + +/** + *ZigBee ZCL Shade Configuration cluster protocol registration routine. + * +*/ +void +proto_register_zbee_zcl_shade_configuration(void) +{ + /* Setup list of header fields */ + static hf_register_info hf[] = { + + { &hf_zbee_zcl_shade_configuration_attr_id, + { "Attribute", "zbee_zcl_closures.shade_configuration.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_shade_configuration_attr_names), + 0x00, NULL, HFILL } }, + + /* start Shade Configuration Status fields */ + { &hf_zbee_zcl_shade_configuration_status, + { "Shade Configuration Status", "zbee_zcl_closures.shade_configuration.attr.status", FT_UINT8, BASE_HEX, NULL, + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_shade_configuration_status_shade_operational, + { "Shade Operational", "zbee_zcl_closures.shade_configuration.attr.status.shade_operational", FT_BOOLEAN, 8, TFS(&tfs_no_yes), + ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_OPERATIONAL, NULL, HFILL } }, + + { &hf_zbee_zcl_shade_configuration_status_shade_adjusting, + { "Shade Adjusting", "zbee_zcl_closures.shade_configuration.attr.status.shade_adjusting", FT_BOOLEAN, 8, TFS(&tfs_no_yes), + ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_ADJUSTING, NULL, HFILL } }, + + { &hf_zbee_zcl_shade_configuration_status_shade_direction, + { "Shade Direction", "zbee_zcl_closures.shade_configuration.attr.status.shade_direction", FT_UINT8, 8, VALS(zbee_zcl_shade_configuration_shade_motor_direction_names), + ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_SHADE_DIRECTION, NULL, HFILL } }, + + { &hf_zbee_zcl_shade_configuration_status_motor_forward_direction, + { "Motor Forward Direction", "zbee_zcl_closures.shade_configuration.attr.status.motor_forward_direction", FT_UINT8, 8, VALS(zbee_zcl_shade_configuration_shade_motor_direction_names), + ZBEE_ZCL_SHADE_CONFIGURATION_STATUS_MOTOR_FORWARD_DIRECTION, NULL, HFILL } }, + /* end Shade Configuration Status fields */ + + { &hf_zbee_zcl_shade_configuration_mode, + { "Mode", "zbee_zcl_closures.shade_configuration.attr.mode", FT_UINT8, BASE_HEX, VALS(zbee_zcl_shade_configuration_mode_names), + 0x00, NULL, HFILL } } + }; + + /* ZCL Shade Configuration subtrees */ + static gint *ett[ZBEE_ZCL_SHADE_CONFIGURATION_NUM_ETT]; + + ett[0] = &ett_zbee_zcl_shade_configuration; + ett[1] = &ett_zbee_zcl_shade_configuration_status; + + /* Register the ZigBee ZCL Shade Configuration cluster protocol name and description */ + proto_zbee_zcl_shade_configuration = proto_register_protocol("ZigBee ZCL Shade Configuration", "ZCL Shade Configuration", ZBEE_PROTOABBREV_ZCL_SHADE_CONFIG); + proto_register_field_array(proto_zbee_zcl_shade_configuration, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + /* Register the ZigBee ZCL Shade Configuration dissector. */ + register_dissector(ZBEE_PROTOABBREV_ZCL_SHADE_CONFIG, dissect_zbee_zcl_shade_configuration, proto_zbee_zcl_shade_configuration); +} /*proto_register_zbee_zcl_shade_configuration*/ + +/** + *Hands off the ZCL Shade Configuration dissector. + * +*/ +void +proto_reg_handoff_zbee_zcl_shade_configuration(void) +{ + dissector_handle_t shade_config_handle; + + /* Register our dissector with the ZigBee application dissectors. */ + shade_config_handle = find_dissector(ZBEE_PROTOABBREV_ZCL_SHADE_CONFIG); + dissector_add_uint("zbee.zcl.cluster", ZBEE_ZCL_CID_SHADE_CONFIG, shade_config_handle); + + zbee_zcl_init_cluster( proto_zbee_zcl_shade_configuration, + ett_zbee_zcl_shade_configuration, + ZBEE_ZCL_CID_SHADE_CONFIG, + hf_zbee_zcl_shade_configuration_attr_id, + -1, -1, + (zbee_zcl_fn_attr_data)dissect_zcl_shade_configuration_attr_data + ); +} /*proto_reg_handoff_zbee_zcl_shade_configuration*/ + + +/* ########################################################################## */ +/* #### (0x0101) DOOR LOCK CLUSTER ########################################## */ +/* ########################################################################## */ + +/*************************/ +/* Defines */ +/*************************/ + +#define ZBEE_ZCL_DOOR_LOCK_NUM_ETT 1 + +/* Attributes */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_STATE 0x0000 /* Lock State */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_TYPE 0x0001 /* Lock Type */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_ACTUATOR_ENABLED 0x0002 /* Actuator Enabled */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_STATE 0x0003 /* Door State */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_OPEN_EVENTS 0x0004 /* Door Open Events */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS 0x0005 /* Door Closed Events */ +#define ZBEE_ZCL_ATTR_ID_DOOR_LOCK_OPEN_PERIOD 0x0006 /* Open Period */ + +/* Server Commands Received */ +#define ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR 0x00 /* Lock Door */ +#define ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR 0x01 /* Unlock Door */ + +/* Server Commands Generated */ +#define ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR_RESPONSE 0x00 /* Lock Door Response */ +#define ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR_RESPONSE 0x01 /* Unlock Door Response */ + + +/*************************/ +/* Function Declarations */ +/*************************/ + +void proto_register_zbee_zcl_door_lock(void); +void proto_reg_handoff_zbee_zcl_door_lock(void); + +/* Command Dissector Helpers */ +static void dissect_zcl_door_lock_lock_unlock_door_response (tvbuff_t *tvb, proto_tree *tree, guint *offset); + +static void dissect_zcl_door_lock_attr_data (proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 attr_id, guint data_type); + +/* Private functions prototype */ + +/*************************/ +/* Global Variables */ +/*************************/ +/* Initialize the protocol and registered fields */ +static int proto_zbee_zcl_door_lock = -1; + +static int hf_zbee_zcl_door_lock_attr_id = -1; +static int hf_zbee_zcl_door_lock_lock_state = -1; +static int hf_zbee_zcl_door_lock_lock_type = -1; +static int hf_zbee_zcl_door_lock_door_state = -1; +static int hf_zbee_zcl_door_lock_actuator_enabled = -1; +static int hf_zbee_zcl_door_lock_status = -1; +static int hf_zbee_zcl_door_lock_srv_rx_cmd_id = -1; +static int hf_zbee_zcl_door_lock_srv_tx_cmd_id = -1; + +/* Initialize the subtree pointers */ +static gint ett_zbee_zcl_door_lock = -1; + +/* Attributes */ +static const value_string zbee_zcl_door_lock_attr_names[] = { + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_STATE, "Lock State" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_TYPE, "Lock Type" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_ACTUATOR_ENABLED, "Actuator Enabled" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_STATE, "Door State" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_OPEN_EVENTS, "Door Open Events" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS, "Door Closed Events" }, + { ZBEE_ZCL_ATTR_ID_DOOR_LOCK_OPEN_PERIOD, "Open Period" }, + { 0, NULL } +}; + +/* Server Commands Received */ +static const value_string zbee_zcl_door_lock_srv_rx_cmd_names[] = { + { ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR, "Lock Door" }, + { ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR, "Unlock Door" }, + { 0, NULL } +}; + +/* Server Commands Generated */ +static const value_string zbee_zcl_door_lock_srv_tx_cmd_names[] = { + { ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR_RESPONSE, "Lock Door Response" }, + { ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR_RESPONSE, "Unlock Door Response" }, + { 0, NULL } +}; + +/* Lock State Values */ +static const value_string zbee_zcl_door_lock_lock_state_values[] = { + { 0x00, "Not Fully Locked" }, + { 0x01, "Locked" }, + { 0x02, "Unlocked" }, + { 0, NULL } +}; + +/* Lock Type Values */ +static const value_string zbee_zcl_door_lock_lock_type_values[] = { + { 0x00, "Deadbolt" }, + { 0x01, "Magnetic" }, + { 0x02, "Other" }, + { 0, NULL } +}; + +/* Door State Values */ +static const value_string zbee_zcl_door_lock_door_state_values[] = { + { 0x00, "Open" }, + { 0x01, "Closed" }, + { 0x02, "Error (Jammed)" }, + { 0x03, "Error (Forced Open)" }, + { 0x04, "Error (Unspecified)" }, + { 0, NULL } +}; + + +/*************************/ +/* Function Bodies */ +/*************************/ + +/** + *ZigBee ZCL Door Lock cluster 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_zcl_door_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) +{ + proto_tree *payload_tree; + zbee_zcl_packet *zcl; + guint offset = 0; + guint8 cmd_id; + gint rem_len; + + /* Reject the packet if data is NULL */ + if (data == NULL) + return 0; + zcl = (zbee_zcl_packet *)data; + cmd_id = zcl->cmd_id; + + /* Create a subtree for the ZCL Command frame, and add the command ID to it. */ + if (zcl->direction == ZBEE_ZCL_FCF_TO_SERVER) { + /* Append the command name to the info column. */ + col_append_fstr(pinfo->cinfo, COL_INFO, "%s, Seq: %u", + val_to_str_const(cmd_id, zbee_zcl_door_lock_srv_rx_cmd_names, "Unknown Command"), + zcl->tran_seqno); + + /* Add the command ID. */ + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_srv_rx_cmd_id, tvb, offset, 1, cmd_id); + + /* Check if this command has a payload, then add the payload tree */ + rem_len = tvb_reported_length_remaining(tvb, ++offset); + if (rem_len > 0) { + payload_tree = proto_tree_add_subtree(tree, tvb, offset, rem_len, ett_zbee_zcl_door_lock, NULL, "Payload"); + + /* Call the appropriate command dissector */ + switch (cmd_id) { + case ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR: + case ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR: + /* No Payload */ + default: + break; + } + } + } + else { /* ZBEE_ZCL_FCF_TO_CLIENT */ + /* Append the command name to the info column. */ + col_append_fstr(pinfo->cinfo, COL_INFO, "%s, Seq: %u", + val_to_str_const(cmd_id, zbee_zcl_door_lock_srv_tx_cmd_names, "Unknown Command"), + zcl->tran_seqno); + + /* Add the command ID. */ + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_srv_tx_cmd_id, tvb, offset, 1, cmd_id); + + /* Check if this command has a payload, then add the payload tree */ + rem_len = tvb_reported_length_remaining(tvb, ++offset); + if (rem_len > 0) { + payload_tree = proto_tree_add_subtree(tree, tvb, offset, rem_len, ett_zbee_zcl_door_lock, NULL, "Payload"); + + /* Call the appropriate command dissector */ + switch (cmd_id) { + case ZBEE_ZCL_CMD_ID_DOOR_LOCK_LOCK_DOOR_RESPONSE: + case ZBEE_ZCL_CMD_ID_DOOR_LOCK_UNLOCK_DOOR_RESPONSE: + dissect_zcl_door_lock_lock_unlock_door_response(tvb, payload_tree, &offset); + break; + + default: + break; + } + } + } + + return tvb_captured_length(tvb); +} /*dissect_zbee_zcl_door_lock*/ + + +/** + *This function decodes the lock and unlock door response + * + *@param tvb the tv buffer of the current data_type + *@param tree the tree to append this item to + *@param offset offset of data in tvb +*/ +static void +dissect_zcl_door_lock_lock_unlock_door_response(tvbuff_t *tvb, proto_tree *tree, guint *offset) +{ + /* Retrieve "Status" field */ + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_status, tvb, *offset, 1, ENC_LITTLE_ENDIAN); + *offset += 1; + +} /*dissect_zcl_door_lock_lock_unlock_door_response*/ + + +/** + *This function is called by ZCL foundation dissector in order to decode + * + *@param tree pointer to data tree Wireshark uses to display packet. + *@param tvb pointer to buffer containing raw packet. + *@param offset pointer to buffer offset + *@param attr_id attribute identifier + *@param data_type attribute data type +*/ +void +dissect_zcl_door_lock_attr_data(proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 attr_id, guint data_type) +{ + /* Dissect attribute data type and data */ + switch ( attr_id ) { + + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_STATE: + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_lock_state, tvb, *offset, 1, ENC_LITTLE_ENDIAN); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_LOCK_TYPE: + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_lock_type, tvb, *offset, 1, ENC_LITTLE_ENDIAN); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_ACTUATOR_ENABLED: + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_actuator_enabled, tvb, *offset, 1, ENC_LITTLE_ENDIAN); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_STATE: + proto_tree_add_item(tree, hf_zbee_zcl_door_lock_door_state, tvb, *offset, 1, ENC_LITTLE_ENDIAN); + *offset += 1; + break; + + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_OPEN_EVENTS: + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS: + case ZBEE_ZCL_ATTR_ID_DOOR_LOCK_OPEN_PERIOD: + default: + dissect_zcl_attr_data(tvb, tree, offset, data_type); + break; + } + +} /*dissect_zcl_door_lock_attr_data*/ + + +/** + *ZigBee ZCL Door Lock cluster protocol registration routine. + * +*/ +void +proto_register_zbee_zcl_door_lock(void) +{ + /* Setup list of header fields */ + static hf_register_info hf[] = { + + { &hf_zbee_zcl_door_lock_attr_id, + { "Attribute", "zbee_zcl_closures.door_lock.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_door_lock_attr_names), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_lock_state, + { "Lock State", "zbee_zcl_closures.door_lock.attr.lock_state", FT_UINT8, BASE_HEX, VALS(zbee_zcl_door_lock_lock_state_values), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_lock_type, + { "Lock Type", "zbee_zcl_closures.door_lock.attr.lock_type", FT_UINT8, BASE_HEX, VALS(zbee_zcl_door_lock_lock_type_values), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_door_state, + { "Door State", "zbee_zcl_closures.door_lock.attr.door_state", FT_UINT8, BASE_HEX, VALS(zbee_zcl_door_lock_door_state_values), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_actuator_enabled, + { "Actuator enabled", "zbee_zcl_closures.door_lock.attr.actuator_enabled", FT_BOOLEAN, 8, TFS(&tfs_disabled_enabled), + 0x01, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_status, + { "Lock Status", "zbee_zcl_closures.door_lock.status", FT_UINT8, BASE_HEX, VALS(zbee_zcl_status_names), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_srv_rx_cmd_id, + { "Command", "zbee_zcl_closures.door_lock.cmd.srv_rx.id", FT_UINT8, BASE_HEX, VALS(zbee_zcl_door_lock_srv_rx_cmd_names), + 0x00, NULL, HFILL } }, + + { &hf_zbee_zcl_door_lock_srv_tx_cmd_id, + { "Command", "zbee_zcl_closures.door_lock.cmd.srv_tx.id", FT_UINT8, BASE_HEX, VALS(zbee_zcl_door_lock_srv_tx_cmd_names), + 0x00, NULL, HFILL } } + + }; + + /* ZCL Door Lock subtrees */ + static gint *ett[ZBEE_ZCL_DOOR_LOCK_NUM_ETT]; + ett[0] = &ett_zbee_zcl_door_lock; + + /* Register the ZigBee ZCL Door Lock cluster protocol name and description */ + proto_zbee_zcl_door_lock = proto_register_protocol("ZigBee ZCL Door Lock", "ZCL Door Lock", ZBEE_PROTOABBREV_ZCL_DOOR_LOCK); + proto_register_field_array(proto_zbee_zcl_door_lock, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + /* Register the ZigBee ZCL Door Lock dissector. */ + register_dissector(ZBEE_PROTOABBREV_ZCL_DOOR_LOCK, dissect_zbee_zcl_door_lock, proto_zbee_zcl_door_lock); + +} /*proto_register_zbee_zcl_door_lock*/ + + +/** + *Hands off the ZCL Door Lock dissector. + * +*/ +void +proto_reg_handoff_zbee_zcl_door_lock(void) +{ + dissector_handle_t door_lock_handle; + + /* Register our dissector with the ZigBee application dissectors. */ + door_lock_handle = find_dissector(ZBEE_PROTOABBREV_ZCL_DOOR_LOCK); + dissector_add_uint("zbee.zcl.cluster", ZBEE_ZCL_CID_DOOR_LOCK, door_lock_handle); + + zbee_zcl_init_cluster( proto_zbee_zcl_door_lock, + ett_zbee_zcl_door_lock, + ZBEE_ZCL_CID_DOOR_LOCK, + hf_zbee_zcl_door_lock_attr_id, + hf_zbee_zcl_door_lock_srv_rx_cmd_id, + hf_zbee_zcl_door_lock_srv_tx_cmd_id, + (zbee_zcl_fn_attr_data)dissect_zcl_door_lock_attr_data + ); +} /*proto_reg_handoff_zbee_zcl_door_lock*/ + +/* + * Editor modelines - http://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ diff --git a/epan/dissectors/packet-zbee.h b/epan/dissectors/packet-zbee.h index 058595843c..f14aecf51b 100644 --- a/epan/dissectors/packet-zbee.h +++ b/epan/dissectors/packet-zbee.h @@ -1152,6 +1152,8 @@ #define ZBEE_PROTOABBREV_ZCL_KE "zbee_zcl_se.ke" #define ZBEE_PROTOABBREV_ZCL_MSG "zbee_zcl_se.msg" #define ZBEE_PROTOABBREV_ZCL_TUN "zbee_zcl_se.tun" +#define ZBEE_PROTOABBREV_ZCL_SHADE_CONFIG "zbee_zcl_closures.shade_config" +#define ZBEE_PROTOABBREV_ZCL_DOOR_LOCK "zbee_zcl_closures.door_lock" /* Helper Functions */ extern guint zbee_get_bit_field(guint input, guint mask); -- cgit v1.2.3