diff options
author | JimSchaettle <jimschaettle@gmail.com> | 2020-02-24 19:18:04 -0600 |
---|---|---|
committer | Anders Broman <a.broman58@gmail.com> | 2020-03-18 11:15:54 +0000 |
commit | 04d2d01d988cfeef0ca0b239dd8ee952adba2fda (patch) | |
tree | ef6b51c82450a4f9223803153f24348080f335ae | |
parent | 3d8cf862cc782b50c463bdbe47fdb71caf96e586 (diff) |
Added RDMnet protocol
Transmit RDM packet over Ethernet using ACN protocol.
http://rdmprotocol.org/rdm/rdmnet/
Change-Id: I5bc1819e05b0d7a3c207b57cf2d86dc08aa9d1c3
Reviewed-on: https://code.wireshark.org/review/36194
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>
-rw-r--r-- | epan/dissectors/packet-acn.c | 3605 | ||||
-rw-r--r-- | epan/dissectors/packet-rdm.c | 8579 |
2 files changed, 9252 insertions, 2932 deletions
diff --git a/epan/dissectors/packet-acn.c b/epan/dissectors/packet-acn.c index e91d9a4fb3..3d92c98f08 100644 --- a/epan/dissectors/packet-acn.c +++ b/epan/dissectors/packet-acn.c @@ -33,6 +33,9 @@ #include <epan/to_str.h> #include <epan/expert.h> +#include "packet-rdm.h" +#include "packet-tcp.h" + /* Forward declarations */ void proto_register_acn(void); void proto_reg_handoff_acn(void); @@ -74,17 +77,21 @@ void proto_reg_handoff_acn(void); #define ACN_DMP_ADT_A_4 2 #define ACN_DMP_ADT_A_R 3 -#define ACN_PROTOCOL_ID_SDT 1 -#define ACN_PROTOCOL_ID_DMP 2 -#define ACN_PROTOCOL_ID_DMX 3 -#define ACN_PROTOCOL_ID_DMX_2 4 +#define ACN_PROTOCOL_ID_SDT 0x00000001 +#define ACN_PROTOCOL_ID_DMP 0x00000002 +#define ACN_PROTOCOL_ID_DMX 0x00000003 +#define ACN_PROTOCOL_ID_DMX_2 0x00000004 +#define ACN_PROTOCOL_ID_RPT 0x00000005 +#define ACN_PROTOCOL_ID_BROKER 0x00000009 +#define ACN_PROTOCOL_ID_LLRP 0x0000000A +#define ACN_PROTOCOL_ID_EPT 0x0000000B #define ACN_ADDR_NULL 0 #define ACN_ADDR_IPV4 1 #define ACN_ADDR_IPV6 2 #define ACN_ADDR_IPPORT 3 -/* STD Messages */ +/* SDT Messages */ #define ACN_SDT_VECTOR_UNKNOWN 0 #define ACN_SDT_VECTOR_REL_WRAP 1 #define ACN_SDT_VECTOR_UNREL_WRAP 2 @@ -173,6 +180,9 @@ void proto_reg_handoff_acn(void); #define ACN_BLOB_DHCP_CONFIG_STATIC_ROUTE 28 #define ACN_BLOB_ENERGY_MANAGEMENT 29 #define ACN_BLOB_TIME3 30 +#define ACN_BLOB_ENERGY_COST 31 +#define ACN_BLOB_SEQUENCE_OPERATIONS 32 +#define ACN_BLOB_SEQUENCE_STEP_PROPERTIES 33 #define ACN_BLOB_PRESET_PROPERTIES 250 @@ -240,13 +250,173 @@ void proto_reg_handoff_acn(void); #define V2_CMD_PHYSICAL_BEACON_BY_CID 12 #define V2_CMD_NET2_DOWNLOAD 110163 -#define MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE 0 -#define MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE 1 +#define MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE 0 +#define MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE 1 #define MAGIC_DYNAMIC_IP_MAINTAIN_LEASE 0 #define MAGIC_DYNAMIC_IP_RESET_LEASE 1 #define MAGIC_STATIC_IP 2 +/* E1.33 Table A-1 Broadcast UID Defines */ +#define ACN_RPT_ALL_CONTROLLERS 0xFFFCFFFFFFFF +#define ACN_RPT_ALL_DEVICES 0xFFFDFFFFFFFF +#define ACN_RPT_ALL_MID_DEVICES 0xFFFDmmmmFFFF /*Addresses all Devices with the specific Manufacturer ID 0xmmmm*/ + +/* E1.33 Table A-2 LLRP Constants */ +#define ACN_LLRP_MULTICAST_IPV4_ADDRESS_REQUEST 239.255.250.133 +#define ACN_LLRP_MULTICAST_IPV4_ADDRESS_RESPONSE 239.255.250.134 +#define ACN_LLRP_MULTICAST_IPV6_ADDRESS_REQUEST ff18::85:0:0:85 +#define ACN_LLRP_MULTICAST_IPV6_ADDRESS_RESPONSE ff18::85:0:0:86 +#define ACN_LLRP_PORT 5569 +#define ACN_LLRP_TIMEOUT 2 /*seconds*/ +#define ACN_LLRP_TARGET_TIMEOUT 500 /*milliseconds*/ +#define ACN_LLRP_MAX_BACKOFF 1.5 /*seconds*/ +#define ACN_LLRP_KNOWN_UID_SIZE 200 +#define ACN_LLRP_BROADCAST_CID FBAD822C-BD0C-4D4C-BDC8-7EABEBC85AFF + +/* E1.33 Table A-3 Vector Defines for Root Layer PDU */ +/* (already defined above) + * #define ACN_PDU_VECTOR_ROOT_LLRP 0x0000000A + * #define ACN_PDU_VECTOR_ROOT_RPT 0x00000005 + * #define ACN_PDU_VECTOR_ROOT_BROKER 0x00000009 + * #define ACN_PDU_VECTOR_ROOT_EPT 0x0000000B + */ + +/* E1.33 Table A-4 LLRP Messages */ +#define RDMNET_LLRP_VECTOR_PROBE_REQUEST 0x00000001 +#define RDMNET_LLRP_VECTOR_PROBE_REPLY 0x00000002 +#define RDMNET_LLRP_VECTOR_RDM_CMD 0x00000003 + +#define RDMNET_LLRP_VECTOR_PROBE_REQUEST_CLIENT_TCP_INACTIVE 0x01 +#define RDMNET_LLRP_VECTOR_PROBE_REQUEST_BROKERS_ONLY 0x02 + +#define RDMNET_LLRP_VECTOR_RDM_CMD_START_CODE 0xCC + +/* E1.33 Table A-5 LLRP Probe Request Messages */ +#define VECTOR_PROBE_REQUEST_DATA 0x01 + +/* E1.33 Table A-6 LLRP Probe Reply Messages */ +#define VECTOR_PROBE_REPLY_DATA 0x01 + +/* E1.33 Table A-7 Broker Messages */ +#define RDMNET_BROKER_VECTOR_CONNECT 0x0001 +#define RDMNET_BROKER_VECTOR_CONNECT_REPLY 0x0002 +#define RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE 0x0003 +#define RDMNET_BROKER_VECTOR_REDIRECT_V4 0x0004 +#define RDMNET_BROKER_VECTOR_REDIRECT_V6 0x0005 +#define RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST 0x0006 +#define RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST 0x0007 +#define RDMNET_BROKER_VECTOR_CLIENT_ADD 0x0008 +#define RDMNET_BROKER_VECTOR_CLIENT_REMOVE 0x0009 +#define RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE 0x000A +#define RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS 0x000B +#define RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS 0x000C +#define RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST 0x000D +#define RDMNET_BROKER_VECTOR_DISCONNECT 0x000E +#define RDMNET_BROKER_VECTOR_NULL 0x000F + +#define RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES 0x01 + +/* E1.33 Table A-8 RPT Messages */ +#define RDMNET_RPT_VECTOR_REQUEST 0x00000001 +#define RDMNET_RPT_VECTOR_STATUS 0x00000002 +#define RDMNET_RPT_VECTOR_NOTIFICATION 0x00000003 + +/* E1.33 Table A-9 RPT Request PDUs */ +#define RDMNET_RPT_VECTOR_REQUEST_RDM_CMD 0x01 + +/* E1.33 Table A-10 RPT Status PDUs */ +#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID 0x0001 +#define RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT 0x0002 +#define RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE 0x0003 +#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID 0x0004 +#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT 0x0005 +#define RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE 0x0006 +#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR 0x0007 +#define RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE 0x0008 +#define RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS 0x0009 + +/* E1.33 Table A-11 RPT Notification PDUs */ +#define RDMNET_RPT_VECTOR_NOTIFICATION_RDM_CMD 0x01 + +/* E1.33 Table A-12 RDM Command PDUs */ +#define RDMNET_RPT_VECTOR_RDM_CMD_RD_DATA 0xCC + +/* E1.33 Table A-13 EPT PDUs */ +#define RDMNET_EPT_VECTOR_DATA 0x00000001 +#define RDMNET_EPT_VECTOR_STATUS 0x00000002 + +/* E1.33 Table A-14 EPT Status PDUs */ +#define RDMNET_EPT_VECTOR_UNKNOWN_CID 0x0001 +#define RDMNET_EPT_VECTOR_UNKNOWN_VECTOR 0x0002 + +/* E1.33 Table A-15 RDM Parameter IDs (only used in packet-rdm.c) */ + +/* E1.33 Table A-16 RDM NACK Reason Codes (only used in packet-rdm.c) */ + +/* E1.33 Table A-17 Static Config Types for Component Scope Messages (only used in packet-rdm.c) */ + +/* E1.33 Table A-18 Broker States for Broker Status Messages (only used in packet-rdm.c) */ + +/* E1.33 Table A-19 Connection Status Codes for Broker Connect */ +#define RDMNET_BROKER_CONNECT_OK 0x0000 +#define RDMNET_BROKER_CONNECT_SCOPE_MISMATCH 0x0001 +#define RDMNET_BROKER_CONNECT_CAPACITY_EXCEEDED 0x0002 +#define RDMNET_BROKER_CONNECT_DUPLICATE_UID 0x0003 +#define RDMNET_BROKER_CONNECT_INVALID_CLIENT_ENTRY 0x0004 +#define RDMNET_BROKER_CONNECT_INVALID_UID 0x0005 + +/* E1.33 Table A-20 Status Codes for Dynamic UID Mapping*/ +#define RDMNET_DYNAMIC_UID_STATUS_OK 0x0000 +#define RDMNET_DYNAMIC_UID_STATUS_INVALID_REQUEST 0x0001 +#define RDMNET_DYNAMIC_UID_STATUS_UID_NOT_FOUND 0x0002 +#define RDMNET_DYNAMIC_UID_STATUS_DUPLICATE_RID 0x0003 +#define RDMNET_DYNAMIC_UID_STATUS_CAPACITY_EXHAUSTED 0x0004 + +/* E1.33 Table A-21 Client Protocol Codes */ +#define RDMNET_CLIENT_PROTOCOL_RPT 0x00000005 +#define RDMNET_CLIENT_PROTOCOL_EPT 0x0000000B + +/* E1.33 Table A-22 RPT Client Type Codes */ +#define RDMNET_RPT_CLIENT_TYPE_DEVICE 0x00 +#define RDMNET_RPT_CLIENT_TYPE_CONTROLLER 0x01 + +/* E1.33 Table A-23 LLRP Component Type Codes - LLRP TARGETS */ +#define RDMNET_LLRP_COMPONENT_TYPE_RPT_DEVICE 0x00 /* Target is a Device */ +#define RDMNET_LLRP_COMPONENT_TYPE_RPT_CONTROLLER 0x01 /* Target is a Controller */ +#define RDMNET_LLRP_COMPONENT_TYPE_BROKER 0x02 /* Target is a Broker */ +#define RDMNET_LLRP_COMPONENT_TYPE_NON_RDMNET 0xFF /* Target does not implement RDMnet other than LLRP */ + +/* E1.33 Table A-24 RPT Client Disconnect Reason Codes */ +#define RDMNET_RPT_DISCONNECT_SHUTDOWN 0x0000 /* Sent by Components to indicate that they are */ + /* about to shut down. */ +#define RDMNET_RPT_DISCONNECT_CAPACITY_EXHAUSTED 0x0001 /* Sent by Components when they do not */ + /* have the ability to support this connection. */ + /* Note that a Component must reserve certain */ + /* resources to be able to send this message */ + /* when it is in such a state. */ +#define RDMNET_RPT_DISCONNECT_HARDWARE_FAULT 0x0002 /* Sent by Components which must terminate a */ + /* connection due to an internal hardware fault */ +#define RDMNET_RPT_DISCONNECT_SOFTWARE_FAULT 0x0003 /* Sent by Components which must terminate a */ + /* connection due to a software fault. */ +#define RDMNET_RPT_DISCONNECT_SOFTWARE_RESET 0x0004 /* Sent by Components which must terminate a */ + /* connection because of a software reset. */ + /* This message should not be sent in the case */ + /* of a reboot, as the Shutdown message */ + /* is preferred. */ +#define RDMNET_RPT_DISCONNECT_INCORRECT_SCOPE 0x0005 /* Sent by Brokers that are not on the */ + /* desired Scope. */ +#define RDMNET_RPT_DISCONNECT_RPT_RECONFIGURE 0x0006 /* Sent by components which must terminate a */ + /* connection because they were reconfigured */ + /* using RPT */ +#define RDMNET_RPT_DISCONNECT_LLRP_RECONFIGURE 0x0007 /* Sent by Components which must terminate a */ + /* connection because they were reconfigured */ + /* using LLRP. */ +#define RDMNET_RPT_DISCONNECT_USER_RECONFIGURE 0x0008 /* Sent by Components which must terminate a */ + /* connection because they were reconfigured */ + /* through some means outside the scope of this */ + /* standard (i.e. front panel configuration) */ + typedef struct { guint32 start; @@ -270,12 +440,14 @@ typedef struct * See * ANSI BSR E1.17 Architecture for Control Networks * ANSI BSR E1.31 + * ANSI BSR E1.33 RDMnet */ #define ACTUAL_ADDRESS 0 /* forward reference */ static guint32 acn_add_address(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, const char *label); static int dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static int dissect_rdmnet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 data_offset, gboolean is_udp); /* Global variables */ static int proto_acn = -1; @@ -292,11 +464,35 @@ static gint ett_acn_sdt_pdu = -1; static gint ett_acn_sdt_client_pdu = -1; static gint ett_acn_sdt_base_pdu = -1; static gint ett_acn_root_pdu = -1; + static gint ett_acn_dmx_address = -1; static gint ett_acn_dmx_2_options = -1; static gint ett_acn_dmx_data_pdu = -1; static gint ett_acn_dmx_pdu = -1; +static gint ett_rdmnet_pdu_flags = -1; +static gint ett_rdmnet_llrp_base_pdu = -1; +static gint ett_rdmnet_llrp_probe_request_pdu = -1; +static gint ett_rdmnet_llrp_probe_request_filter_flags = -1; +static gint ett_rdmnet_llrp_probe_reply_pdu = -1; +static gint ett_rdmnet_llrp_rdm_command_pdu = -1; + +static gint ett_rdmnet_broker_base_pdu = -1; +static gint ett_rdmnet_broker_client_entry_pdu = -1; +static gint ett_rdmnet_broker_client_entry_manufacturer_protocol_ids = -1; +static gint ett_rdmnet_broker_connect_connection_flags = -1; +static gint ett_rdmnet_broker_client_entry_update_connection_flags = -1; + +static gint ett_rdmnet_rpt_base_pdu = -1; +static gint ett_rdmnet_rpt_request_pdu = -1; +static gint ett_rdmnet_rpt_status_pdu = -1; +static gint ett_rdmnet_rpt_notification_pdu = -1; + +static gint ett_rdmnet_ept_base_pdu = -1; +static gint ett_rdmnet_ept_data_pdu = -1; +static gint ett_rdmnet_ept_data_vector_pdu = -1; +static gint ett_rdmnet_ept_status_pdu = -1; + /* Register fields */ /* In alphabetical order */ static int hf_acn_association = -1; @@ -379,6 +575,7 @@ static int hf_acn_reliable_sequence_number = -1; static int hf_acn_adhoc_expiry = -1; /* static int hf_acn_sdt_pdu = -1; */ static int hf_acn_sdt_vector = -1; + static int hf_acn_dmx_vector = -1; /* static int hf_acn_session_count = -1; */ static int hf_acn_total_sequence_number = -1; @@ -407,7 +604,6 @@ static gint global_acn_dmx_display_line_format = 0; static gboolean global_acn_dmx_display_zeros = FALSE; static gboolean global_acn_dmx_display_leading_zeros = FALSE; - static int proto_magic = -1; static gint ett_magic = -1; @@ -443,11 +639,119 @@ static int hf_magic_reply_dcid = -1; static expert_field ei_magic_reply_invalid_type = EI_INIT; + +static int proto_rdmnet = -1; +static gint ett_rdmnet = -1; + +/* Register fields */ +static int hf_rdmnet_cid = -1; +static int hf_rdmnet_packet_identifier = -1; +static int hf_rdmnet_pdu = -1; +static int hf_rdmnet_pdu_flag_d = -1; +static int hf_rdmnet_pdu_flag_h = -1; +static int hf_rdmnet_pdu_flag_l = -1; +static int hf_rdmnet_pdu_flag_v = -1; +static int hf_rdmnet_pdu_flags = -1; +static int hf_rdmnet_pdu_length = -1; +static int hf_rdmnet_postamble_size = -1; +static int hf_rdmnet_preamble_size = -1; +static int hf_rdmnet_protocol_id = -1; +static int hf_rdmnet_tcp_length = -1; + +static int hf_rdmnet_llrp_vector = -1; +static int hf_rdmnet_llrp_destination_cid = -1; +static int hf_rdmnet_llrp_transaction_number = -1; +static int hf_rdmnet_llrp_probe_request_vector = -1; +static int hf_rdmnet_llrp_probe_request_pdu_length = -1; +static int hf_rdmnet_llrp_probe_request_lower_uid = -1; +static int hf_rdmnet_llrp_probe_request_upper_uid = -1; +static int hf_rdmnet_llrp_probe_request_filter = -1; +static int hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive = -1; +static int hf_rdmnet_llrp_probe_request_filter_brokers_only = -1; +static int hf_rdmnet_llrp_probe_request_known_uid = -1; + +static int hf_rdmnet_llrp_probe_reply_vector = -1; +static int hf_rdmnet_llrp_probe_reply_uid = -1; +static int hf_rdmnet_llrp_probe_reply_hardware_address = -1; +static int hf_rdmnet_llrp_probe_reply_component_type = -1; +static int hf_rdmnet_llrp_rdm_command_start_code = -1; + +static int hf_rdmnet_rpt_vector = -1; +static int hf_rdmnet_rpt_source_uid = -1; +static int hf_rdmnet_rpt_source_endpoint_id = -1; +static int hf_rdmnet_rpt_destination_uid = -1; +static int hf_rdmnet_rpt_destination_endpoint_id = -1; +static int hf_rdmnet_rpt_sequence_number = -1; +static int hf_rdmnet_rpt_reserved = -1; +static int hf_rdmnet_rpt_request_vector = -1; +static int hf_rdmnet_rpt_request_rdm_command = -1; +static int hf_rdmnet_rpt_status_vector = -1; +static int hf_rdmnet_rpt_status_unknown_rpt_uid_string = -1; +static int hf_rdmnet_rpt_status_rdm_timeout_string = -1; +static int hf_rdmnet_rpt_status_rdm_invalid_response_string = -1; +static int hf_rdmnet_rpt_status_unknown_rdm_uid_string = -1; +static int hf_rdmnet_rpt_status_unknown_endpoint_string = -1; +static int hf_rdmnet_rpt_status_broadcast_complete_string = -1; +static int hf_rdmnet_rpt_status_unknown_vector_string = -1; +static int hf_rdmnet_rpt_notification_vector = -1; +static int hf_rdmnet_rpt_notification_rdm_command = -1; + +static int hf_rdmnet_broker_vector = -1; +static int hf_rdmnet_broker_client_protocol_vector = -1; +static int hf_rdmnet_broker_client_protocol_cid = -1; +static int hf_rdmnet_broker_client_rpt_client_uid = -1; +static int hf_rdmnet_broker_client_rpt_client_type = -1; +static int hf_rdmnet_broker_client_rpt_binding_cid = -1; +static int hf_rdmnet_broker_client_ept_protocol_vector = -1; +static int hf_rdmnet_broker_client_ept_protocol_manufacturer_id = -1; +static int hf_rdmnet_broker_client_ept_protocol_protocol_id = -1; +static int hf_rdmnet_broker_client_ept_protocol_string = -1; +static int hf_rdmnet_broker_connect_client_scope = -1; +static int hf_rdmnet_broker_connect_e133_version = -1; +static int hf_rdmnet_broker_connect_search_domain = -1; +static int hf_rdmnet_broker_connect_connection_flags = -1; +static int hf_rdmnet_broker_connect_connection_flags_incremental_updates = -1; +static int hf_rdmnet_broker_connect_reply_connection_code = -1; +static int hf_rdmnet_broker_connect_reply_e133_version = -1; +static int hf_rdmnet_broker_connect_reply_broker_uid = -1; +static int hf_rdmnet_broker_connect_reply_client_uid = -1; +static int hf_rdmnet_broker_client_entry_update_connection_flags = -1; +static int hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates = -1; +static int hf_rdmnet_broker_redirect_ipv4_address = -1; +static int hf_rdmnet_broker_redirect_ipv4_tcp_port = -1; +static int hf_rdmnet_broker_redirect_ipv6_address = -1; +static int hf_rdmnet_broker_redirect_ipv6_tcp_port = -1; +static int hf_rdmnet_broker_disconnect_reason = -1; +static int hf_rdmnet_broker_dynamic_uid_request = -1; +static int hf_rdmnet_broker_rid = -1; +static int hf_rdmnet_broker_assigned_dynamic_uid = -1; +static int hf_rdmnet_broker_assigned_rid = -1; +static int hf_rdmnet_broker_assigned_status_code = -1; +static int hf_rdmnet_broker_fetch_dynamic_uid = -1; + +static int hf_rdmnet_ept_vector = -1; +static int hf_rdmnet_ept_destination_cid = -1; +static int hf_rdmnet_ept_data_pdu_length = -1; +static int hf_rdmnet_ept_data_vector = -1; +static int hf_rdmnet_ept_data_vector_manfacturer_id = -1; +static int hf_rdmnet_ept_data_vector_protocol_id = -1; +static int hf_rdmnet_ept_data_opaque_data = -1; +static int hf_rdmnet_ept_status_pdu_length = -1; +static int hf_rdmnet_ept_status_vector = -1; +static int hf_rdmnet_ept_status_unknown_cid = -1; +static int hf_rdmnet_ept_status_status_string = -1; +static int hf_rdmnet_ept_status_unknown_vector = -1; +static int hf_rdmnet_ept_status_vector_string = -1; + static const value_string acn_protocol_id_vals[] = { - { ACN_PROTOCOL_ID_SDT, "SDT Protocol" }, - { ACN_PROTOCOL_ID_DMP, "DMP Protocol" }, - { ACN_PROTOCOL_ID_DMX, "DMX Protocol" }, - { ACN_PROTOCOL_ID_DMX_2, "Ratified DMX Protocol" }, + { ACN_PROTOCOL_ID_SDT, "SDT Protocol" }, + { ACN_PROTOCOL_ID_DMP, "DMP Protocol" }, + { ACN_PROTOCOL_ID_DMX, "DMX Protocol" }, + { ACN_PROTOCOL_ID_DMX_2, "Ratified DMX Protocol" }, + { ACN_PROTOCOL_ID_RPT, "RDM Packet Transport Protocol" }, + { ACN_PROTOCOL_ID_BROKER, "Broker Protocol" }, + { ACN_PROTOCOL_ID_LLRP, "Low Level Recovery Protocol" }, + { ACN_PROTOCOL_ID_EPT, "Etensible Packet Transport Protocol" }, { 0, NULL }, }; @@ -481,29 +785,29 @@ static const value_string acn_dmp_adt_a_vals[] = { static const value_string acn_sdt_vector_vals[] = { - {ACN_SDT_VECTOR_UNKNOWN, "Unknown"}, - {ACN_SDT_VECTOR_REL_WRAP, "Reliable Wrapper"}, - {ACN_SDT_VECTOR_UNREL_WRAP, "Unreliable Wrapper"}, - {ACN_SDT_VECTOR_CHANNEL_PARAMS, "Channel Parameters"}, - {ACN_SDT_VECTOR_JOIN, "Join"}, - {ACN_SDT_VECTOR_JOIN_REFUSE, "Join Refuse"}, - {ACN_SDT_VECTOR_JOIN_ACCEPT, "Join Accept"}, - {ACN_SDT_VECTOR_LEAVE, "Leave"}, - {ACN_SDT_VECTOR_LEAVING, "Leaving"}, - {ACN_SDT_VECTOR_CONNECT, "Connect"}, - {ACN_SDT_VECTOR_CONNECT_ACCEPT, "Connect Accept"}, - {ACN_SDT_VECTOR_CONNECT_REFUSE, "Connect Refuse"}, - {ACN_SDT_VECTOR_DISCONNECT, "Disconnect"}, - {ACN_SDT_VECTOR_DISCONNECTING, "Disconnecting"}, - {ACN_SDT_VECTOR_ACK, "Ack"}, - {ACN_SDT_VECTOR_NAK, "Nak"}, - {ACN_SDT_VECTOR_GET_SESSION, "Get Session"}, - {ACN_SDT_VECTOR_SESSIONS, "Sessions"}, + { ACN_SDT_VECTOR_UNKNOWN, "Unknown"}, + { ACN_SDT_VECTOR_REL_WRAP, "Reliable Wrapper"}, + { ACN_SDT_VECTOR_UNREL_WRAP, "Unreliable Wrapper"}, + { ACN_SDT_VECTOR_CHANNEL_PARAMS, "Channel Parameters"}, + { ACN_SDT_VECTOR_JOIN, "Join"}, + { ACN_SDT_VECTOR_JOIN_REFUSE, "Join Refuse"}, + { ACN_SDT_VECTOR_JOIN_ACCEPT, "Join Accept"}, + { ACN_SDT_VECTOR_LEAVE, "Leave"}, + { ACN_SDT_VECTOR_LEAVING, "Leaving"}, + { ACN_SDT_VECTOR_CONNECT, "Connect"}, + { ACN_SDT_VECTOR_CONNECT_ACCEPT, "Connect Accept"}, + { ACN_SDT_VECTOR_CONNECT_REFUSE, "Connect Refuse"}, + { ACN_SDT_VECTOR_DISCONNECT, "Disconnect"}, + { ACN_SDT_VECTOR_DISCONNECTING, "Disconnecting"}, + { ACN_SDT_VECTOR_ACK, "Ack"}, + { ACN_SDT_VECTOR_NAK, "Nak"}, + { ACN_SDT_VECTOR_GET_SESSION, "Get Session"}, + { ACN_SDT_VECTOR_SESSIONS, "Sessions"}, { 0, NULL }, }; static const value_string acn_dmx_vector_vals[] = { - {ACN_DMX_VECTOR, "Streaming DMX"}, + { ACN_DMX_VECTOR, "Streaming DMX"}, { 0, NULL }, }; @@ -613,8 +917,8 @@ static const value_string acn_blob_dimmer_properties2_field_name[] = { { 14, "Dimmer Mode" }, { 15, "Dimmer Control" }, { 16, "Dimmer Curve" }, - { 17, "On Level Percent" }, - { 18, "Off Level Percent" }, + { 17, "Off Level Percent" }, + { 18, "On Level Percent" }, { 19, "On Time(sec)" }, { 20, "Off Time(sec)" }, { 21, "Dimmer AF Enabled" }, @@ -635,19 +939,20 @@ static const value_string acn_blob_dimmer_properties2_field_name[] = { { 36, "Allow In Preset" }, { 37, "Allow In Panic" }, { 38, "Allow In Panic DD" }, - { 39, "Loads Reporting Mode" }, - { 40, "New Dimmer Space Number" }, - { 41, "New Dimmer Number" }, - { 42, "DMX A Patch" }, - { 43, "DMX B Patch" }, - { 44, "sACN Patch" }, - { 45, "DMX A Patch DD" }, - { 46, "DMX B Patch DD" }, - { 47, "sACN Patch DD" }, - { 48, "DMX A 16-bit Enable" }, - { 49, "DMX B 16-bit Enable" }, - { 50, "sACN 16-bit Enable" }, - { 51, "Dimmer Zone" }, + { 39, "Report No Loads" }, + { 40, "Loads Error Reporting Enabled" }, + { 41, "New Dimmer Space Number" }, + { 42, "New Dimmer Number" }, + { 43, "DMX A Patch" }, + { 44, "DMX B Patch" }, + { 45, "sACN Patch" }, + { 46, "DMX A Patch DD" }, + { 47, "DMX B Patch DD" }, + { 48, "sACN Patch DD" }, + { 49, "DMX A 16-bit Enable" }, + { 40, "DMX B 16-bit Enable" }, + { 51, "sACN 16-bit Enable" }, + { 52, "Dimmer Zone" }, { 0, NULL } }; static value_string_ext acn_blob_dimmer_properties2_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_dimmer_properties2_field_name); @@ -681,31 +986,33 @@ static const value_string acn_blob_dimmer_rack_properties2_field_name[] = { { 26, "Data Loss Fade Time sACN" }, { 27, "Data Loss Preset DMX A" }, { 28, "Data Loss Preset DMX B" }, - { 29, "Data Port Priority DMX A" }, - { 30, "Data Port Priority DMX B" }, - { 31, "Data Port Enabled DMX A" }, - { 32, "Data Port Enabled DMX B" }, - { 33, "Data Port Enabled sACN" }, - { 34, "16 Bit Enabled DMX A" }, - { 35, "16 Bit Enabled DMX B" }, - { 36, "16 Bit Enabled sACN" }, - { 37, "Patch From Home Screen" }, - { 38, "SCR Off Time" }, - { 39, "Time Mode" }, - { 40, "Offset from UTC" }, - { 41, "Universal Hold Last Look Time" }, - { 42, "Reactivate Presets On Boot" }, - { 43, "Voltage High Warning Level" }, - { 44, "Temperature High Warning Level" }, - { 45, "Fan Operation Timing" }, - { 46, "Allow Backplane Communication Errors" }, - { 47, "Activate Presets on Boot" }, - { 48, "SmartLink2 Power Supply Enable" }, - { 49, "Remote Record Enable" }, - { 50, "System Number" }, - { 51, "Architectural Priority" }, - { 52, "Data Loss Preset Space DMX A" }, - { 53, "Data Loss Preset Space DMX B" }, + { 29, "Data Loss Preset sACN" }, + { 20, "Data Port Priority DMX A" }, + { 31, "Data Port Priority DMX B" }, + { 32, "Data Port Enabled DMX A" }, + { 33, "Data Port Enabled DMX B" }, + { 34, "Data Port Enabled sACN" }, + { 35, "16 Bit Enabled DMX A" }, + { 36, "16 Bit Enabled DMX B" }, + { 37, "16 Bit Enabled sACN" }, + { 38, "Patch From Home Screen" }, + { 39, "SCR Off Time" }, + { 30, "Time Mode" }, + { 41, "Offset from UTC" }, + { 42, "Universal Hold Last Look Time" }, + { 43, "Reactivate Presets On Boot" }, + { 44, "Voltage High Warning Level" }, + { 45, "Temperature High Warning Level" }, + { 46, "Fan Operation Timing" }, + { 47, "Allow Backplane Communication Errors" }, + { 48, "Activate Presets on Boot" }, + { 49, "SmartLink2 Power Supply Enable" }, + { 40, "Remote Record Enable" }, + { 51, "System Number" }, + { 52, "Architectural Priority" }, + { 53, "Data Loss Preset Space DMX A" }, + { 54, "Data Loss Preset Space DMX B" }, + { 55, "Arch. Off Behavior" }, { 0, NULL } }; static value_string_ext acn_blob_dimmer_rack_properties2_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_dimmer_rack_properties2_field_name); @@ -2118,6 +2425,233 @@ static const value_string acn_blob_time3_locality_vals[] = { { 0, NULL } }; +static const value_string acn_blob_energy_cost_field_name[] = { + { 1, "Month" }, + { 2, "Day" }, + { 3, "Cost per Hour" }, + { 0, NULL } +}; + +static const value_string acn_blob_sequence_operation_field_name[] = { + { 1, "Operation Type" }, + { 2, "Space" }, + { 3, "Sequence Number" }, + { 3, "Step Number" }, + { 0, NULL } +}; + +static const value_string acn_blob_sequence_step_properties_field_name[] = { + { 1, "System" }, + { 2, "Processor" }, + { 3, "Rack" }, + { 4, "Lug" }, + { 5, "Module" }, + { 6, "Station" }, + { 7, "Port" }, + { 8, "Subdevice" }, + { 9, "Space" }, + { 10, "UDN" }, + { 11, "Reserved" }, + { 12, "Sequence Number" }, + { 13, "Step Number" }, + { 14, "Fade Time" }, + { 15, "Hold Time" }, + { 16, "Level[0]" }, + { 17, "Level[1]" }, + { 18, "Level[2]" }, + { 19, "Level[3]" }, + { 20, "Level[4]" }, + { 21, "Level[5]" }, + { 22, "Level[6]" }, + { 23, "Level[7]" }, + { 24, "Level[8]" }, + { 25, "Level[9]" }, + { 26, "Level[10]" }, + { 27, "Level[11]" }, + { 28, "Level[12]" }, + { 29, "Level[13]" }, + { 30, "Level[14]" }, + { 31, "Level[15]" }, + { 32, "Level[16]" }, + { 33, "Level[17]" }, + { 34, "Level[18]" }, + { 35, "Level[19]" }, + { 36, "Level[20]" }, + { 37, "Level[21]" }, + { 38, "Level[22]" }, + { 39, "Level[23]" }, + { 40, "Level[24]" }, + { 41, "Level[25]" }, + { 42, "Level[26]" }, + { 43, "Level[27]" }, + { 44, "Level[28]" }, + { 45, "Level[29]" }, + { 46, "Level[30]" }, + { 47, "Level[31]" }, + { 48, "Level[32]" }, + { 49, "Level[33]" }, + { 50, "Level[34]" }, + { 51, "Level[35]" }, + { 52, "Level[36]" }, + { 53, "Level[37]" }, + { 54, "Level[38]" }, + { 55, "Level[39]" }, + { 56, "Level[40]" }, + { 57, "Level[41]" }, + { 58, "Level[42]" }, + { 59, "Level[43]" }, + { 60, "Level[44]" }, + { 61, "Level[45]" }, + { 62, "Level[46]" }, + { 63, "Level[47]" }, + { 64, "Level[48]" }, + { 65, "Level[49]" }, + { 66, "Level[50]" }, + { 67, "Level[51]" }, + { 68, "Level[52]" }, + { 69, "Level[53]" }, + { 70, "Level[54]" }, + { 71, "Level[55]" }, + { 72, "Level[56]" }, + { 73, "Level[57]" }, + { 74, "Level[58]" }, + { 75, "Level[59]" }, + { 76, "Level[60]" }, + { 77, "Level[61]" }, + { 78, "Level[62]" }, + { 79, "Level[63]" }, + { 80, "Level[64]" }, + { 81, "Level[65]" }, + { 82, "Level[66]" }, + { 83, "Level[67]" }, + { 84, "Level[68]" }, + { 85, "Level[69]" }, + { 86, "Level[70]" }, + { 87, "Level[71]" }, + { 88, "Level[72]" }, + { 89, "Level[73]" }, + { 90, "Level[74]" }, + { 91, "Level[75]" }, + { 92, "Level[76]" }, + { 93, "Level[77]" }, + { 94, "Level[78]" }, + { 95, "Level[79]" }, + { 96, "Level[80]" }, + { 97, "Level[81]" }, + { 98, "Level[82]" }, + { 99, "Level[83]" }, + { 100, "Level[84]" }, + { 101, "Level[85]" }, + { 102, "Level[86]" }, + { 103, "Level[87]" }, + { 104, "Level[88]" }, + { 105, "Level[89]" }, + { 106, "Level[90]" }, + { 107, "Level[91]" }, + { 108, "Level[92]" }, + { 109, "Level[93]" }, + { 110, "Level[94]" }, + { 111, "Level[95]" }, + { 112, "Level[96]" }, + { 113, "Level[97]" }, + { 114, "Level[98]" }, + { 115, "Level[99]" }, + { 116, "Level[100]" }, + { 117, "Level[101]" }, + { 118, "Level[102]" }, + { 119, "Level[103]" }, + { 120, "Level[104]" }, + { 121, "Level[105]" }, + { 122, "Level[106]" }, + { 123, "Level[107]" }, + { 124, "Level[108]" }, + { 125, "Level[109]" }, + { 126, "Level[110]" }, + { 127, "Level[111]" }, + { 128, "Level[112]" }, + { 129, "Level[113]" }, + { 130, "Level[114]" }, + { 131, "Level[115]" }, + { 132, "Level[116]" }, + { 133, "Level[117]" }, + { 134, "Level[118]" }, + { 135, "Level[119]" }, + { 136, "Level[120]" }, + { 137, "Level[121]" }, + { 138, "Level[122]" }, + { 139, "Level[123]" }, + { 140, "Level[124]" }, + { 141, "Level[125]" }, + { 142, "Level[126]" }, + { 143, "Level[127]" }, + { 144, "Level[128]" }, + { 145, "Level[129]" }, + { 146, "Level[130]" }, + { 147, "Level[131]" }, + { 148, "Level[132]" }, + { 149, "Level[133]" }, + { 150, "Level[134]" }, + { 151, "Level[135]" }, + { 152, "Level[136]" }, + { 153, "Level[137]" }, + { 154, "Level[138]" }, + { 155, "Level[139]" }, + { 156, "Level[140]" }, + { 157, "Level[141]" }, + { 158, "Level[142]" }, + { 159, "Level[143]" }, + { 160, "Level[144]" }, + { 161, "Level[145]" }, + { 162, "Level[146]" }, + { 163, "Level[147]" }, + { 164, "Level[148]" }, + { 165, "Level[149]" }, + { 166, "Level[150]" }, + { 167, "Level[151]" }, + { 168, "Level[152]" }, + { 169, "Level[153]" }, + { 170, "Level[154]" }, + { 171, "Level[155]" }, + { 172, "Level[156]" }, + { 173, "Level[157]" }, + { 174, "Level[158]" }, + { 175, "Level[159]" }, + { 176, "Level[160]" }, + { 177, "Level[161]" }, + { 178, "Level[162]" }, + { 179, "Level[163]" }, + { 180, "Level[164]" }, + { 181, "Level[165]" }, + { 182, "Level[166]" }, + { 183, "Level[167]" }, + { 184, "Level[168]" }, + { 185, "Level[169]" }, + { 186, "Level[170]" }, + { 187, "Level[171]" }, + { 188, "Level[172]" }, + { 189, "Level[173]" }, + { 190, "Level[174]" }, + { 191, "Level[175]" }, + { 192, "Level[176]" }, + { 193, "Level[177]" }, + { 194, "Level[178]" }, + { 195, "Level[179]" }, + { 196, "Level[180]" }, + { 197, "Level[181]" }, + { 198, "Level[182]" }, + { 199, "Level[183]" }, + { 200, "Level[184]" }, + { 201, "Level[185]" }, + { 202, "Level[186]" }, + { 203, "Level[187]" }, + { 204, "Level[188]" }, + { 205, "Level[189]" }, + { 206, "Level[190]" }, + { 207, "Level[191]" }, + { 0, NULL } +}; +static value_string_ext acn_blob_sequence_step_properties_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_sequence_step_properties_field_name); + static const value_string acn_blob_type_vals[] = { { ACN_BLOB_IPV4, "IPv4 Blob" }, { ACN_BLOB_IPV6, "IPv6 Blob" }, @@ -2150,6 +2684,9 @@ static const value_string acn_blob_type_vals[] = { { ACN_BLOB_ENERGY_MANAGEMENT, "Energy Management Blob" }, { ACN_BLOB_PRESET_PROPERTIES, "Preset Properties Blob" }, { ACN_BLOB_TIME3, "Time Blob v2" }, + { ACN_BLOB_ENERGY_COST, "Energy Cost Blob" }, + { ACN_BLOB_SEQUENCE_OPERATIONS, "Sequence Operations Blob" }, + { ACN_BLOB_SEQUENCE_STEP_PROPERTIES, "Sequence Step Properties Blob" }, { 0, NULL } }; @@ -2267,8 +2804,8 @@ static const value_string magic_command_vals[] = { }; static const value_string magic_reset_lease_vals[] = { - { MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE, "Reset lease" }, { MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE, "Maintain lease" }, + { MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE, "Reset lease" }, { 0, NULL } }; @@ -2279,6 +2816,142 @@ static const value_string magic_ip_configuration_vals[] = { { 0, NULL } }; +static const value_string rdmnet_llrp_vector_vals[] = { + { RDMNET_LLRP_VECTOR_PROBE_REQUEST, "LLRP probe request" }, + { RDMNET_LLRP_VECTOR_PROBE_REPLY, "LLRP probe reply" }, + { RDMNET_LLRP_VECTOR_RDM_CMD, "LLRP RDM command" }, + { 0, NULL } +}; + +static const value_string rdmnet_llrp_probe_request_vals[] = { + { VECTOR_PROBE_REQUEST_DATA, "Vector probe request data" }, + { 0, NULL } +}; + +static const value_string rdmnet_llrp_probe_reply_vals[] = { + { VECTOR_PROBE_REPLY_DATA, "Vector probe reply data" }, + { 0, NULL } +}; + +static const value_string rdmnet_llrp_probe_reply_component_type_vals[] = { + { RDMNET_LLRP_COMPONENT_TYPE_RPT_DEVICE, "Device target" }, + { RDMNET_LLRP_COMPONENT_TYPE_RPT_CONTROLLER, "Controller target" }, + { RDMNET_LLRP_COMPONENT_TYPE_BROKER, "Broker target" }, + { RDMNET_LLRP_COMPONENT_TYPE_NON_RDMNET, "Non RDMnet target" }, + { 0, NULL } +}; + +static const value_string rdmnet_llrp_rdm_command_start_code_vals[] = { + { RDMNET_LLRP_VECTOR_RDM_CMD_START_CODE, "RDM Start Code" }, + { 0, NULL } +}; + +static const value_string rdmnet_broker_disconnect_reason_vals[] = { + { RDMNET_RPT_DISCONNECT_SHUTDOWN, "Component shut down" }, + { RDMNET_RPT_DISCONNECT_CAPACITY_EXHAUSTED, "Component capacity exhausted" }, + { RDMNET_RPT_DISCONNECT_HARDWARE_FAULT, "Component hardware fault" }, + { RDMNET_RPT_DISCONNECT_SOFTWARE_FAULT, "Component software fault" }, + { RDMNET_RPT_DISCONNECT_SOFTWARE_RESET, "Component software reset" }, + { RDMNET_RPT_DISCONNECT_INCORRECT_SCOPE, "Broker incorrect scope" }, + { RDMNET_RPT_DISCONNECT_LLRP_RECONFIGURE, "Component reconfigured by LLRP" }, + { RDMNET_RPT_DISCONNECT_RPT_RECONFIGURE, "Component reconfigured by RPT" }, + { RDMNET_RPT_DISCONNECT_USER_RECONFIGURE, "Component reconfigured by user" }, + { 0, NULL } +}; + +static const value_string rdmnet_rpt_vector_vals[] = { + { RDMNET_RPT_VECTOR_REQUEST, "Request" }, + { RDMNET_RPT_VECTOR_STATUS, "Status" }, + { RDMNET_RPT_VECTOR_NOTIFICATION, "Notification" }, + { 0, NULL } +}; + +static const value_string rdmnet_rpt_request_vals[] = { + { RDMNET_RPT_VECTOR_REQUEST_RDM_CMD, "RDM Command" }, + { 0, NULL } +}; + +static const value_string rdmnet_rpt_status_vector_vals[] = { + { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID, "Unknown RPT UID" }, + { RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT, "RDM Timeout" }, + { RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE, "Invalid RDM Response" }, + { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID, "Unknown RDM UID" }, + { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT, "Unknown Endpoint" }, + { RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE, "Broadcast Complete" }, + { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR, "Unknown Vector" }, + { RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE, "Invalid Message" }, + { RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS, "Invalid Command Class" }, + { 0, NULL } +}; + +static const value_string rdmnet_rpt_notification_vals[] = { + { RDMNET_RPT_VECTOR_NOTIFICATION_RDM_CMD, "RDM Command" }, + { 0, NULL } +}; + +static const value_string rdmnet_rpt_request_rdm_command_start_code_vals[] = { + { RDMNET_RPT_VECTOR_RDM_CMD_RD_DATA, "RDM Start Code" }, + { 0, NULL } +}; + +static const value_string rdmnet_broker_vector_vals[] = { + { RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST, "Fetch client list" }, + { RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST, "Connected client list" }, + { RDMNET_BROKER_VECTOR_CLIENT_ADD, "Add client" }, + { RDMNET_BROKER_VECTOR_CLIENT_REMOVE, "Remove client" }, + { RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE, "Change client entry" }, + { RDMNET_BROKER_VECTOR_CONNECT, "Connect" }, + { RDMNET_BROKER_VECTOR_CONNECT_REPLY, "Connect reply" }, + { RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE, "Update client entry" }, + { RDMNET_BROKER_VECTOR_REDIRECT_V4, "Redirect IP v4" }, + { RDMNET_BROKER_VECTOR_REDIRECT_V6, "Redirect IP v6" }, + { RDMNET_BROKER_VECTOR_DISCONNECT, "Disconnect" }, + { RDMNET_BROKER_VECTOR_NULL, "Null" }, + { RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS, "Request Dynamic UIDs" }, + { RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS, "Assigned Dynamic UIDs" }, + { RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST, "Fetch dynamic UID List" }, + { 0, NULL } +}; + +static const value_string rdmnet_broker_status_code_vals[] = { + { RDMNET_BROKER_CONNECT_OK, "Ok" }, + { RDMNET_BROKER_CONNECT_SCOPE_MISMATCH, "Scope mismatch" }, + { RDMNET_BROKER_CONNECT_CAPACITY_EXCEEDED, "Capacity exceeded" }, + { RDMNET_BROKER_CONNECT_DUPLICATE_UID, "Duplicate UID" }, + { RDMNET_BROKER_CONNECT_INVALID_CLIENT_ENTRY, "Invalid client entry" }, + { RDMNET_BROKER_CONNECT_INVALID_UID, "Invalid UID" }, + { 0, NULL } +}; + +static const value_string dynamic_uid_mapping_status_code_vals[] = { + { RDMNET_DYNAMIC_UID_STATUS_OK, "Dynamic UID Status Ok" }, + { RDMNET_DYNAMIC_UID_STATUS_INVALID_REQUEST, "Dynamic UID Status Invalid Request" }, + { RDMNET_DYNAMIC_UID_STATUS_UID_NOT_FOUND, "Dynamic UID Status UID Not Found" }, + { RDMNET_DYNAMIC_UID_STATUS_DUPLICATE_RID, "Dynamic UID Status Duplicate RID" }, + { RDMNET_DYNAMIC_UID_STATUS_CAPACITY_EXHAUSTED, "Dynamic UID Status Capacity Exhausted" }, + { 0, NULL } +}; + +static const value_string broker_client_protocol_vals[] = { + { RDMNET_CLIENT_PROTOCOL_RPT, "Client Protocol RPT" }, + { RDMNET_CLIENT_PROTOCOL_EPT, "Client Protocol EPT" }, + { 0, NULL } +}; + +static const value_string broker_client_rpt_client_type_vals[] = { + { RDMNET_RPT_CLIENT_TYPE_DEVICE, "Device" }, + { RDMNET_RPT_CLIENT_TYPE_CONTROLLER, "Controller" }, + { 0, NULL } +}; + +static const value_string rdmnet_ept_vector_vals[] = { + { RDMNET_EPT_VECTOR_DATA, "Data" }, + { RDMNET_EPT_VECTOR_STATUS, "Status" }, + { 0, NULL } +}; + +static dissector_handle_t rdm_handle; + /******************************************************************************/ /* Test to see if it is a Magic Bullet Packet */ static gboolean @@ -2488,27 +3161,111 @@ dissect_magic(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) } /******************************************************************************/ -/* Test to see if it is an ACN Packet */ +/* Test to see if it is an ACN or an RDMnet Packet over UDP */ static gboolean -is_acn(tvbuff_t *tvb) +is_acn_or_rdmnet_over_udp(tvbuff_t *tvb, guint32 *protocol_id) { static const char acn_packet_id[] = "ASC-E1.17\0\0\0"; /* must be 12 bytes */ + guint32 offset; + guint8 pdu_flags; - if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id))) + if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id) + 6)) return FALSE; /* Check the bytes in octets 4 - 16 */ if (tvb_memeql(tvb, 4, acn_packet_id, sizeof(acn_packet_id)-1) != 0) return FALSE; + offset = 16; + pdu_flags = tvb_get_guint8(tvb, offset) & 0xf0; + if (pdu_flags & ACN_PDU_FLAG_L) { + /* length bit is set: there are three length bytes */ + offset += 3; + } + else { + /* length bit is clear: there are two length bytes */ + offset += 2; + } + + *protocol_id = tvb_get_ntohl(tvb, offset); return TRUE; } +/******************************************************************************/ +/* Test to see if it is an RDMnet Packet over TCP */ +static gboolean +is_rdmnet_over_tcp(tvbuff_t *tvb) +{ + static const char acn_packet_id[] = "ASC-E1.17\0\0\0"; /* must be 12 bytes */ + guint32 offset; + guint32 protocol_id; + guint8 pdu_flags; + + if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id))) { + return FALSE; + } + + /* Check the bytes in octets 0 - 12 */ + if (tvb_memeql(tvb, 0, acn_packet_id, sizeof(acn_packet_id)-1) != 0) { + return FALSE; + } + + offset = 16; + pdu_flags = tvb_get_guint8(tvb, offset) & 0xf0; + if (pdu_flags & ACN_PDU_FLAG_L) { + /* length bit is set: there are three length bytes */ + offset += 3; + } else { + /* length bit is clear: there are two length bytes */ + offset += 2; + } + + protocol_id = tvb_get_ntohl(tvb, offset); + if ((protocol_id == ACN_PROTOCOL_ID_BROKER) || + (protocol_id == ACN_PROTOCOL_ID_RPT) || + (protocol_id == ACN_PROTOCOL_ID_EPT)) { + return TRUE; + } + + return FALSE; +} + +/******************************************************************************/ +/* Test to see if it is an ACN Packet */ +static gboolean +is_acn(tvbuff_t *tvb) +{ + guint32 protocol_id; + + if (is_acn_or_rdmnet_over_udp(tvb, &protocol_id)) { + if ((protocol_id == ACN_PROTOCOL_ID_DMX) || + (protocol_id == ACN_PROTOCOL_ID_DMX_2) || + (protocol_id == ACN_PROTOCOL_ID_SDT)) + return TRUE; + } + + return FALSE; +} + +/******************************************************************************/ +/* Test to see if it is an ACN Packet */ +static gboolean +is_rdmnet_over_udp(tvbuff_t *tvb) +{ + guint32 protocol_id; + + if (is_acn_or_rdmnet_over_udp(tvb, &protocol_id) && (protocol_id == ACN_PROTOCOL_ID_LLRP)) { + return TRUE; + } + + return FALSE; +} + /******************************************************************************/ /* Heuristic dissector */ static gboolean -dissect_acn_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ ) +dissect_acn_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) { /* This is a heuristic dissector, which means we get all the UDP * traffic not sent to a known dissector and not claimed by @@ -2529,6 +3286,59 @@ dissect_acn_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat return FALSE; } + +/******************************************************************************/ +/* Heuristic dissector */ +static gboolean +dissect_rdmnet_over_udp_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + if (!is_rdmnet_over_udp(tvb)) { + return FALSE; + } + + dissect_rdmnet(tvb, pinfo, tree, 0, 1); + return TRUE; +} + +#define RDMNET_TCP_FRAME_HEADER_LENGTH 16 + +static int +dissect_one_rdmnet_over_tcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + if (!is_rdmnet_over_tcp(tvb)) { + return 0; + } + + dissect_rdmnet(tvb, pinfo, tree, 0, 0); + return tvb_captured_length(tvb); +} + + +static guint +get_rdmnet_tcp_message_length(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_) +{ + return (guint)tvb_get_ntohl(tvb, offset + 12) + 16; +} + +static int +dissect_rdmnet_over_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + tcp_dissect_pdus(tvb, pinfo, tree, TRUE, RDMNET_TCP_FRAME_HEADER_LENGTH, + get_rdmnet_tcp_message_length, dissect_one_rdmnet_over_tcp_message, data); + return tvb_captured_length(tvb); +} + + +/******************************************************************************/ +/* Heuristic dissector */ +static gboolean +dissect_rdmnet_over_tcp_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + dissect_rdmnet_over_tcp(tvb, pinfo, tree, data); + return TRUE; +} + + /******************************************************************************/ /* Adds tree branch for channel owner info block */ static guint32 @@ -3421,6 +4231,15 @@ get_field_name(guint8 blob_type, guint16 field_number) case ACN_BLOB_TIME3: field_name = val_to_str(field_number, acn_blob_time3_field_name, "not valid (%d)"); break; + case ACN_BLOB_ENERGY_COST: + field_name = val_to_str(field_number, acn_blob_energy_cost_field_name, "not valid (%d)"); + break; + case ACN_BLOB_SEQUENCE_OPERATIONS: + field_name = val_to_str(field_number, acn_blob_sequence_operation_field_name, "not valid (%d)"); + break; + case ACN_BLOB_SEQUENCE_STEP_PROPERTIES: + field_name = val_to_str_ext(field_number, &acn_blob_sequence_step_properties_field_name_ext, "not valid (%d)"); + break; default: field_name = "Unknown field"; break; @@ -3922,6 +4741,133 @@ dissect_acn_blob(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *pdu_tree, in } /******************************************************************************/ +/* Dissect PDU L bit flag */ +static void +dissect_pdu_bit_flag_l(tvbuff_t *tvb, int *offset, guint8 *pdu_flags, guint32 *pdu_length, guint32 *pdu_flvh_length) +{ + guint8 octet; + guint32 length1; + guint32 length2; + guint32 length3; + + /* get PDU flags and length flag */ + octet = tvb_get_guint8(tvb, (*offset)++); + *pdu_flags = octet & 0xf0; + length1 = octet & 0x0f; /* bottom 4 bits only */ + length2 = tvb_get_guint8(tvb, (*offset)++); + + /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ + /* flvh = flags, length, vector, header */ + if (*pdu_flags & ACN_PDU_FLAG_L) { + length3 = tvb_get_guint8(tvb, *offset); + *offset += 1; + *pdu_length = length3 | (length2 << 8) | (length1 << 16); + *pdu_flvh_length = 3; + } else { + *pdu_length = length2 | (length1 << 8); + *pdu_flvh_length = 2; + } +} + +/******************************************************************************/ +/* Dissect PDU V bit flag */ +static void +dissect_pdu_bit_flag_v(int *offset, guint8 pdu_flags, guint32 *vector_offset, acn_pdu_offsets *last_pdu_offsets, guint32 *pdu_flvh_length, guint8 increment) +{ + /* Set vector offset */ + if (pdu_flags & ACN_PDU_FLAG_V) { + /* use new values */ + *vector_offset = *offset; + last_pdu_offsets->vector = *offset; + *offset += increment; + *pdu_flvh_length += increment; + } else { + /* use last values */ + *vector_offset = last_pdu_offsets->vector; + } +} + +/******************************************************************************/ +/* Dissect PDU H bit flag */ +static void +dissect_pdu_bit_flag_h(int *offset, guint8 pdu_flags, guint32 *header_offset, acn_pdu_offsets *last_pdu_offsets, guint32 *pdu_flvh_length, guint8 increment) +{ + /* Set header offset */ + if (pdu_flags & ACN_PDU_FLAG_H) { + /* use new values */ + *header_offset = *offset; + last_pdu_offsets->header = *offset; + *offset += increment; + *pdu_flvh_length += increment; + } else { + /* use last values */ + *header_offset = last_pdu_offsets->header; + } +} + +/******************************************************************************/ +/* Dissect PDU D bit flag */ +static void +dissect_pdu_bit_flag_d(int offset, guint8 pdu_flags, guint32 pdu_length, guint32 *data_offset, guint32 *data_length, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_flvh_length, gboolean set_last_value_length) +{ + /* Adjust data */ + if (pdu_flags & ACN_PDU_FLAG_D) { + /* use new values */ + *data_offset = offset; + *data_length = pdu_length - pdu_flvh_length; + last_pdu_offsets->data = offset; + last_pdu_offsets->data_length = *data_length; + } else { + /* use last values */ + *data_offset = last_pdu_offsets->data; + if (set_last_value_length) { + *data_length = last_pdu_offsets->data_length; + } + } +} + +/******************************************************************************/ +/* Add flag and flag tree */ +static void +begin_dissect_acn_pdu(proto_tree **pdu_tree, tvbuff_t *tvb, proto_item **ti, proto_tree *tree, guint32 *pdu_start, int *offset, guint8 *pdu_flags, guint32 *pdu_length, guint32 *pdu_flvh_length, gint ett_base_pdu, gboolean is_acn) +{ + proto_item *pi; + proto_tree *flag_tree; + + /* save start of pdu block */ + *pdu_start = *offset; + + dissect_pdu_bit_flag_l(tvb, offset, pdu_flags, pdu_length, pdu_flvh_length); + /* offset should now be pointing to vector (if one exists) */ + + /* add pdu item and tree */ + if (is_acn) { + *ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, *pdu_start, *pdu_length, ENC_NA); + } else { + *ti = proto_tree_add_item(tree, hf_rdmnet_pdu, tvb, *pdu_start, *pdu_length, ENC_NA); + } + *pdu_tree = proto_item_add_subtree(*ti, ett_base_pdu); + + /* add flag item and tree */ + if (is_acn) { + pi = proto_tree_add_uint(*pdu_tree, hf_acn_pdu_flags, tvb, *pdu_start, 1, *pdu_flags); + flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); + proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + } + else { + pi = proto_tree_add_uint(*pdu_tree, hf_rdmnet_pdu_flags, tvb, *pdu_start, 1, *pdu_flags); + flag_tree = proto_item_add_subtree(pi, ett_rdmnet_pdu_flags); + proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_l, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_v, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_h, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_d, tvb, *pdu_start, 1, ENC_BIG_ENDIAN); + } +} + +/******************************************************************************/ /* Dissect wrapped SDT PDU */ static guint32 dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) @@ -3933,10 +4879,6 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ guint8 D; - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; guint32 header_offset; guint32 data_offset; @@ -3947,9 +4889,8 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off guint32 blob_offset; guint32 blob_end_offset = 0; - proto_item *ti, *pi; + proto_item *ti; proto_tree *pdu_tree = NULL; - proto_tree *flag_tree = NULL; /* this pdu */ const gchar *name; @@ -3957,54 +4898,12 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off acn_dmp_adt_type adt2 = {0,0,0,0,0,0}; guint32 vector; - /* save start of pdu block */ - pdu_start = offset; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_dmp_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_dmp_pdu, 1); /* Add PDU Length item */ proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 1; - pdu_flvh_length++; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } + dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1); /* offset should now be pointing to header (if one exists) */ /* Add Vector item */ @@ -4016,34 +4915,13 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off proto_item_append_text(ti, ": "); proto_item_append_text(ti, "%s", name); - /* Set header offset */ - if (pdu_flags & ACN_PDU_FLAG_H) { - /* use new values */ - header_offset = offset; - last_pdu_offsets->header = offset; - offset += 1; - pdu_flvh_length++; - } else { - /* use last values */ - header_offset = last_pdu_offsets->header; - } + dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 1); /* offset should now be pointing to data (if one exists) */ /* header contains address and data type */ acn_add_dmp_address_type(tvb, pinfo, pdu_tree, header_offset, &adt); - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1); end_offset = data_offset + data_length; /* Check if blob exists, find beginning offset */ @@ -4267,74 +5145,27 @@ static guint32 dissect_acn_sdt_wrapped_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) { /* common to all pdu */ - guint8 pdu_flags; - guint32 pdu_start; - guint32 pdu_length; - guint32 pdu_flvh_length; /* flags, length, vector, header */ - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; - guint32 vector_offset; - guint32 data_offset; - guint32 data_length; - - proto_item *ti, *pi; + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; proto_tree *pdu_tree = NULL; - proto_tree *flag_tree = NULL; /* this pdu */ const gchar *name; guint32 vector; - /* save start of pdu block */ - pdu_start = offset; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_sdt_pdu, 1); /* Add PDU Length item */ proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 1; - pdu_flvh_length++; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } + dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1); /* offset should now be pointing to header (if one exists) */ /* Add Vector item */ @@ -4348,18 +5179,7 @@ dissect_acn_sdt_wrapped_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, /* NO HEADER DATA ON THESE* (at least so far) */ - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - /*data_length = last_pdu_offsets->data_length;*/ - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); switch (vector) { case ACN_SDT_VECTOR_ACK: @@ -4421,10 +5241,6 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; guint32 header_offset; guint32 data_offset; @@ -4432,9 +5248,8 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 old_offset; guint32 end_offset; - proto_item *ti, *pi; + proto_item *ti; proto_tree *pdu_tree = NULL; - proto_tree *flag_tree = NULL; /* this pdu */ const gchar *name; @@ -4442,72 +5257,19 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 protocol_id; guint16 association; - /* save start of pdu block */ - pdu_start = offset; - pdu_offsets.start = pdu_start; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_client_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_sdt_client_pdu, 1); /* Add PDU Length item */ proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 2; - pdu_flvh_length += 2; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } + dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 2); /* offset should now be pointing to header (if one exists) */ /* add Member ID item */ member_id = tvb_get_ntohs(tvb, vector_offset); proto_tree_add_uint(pdu_tree, hf_acn_member_id, tvb, vector_offset, 2, member_id); - /* Set header offset */ - if (pdu_flags & ACN_PDU_FLAG_H) { - /* use new values */ - header_offset = offset; - last_pdu_offsets->header = offset; - offset += 6; - pdu_flvh_length += 6; - } else { - /* use last values */ - header_offset = last_pdu_offsets->header; - } + dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 6); /* offset should now be pointing to data (if one exists) */ /* add Protocol ID item (Header)*/ @@ -4525,18 +5287,7 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_tree_add_uint(pdu_tree, hf_acn_association, tvb, header_offset, 2, association); /*header_offset += 2;*/ - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1); end_offset = data_offset + data_length; switch (protocol_id) { @@ -4563,7 +5314,7 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, /* level to string (ascii) */ /* level : 8 bit value */ /* string : pointer to buffer to fill */ -/* leading_char: character to buffer left of digits */ +/* leading_char: character to buffer left of digits */ /* min_char : minimum number of characters (for filling, not including space)*/ /* show_zero: show zeros or dots */ /* also adds a space to right end */ @@ -4623,10 +5374,6 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, guint32 pdu_start; guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; guint32 data_offset; guint32 end_offset; @@ -4635,9 +5382,8 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, guint32 total_cnt; guint32 item_cnt; - proto_item *ti, *pi; + proto_item *ti; proto_tree *pdu_tree; - proto_tree *flag_tree; /* this pdu */ acn_dmp_adt_type adt = {0,0,0,0,0,0}; @@ -4660,54 +5406,12 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, buffer = (gchar*)wmem_alloc(wmem_packet_scope(), BUFFER_SIZE); buffer[0] = '\0'; - /* save start of pdu block */ - pdu_start = offset; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_dmx_data_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_dmx_data_pdu, 1); /* Add PDU Length item */ proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 1; - pdu_flvh_length += 1; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } + dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1); /* offset should now be pointing to header (if one exists) */ /* Add Vector item */ @@ -4719,42 +5423,21 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_item_append_text(ti, ": "); proto_item_append_text(ti, "%s", name); - /* Set header offset */ - if (pdu_flags & ACN_PDU_FLAG_H) { - /* use new values */ - header_offset = offset; - last_pdu_offsets->header = offset; - offset += 1; - pdu_flvh_length++; - } else { - /* use last values */ - header_offset = last_pdu_offsets->header; - } + dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 1); /* offset should now be pointing to data (if one exists) */ /* process based on vector */ acn_add_dmp_address_type(tvb, pinfo, pdu_tree, header_offset, &adt); - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1); end_offset = data_offset + data_length; switch (vector) { case ACN_DMP_VECTOR_SET_PROPERTY: dmx_start_code = tvb_get_ntohs(tvb, data_offset); - if (protocol_id==ACN_PROTOCOL_ID_DMX_2) { + if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { proto_tree_add_item(pdu_tree, hf_acn_dmx_2_first_property_address, tvb, data_offset, 2, ENC_BIG_ENDIAN); - } else{ + } else { proto_tree_add_item(pdu_tree, hf_acn_dmx_start_code, tvb, data_offset, 2, ENC_BIG_ENDIAN); } data_offset += 2; @@ -4764,7 +5447,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_tree_add_item(pdu_tree, hf_acn_dmx_count, tvb, data_offset, 2, ENC_BIG_ENDIAN); data_offset += 2; - if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { + if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { dmx_2_start_code = (guint8)tvb_get_ntohs(tvb, data_offset - 1); proto_tree_add_item(pdu_tree, hf_acn_dmx_2_start_code, tvb, data_offset, 1, ENC_BIG_ENDIAN); data_offset += 1; @@ -4789,7 +5472,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, min_char = 2; base = 16; break; -/* case ACN_PREF_DMX_DISPLAY_PER: */ +/* case ACN_PREF_DMX_DISPLAY_PER: */ default: min_char = 3; base = 10; @@ -4802,12 +5485,12 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, leading_char = ' '; } /* add a snippet to info (this may be slow) */ - if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { - info_start_code = dmx_2_start_code; - } - else { - info_start_code = dmx_start_code; - } + if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { + info_start_code = dmx_2_start_code; + } + else { + info_start_code = dmx_start_code; + } col_append_fstr(pinfo->cinfo,COL_INFO, ", Sc %02x, [%02x %02x %02x %02x %02x %02x...]", info_start_code, tvb_get_guint8(tvb, data_offset), @@ -4818,6 +5501,9 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, tvb_get_guint8(tvb, data_offset+5)); /* add a header line */ + *buf_ptr++ = ' '; + *buf_ptr++ = ' '; + *buf_ptr++ = ' '; for (x=0; x<perline; x++) { buf_ptr = ltos((guint8)(x+1), buf_ptr, 10, ' ', min_char, FALSE); if ((x+1)==halfline) { @@ -4836,7 +5522,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, item_cnt = 0; for (x=data_offset; x<end_offset; x++) { level = tvb_get_guint8(tvb, x); - if (global_acn_dmx_display_view==ACN_PREF_DMX_DISPLAY_PER) { + if (global_acn_dmx_display_view == ACN_PREF_DMX_DISPLAY_PER) { if ((level > 0) && (level < 3)) { level = 1; } else { @@ -4863,25 +5549,43 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, } } } - /* NOTE: - address data type (fixed at 0xA2) - start code - 1 byte, reserved (should be 0) - - 1 byte, start code (0x255) - - 2 bytes, packet offset (should be 0000) - address increment - 4 bytes (ignore) - number of dmx values - 4 bytes (0-512) - dmx values 0-512 bytes (data) - */ + /* NOTE: + address data type (fixed at 0xA2) + start code - 1 byte, reserved (should be 0) + - 1 byte, start code (0x255) + - 2 bytes, packet offset (should be 0000) + address increment - 4 bytes (ignore) + number of dmx values - 4 bytes (0-512) + dmx values 0-512 bytes (data) + */ - break; + break; } return pdu_start + pdu_length; } /******************************************************************************/ +/* Dissect Common Base PDU */ +static void +dissect_acn_common_base_pdu(tvbuff_t *tvb, proto_tree *tree, int *offset, acn_pdu_offsets *last_pdu_offsets, guint8 *pdu_flags, guint32 *pdu_start, guint32 *pdu_length, guint32 *pdu_flvh_length, guint32 *vector_offset, proto_item **ti, proto_tree **pdu_tree, gint ett_base_pdu, guint8 v_flag_increment, gboolean is_acn) +{ + begin_dissect_acn_pdu(pdu_tree, tvb, ti, tree, pdu_start, offset, pdu_flags, pdu_length, pdu_flvh_length, ett_base_pdu, is_acn); + + /* Add PDU Length item */ + if (is_acn) { + proto_tree_add_uint(*pdu_tree, hf_acn_pdu_length, tvb, *pdu_start, *pdu_flvh_length, *pdu_length); + } else { + proto_tree_add_uint(*pdu_tree, hf_rdmnet_pdu_length, tvb, *pdu_start, *pdu_flvh_length, *pdu_length); + } + + dissect_pdu_bit_flag_v(offset, *pdu_flags, vector_offset, last_pdu_offsets, pdu_flvh_length, v_flag_increment); + /* offset should now be pointing to header (if one exists) */ +} + +/******************************************************************************/ /* Dissect DMX Base PDU */ static guint32 -dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +dissect_acn_dmx_base_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) { /* common to all pdu */ guint8 pdu_flags; @@ -4889,11 +5593,7 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; - guint8 octet; guint8 option_flags; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; guint32 data_offset; guint32 data_length; @@ -4902,66 +5602,15 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot proto_tree *pdu_tree; proto_tree *flag_tree; + /* this pdu */ const char *name; - -/* this pdu */ guint32 vector; guint32 universe; guint32 priority; guint32 sequence; - /* save start of pdu block */ - pdu_start = offset; - pdu_offsets.start = pdu_start; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_dmx_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - - /* Add PDU Length item */ - proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 4; - pdu_flvh_length += 4; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } - /* offset should now be pointing to header (if one exists) */ + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_acn_dmx_pdu, 4, 1); /* Add Vector item */ vector = tvb_get_ntohl(tvb, vector_offset); @@ -4974,26 +5623,15 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot /* NO HEADER DATA ON THESE* (at least so far) */ - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - /*data_length = last_pdu_offsets->data_length;*/ - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); /* process based on vector */ switch (vector) { - case 0x02: - if (protocol_id==ACN_PROTOCOL_ID_DMX_2) { + case ACN_DMP_VECTOR_SET_PROPERTY: + if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { proto_tree_add_item(pdu_tree, hf_acn_dmx_source_name, tvb, data_offset, 64, ENC_UTF_8|ENC_NA); data_offset += 64; - } else{ + } else { proto_tree_add_item(pdu_tree, hf_acn_dmx_source_name, tvb, data_offset, 32, ENC_UTF_8|ENC_NA); data_offset += 32; } @@ -5002,7 +5640,7 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot proto_tree_add_item(pdu_tree, hf_acn_dmx_priority, tvb, data_offset, 1, ENC_BIG_ENDIAN); data_offset += 1; - if (protocol_id==ACN_PROTOCOL_ID_DMX_2) { + if (protocol_id == ACN_PROTOCOL_ID_DMX_2) { proto_tree_add_item(pdu_tree, hf_acn_dmx_2_reserved, tvb, data_offset, 2, ENC_BIG_ENDIAN); data_offset += 2; } @@ -5046,10 +5684,6 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; guint32 data_offset; guint32 end_offset; @@ -5058,63 +5692,13 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in proto_item *ti, *pi; proto_tree *pdu_tree; - proto_tree *flag_tree; /* this pdu */ const gchar *name; guint32 vector; guint32 member_id; - /* save start of pdu block */ - pdu_start = offset; - pdu_offsets.start = pdu_start; - - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); - - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; - } - /* offset should now be pointing to vector (if one exists) */ - - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_base_pdu); - - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - - /* Add PDU Length item */ - proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 1; - pdu_flvh_length++; - } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; - } - /* offset should now be pointing to header (if one exists) */ + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_acn_sdt_base_pdu, 1, 1); /* Add Vector item */ vector = tvb_get_guint8(tvb, vector_offset); @@ -5122,23 +5706,12 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in /* Add Vector item to tree*/ name = val_to_str(vector, acn_sdt_vector_vals, "not valid (%d)"); - proto_item_append_text(ti, ": "); - proto_item_append_text(ti, "%s", name); + proto_item_append_text(ti, ": %s", name); + /* proto_item_append_text(ti, "%s", name); */ /* NO HEADER DATA ON THESE* (at least so far) */ - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; - } + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1); end_offset = data_offset + data_length; /* process based on vector */ @@ -5275,185 +5848,1240 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in return pdu_start + pdu_length; } + /******************************************************************************/ -/* Dissect Root PDU */ +/* Dissect LLRP Probe Request PDU */ +static guint32 +dissect_llrp_probe_request_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + /* common to all pdu */ + guint8 pdu_flags; + guint8 vector; + guint8 filter_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 data_offset; + guint32 end_offset; + + proto_item *ti, *pi; + proto_tree *flag_tree; + proto_tree *pdu_tree; + + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_probe_request_pdu, 0); + + /* Add PDU Length item */ + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + + dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2); + /* offset should now be pointing to header (if one exists) */ + + /* add vector item */ + vector = tvb_get_guint8(tvb, data_offset); + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_vector, tvb, data_offset, 1, vector); + + dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6); + data_offset -= 1; + /* offset should now be pointing to data (if one exists) */ + + /* lower uid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_lower_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* upper uid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_upper_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* filter */ + filter_flags = tvb_get_guint8(tvb, data_offset); + filter_flags = filter_flags & 0x03; + pi = proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_filter, tvb, data_offset, 1, filter_flags); + flag_tree = proto_item_add_subtree(pi, ett_rdmnet_llrp_probe_request_filter_flags); + proto_tree_add_item(flag_tree, hf_rdmnet_llrp_probe_request_filter_brokers_only, tvb, data_offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(flag_tree, hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive, tvb, data_offset, 2, ENC_BIG_ENDIAN); + data_offset += 2; + + /* known uids */ + end_offset = pdu_start + pdu_length; + while (data_offset + 6 <= end_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_known_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + } + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect LLRP Probe Reply PDU */ +static guint32 +dissect_llrp_probe_reply_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + /* common to all pdu */ + guint8 pdu_flags; + guint8 vector; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 data_offset; + + proto_item *ti; + proto_tree *pdu_tree; + + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_probe_reply_pdu, 0); + + /* Add PDU Length item */ + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + + dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2); + /* offset should now be pointing to header (if one exists) */ + + /* add vector item */ + vector = tvb_get_guint8(tvb, data_offset); + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_reply_vector, tvb, data_offset, 1, vector); + + dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6); + data_offset -= 1; + /* offset should now be pointing to data (if one exists) */ + + /* uid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* hardware address */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_hardware_address, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* component type */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_component_type, tvb, data_offset, 1, ENC_BIG_ENDIAN); + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect RDM Command */ +static guint32 +dissect_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *pdu_tree, guint32 data_offset, guint32 length) +{ + gboolean save_info; + gboolean save_protocol; + guint32 data_end; + tvbuff_t *next_tvb; + + save_info = col_get_writable(pinfo->cinfo, COL_INFO); + save_protocol = col_get_writable(pinfo->cinfo, COL_PROTOCOL); + col_set_writable(pinfo->cinfo, COL_INFO, FALSE); + col_set_writable(pinfo->cinfo, COL_PROTOCOL, FALSE); + + data_end = data_offset + length; + next_tvb = tvb_new_subset_length(tvb, data_offset, length); + call_dissector(rdm_handle, next_tvb, pinfo, pdu_tree); + + col_set_writable(pinfo->cinfo, COL_INFO, save_info); + col_set_writable(pinfo->cinfo, COL_PROTOCOL, save_protocol); + + return data_end; +} + + +/******************************************************************************/ +/* Dissect LLRP RDM Command PDU */ static guint32 -dissect_acn_root_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +dissect_llrp_rdm_command_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) { /* common to all pdu */ guint8 pdu_flags; + guint8 vector; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 data_offset; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_rdm_command_pdu, 0); + + /* Add PDU Length item */ + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + + dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2); + /* offset should now be pointing to header (if one exists) */ + + /* add vector item */ + vector = tvb_get_guint8(tvb, data_offset); + proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_rdm_command_start_code, tvb, data_offset, 1, vector); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_llrp_rdm_command_start_code_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6); + data_offset -= 1; + /* offset should now be pointing to data (if one exists) */ + + pdu_end = pdu_start + pdu_length; + dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4)); + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect LLRP Base PDU */ +static guint32 +dissect_acn_llrp_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; guint32 pdu_start; guint32 pdu_length; guint32 pdu_flvh_length; /* flags, length, vector, header */ acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; - guint8 octet; - guint32 length1; - guint32 length2; - guint32 length3; guint32 vector_offset; - guint32 header_offset; guint32 data_offset; + guint32 data_length; + e_guid_t guid; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint32 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_llrp_base_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_llrp_vector_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* get destination (CID) 16 bytes */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_destination_cid, tvb, data_offset, 16, ENC_BIG_ENDIAN); + tvb_get_guid(tvb, data_offset, &guid, ENC_BIG_ENDIAN); + proto_item_append_text(ti, ", Dest: %s", guid_to_str(wmem_packet_scope(), &guid)); + data_offset += 16; + + /* transaction number (4 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_transaction_number, tvb, data_offset, 4, ENC_BIG_ENDIAN); + data_offset += 4; + + /* process based on vector */ + switch (vector) { + case RDMNET_LLRP_VECTOR_PROBE_REQUEST: + dissect_llrp_probe_request_pdu(tvb, pdu_tree, data_offset, &pdu_offsets); + break; + case RDMNET_LLRP_VECTOR_PROBE_REPLY: + dissect_llrp_probe_reply_pdu(tvb, pdu_tree, data_offset, &pdu_offsets); + break; + case RDMNET_LLRP_VECTOR_RDM_CMD: + dissect_llrp_rdm_command_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + break; + } + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect Broker Client Entry PDU */ +static guint32 +dissect_broker_client_entry_pdu(tvbuff_t *tvb, proto_tree *tree, guint32 offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_item *ti2; + proto_tree *pdu_tree; + proto_tree *pdu_tree2; + + /* this pdu */ + const gchar *name; + guint32 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_broker_client_entry_pdu, 1, 0); + pdu_end = pdu_start + pdu_length; + + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_protocol_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, broker_client_protocol_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* client protocol cid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_protocol_cid, tvb, data_offset, 16, ENC_NA); + data_offset += 16; + + /* process based on vector */ + switch (vector) { + case RDMNET_CLIENT_PROTOCOL_RPT: + /* client uid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_client_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* client type */ + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_client_type, tvb, data_offset, 1, ENC_BIG_ENDIAN); + data_offset += 1; + + /* binding cid */ + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_binding_cid, tvb, data_offset, 16, ENC_NA); + data_offset += 16; + break; + case RDMNET_CLIENT_PROTOCOL_EPT: + while (offset + 36 < pdu_end) { + /* protocol vector (manufacturer id + protocol id) */ + ti2 = proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_ept_protocol_vector, tvb, data_offset, 4, ENC_NA); + pdu_tree2 = proto_item_add_subtree(ti2, ett_rdmnet_broker_client_entry_manufacturer_protocol_ids); + proto_tree_add_item(pdu_tree2, hf_rdmnet_broker_client_ept_protocol_manufacturer_id, tvb, 0, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(pdu_tree2, hf_rdmnet_broker_client_ept_protocol_protocol_id, tvb, 2, 2, ENC_BIG_ENDIAN); + offset += 4; + + /* protocol string */ + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_ept_protocol_string, tvb, data_offset, 32, ENC_ASCII|ENC_NA); + data_offset += 32; + } + break; + } + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect Broker Connect */ +static guint32 +dissect_broker_connect(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_end) +{ + guint8 connection_flags; + proto_item *pi; + proto_tree *flag_tree; + + /* client scope */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_client_scope, tvb, offset, 63, ENC_ASCII|ENC_NA); + offset += 63; + + /* e133 version */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_e133_version, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* search domain */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_search_domain, tvb, offset, 231, ENC_ASCII|ENC_NA); + offset += 231; + + /* connection flags */ + connection_flags = tvb_get_guint8(tvb, offset); + connection_flags = connection_flags & 0x01; + pi = proto_tree_add_uint(tree, hf_rdmnet_broker_connect_connection_flags, tvb, offset, 1, connection_flags); + flag_tree = proto_item_add_subtree(pi, ett_rdmnet_broker_connect_connection_flags); + proto_tree_add_item(flag_tree, hf_rdmnet_broker_connect_connection_flags_incremental_updates, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* client_entry_pdu */ + dissect_broker_client_entry_pdu(tvb, tree, offset, last_pdu_offsets); + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect Broker Connect Reply */ +static guint32 +dissect_broker_connect_reply(tvbuff_t *tvb, proto_tree *tree, int offset) +{ + /* connection code */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_connection_code, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* e133 version */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_e133_version, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* broker uid */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_broker_uid, tvb, offset, 6, ENC_NA); + offset += 6; + + /* client uid */ + proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_client_uid, tvb, offset, 6, ENC_NA); + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Client Entry Update */ +static guint32 +dissect_broker_client_entry_update(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_end) +{ + guint8 connection_flags; + + proto_item *pi; + proto_tree *flag_tree; + + /* connection flags */ + connection_flags = tvb_get_guint8(tvb, offset); + connection_flags = connection_flags & 0x01; + pi = proto_tree_add_uint(tree, hf_rdmnet_broker_client_entry_update_connection_flags, tvb, offset, 1, connection_flags); + flag_tree = proto_item_add_subtree(pi, ett_rdmnet_broker_client_entry_update_connection_flags); + proto_tree_add_item(flag_tree, hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* client_entry_pdu */ + dissect_broker_client_entry_pdu(tvb, tree, offset, last_pdu_offsets); + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect Broker Redirect V4 */ +static guint32 +dissect_broker_redirect_v4(tvbuff_t *tvb, proto_tree *tree, int offset) +{ + /* ipv4 address */ + proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv4_address, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* tcp port */ + proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv4_tcp_port, tvb, offset, 2, ENC_BIG_ENDIAN); + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Redirect V6 */ +static guint32 +dissect_broker_redirect_v6(tvbuff_t *tvb, proto_tree *tree, int offset) +{ + /* ipv4 address */ + proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv6_address, tvb, offset, 16, ENC_NA); + offset += 16; + + /* tcp port */ + proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv6_tcp_port, tvb, offset, 2, ENC_BIG_ENDIAN); + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Disconnect */ +static guint32 +dissect_broker_disconnect(tvbuff_t *tvb, proto_tree *tree, int offset) +{ + /* disconnect reason */ + proto_tree_add_item(tree, hf_rdmnet_broker_disconnect_reason, tvb, offset, 2, ENC_BIG_ENDIAN); + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Request Dynamic UIDs */ +static guint32 +dissect_broker_request_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end) +{ + /* packed list of dynamic uid request (6 bytes) and rid (16 bytes) */ + while (offset + 22 < pdu_end) { + /* dynamic uid request (6 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_dynamic_uid_request, tvb, offset, 6, ENC_NA); + offset += 6; + + /* rid (16 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_rid, tvb, offset, 16, ENC_NA); + offset += 16; + } + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Assigned Dynamic UIDs */ +static guint32 +dissect_broker_assigned_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end) +{ + /* packed list of dynamic uid request (6 bytes), rid (16 bytes), and status_code (2 bytes) */ + while (offset + 24 < pdu_end) { + /* dynamic uid request (6 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_assigned_dynamic_uid, tvb, offset, 6, ENC_NA); + offset += 6; + + /* rid (16 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_assigned_rid, tvb, offset, 16, ENC_NA); + offset += 16; + + /* status code (2 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_assigned_status_code, tvb, offset, 2, ENC_NA); + offset += 2; + } + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Fetch Dynamic UIDs */ +static guint32 +dissect_broker_fetch_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end) +{ + /* packed list of dynamic uid request (6 bytes) */ + while (offset + 6 < pdu_end) { + /* dynamic uid request (6 bytes) */ + proto_tree_add_item(tree, hf_rdmnet_broker_fetch_dynamic_uid, tvb, offset, 6, ENC_NA); + offset += 6; + } + + return 0; +} + + +/******************************************************************************/ +/* Dissect Broker Base PDU */ +static guint32 +dissect_acn_broker_base_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; + guint32 old_offset; guint32 end_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint16 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_broker_base_pdu, 1, 0); + pdu_end = pdu_start + pdu_length; + + /* Add Vector item */ + vector = tvb_get_ntohs(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_broker_vector, tvb, vector_offset, 2, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_broker_vector_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 1; + + /* process based on vector */ + switch (vector) { + case RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST: + case RDMNET_BROKER_VECTOR_NULL: + /* no data */ + break; + case RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST: + case RDMNET_BROKER_VECTOR_CLIENT_ADD: + case RDMNET_BROKER_VECTOR_CLIENT_REMOVE: + case RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE: + end_offset = pdu_start + pdu_length; + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_broker_client_entry_pdu(tvb, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; + } + break; + case RDMNET_BROKER_VECTOR_CONNECT: + dissect_broker_connect(tvb, pdu_tree, data_offset, &pdu_offsets, pdu_end); + break; + case RDMNET_BROKER_VECTOR_CONNECT_REPLY: + dissect_broker_connect_reply(tvb, pdu_tree, data_offset); + break; + case RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE: + dissect_broker_client_entry_update(tvb, pdu_tree, data_offset, &pdu_offsets, pdu_end); + break; + case RDMNET_BROKER_VECTOR_REDIRECT_V4: + dissect_broker_redirect_v4(tvb, pdu_tree, data_offset); + break; + case RDMNET_BROKER_VECTOR_REDIRECT_V6: + dissect_broker_redirect_v6(tvb, pdu_tree, data_offset); + break; + case RDMNET_BROKER_VECTOR_DISCONNECT: + dissect_broker_disconnect(tvb, pdu_tree, data_offset); + break; + case RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS: + dissect_broker_request_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end); + break; + case RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS: + dissect_broker_assigned_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end); + break; + case RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST: + dissect_broker_fetch_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end); + break; + } + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect RPT Request RDM Command */ +static guint32 +dissect_rpt_request_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint8 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_guint8(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_request_rdm_command, tvb, vector_offset, 1, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_rpt_request_rdm_command_start_code_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + /* data_offset += 3; */ + + pdu_end = pdu_start + pdu_length; + dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4)); + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect RPT Request */ +static guint32 +dissect_rpt_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint32 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_request_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_rpt_request_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* rdm command */ + dissect_rpt_request_rdm_command(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + + return 0; +} + + +/******************************************************************************/ +/* Dissect RPT Status */ +static guint32 +dissect_rpt_status(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint16 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_status_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_ntohs(tvb, vector_offset); + proto_item_append_text(ti, ", vector = %u", vector); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_vector, tvb, vector_offset, 2, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_rpt_status_vector_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + pdu_end = pdu_start + pdu_length; + switch (vector) { + case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_rpt_uid_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_rdm_timeout_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_rdm_invalid_response_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_rdm_uid_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_endpoint_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_broadcast_complete_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR: + if (pdu_end > data_offset) { + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_vector_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + } + break; + case RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE: + case RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS: + /* no data */ + break; + } + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect RPT Notification RDM Command */ +static guint32 +dissect_rpt_notification_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint8 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_guint8(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_notification_rdm_command, tvb, vector_offset, 1, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_rpt_request_rdm_command_start_code_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + /* data_offset += 3; */ + + pdu_end = pdu_start + pdu_length; + dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4)); + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect RPT Notification */ +static guint32 +dissect_rpt_notification(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; guint32 old_offset; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint32 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_notification_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_notification_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); + + /* Add Vector item to tree "RDM Command" */ + name = val_to_str(vector, rdmnet_rpt_notification_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* rdm command */ + pdu_end = pdu_start + pdu_length; + while (data_offset < pdu_end) { + old_offset = data_offset; + data_offset = dissect_rpt_notification_rdm_command(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; + } + + return pdu_end; +} + + +/******************************************************************************/ +/* Dissect RPT Base PDU */ +static guint32 +dissect_acn_rpt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; guint32 data_length; - proto_item *ti, *pi; + proto_item *ti; proto_tree *pdu_tree; - proto_tree *flag_tree; /* this pdu */ - guint32 protocol_id; - e_guid_t guid; + const gchar *name; + guint32 vector; - /* save start of pdu block */ - pdu_start = offset; - pdu_offsets.start = pdu_start; + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_base_pdu, 1, 0); - /* get PDU flags and length flag first */ - octet = tvb_get_guint8(tvb, offset++); - pdu_flags = octet & 0xf0; - length1 = octet & 0x0f; /* bottom 4 bits only */ - length2 = tvb_get_guint8(tvb, offset++); + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); - /* if length flag is set, then we have a 20 bit length else we have a 12 bit */ - /* flvh = flags, length, vector, header */ - if (pdu_flags & ACN_PDU_FLAG_L) { - length3 = tvb_get_guint8(tvb, offset); - offset += 1; - pdu_length = length3 | (length2 << 8) | (length1 << 16); - pdu_flvh_length = 3; - } else { - pdu_length = length2 | (length1 << 8); - pdu_flvh_length = 2; + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_rpt_vector_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* source uid (6 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_source_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* source endpoint id (2 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_source_endpoint_id, tvb, data_offset, 2, ENC_BIG_ENDIAN); + data_offset += 2; + + /* destination uid (6 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_destination_uid, tvb, data_offset, 6, ENC_NA); + data_offset += 6; + + /* destination endpoint id (2 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_destination_endpoint_id, tvb, data_offset, 2, ENC_BIG_ENDIAN); + data_offset += 2; + + /* sequence number (4 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_sequence_number, tvb, data_offset, 4, ENC_BIG_ENDIAN); + data_offset += 4; + + /* reserved (1 byte) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_reserved, tvb, data_offset, 1, ENC_BIG_ENDIAN); + data_offset += 1; + + /* process based on vector */ + switch (vector) { + case RDMNET_RPT_VECTOR_REQUEST: + dissect_rpt_request(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + break; + case RDMNET_RPT_VECTOR_STATUS: + dissect_rpt_status(tvb, pdu_tree, data_offset, &pdu_offsets); + break; + case RDMNET_RPT_VECTOR_NOTIFICATION: + dissect_rpt_notification(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + break; } - /* offset should now be pointing to vector (if one exists) */ - /* Add pdu item and tree */ - ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA); - pdu_tree = proto_item_add_subtree(ti, ett_acn_root_pdu); + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect EPT Data */ +static guint32 +dissect_ept_data(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + + proto_item *ti; + proto_item *ti2; + proto_tree *pdu_tree; + proto_tree *pdu_tree2; - /* Add flag item and tree */ - pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags); - flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN); - proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN); + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_data_pdu, 1, 0); /* Add PDU Length item */ - proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + proto_tree_add_uint(pdu_tree, hf_rdmnet_ept_data_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); - /* Set vector offset */ - if (pdu_flags & ACN_PDU_FLAG_V) { - /* use new values */ - vector_offset = offset; - last_pdu_offsets->vector = offset; - offset += 4; - pdu_flvh_length += 4; + dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2); + /* offset should now be pointing to header (if one exists) */ + + /* esta manufacturer id + protocol id (4 bytes) */ + ti2 = proto_tree_add_item(pdu_tree, hf_rdmnet_ept_data_vector, tvb, data_offset, 4, ENC_BIG_ENDIAN); + pdu_tree2 = proto_item_add_subtree(ti2, ett_rdmnet_ept_data_vector_pdu); + proto_tree_add_item(pdu_tree2, hf_rdmnet_ept_data_vector_manfacturer_id, tvb, 0, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(pdu_tree2, hf_rdmnet_ept_data_vector_protocol_id, tvb, 2, 2, ENC_BIG_ENDIAN); + data_offset += 4; + + /* opaque data */ + pdu_end = pdu_start + pdu_length; + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_data_opaque_data, tvb, data_offset, (pdu_end - data_offset), ENC_NA); + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect EPT Status */ +static guint32 +dissect_ept_status(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint16 vector; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_end; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + guint32 vector_offset; + guint32 data_offset; + + proto_item *ti; + proto_tree *pdu_tree; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_status_pdu, 1, 0); + + /* Add PDU Length item */ + proto_tree_add_uint(pdu_tree, hf_rdmnet_ept_status_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + + dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2); + /* offset should now be pointing to header (if one exists) */ + + vector = tvb_get_ntohs(tvb, data_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_vector, tvb, data_offset, 2, ENC_NA); + data_offset += 2; + + /* process based on vector */ + switch (vector) { + case RDMNET_EPT_VECTOR_UNKNOWN_CID: + /* unknown cid (16 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_unknown_cid, tvb, data_offset, 16, ENC_NA); + data_offset += 16; + + /* status string */ + pdu_end = pdu_start + pdu_length; + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_status_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + break; + case RDMNET_EPT_VECTOR_UNKNOWN_VECTOR: + /* unknown cid (4 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_unknown_vector, tvb, data_offset, 4, ENC_NA); + data_offset += 4; + + /* vector string */ + pdu_end = pdu_start + pdu_length; + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_vector_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA); + break; + } + + return pdu_start + pdu_length; +} + + +/******************************************************************************/ +/* Dissect EPT Base PDU */ +static guint32 +dissect_acn_ept_base_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets) +{ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + const gchar *name; + guint32 vector; + + dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_base_pdu, 1, 0); + + /* Add Vector item */ + vector = tvb_get_ntohl(tvb, vector_offset); + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN); + + /* Add Vector item to tree */ + name = val_to_str(vector, rdmnet_ept_vector_vals, "unknown (%d)"); + proto_item_append_text(ti, ": %s", name); + + /* NO HEADER DATA ON THESE* (at least so far) */ + + dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0); + data_offset += 3; + + /* destination cid (16 bytes) */ + proto_tree_add_item(pdu_tree, hf_rdmnet_ept_destination_cid, tvb, data_offset, 16, ENC_NA); + data_offset += 16; + + /* process based on vector */ + switch (vector) { + case RDMNET_EPT_VECTOR_DATA: + dissect_ept_data(tvb, pdu_tree, data_offset, &pdu_offsets); + break; + case RDMNET_EPT_VECTOR_STATUS: + dissect_ept_status(tvb, pdu_tree, data_offset, &pdu_offsets); + break; + } + + return pdu_start + pdu_length; +} + +/******************************************************************************/ +/* Dissect Root PDU */ +static guint32 +dissect_acn_root_pdu_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *pdu_tree, proto_item *ti, const char *title, int *offset, guint8 pdu_flags, guint32 pdu_length, guint32 *data_offset, guint32 *data_length, acn_pdu_offsets *last_pdu_offsets, gboolean add_cid_to_info, guint32 *pdu_flvh_length, gboolean is_acn) +{ + guint32 header_offset; + e_guid_t guid; + + /* Adjust header */ + proto_item_append_text(ti, "%s", title); + + dissect_pdu_bit_flag_h(offset, pdu_flags, &header_offset, last_pdu_offsets, pdu_flvh_length, 16); + /* offset should now be pointing to data (if one exists) */ + + /* get Header (CID) 16 bytes */ + tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN); + proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid)); + + if (add_cid_to_info) { + /* add cid to info */ + col_add_fstr(pinfo->cinfo, COL_INFO, "CID %s", guid_to_str(wmem_packet_scope(), &guid)); + } + + if (is_acn) { + proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN); } else { - /* use last values */ - vector_offset = last_pdu_offsets->vector; + proto_tree_add_item(pdu_tree, hf_rdmnet_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN); } + /* header_offset += 16; */ + + dissect_pdu_bit_flag_d(*offset, pdu_flags, pdu_length, data_offset, data_length, last_pdu_offsets, *pdu_flvh_length, 1); + + return (*data_offset) + (*data_length); +} + +/******************************************************************************/ +/* Dissect Root PDU */ +static guint32 +dissect_acn_root_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, gboolean is_acn) +{ + /* common to all pdu */ + guint8 pdu_flags; + guint32 pdu_start; + guint32 pdu_length; + guint32 pdu_flvh_length; /* flags, length, vector, header */ + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + guint32 vector_offset; + guint32 data_offset; + guint32 end_offset; + guint32 old_offset; + guint32 data_length; + + proto_item *ti; + proto_tree *pdu_tree; + + /* this pdu */ + guint32 protocol_id; + + begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_root_pdu, is_acn); + + /* Add PDU Length item */ + if (is_acn) { + proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + } else { + proto_tree_add_uint(pdu_tree, hf_rdmnet_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length); + } + + dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 4); /* offset should now be pointing to header (if one exists) */ /* Get Protocol ID (vector) */ protocol_id = tvb_get_ntohl(tvb, vector_offset); - proto_tree_add_uint(pdu_tree, hf_acn_protocol_id, tvb, vector_offset, 4, protocol_id); + if (is_acn) { + proto_tree_add_uint(pdu_tree, hf_acn_protocol_id, tvb, vector_offset, 4, protocol_id); + } else { + proto_tree_add_uint(pdu_tree, hf_rdmnet_protocol_id, tvb, vector_offset, 4, protocol_id); + } /* process based on protocol_id */ switch (protocol_id) { case ACN_PROTOCOL_ID_DMX: case ACN_PROTOCOL_ID_DMX_2: if (global_acn_dmx_enable) { - proto_item_append_text(ti,": Root DMX"); - - /* Set header offset */ - if (pdu_flags & ACN_PDU_FLAG_H) { - /* use new values */ - header_offset = offset; - last_pdu_offsets->header = offset; - offset += 16; - pdu_flvh_length += 16; - } else { - /* use last values */ - header_offset = last_pdu_offsets->header; - } - /* offset should now be pointing to data (if one exists) */ - - /* get Header (CID) 16 bytes */ - tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN); - proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid)); - - /* add cid to info */ - col_add_fstr(pinfo->cinfo,COL_INFO, "CID %s", guid_to_str(wmem_packet_scope(), &guid)); - - proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN); - /*header_offset += 16;*/ - - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; - } - end_offset = data_offset + data_length; + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root DMX", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 1, &pdu_flvh_length, 1); /* adjust for what we used */ while (data_offset < end_offset) { old_offset = data_offset; - data_offset = dissect_acn_dmx_pdu(protocol_id, tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + data_offset = dissect_acn_dmx_base_pdu(protocol_id, tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); if (data_offset == old_offset) break; } } break; case ACN_PROTOCOL_ID_SDT: - /* Adjust header */ - proto_item_append_text(ti,": Root SDT"); - - /* Set header offset */ - if (pdu_flags & ACN_PDU_FLAG_H) { - /* use new values */ - header_offset = offset; - last_pdu_offsets->header = offset; - offset += 16; - pdu_flvh_length += 16; - } else { - /* use last values */ - header_offset = last_pdu_offsets->header; + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root SDT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 1); + + /* adjust for what we used */ + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_acn_sdt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; } - /* offset should now be pointing to data (if one exists) */ - - /* get Header (CID) 16 bytes */ - tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN); - proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid)); - - proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN); - /*header_offset += 16;*/ - - /* Adjust data */ - if (pdu_flags & ACN_PDU_FLAG_D) { - /* use new values */ - data_offset = offset; - data_length = pdu_length - pdu_flvh_length; - last_pdu_offsets->data = offset; - last_pdu_offsets->data_length = data_length; - } else { - /* use last values */ - data_offset = last_pdu_offsets->data; - data_length = last_pdu_offsets->data_length; + break; + case ACN_PROTOCOL_ID_RPT: + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root RPT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0); + + /* adjust for what we used */ + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_acn_rpt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; + } + break; + case ACN_PROTOCOL_ID_BROKER: + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root Broker", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0); + + /* adjust for what we used */ + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_acn_broker_base_pdu(tvb, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; } - end_offset = data_offset + data_length; + break; + case ACN_PROTOCOL_ID_LLRP: + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root LLRP", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0); /* adjust for what we used */ while (data_offset < end_offset) { old_offset = data_offset; - data_offset = dissect_acn_sdt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + data_offset = dissect_acn_llrp_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets); + if (data_offset == old_offset) break; + } + break; + case ACN_PROTOCOL_ID_EPT: + end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root EPT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0); + + /* adjust for what we used */ + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_acn_ept_base_pdu(tvb, pdu_tree, data_offset, &pdu_offsets); if (data_offset == old_offset) break; } break; @@ -5480,8 +7108,7 @@ dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) /* Set the protocol column */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "ACN"); - - col_add_fstr(pinfo->cinfo,COL_INFO, "ACN [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport ); + col_add_fstr(pinfo->cinfo, COL_INFO, "ACN [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport ); ti = proto_tree_add_item(tree, proto_acn, tvb, 0, -1, ENC_NA); acn_tree = proto_item_add_subtree(ti, ett_acn); @@ -5498,13 +7125,72 @@ dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) end_offset = data_offset + tvb_reported_length_remaining(tvb, data_offset); while (data_offset < end_offset) { old_offset = data_offset; - data_offset = dissect_acn_root_pdu(tvb, pinfo, acn_tree, data_offset, &pdu_offsets); + data_offset = dissect_acn_root_pdu(tvb, pinfo, acn_tree, data_offset, &pdu_offsets, 1); if (data_offset == old_offset) break; } return tvb_reported_length(tvb); } /******************************************************************************/ +/* Dissect RDMnet */ +static int +dissect_rdmnet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 data_offset, gboolean is_udp) +{ + proto_item *ti; + proto_tree *rdmnet_tree; + /* guint32 data_offset = 0; */ + guint32 old_offset; + guint32 end_offset; + guint32 pdu_length; + acn_pdu_offsets pdu_offsets = {0,0,0,0,0}; + + /* Set the protocol column */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDMnet"); + col_add_fstr(pinfo->cinfo, COL_INFO, "RDMnet [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport ); + + if (is_udp) { + ti = proto_tree_add_item(tree, proto_rdmnet, tvb, data_offset, -1, ENC_NA); + } else { + pdu_length = tvb_get_ntohl(tvb, 12) + 16; + ti = proto_tree_add_item(tree, proto_rdmnet, tvb, data_offset, pdu_length, ENC_NA); + } + rdmnet_tree = proto_item_add_subtree(ti, ett_rdmnet); + + if (is_udp) { + /* UDP only: preamble and postamble */ + proto_tree_add_item(rdmnet_tree, hf_rdmnet_preamble_size, tvb, data_offset, 2, ENC_BIG_ENDIAN); + data_offset += 2; + proto_tree_add_item(rdmnet_tree, hf_rdmnet_postamble_size, tvb, data_offset, 2, ENC_BIG_ENDIAN); + data_offset += 2; + } + /* add ACN Packet ID */ + proto_tree_add_item(rdmnet_tree, hf_rdmnet_packet_identifier, tvb, data_offset, 12, ENC_UTF_8 | ENC_NA); + data_offset += 12; + + pdu_length = 0; + if (!is_udp) { + /* TCP only: data length (may be less than packet length) */ + proto_tree_add_item(rdmnet_tree, hf_rdmnet_tcp_length, tvb, data_offset, 4, ENC_BIG_ENDIAN); + pdu_length = tvb_get_ntohl(tvb, data_offset); + data_offset += 4; + } + + /* one past the last byte */ + if (is_udp) { + end_offset = data_offset + tvb_reported_length_remaining(tvb, data_offset); + } else { + end_offset = data_offset + pdu_length; + } + while (data_offset < end_offset) { + old_offset = data_offset; + data_offset = dissect_acn_root_pdu(tvb, pinfo, rdmnet_tree, data_offset, &pdu_offsets, 0); + if (data_offset == old_offset) break; + } + + return end_offset; +} + +/******************************************************************************/ /* Register protocol */ void proto_register_acn(void) @@ -5839,7 +7525,7 @@ proto_register_acn(void) FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, - /* MemberID */ + /* Member ID */ { &hf_acn_member_id, { "Member ID", "acn.member_id", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, @@ -5875,7 +7561,7 @@ proto_register_acn(void) FT_UINT32, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, - /* Preamble Sizet */ + /* Preamble Size */ { &hf_acn_preamble_size, { "Size of preamble", "acn.preamble_size", FT_UINT16, BASE_DEC, NULL, 0x0, @@ -5975,7 +7661,7 @@ proto_register_acn(void) }, /* SDT Vector */ { &hf_acn_sdt_vector, - { "STD Vector", "acn.sdt_vector", + { "SDT Vector", "acn.sdt_vector", FT_UINT8, BASE_DEC, VALS(acn_sdt_vector_vals), 0x0, NULL, HFILL } }, @@ -6275,6 +7961,559 @@ proto_register_acn(void) }, }; + static hf_register_info rdmnet_hf[] = { + /* CID */ + { &hf_rdmnet_cid, + { "CID", "rdmnet.cid", + FT_GUID, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* Packet Identifier */ + { &hf_rdmnet_packet_identifier, + { "Packet Identifier", "rdmnet.packet_identifier", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* PDU */ + { &hf_rdmnet_pdu, + { "PDU", "rdmnet.pdu", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* PDU flags*/ + { &hf_rdmnet_pdu_flags, + { "Flags", "rdmnet.pdu.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + "PDU Flags", HFILL } + }, + { &hf_rdmnet_pdu_flag_d, + { "Data", "rdmnet.pdu.flag_d", + FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_D, + "Data flag", HFILL } + }, + { &hf_rdmnet_pdu_flag_h, + { "Header", "rdmnet.pdu.flag_h", + FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_H, + "Header flag", HFILL } + }, + { &hf_rdmnet_pdu_flag_l, + { "Length", "rdmnet.pdu.flag_l", + FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_L, + "Length flag", HFILL } + }, + { &hf_rdmnet_pdu_flag_v, + { "Vector", "rdmnet.pdu.flag_v", + FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_V, + "Vector flag", HFILL } + }, + /* PDU Length */ + { &hf_rdmnet_pdu_length, + { "Length", "rdmnet.pdu.length", + FT_UINT32, BASE_DEC, NULL, 0x0, + "PDU Length", HFILL } + }, + /* Postamble Size */ + { &hf_rdmnet_postamble_size, + { "Size of postamble", "rdmnet.postamble_size", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Postamble size in bytes", HFILL } + }, + /* Preamble Size */ + { &hf_rdmnet_preamble_size, + { "Size of preamble", "rdmnet.preamble_size", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Preamble size in bytes", HFILL } + }, + /* Protocol ID */ + { &hf_rdmnet_protocol_id, + { "Protocol ID", "rdmnet.protocol_id", + FT_UINT32, BASE_DEC, VALS(acn_protocol_id_vals), 0x0, + NULL, HFILL } + }, + /* Postamble Size */ + { &hf_rdmnet_tcp_length, + { "Data length", "rdmnet.tcp_length", + FT_UINT32, BASE_DEC, NULL, 0x0, + "TCP data size in bytes", HFILL } + }, + /* LLRP Vector */ + { &hf_rdmnet_llrp_vector, + { "LLRP Vector", "rdmnet.llrp_vector", + FT_UINT32, BASE_DEC, VALS(rdmnet_llrp_vector_vals), 0x0, + NULL, HFILL } + }, + /* LLRP Destination CID */ + { &hf_rdmnet_llrp_destination_cid, + { "CID", "rdmnet.llrp.destination_cid", + FT_GUID, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Transaction Number */ + { &hf_rdmnet_llrp_transaction_number, + { "Transaction Number", "rdmnet.llrp.transaction_number", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Request PDU Length */ + { &hf_rdmnet_llrp_probe_request_pdu_length, + { "Length", "rdmnet.llrp.probe_request.pdu.length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "PDU Length", HFILL } + }, + /* LLRP Probe Request Vector */ + { &hf_rdmnet_llrp_probe_request_vector, + { "LLRP Vector", "rdmnet.llrp.probe_request_vector", + FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_request_vals), 0x0, + NULL, HFILL } + }, + /* LLRP Probe Request Lower UID */ + { &hf_rdmnet_llrp_probe_request_lower_uid, + { "Lower UID", "rdmnet.llrp.probe_request.lower_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Request Upper UID */ + { &hf_rdmnet_llrp_probe_request_upper_uid, + { "Upper UID", "rdmnet.llrp.probe_request.upper_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Request Filter */ + { &hf_rdmnet_llrp_probe_request_filter, + { "Filter", "rdmnet.llrp.probe_request.filter", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_rdmnet_llrp_probe_request_filter_brokers_only, + { "Brokers Only", "rdmnet.llrp.probe_request.filter_brokers_only", + FT_BOOLEAN, 8, NULL, RDMNET_LLRP_VECTOR_PROBE_REQUEST_BROKERS_ONLY, + "Brokers only flag", HFILL } + }, + { &hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive, + { "Client TCP Inactive", "rdmnet.llrp.probe_request.filter_client_tcp_inactive", + FT_BOOLEAN, 8, NULL, RDMNET_LLRP_VECTOR_PROBE_REQUEST_CLIENT_TCP_INACTIVE, + "Client TCP inactive flag", HFILL } + }, + /* LLRP Probe Request Unknown UID */ + { &hf_rdmnet_llrp_probe_request_known_uid, + { "Known UID", "rdmnet.llrp.probe_request.known_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Reply Vector */ + { &hf_rdmnet_llrp_probe_reply_vector, + { "LLRP Vector", "rdmnet.llrp.probe_reply_vector", + FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_reply_vals), 0x0, + NULL, HFILL } + }, + /* LLRP Probe Reply UID */ + { &hf_rdmnet_llrp_probe_reply_uid, + { "UID", "rdmnet.llrp.probe_reply.uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Reply Hardware Address */ + { &hf_rdmnet_llrp_probe_reply_hardware_address, + { "Hardware Address", "rdmnet.llrp.probe_reply.hardware_address", + FT_BYTES, SEP_COLON, NULL, 0x0, + NULL, HFILL } + }, + /* LLRP Probe Reply Component Type */ + { &hf_rdmnet_llrp_probe_reply_component_type, + { "Component Type", "rdmnet.llrp.probe_reply.component_type", + FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_reply_component_type_vals), 0x0, + NULL, HFILL } + }, + /* LLRP RDM Command Start Code */ + { &hf_rdmnet_llrp_rdm_command_start_code, + { "RDM Command", "rdmnet.llrp.rdm_command.start_code", + FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_rdm_command_start_code_vals), 0x0, + NULL, HFILL } + }, + /* RPT Vector */ + { &hf_rdmnet_rpt_vector, + { "RPT Vector", "rdmnet.rpt_vector", + FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_vector_vals), 0x0, + NULL, HFILL } + }, + /* RPT Source UID */ + { &hf_rdmnet_rpt_source_uid, + { "Source UID", "rdmnet.rpt.source_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Source Endpoint ID */ + { &hf_rdmnet_rpt_source_endpoint_id, + { "Source Endpoint ID", "rdmnet.rpt.source_endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Destination UID */ + { &hf_rdmnet_rpt_destination_uid, + { "Destination UID", "rdmnet.rpt.destination_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Destination Endpoint ID */ + { &hf_rdmnet_rpt_destination_endpoint_id, + { "Destination Endpoint ID", "rdmnet.rpt.destination_endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Sequence Number */ + { &hf_rdmnet_rpt_sequence_number, + { "Sequence Number", "rdmnet.rpt.sequence_number", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Reserved */ + { &hf_rdmnet_rpt_reserved, + { "Reserved", "rdmnet.rpt.reserved", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Request Vector */ + { &hf_rdmnet_rpt_request_vector, + { "RPT Request Vector", "rdmnet.rpt.request_vector", + FT_UINT32, BASE_DEC, VALS(rdmnet_rpt_request_vals), 0x0, + NULL, HFILL } + }, + /* RPT Request RDM Command */ + { &hf_rdmnet_rpt_request_rdm_command, + { "RDM Command", "rdmnet.rpt.request.rdm_command", + FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_request_rdm_command_start_code_vals), 0x0, + NULL, HFILL } + }, + /* RPT Status Vector */ + { &hf_rdmnet_rpt_status_vector, + { "Status Vector", "rdmnet.rpt.status.vector", + FT_UINT16, BASE_DEC, VALS(rdmnet_rpt_status_vector_vals), 0x0, + NULL, HFILL } + }, + /* RPT Status Unknown RPT UID String */ + { &hf_rdmnet_rpt_status_unknown_rpt_uid_string, + { "Status", "rdmnet.rpt.status.unknown_rpt_uid_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status RDM Timeout String */ + { &hf_rdmnet_rpt_status_rdm_timeout_string, + { "Status", "rdmnet.rpt.status.rdm_timeout_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status Invalid RDM Response String */ + { &hf_rdmnet_rpt_status_rdm_invalid_response_string, + { "Status", "rdmnet.rpt.status.invalid_rdm_response_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status Unknown RDM UID String */ + { &hf_rdmnet_rpt_status_unknown_rdm_uid_string, + { "Status", "rdmnet.rpt.status.unknown_rdm_uid_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status Unknown Endpoint String */ + { &hf_rdmnet_rpt_status_unknown_endpoint_string, + { "Status", "rdmnet.rpt.status.unknown_endpoint_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status Broadcast Complete String */ + { &hf_rdmnet_rpt_status_broadcast_complete_string, + { "Status", "rdmnet.rpt.status.broadcast_complete_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Status Unknown Vector String */ + { &hf_rdmnet_rpt_status_unknown_vector_string, + { "Status", "rdmnet.rpt.status.unknown_vector_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* RPT Notification Vector */ + { &hf_rdmnet_rpt_notification_vector, + { "RPT Notification Vector", "rdmnet.rpt.notification_vector", + FT_UINT32, BASE_DEC, VALS(rdmnet_rpt_notification_vals), 0x0, + NULL, HFILL } + }, + /* RPT Notification RDM Command */ + { &hf_rdmnet_rpt_notification_rdm_command, + { "RDM Command", "rdmnet.rpt.notification.rdm_command", + FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_request_rdm_command_start_code_vals), 0x0, + NULL, HFILL } + }, + /* Broker Vector */ + { &hf_rdmnet_broker_vector, + { "Broker Vector", "rdmnet.broker_vector", + FT_UINT8, BASE_DEC, VALS(rdmnet_broker_vector_vals), 0x0, + NULL, HFILL } + }, + /* Broker Client Protocol Vector */ + { &hf_rdmnet_broker_client_protocol_vector, + { "Client Protocol", "rdmnet.broker_client_protocol_vector", + FT_UINT32, BASE_DEC, VALS(broker_client_protocol_vals), 0x0, + NULL, HFILL } + }, + /* Broker Client Protocol CID */ + { &hf_rdmnet_broker_client_protocol_cid, + { "Client CID", "rdmnet.broker_client_cid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client RPT Client UID */ + { &hf_rdmnet_broker_client_rpt_client_uid, + { "Client UID", "rdmnet.broker_client_rpt_client_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client RPT Client Type */ + { &hf_rdmnet_broker_client_rpt_client_type, + { "RPT client type", "rdmnet.broker_client_rpt_client_type", + FT_UINT8, BASE_DEC, VALS(broker_client_rpt_client_type_vals), 0x0, + NULL, HFILL } + }, + /* Broker Client RPT Binding CID */ + { &hf_rdmnet_broker_client_rpt_binding_cid, + { "Binding CID", "rdmnet.broker_client_rpt_binding_cid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client EPT Protocol Vector */ + { &hf_rdmnet_broker_client_ept_protocol_vector, + { "Protocol Vector", "rdmnet.broker_client_ept_vector", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client EPT Manufacturer ID */ + { &hf_rdmnet_broker_client_ept_protocol_manufacturer_id, + { "Manufacturer ID", "rdmnet.broker_client_ept_manufacturer_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client EPT Protocol ID */ + { &hf_rdmnet_broker_client_ept_protocol_protocol_id, + { "Protocol ID", "rdmnet.broker_client_ept_protocol_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client EPT Protocol String */ + { &hf_rdmnet_broker_client_ept_protocol_string, + { "Protocol String", "rdmnet.broker_client_ept_protocol_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect Scope */ + { &hf_rdmnet_broker_connect_client_scope, + { "Client Scope", "rdmnet.broker.connect.client_scope", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect E1.33 Version */ + { &hf_rdmnet_broker_connect_e133_version, + { "E1.33 Version", "rdmnet.broker.connect.e133_version", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect Search Domain */ + { &hf_rdmnet_broker_connect_search_domain, + { "Search Domain", "rdmnet.broker.connect.search_domain", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect Connection Flags */ + { &hf_rdmnet_broker_connect_connection_flags, + { "Flags", "rdmnet.broker.connect.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + "Connection Flags", HFILL } + }, + { &hf_rdmnet_broker_connect_connection_flags_incremental_updates, + { "Incremental Updates", "rdmnet.broker.connect.flags_incremental_updates", + FT_BOOLEAN, 8, NULL, RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES, + "Incremental updates flag", HFILL } + }, + /* Broker Connect Reply Connection Code */ + { &hf_rdmnet_broker_connect_reply_connection_code, + { "Connection Code", "rdmnet.broker.connect_reply.connection_code", + FT_UINT16, BASE_DEC, VALS(rdmnet_broker_status_code_vals), 0x0, + NULL, HFILL } + }, + /* Broker Connect Reply E1.33 Version */ + { &hf_rdmnet_broker_connect_reply_e133_version, + { "E1.33 Version", "rdmnet.broker.connect_reply.e133_version", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect Reply Broker UID */ + { &hf_rdmnet_broker_connect_reply_broker_uid, + { "Broker UID", "rdmnet.broker.connect_reply.broker_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Connect Reply Client UID */ + { &hf_rdmnet_broker_connect_reply_client_uid, + { "Client UID", "rdmnet.broker.connect_reply.client_uid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Client Entry Update Connection Flags */ + { &hf_rdmnet_broker_client_entry_update_connection_flags, + { "Flags", "rdmnet.broker.client_entry_update.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + "Connection Flags", HFILL } + }, + { &hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates, + { "Incremental Updates", "rdmnet.broker.client_entry_update.flags_incremental_updates", + FT_BOOLEAN, 8, NULL, RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES, + "Incremental updates flag", HFILL } + }, + /* Broker Redirect IPv4 Address */ + { &hf_rdmnet_broker_redirect_ipv4_address, + { "IPv4 Address", "rdmnet.broker.redirect_ipv4.ipv4_address", + FT_IPv4, BASE_NONE, NULL, 0x0, + "Redirect IPv4 address", HFILL } + }, + /* Broker Redirect IPv4 TCP Port */ + { &hf_rdmnet_broker_redirect_ipv4_tcp_port, + { "IPv4 TCP Port", "rdmnet.broker.redirect_ipv4.tcp_port", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Redirect IPv4 TCP port", HFILL } + }, + /* Broker Redirect IPv6 Address */ + { &hf_rdmnet_broker_redirect_ipv6_address, + { "IPv6 Address", "rdmnet.broker.redirect_ipv6.ipv4_address", + FT_IPv6, BASE_NONE, NULL, 0x0, + "Redirect IPv6 address", HFILL } + }, + /* Broker Redirect IPv6 TCP Port */ + { &hf_rdmnet_broker_redirect_ipv6_tcp_port, + { "TCP Port", "rdmnet.broker.redirect_ipv6.tcp_port", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Redirect IPv6 TCP port", HFILL } + }, + /* Broker Disconnect Reason */ + { &hf_rdmnet_broker_disconnect_reason, + { "Reason", "rdmnet.broker.disconnect.reason", + FT_UINT16, BASE_DEC, VALS(rdmnet_broker_disconnect_reason_vals), 0x0, + "Disconnect reason", HFILL } + }, + /* Broker Dynamic UID Request */ + { &hf_rdmnet_broker_dynamic_uid_request, + { "Dynamic UID Request", "rdmnet.broker.request_dynamic_uids.dynamic_uid_request", + FT_BYTES, SEP_DOT, NULL, 0x0, + NULL, HFILL } + }, + /* Broker RID */ + { &hf_rdmnet_broker_rid, + { "RID", "rdmnet.broker.request_dynamic_uids.rid", + FT_BYTES, SEP_DOT, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Assigned Dynamic UID */ + { &hf_rdmnet_broker_assigned_dynamic_uid, + { "Dynamic UID Request", "rdmnet.broker.assigned_dynamic_uids.dynamic_uid", + FT_BYTES, SEP_DOT, NULL, 0x0, + NULL, HFILL } + }, + /* Broker Assigned RID */ + { &hf_rdmnet_broker_assigned_rid, + { "RID", "rdmnet.broker.assigned_dynamic_uids.rid", + FT_BYTES, SEP_DOT, NULL, 0x0, + NULL, HFILL } + }, + /* Broker_Assigned Status Code */ + { &hf_rdmnet_broker_assigned_status_code, + { "Status Code", "rdmnet.broker.assigned_dynamic_uids.status_code", + FT_UINT16, BASE_DEC, VALS(dynamic_uid_mapping_status_code_vals), 0x0, + NULL, HFILL } + }, + /* Broker Fetch Dynamic UID */ + { &hf_rdmnet_broker_fetch_dynamic_uid, + { "Dynamic UID", "rdmnet.broker.fetch_dynamic_uids.dynamic_uid", + FT_BYTES, SEP_DOT, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Vector */ + { &hf_rdmnet_ept_vector, + { "EPT Vector", "rdmnet.ept_vector", + FT_UINT8, BASE_DEC, VALS(rdmnet_ept_vector_vals), 0x0, + NULL, HFILL } + }, + /* EPT Destination CID */ + { &hf_rdmnet_ept_destination_cid, + { "Destination CID", "rdmnet.ept.destination_cid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Data PDU Length */ + { &hf_rdmnet_ept_data_pdu_length, + { "Length", "rdmnet.ept.data.pdu.length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "PDU Length", HFILL } + }, + /* EPT Data Vector */ + { &hf_rdmnet_ept_data_vector, + { "Vector", "rdmnet.ept.data.vector", + FT_UINT32, BASE_HEX, NULL, 0x0, + "Data vector", HFILL } + }, + /* EPT Data Vector Manfacturer ID */ + { &hf_rdmnet_ept_data_vector_manfacturer_id, + { "Manfac. ID", "rdmnet.ept.data.vector.manfacturer_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Manfacturer id", HFILL } + }, + /* EPT Data Vector Protocol ID */ + { &hf_rdmnet_ept_data_vector_protocol_id, + { "Protocol", "rdmnet.ept.data.vector.protocol_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + "Protocol id", HFILL } + }, + /* EPT Data Opaque Data */ + { &hf_rdmnet_ept_data_opaque_data, + { "Data", "rdmnet.ept.data.opaque_data", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Status PDU Length */ + { &hf_rdmnet_ept_status_pdu_length, + { "Length", "rdmnet.ept.status.pdu.length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "PDU Length", HFILL } + }, + /* EPT Status Unknown CID */ + { &hf_rdmnet_ept_status_unknown_cid, + { "Unknown CID", "rdmnet.ept.status.unknown_cid", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Status Status String */ + { &hf_rdmnet_ept_status_status_string, + { "Status String", "rdmnet.ept.status.status_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Status Vector */ + { &hf_rdmnet_ept_status_vector, + { "Unknown Vector", "rdmnet.ept.status.vector", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Status Unknown Vector */ + { &hf_rdmnet_ept_status_unknown_vector, + { "Unknown Vector", "rdmnet.ept.status.unknown_vector", + FT_BYTES, SEP_SPACE, NULL, 0x0, + NULL, HFILL } + }, + /* EPT Status Vector String */ + { &hf_rdmnet_ept_status_vector_string, + { "Vector String", "rdmnet.ept.status.vector_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL } + } + }; + /* Setup protocol subtree array */ static gint *ett[] = { &ett_acn, @@ -6301,6 +8540,30 @@ proto_register_acn(void) &ett_magic }; + /* Setup protocol subtree array */ + static gint *rdmnet_ett[] = { + &ett_rdmnet, + &ett_rdmnet_pdu_flags, + &ett_rdmnet_llrp_base_pdu, + &ett_rdmnet_llrp_probe_request_pdu, + &ett_rdmnet_llrp_probe_request_filter_flags, + &ett_rdmnet_llrp_probe_reply_pdu, + &ett_rdmnet_llrp_rdm_command_pdu, + &ett_rdmnet_rpt_base_pdu, + &ett_rdmnet_rpt_request_pdu, + &ett_rdmnet_rpt_status_pdu, + &ett_rdmnet_rpt_notification_pdu, + &ett_rdmnet_broker_base_pdu, + &ett_rdmnet_broker_client_entry_pdu, + &ett_rdmnet_broker_client_entry_manufacturer_protocol_ids, + &ett_rdmnet_broker_connect_connection_flags, + &ett_rdmnet_broker_client_entry_update_connection_flags, + &ett_rdmnet_ept_base_pdu, + &ett_rdmnet_ept_data_pdu, + &ett_rdmnet_ept_data_vector_pdu, + &ett_rdmnet_ept_status_pdu + }; + static ei_register_info ei[] = { { &ei_magic_reply_invalid_type, { "magic.reply.invalid_type", PI_PROTOCOL, PI_WARN, "Invalid type", EXPFILL }}, }; @@ -6315,11 +8578,17 @@ proto_register_acn(void) ); proto_magic = proto_register_protocol( - "Magic", /* name */ + "Magic Bullet", /* name */ "MAGIC", /* short name */ "magic" /* abbrev */ ); + proto_rdmnet = proto_register_protocol( + "RDMnet", /* name */ + "RDMnet", /* short name */ + "rdmnet" /* abbrev */ + ); + proto_register_field_array(proto_acn, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); @@ -6359,6 +8628,9 @@ proto_register_acn(void) proto_register_subtree_array(magic_ett, array_length(magic_ett)); expert_acn = expert_register_protocol(proto_magic); expert_register_field_array(expert_acn, ei, array_length(ei)); + + proto_register_field_array(proto_rdmnet, rdmnet_hf, array_length(rdmnet_hf)); + proto_register_subtree_array(rdmnet_ett, array_length(rdmnet_ett)); } @@ -6370,7 +8642,12 @@ proto_reg_handoff_acn(void) /* dissector_handle_t acn_handle; */ /* acn_handle = create_dissector_handle(dissect_acn, proto_acn); */ /* dissector_add_for_decode_as_with_preference("udp.port", acn_handle); */ - heur_dissector_add("udp", dissect_acn_heur, "ACN over UDP", "acn_udp", proto_acn, HEURISTIC_DISABLE); + + rdm_handle = find_dissector_add_dependency("rdm", proto_acn); + + heur_dissector_add("udp", dissect_acn_heur, "ACN", "acn", proto_acn, HEURISTIC_DISABLE); + heur_dissector_add("udp", dissect_rdmnet_over_udp_heur, "RDMnet over UDP (LLRP)", "rdmnet_udp", proto_acn, HEURISTIC_DISABLE); + heur_dissector_add("tcp", dissect_rdmnet_over_tcp_heur, "RDMnet over TCP (Broker, RPT, EPT)", "rdmnet_tcp", proto_acn, HEURISTIC_DISABLE); } /* diff --git a/epan/dissectors/packet-rdm.c b/epan/dissectors/packet-rdm.c index 426d1e974d..c0bc20f1c2 100644 --- a/epan/dissectors/packet-rdm.c +++ b/epan/dissectors/packet-rdm.c @@ -15,6 +15,7 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ + /* * ANSI E1.20-2006, Entertainment Technology * Remote Device Management over USITT DMX512, describes a method of @@ -32,512 +33,789 @@ #include <epan/packet.h> #include <epan/expert.h> #include "packet-rdm.h" +#include "packet-arp.h" void proto_register_rdm(void); void proto_reg_handoff_rdm(void); -#define RDM_SC_RDM 0xCC -#define RDM_SC_SUB_MESSAGE 0x01 +#define RDM_SC_RDM 0xCC +#define RDM_SC_SUB_MESSAGE 0x01 -#define RDM_CC_COMMAND_RESPONSE_FLAG 0x01 +#define RDM_CC_COMMAND_RESPONSE_FLAG 0x01 -#define RDM_CC_DISCOVERY_COMMAND 0x10 -#define RDM_CC_DISCOVERY_COMMAND_RESPONSE 0x11 -#define RDM_CC_GET_COMMAND 0x20 -#define RDM_CC_GET_COMMAND_RESPONSE 0x21 -#define RDM_CC_SET_COMMAND 0x30 -#define RDM_CC_SET_COMMAND_RESPONSE 0x31 +#define RDM_CC_DISCOVERY_COMMAND 0x10 +#define RDM_CC_DISCOVERY_COMMAND_RESPONSE 0x11 +#define RDM_CC_GET_COMMAND 0x20 +#define RDM_CC_GET_COMMAND_RESPONSE 0x21 +#define RDM_CC_SET_COMMAND 0x30 +#define RDM_CC_SET_COMMAND_RESPONSE 0x31 static const value_string rdm_cc_vals[] = { - { RDM_CC_DISCOVERY_COMMAND, "Discovery Command" }, - { RDM_CC_DISCOVERY_COMMAND_RESPONSE, "Discovery Command Response" }, - { RDM_CC_GET_COMMAND, "Get Command" }, - { RDM_CC_GET_COMMAND_RESPONSE, "Get Command Response" }, - { RDM_CC_SET_COMMAND, "Set Command" }, - { RDM_CC_SET_COMMAND_RESPONSE, "Set Command Response" }, - { 0, NULL }, + { RDM_CC_DISCOVERY_COMMAND, "Discovery Command" }, + { RDM_CC_DISCOVERY_COMMAND_RESPONSE, "Discovery Command Response" }, + { RDM_CC_GET_COMMAND, "Get Command" }, + { RDM_CC_GET_COMMAND_RESPONSE, "Get Command Response" }, + { RDM_CC_SET_COMMAND, "Set Command" }, + { RDM_CC_SET_COMMAND_RESPONSE, "Set Command Response" }, + { 0, NULL }, }; -#define RDM_RESPONSE_TYPE_ACK 0x00 -#define RDM_RESPONSE_TYPE_ACK_TIMER 0x01 -#define RDM_RESPONSE_TYPE_NACK_REASON 0x02 -#define RDM_RESPONSE_TYPE_ACK_OVERFLOW 0x03 +#define RDM_RESPONSE_TYPE_ACK 0x00 +#define RDM_RESPONSE_TYPE_ACK_TIMER 0x01 +#define RDM_RESPONSE_TYPE_NACK_REASON 0x02 +#define RDM_RESPONSE_TYPE_ACK_OVERFLOW 0x03 static const value_string rdm_rt_vals[] = { - { RDM_RESPONSE_TYPE_ACK, "Ack" }, - { RDM_RESPONSE_TYPE_ACK_TIMER, "Ack Timer" }, - { RDM_RESPONSE_TYPE_NACK_REASON, "Nack Reason" }, - { RDM_RESPONSE_TYPE_ACK_OVERFLOW, "Ack Overflow" }, - { 0, NULL }, + { RDM_RESPONSE_TYPE_ACK, "Ack" }, + { RDM_RESPONSE_TYPE_ACK_TIMER, "Ack Timer" }, + { RDM_RESPONSE_TYPE_NACK_REASON, "Nack Reason" }, + { RDM_RESPONSE_TYPE_ACK_OVERFLOW, "Ack Overflow" }, + { 0, NULL }, }; -#define RDM_NR_UNKNOWN_PID 0x0000 -#define RDM_NR_FORMAT_ERROR 0x0001 -#define RDM_NR_HARDWARE_FAULT 0x0002 -#define RDM_NR_PROXY_REJECT 0x0003 -#define RDM_NR_WRITE_PROTECT 0x0004 -#define RDM_NR_UNSUPPORTED_COMMAND_CLASS 0x0005 -#define RDM_NR_DATA_OUT_OF_RANGE 0x0006 -#define RDM_NR_BUFFER_FULL 0x0007 -#define RDM_NR_PACKET_SIZE_UNSUPPORTED 0x0008 -#define RDM_NR_SUB_DEVICE_OUT_OF_RANGE 0x0009 -#define RDM_NR_PROXY_BUFFER_FULL 0x000A +#define RDM_NR_UNKNOWN_PID 0x0000 +#define RDM_NR_FORMAT_ERROR 0x0001 +#define RDM_NR_HARDWARE_FAULT 0x0002 +#define RDM_NR_PROXY_REJECT 0x0003 +#define RDM_NR_WRITE_PROTECT 0x0004 +#define RDM_NR_UNSUPPORTED_COMMAND_CLASS 0x0005 +#define RDM_NR_DATA_OUT_OF_RANGE 0x0006 +#define RDM_NR_BUFFER_FULL 0x0007 +#define RDM_NR_PACKET_SIZE_UNSUPPORTED 0x0008 +#define RDM_NR_SUB_DEVICE_OUT_OF_RANGE 0x0009 +#define RDM_NR_PROXY_BUFFER_FULL 0x000A +#define RDM_NR_ACTION_NOT_SUPPORTED 0x000B /* E1.37-2 */ +#define RDM_NR_ENDPOINT_NUMBER_INVALID 0x000C /* E1.37-7 */ +#define RDM_NR_INVALID_ENDPOINT_MODE 0x000D +#define RDM_NR_UNKNOWN_UID 0x000E + +#define RDM_NR_UNKNOWN_SCOPE 0x000F /* E1.33 */ +#define RDM_NR_INVALID_STATIC_CONFIG_TYPE 0x0010 /* E1.33 */ +#define RDM_NR_INVALID_IPV4_ADDRESS 0x0011 /* E1.33 */ +#define RDM_NR_INVALID_IPV6_ADDRESS 0x0012 /* E1.33 */ +#define RDM_NR_INVALID_PORT 0x0013 /* E1.33 */ static const value_string rdm_nr_vals[] = { - { RDM_NR_UNKNOWN_PID, "Unknown PID" }, - { RDM_NR_FORMAT_ERROR, "Format Error" }, - { RDM_NR_HARDWARE_FAULT, "Hardware Fault" }, - { RDM_NR_PROXY_REJECT, "Proxy Reject" }, - { RDM_NR_WRITE_PROTECT, "Write Protect" }, - { RDM_NR_UNSUPPORTED_COMMAND_CLASS, "Unsupported Command Class" }, - { RDM_NR_DATA_OUT_OF_RANGE, "Data Out Of Range" }, - { RDM_NR_BUFFER_FULL, "Buffer Full" }, - { RDM_NR_PACKET_SIZE_UNSUPPORTED, "Packet Size Unsupported" }, - { RDM_NR_SUB_DEVICE_OUT_OF_RANGE, "Sub-Device Out Of Range" }, - { RDM_NR_PROXY_BUFFER_FULL, "Proxy Buffer Full" }, - { 0, NULL }, + { RDM_NR_UNKNOWN_PID, "Unknown PID" }, + { RDM_NR_FORMAT_ERROR, "Format Error" }, + { RDM_NR_HARDWARE_FAULT, "Hardware Fault" }, + { RDM_NR_PROXY_REJECT, "Proxy Reject" }, + { RDM_NR_WRITE_PROTECT, "Write Protect" }, + { RDM_NR_UNSUPPORTED_COMMAND_CLASS, "Unsupported Command Class" }, + { RDM_NR_DATA_OUT_OF_RANGE, "Data Out Of Range" }, + { RDM_NR_BUFFER_FULL, "Buffer Full" }, + { RDM_NR_PACKET_SIZE_UNSUPPORTED, "Packet Size Unsupported" }, + { RDM_NR_SUB_DEVICE_OUT_OF_RANGE, "Sub-Device Out Of Range" }, + { RDM_NR_PROXY_BUFFER_FULL, "Proxy Buffer Full" }, + { RDM_NR_ACTION_NOT_SUPPORTED, "Action Not Supported" }, /* E1.37-2 */ + { RDM_NR_ENDPOINT_NUMBER_INVALID, "Endpoint Number Invalid" }, /* E1.37-7 */ + { RDM_NR_INVALID_ENDPOINT_MODE, "Invalid Endpoint Mode" }, + { RDM_NR_UNKNOWN_UID, "Unknown UID" }, + { RDM_NR_UNKNOWN_SCOPE, "Unknown Scope" }, /* E1.33 */ + { RDM_NR_INVALID_STATIC_CONFIG_TYPE, "Invalid Static Config Type" }, + { RDM_NR_INVALID_IPV4_ADDRESS, "Invalid IPv4 Address" }, + { RDM_NR_INVALID_IPV6_ADDRESS, "Invalid IPv6 Address" }, + { RDM_NR_INVALID_PORT, "Invalid Port" }, + { 0, NULL }, }; -#define RDM_PARAM_ID_DISC_UNIQUE_BRANCH 0x0001 -#define RDM_PARAM_ID_DISC_MUTE 0x0002 -#define RDM_PARAM_ID_DISC_UN_MUTE 0x0003 -#define RDM_PARAM_ID_PROXIED_DEVICES 0x0010 -#define RDM_PARAM_ID_PROXIED_DEVICE_COUNT 0x0011 -#define RDM_PARAM_ID_COMMS_STATUS 0x0015 -#define RDM_PARAM_ID_QUEUED_MESSAGE 0x0020 -#define RDM_PARAM_ID_STATUS_MESSAGES 0x0030 -#define RDM_PARAM_ID_STATUS_ID_DESCRIPTION 0x0031 -#define RDM_PARAM_ID_CLEAR_STATUS_ID 0x0032 -#define RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD 0x0033 -#define RDM_PARAM_ID_SUPPORTED_PARAMETERS 0x0050 -#define RDM_PARAM_ID_PARAMETER_DESCRIPTION 0x0051 -#define RDM_PARAM_ID_DEVICE_INFO 0x0060 -#define RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST 0x0070 -#define RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION 0x0080 -#define RDM_PARAM_ID_MANUFACTURER_LABEL 0x0081 -#define RDM_PARAM_ID_DEVICE_LABEL 0x0082 -#define RDM_PARAM_ID_FACTORY_DEFAULTS 0x0090 -#define RDM_PARAM_ID_LANGUAGE_CAPABILITIES 0x00A0 -#define RDM_PARAM_ID_LANGUAGE 0x00B0 -#define RDM_PARAM_ID_SOFTWARE_VERSION_LABEL 0x00C0 -#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID 0x00C1 -#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL 0x00C2 -#define RDM_PARAM_ID_DMX_PERSONALITY 0x00E0 -#define RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION 0x00E1 -#define RDM_PARAM_ID_DMX_START_ADDRESS 0x00F0 -#define RDM_PARAM_ID_SLOT_INFO 0x0120 -#define RDM_PARAM_ID_SLOT_DESCRIPTION 0x0121 -#define RDM_PARAM_ID_DEFAULT_SLOT_VALUE 0x0122 -#define RDM_PARAM_ID_SENSOR_DEFINITION 0x0200 -#define RDM_PARAM_ID_SENSOR_VALUE 0x0201 -#define RDM_PARAM_ID_RECORD_SENSORS 0x0202 -#define RDM_PARAM_ID_DEVICE_HOURS 0x0400 -#define RDM_PARAM_ID_LAMP_HOURS 0x0401 -#define RDM_PARAM_ID_LAMP_STRIKES 0x0402 -#define RDM_PARAM_ID_LAMP_STATE 0x0403 -#define RDM_PARAM_ID_LAMP_ON_MODE 0x0404 -#define RDM_PARAM_ID_DEVICE_POWER_CYCLES 0x0405 -#define RDM_PARAM_ID_DISPLAY_INVERT 0x0500 -#define RDM_PARAM_ID_DISPLAY_LEVEL 0x0501 -#define RDM_PARAM_ID_PAN_INVERT 0x0600 -#define RDM_PARAM_ID_TILT_INVERT 0x0601 -#define RDM_PARAM_ID_PAN_TILT_SWAP 0x0602 -#define RDM_PARAM_ID_REAL_TIME_CLOCK 0x0603 -#define RDM_PARAM_ID_IDENTIFY_DEVICE 0x1000 -#define RDM_PARAM_ID_RESET_DEVICE 0x1001 -#define RDM_PARAM_ID_POWER_STATE 0x1010 -#define RDM_PARAM_ID_PERFORM_SELFTEST 0x1020 -#define RDM_PARAM_ID_SELF_TEST_DESCRIPTION 0x1021 -#define RDM_PARAM_ID_CAPTURE_PRESET 0x1030 -#define RDM_PARAM_ID_PRESET_PLAYBACK 0x1031 +/* E1.20, E1.33, and E1.37 PIDs */ +#define RDM_PARAM_ID_DISC_UNIQUE_BRANCH 0x0001 +#define RDM_PARAM_ID_DISC_MUTE 0x0002 +#define RDM_PARAM_ID_DISC_UN_MUTE 0x0003 +#define RDM_PARAM_ID_PROXIED_DEVICES 0x0010 +#define RDM_PARAM_ID_PROXIED_DEVICE_COUNT 0x0011 +#define RDM_PARAM_ID_COMMS_STATUS 0x0015 +#define RDM_PARAM_ID_QUEUED_MESSAGE 0x0020 +#define RDM_PARAM_ID_STATUS_MESSAGES 0x0030 +#define RDM_PARAM_ID_STATUS_ID_DESCRIPTION 0x0031 +#define RDM_PARAM_ID_CLEAR_STATUS_ID 0x0032 +#define RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD 0x0033 +#define RDM_PARAM_ID_SUPPORTED_PARAMETERS 0x0050 +#define RDM_PARAM_ID_PARAMETER_DESCRIPTION 0x0051 +#define RDM_PARAM_ID_DEVICE_INFO 0x0060 +#define RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST 0x0070 +#define RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION 0x0080 +#define RDM_PARAM_ID_MANUFACTURER_LABEL 0x0081 +#define RDM_PARAM_ID_DEVICE_LABEL 0x0082 +#define RDM_PARAM_ID_FACTORY_DEFAULTS 0x0090 +#define RDM_PARAM_ID_LANGUAGE_CAPABILITIES 0x00A0 +#define RDM_PARAM_ID_LANGUAGE 0x00B0 +#define RDM_PARAM_ID_SOFTWARE_VERSION_LABEL 0x00C0 +#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID 0x00C1 +#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL 0x00C2 +#define RDM_PARAM_ID_DMX_PERSONALITY 0x00E0 +#define RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION 0x00E1 +#define RDM_PARAM_ID_DMX_START_ADDRESS 0x00F0 +#define RDM_PARAM_ID_SLOT_INFO 0x0120 +#define RDM_PARAM_ID_SLOT_DESCRIPTION 0x0121 +#define RDM_PARAM_ID_DEFAULT_SLOT_VALUE 0x0122 + +#define RDM_PARAM_ID_DMX_BLOCK_ADDRESS 0x0140 /* E1.37-1 */ +#define RDM_PARAM_ID_DMX_FAIL_MODE 0x0141 +#define RDM_PARAM_ID_DMX_STARTUP_MODE 0x0142 + +#define RDM_PARAM_ID_SENSOR_DEFINITION 0x0200 +#define RDM_PARAM_ID_SENSOR_VALUE 0x0201 +#define RDM_PARAM_ID_RECORD_SENSORS 0x0202 + +#define RDM_PARAM_ID_DIMMER_INFO 0x0340 /* E1.37-1 */ +#define RDM_PARAM_ID_MINIMUM_LEVEL 0x0341 +#define RDM_PARAM_ID_MAXIMUM_LEVEL 0x0342 +#define RDM_PARAM_ID_CURVE 0x0343 +#define RDM_PARAM_ID_CURVE_DESCRIPTION 0x0344 +#define RDM_PARAM_ID_OUTPUT_RESPONSE_TIME 0x0345 +#define RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION 0x0346 +#define RDM_PARAM_ID_MODULATION_FREQUENCY 0x0347 +#define RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION 0x0348 + +#define RDM_PARAM_ID_DEVICE_HOURS 0x0400 +#define RDM_PARAM_ID_LAMP_HOURS 0x0401 +#define RDM_PARAM_ID_LAMP_STRIKES 0x0402 +#define RDM_PARAM_ID_LAMP_STATE 0x0403 +#define RDM_PARAM_ID_LAMP_ON_MODE 0x0404 +#define RDM_PARAM_ID_DEVICE_POWER_CYCLES 0x0405 + +#define RDM_PARAM_ID_BURN_IN 0x0440 /* E1.37-1 */ + +#define RDM_PARAM_ID_DISPLAY_INVERT 0x0500 +#define RDM_PARAM_ID_DISPLAY_LEVEL 0x0501 +#define RDM_PARAM_ID_PAN_INVERT 0x0600 +#define RDM_PARAM_ID_TILT_INVERT 0x0601 +#define RDM_PARAM_ID_PAN_TILT_SWAP 0x0602 +#define RDM_PARAM_ID_REAL_TIME_CLOCK 0x0603 + +#define RDM_PARAM_ID_LOCK_PIN 0x0640 /* E1.37-1 */ +#define RDM_PARAM_ID_LOCK_STATE 0x0641 +#define RDM_PARAM_ID_LOCK_STATE_DESCRIPTION 0x0642 + +#define RDM_PARAM_ID_LIST_INTERFACES 0x0700 /* E1.37-2 */ +#define RDM_PARAM_ID_INTERFACE_LABEL 0x0701 +#define RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1 0x0702 +#define RDM_PARAM_ID_IPV4_DHCP_MODE 0x0703 +#define RDM_PARAM_ID_IPV4_ZEROCONF_MODE 0x0704 +#define RDM_PARAM_ID_IPV4_CURRENT_ADDRESS 0x0705 +#define RDM_PARAM_ID_IPV4_STATIC_ADDRESS 0x0706 +#define RDM_PARAM_ID_INTERFACE_RENEW_DHCP 0x0707 +#define RDM_PARAM_ID_INTERFACE_RELEASE_DHCP 0x0708 +#define RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION 0x0709 +#define RDM_PARAM_ID_IPV4_DEFAULT_ROUTE 0x070A +#define RDM_PARAM_ID_DNS_IPV4_NAME_SERVER 0x070B +#define RDM_PARAM_ID_DNS_HOSTNAME 0x070C +#define RDM_PARAM_ID_DNS_DOMAIN_NAME 0x070D + +#define RDM_PARAM_ID_COMPONENT_SCOPE 0x0800 /* E1.33 */ +#define RDM_PARAM_ID_SEARCH_DOMAIN 0x0801 /* E1.33 */ +#define RDM_PARAM_ID_TCP_COMMS_STATUS 0x0802 /* E1.33 */ +#define RDM_PARAM_ID_BROKER_STATUS 0x0803 /* E1.33 */ + +#define RDM_PARAM_ID_ENDPOINT_LIST 0x0900 /* E1.37-7 */ +#define RDM_PARAM_ID_ENDPOINT_LIST_CHANGE 0x0901 +#define RDM_PARAM_ID_IDENTIFY_ENDPOINT 0x0902 +#define RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE 0x0903 +#define RDM_PARAM_ID_ENDPOINT_MODE 0x0904 +#define RDM_PARAM_ID_ENDPOINT_LABEL 0x0905 +#define RDM_PARAM_ID_RDM_TRAFFIC_ENABLE 0x0906 +#define RDM_PARAM_ID_DISCOVERY_STATE 0x0907 +#define RDM_PARAM_ID_BACKGROUND_DISCOVERY 0x0908 +#define RDM_PARAM_ID_ENDPOINT_TIMING 0x0909 +#define RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION 0x090A +#define RDM_PARAM_ID_ENDPOINT_RESPONDERS 0x090B +#define RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE 0x090C +#define RDM_PARAM_ID_BINDING_CONTROL_FIELDS 0x090D +#define RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY 0x090E +#define RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION 0x090F + +#define RDM_PARAM_ID_IDENTIFY_DEVICE 0x1000 +#define RDM_PARAM_ID_RESET_DEVICE 0x1001 +#define RDM_PARAM_ID_POWER_STATE 0x1010 +#define RDM_PARAM_ID_PERFORM_SELFTEST 0x1020 +#define RDM_PARAM_ID_SELF_TEST_DESCRIPTION 0x1021 +#define RDM_PARAM_ID_CAPTURE_PRESET 0x1030 +#define RDM_PARAM_ID_PRESET_PLAYBACK 0x1031 + +#define RDM_PARAM_ID_IDENTIFY_MODE 0x1040 /* E1.37-1 */ +#define RDM_PARAM_ID_PRESET_INFO 0x1041 +#define RDM_PARAM_ID_PRESET_STATUS 0x1042 +#define RDM_PARAM_ID_PRESET_MERGEMODE 0x1043 +#define RDM_PARAM_ID_POWER_ON_SELF_TEST 0x1044 const value_string rdm_param_id_vals[] = { - { RDM_PARAM_ID_DISC_UNIQUE_BRANCH, "DISC_UNIQUE_BRANCH" }, - { RDM_PARAM_ID_DISC_MUTE, "DISC_MUTE" }, - { RDM_PARAM_ID_DISC_UN_MUTE, "DISC_UN_MUTE" }, - { RDM_PARAM_ID_PROXIED_DEVICES, "PROXIED_DEVICES" }, - { RDM_PARAM_ID_PROXIED_DEVICE_COUNT, "PROXIED_DEVICE_COUNT" }, - { RDM_PARAM_ID_COMMS_STATUS, "COMMS_STATUS" }, - { RDM_PARAM_ID_QUEUED_MESSAGE, "QUEUED_MESSAGE" }, - { RDM_PARAM_ID_STATUS_MESSAGES, "STATUS_MESSAGES" }, - { RDM_PARAM_ID_STATUS_ID_DESCRIPTION, "STATUS_ID_DESCRIPTION" }, - { RDM_PARAM_ID_CLEAR_STATUS_ID, "CLEAR_STATUS_ID" }, - { RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD, "DEVICE_STATUS_REPORT_THRESHOLD" }, - { RDM_PARAM_ID_SUPPORTED_PARAMETERS, "SUPPORTED_PARAMETERS" }, - { RDM_PARAM_ID_PARAMETER_DESCRIPTION, "PARAMETER_DESCRIPTION" }, - { RDM_PARAM_ID_DEVICE_INFO, "DEVICE_INFO" }, - { RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST, "PRODUCT_DETAIL_ID_LIST" }, - { RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION, "DEVICE_MODEL_DESCRIPTION" }, - { RDM_PARAM_ID_MANUFACTURER_LABEL, "MANUFACTURER_LABEL" }, - { RDM_PARAM_ID_DEVICE_LABEL, "DEVICE_LABEL" }, - { RDM_PARAM_ID_FACTORY_DEFAULTS, "FACTORY_DEFAULTS" }, - { RDM_PARAM_ID_LANGUAGE_CAPABILITIES, "LANGUAGE_CAPABILITIES" }, - { RDM_PARAM_ID_LANGUAGE, "LANGUAGE" }, - { RDM_PARAM_ID_SOFTWARE_VERSION_LABEL, "SOFTWARE_VERSION_LABEL" }, - { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID, "BOOT_SOFTWARE_VERSION_ID" }, - { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL, "BOOT_SOFTWARE_VERSION_LABEL" }, - { RDM_PARAM_ID_DMX_PERSONALITY, "DMX_PERSONALITY" }, - { RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION, "DMX_PERSONALITY_DESCRIPTION" }, - { RDM_PARAM_ID_DMX_START_ADDRESS, "DMX_START_ADDRESS" }, - { RDM_PARAM_ID_SLOT_INFO, "SLOT_INFO" }, - { RDM_PARAM_ID_SLOT_DESCRIPTION, "SLOT_DESCRIPTION" }, - { RDM_PARAM_ID_DEFAULT_SLOT_VALUE, "DEFAULT_SLOT_VALUE" }, - { RDM_PARAM_ID_SENSOR_DEFINITION, "SENSOR_DEFINITION" }, - { RDM_PARAM_ID_SENSOR_VALUE, "SENSOR_VALUE" }, - { RDM_PARAM_ID_RECORD_SENSORS, "RECORD_SENSORS" }, - { RDM_PARAM_ID_DEVICE_HOURS, "DEVICE_HOURS" }, - { RDM_PARAM_ID_LAMP_HOURS, "LAMP_HOURS" }, - { RDM_PARAM_ID_LAMP_STRIKES, "LAMP_STRIKES" }, - { RDM_PARAM_ID_LAMP_STATE, "LAMP_STATE" }, - { RDM_PARAM_ID_LAMP_ON_MODE, "LAMP_ON_MODE" }, - { RDM_PARAM_ID_DEVICE_POWER_CYCLES, "DEVICE_POWER_CYCLES" }, - { RDM_PARAM_ID_DISPLAY_INVERT, "DISPLAY_INVERT" }, - { RDM_PARAM_ID_DISPLAY_LEVEL, "DISPLAY_LEVEL" }, - { RDM_PARAM_ID_PAN_INVERT, "PAN_INVERT" }, - { RDM_PARAM_ID_TILT_INVERT, "TILT_INVERT" }, - { RDM_PARAM_ID_PAN_TILT_SWAP, "PAN_TILT_SWAP" }, - { RDM_PARAM_ID_REAL_TIME_CLOCK, "REAL_TIME_CLOCK" }, - { RDM_PARAM_ID_IDENTIFY_DEVICE, "IDENTIFY_DEVICE" }, - { RDM_PARAM_ID_RESET_DEVICE, "RESET_DEVICE" }, - { RDM_PARAM_ID_POWER_STATE, "POWER_STATE" }, - { RDM_PARAM_ID_PERFORM_SELFTEST, "PERFORM_SELFTEST" }, - { RDM_PARAM_ID_SELF_TEST_DESCRIPTION, "SELF_TEST_DESCRIPTION" }, - { RDM_PARAM_ID_CAPTURE_PRESET, "CAPTURE_PRESET" }, - { RDM_PARAM_ID_PRESET_PLAYBACK, "PRESET_PLAYBACK" }, - { 0, NULL }, + { RDM_PARAM_ID_DISC_UNIQUE_BRANCH, "Discovery Unique Branch" }, + { RDM_PARAM_ID_DISC_MUTE, "Discovery Mute" }, + { RDM_PARAM_ID_DISC_UN_MUTE, "Discovery Un-Mute" }, + { RDM_PARAM_ID_PROXIED_DEVICES, "Proxied Devices" }, + { RDM_PARAM_ID_PROXIED_DEVICE_COUNT, "Proxied Device Count" }, + { RDM_PARAM_ID_COMMS_STATUS, "Communication Status" }, + { RDM_PARAM_ID_QUEUED_MESSAGE, "Queued Messages" }, + { RDM_PARAM_ID_STATUS_MESSAGES, "Status Messages" }, + { RDM_PARAM_ID_STATUS_ID_DESCRIPTION, "Status ID Description" }, + { RDM_PARAM_ID_CLEAR_STATUS_ID, "Clear Status ID" }, + { RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD, "Device Status Reporting Threshold" }, + { RDM_PARAM_ID_SUPPORTED_PARAMETERS, "Supported Parameters" }, + { RDM_PARAM_ID_PARAMETER_DESCRIPTION, "Parameter Description" }, + { RDM_PARAM_ID_DEVICE_INFO, "Device Info" }, + { RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST, "Product Detail ID List" }, + { RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION, "Device Model Description" }, + { RDM_PARAM_ID_MANUFACTURER_LABEL, "Manufacturer Label" }, + { RDM_PARAM_ID_DEVICE_LABEL, "Device Label" }, + { RDM_PARAM_ID_FACTORY_DEFAULTS, "Factory Defaults" }, + { RDM_PARAM_ID_LANGUAGE_CAPABILITIES, "Language Capabilities" }, + { RDM_PARAM_ID_LANGUAGE, "Language" }, + { RDM_PARAM_ID_SOFTWARE_VERSION_LABEL, "Software Version Label" }, + { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID, "Boot Software Version ID" }, + { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL, "Boot Software Version Label" }, + { RDM_PARAM_ID_DMX_PERSONALITY, "DMX Personality" }, + { RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION, "DMX Personality Description" }, + { RDM_PARAM_ID_DMX_START_ADDRESS, "DMX Start Address" }, + { RDM_PARAM_ID_SLOT_INFO, "Slot Info" }, + { RDM_PARAM_ID_SLOT_DESCRIPTION, "Slot Description" }, + { RDM_PARAM_ID_DEFAULT_SLOT_VALUE, "Default Slot Value" }, + + { RDM_PARAM_ID_DMX_BLOCK_ADDRESS, "DMX Block Address" }, /* E1.37-1 */ + { RDM_PARAM_ID_DMX_FAIL_MODE, "DMX Fail Mode" }, + { RDM_PARAM_ID_DMX_STARTUP_MODE, "DMX Startup Mode" }, + + { RDM_PARAM_ID_SENSOR_DEFINITION, "Sensor Definition" }, + { RDM_PARAM_ID_SENSOR_VALUE, "Sensor Value" }, + { RDM_PARAM_ID_RECORD_SENSORS, "Record Sensors" }, + + { RDM_PARAM_ID_DIMMER_INFO, "Dimmer Info" }, /* E1.37-1 */ + { RDM_PARAM_ID_MINIMUM_LEVEL, "Minimum Level" }, + { RDM_PARAM_ID_MAXIMUM_LEVEL, "Maximum Level" }, + { RDM_PARAM_ID_CURVE, "Curve" }, + { RDM_PARAM_ID_CURVE_DESCRIPTION, "Curve Description" }, + { RDM_PARAM_ID_OUTPUT_RESPONSE_TIME, "Output Response Time" }, + { RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION, "Output Response Time Description" }, + { RDM_PARAM_ID_MODULATION_FREQUENCY, "Modulation Frequency" }, + { RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION, "Modulation Frequency Description" }, + + { RDM_PARAM_ID_DEVICE_HOURS, "Device Hours" }, + { RDM_PARAM_ID_LAMP_HOURS, "Lamp Hours" }, + { RDM_PARAM_ID_LAMP_STRIKES, "Lamp Strikes" }, + { RDM_PARAM_ID_LAMP_STATE, "Lamp State" }, + { RDM_PARAM_ID_LAMP_ON_MODE, "Lamp On Mode" }, + { RDM_PARAM_ID_DEVICE_POWER_CYCLES, "Device Power Cycles" }, + + { RDM_PARAM_ID_BURN_IN, "Burn In" }, /* E1.37-1 */ + + { RDM_PARAM_ID_DISPLAY_INVERT, "Display Invert" }, + { RDM_PARAM_ID_DISPLAY_LEVEL, "Display Level" }, + { RDM_PARAM_ID_PAN_INVERT, "Pan Invert" }, + { RDM_PARAM_ID_TILT_INVERT, "Tilt Invert" }, + { RDM_PARAM_ID_PAN_TILT_SWAP, "Pan Tilt Swap" }, + { RDM_PARAM_ID_REAL_TIME_CLOCK, "Real Time Clock" }, + + { RDM_PARAM_ID_LOCK_PIN, "Lock PIN" }, /* E1.37-1 */ + { RDM_PARAM_ID_LOCK_STATE, "Lock State" }, + { RDM_PARAM_ID_LOCK_STATE_DESCRIPTION, "Lock State Description" }, + + { RDM_PARAM_ID_LIST_INTERFACES, "List Interfaces" }, /* E1.37-2 */ + { RDM_PARAM_ID_INTERFACE_LABEL, "Interface Label" }, + { RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1, "Interface Hardware Address Type 1" }, + { RDM_PARAM_ID_IPV4_DHCP_MODE, "IPv4 DHCP Mode" }, + { RDM_PARAM_ID_IPV4_ZEROCONF_MODE, "IPv4 Zero Configuration Mode" }, + { RDM_PARAM_ID_IPV4_CURRENT_ADDRESS, "IPv4 Current Address" }, + { RDM_PARAM_ID_IPV4_STATIC_ADDRESS, "IPv4 Static Address" }, + { RDM_PARAM_ID_INTERFACE_RENEW_DHCP, "Interface Renew DHCP" }, + { RDM_PARAM_ID_INTERFACE_RELEASE_DHCP, "Interface Release DHCP" }, + { RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION, "Interface Apply Configuration" }, + { RDM_PARAM_ID_IPV4_DEFAULT_ROUTE, "IPv4 Default Route" }, + { RDM_PARAM_ID_DNS_IPV4_NAME_SERVER, "DNS IPv4 Name Server" }, + { RDM_PARAM_ID_DNS_HOSTNAME, "DNS Hostname" }, + { RDM_PARAM_ID_DNS_DOMAIN_NAME, "DNS Domain Name" }, + + { RDM_PARAM_ID_COMPONENT_SCOPE, "Component Scope" }, + { RDM_PARAM_ID_SEARCH_DOMAIN, "Search Domain" }, + { RDM_PARAM_ID_TCP_COMMS_STATUS, "TCP Communication Status" }, + { RDM_PARAM_ID_BROKER_STATUS, "Broker Status" }, + + { RDM_PARAM_ID_ENDPOINT_LIST, "Endpoint List" }, /* E1.37-7 */ + { RDM_PARAM_ID_ENDPOINT_LIST_CHANGE, "Endpoint List Change" }, + { RDM_PARAM_ID_IDENTIFY_ENDPOINT, "Identify Endpoint" }, + { RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE, "Endpoint To Universe" }, + { RDM_PARAM_ID_ENDPOINT_MODE, "Endpoint Mode" }, + { RDM_PARAM_ID_ENDPOINT_LABEL, "Endpoint Label" }, + { RDM_PARAM_ID_RDM_TRAFFIC_ENABLE, "RDM Traffic Enable" }, + { RDM_PARAM_ID_DISCOVERY_STATE, "Discovery State" }, + { RDM_PARAM_ID_BACKGROUND_DISCOVERY, "Background Discovery" }, + { RDM_PARAM_ID_ENDPOINT_TIMING, "Endpoint Timing" }, + { RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION, "Endpoint Timing Description" }, + { RDM_PARAM_ID_ENDPOINT_RESPONDERS, "Endpoint Responders" }, + { RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE, "Endpoint Responder List Change" }, + { RDM_PARAM_ID_BINDING_CONTROL_FIELDS, "Binding Control Fields" }, + { RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY, "Background Queued Status Policy" }, + { RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION, "Background Queued Status Policy Description" }, + + { RDM_PARAM_ID_IDENTIFY_DEVICE, "Identify Device" }, + { RDM_PARAM_ID_RESET_DEVICE, "Reset Device" }, + { RDM_PARAM_ID_POWER_STATE, "Power State" }, + { RDM_PARAM_ID_PERFORM_SELFTEST, "Perform Self Test" }, + { RDM_PARAM_ID_SELF_TEST_DESCRIPTION, "Self Test Description" }, + { RDM_PARAM_ID_CAPTURE_PRESET, "Capture Preset" }, + { RDM_PARAM_ID_PRESET_PLAYBACK, "Preset Playback" }, + + { RDM_PARAM_ID_IDENTIFY_MODE, "Identify Mode" }, /* E1.37-1 */ + { RDM_PARAM_ID_PRESET_INFO, "Preset Info" }, + { RDM_PARAM_ID_PRESET_STATUS, "Preset Status" }, + { RDM_PARAM_ID_PRESET_MERGEMODE, "Preset Merge Mode" }, + { RDM_PARAM_ID_POWER_ON_SELF_TEST, "Power On Self Test" }, + + { 0, NULL }, }; value_string_ext rdm_param_id_vals_ext = VALUE_STRING_EXT_INIT(rdm_param_id_vals); -#define RDM_STATUS_NONE 0x00 -#define RMD_STATUS_GET_LAST_MESSAGE 0x01 -#define RDM_STATUS_ADVISORY 0x02 -#define RDM_STATUS_WARNING 0x03 -#define RDM_STATUS_ERROR 0x04 +/* manufacturer IDs */ +#define RDM_MANUFACTURER_ID_ETC 0x6574 + +#define RDM_STATUS_NONE 0x00 +#define RMD_STATUS_GET_LAST_MESSAGE 0x01 +#define RDM_STATUS_ADVISORY 0x02 +#define RDM_STATUS_WARNING 0x03 +#define RDM_STATUS_ERROR 0x04 static const value_string rdm_status_vals[] = { - { RDM_STATUS_NONE, "None" }, - { RMD_STATUS_GET_LAST_MESSAGE, "Get Last Message" }, - { RDM_STATUS_ADVISORY, "Advisory" }, - { RDM_STATUS_WARNING, "Warning" }, - { RDM_STATUS_ERROR, "Error" }, - { 0, NULL }, + { RDM_STATUS_NONE, "None" }, + { RMD_STATUS_GET_LAST_MESSAGE, "Get Last Message" }, + { RDM_STATUS_ADVISORY, "Advisory" }, + { RDM_STATUS_WARNING, "Warning" }, + { RDM_STATUS_ERROR, "Error" }, + { 0, NULL }, }; -#define RDM_PREFIX_NONE 0x00 -#define RDM_PREFIX_DECI 0x01 -#define RDM_PREFIX_CENTI 0x02 -#define RDM_PREFIX_MILLI 0x03 -#define RDM_PREFIX_MICRO 0x04 -#define RDM_PREFIX_NANO 0x05 -#define RDM_PREFIX_PICO 0x06 -#define RDM_PREFIX_FEMPTO 0x07 -#define RDM_PREFIX_ATTO 0x08 -#define RDM_PREFIX_ZEPTO 0x09 -#define RDM_PREFIX_YOCTO 0x0A -#define RDM_PREFIX_DECA 0x11 -#define RDM_PREFIX_HECTO 0x12 -#define RDM_PREFIX_KILO 0x13 -#define RDM_PREFIX_MEGA 0x14 -#define RDM_PREFIX_GIGA 0x15 -#define RDM_PREFIX_TERRA 0x16 -#define RDM_PREFIX_PETA 0x17 -#define RDM_PREFIX_EXA 0x18 -#define RDM_PREFIX_ZETTA 0x19 -#define RDM_PREFIX_YOTTA 0x1A +#define RDM_PREFIX_NONE 0x00 +#define RDM_PREFIX_DECI 0x01 +#define RDM_PREFIX_CENTI 0x02 +#define RDM_PREFIX_MILLI 0x03 +#define RDM_PREFIX_MICRO 0x04 +#define RDM_PREFIX_NANO 0x05 +#define RDM_PREFIX_PICO 0x06 +#define RDM_PREFIX_FEMPTO 0x07 +#define RDM_PREFIX_ATTO 0x08 +#define RDM_PREFIX_ZEPTO 0x09 +#define RDM_PREFIX_YOCTO 0x0A +#define RDM_PREFIX_DECA 0x11 +#define RDM_PREFIX_HECTO 0x12 +#define RDM_PREFIX_KILO 0x13 +#define RDM_PREFIX_MEGA 0x14 +#define RDM_PREFIX_GIGA 0x15 +#define RDM_PREFIX_TERRA 0x16 +#define RDM_PREFIX_PETA 0x17 +#define RDM_PREFIX_EXA 0x18 +#define RDM_PREFIX_ZETTA 0x19 +#define RDM_PREFIX_YOTTA 0x1A static const value_string rdm_prefix_vals[] = { - { RDM_PREFIX_NONE, "NONE (x1)" }, - { RDM_PREFIX_DECI, "deci (x10^-1)" }, - { RDM_PREFIX_CENTI, "centi (x10^-2)" }, - { RDM_PREFIX_MILLI, "milli (x10^-3)" }, - { RDM_PREFIX_MICRO, "micro (x10^-6)" }, - { RDM_PREFIX_NANO, "nano (x10^-9)" }, - { RDM_PREFIX_PICO, "pico (x10^-12)" }, - { RDM_PREFIX_FEMPTO, "fempto (x10^-15)" }, - { RDM_PREFIX_ATTO, "atto (x10^-18)" }, - { RDM_PREFIX_ZEPTO, "zepto (x10^-21)" }, - { RDM_PREFIX_YOCTO, "yocto (x10^-24)" }, - { RDM_PREFIX_DECA, "deca (x10^1)" }, - { RDM_PREFIX_HECTO, "hecto (x10^2)" }, - { RDM_PREFIX_KILO, "kilo (x10^3)" }, - { RDM_PREFIX_MEGA, "mega (x10^6)" }, - { RDM_PREFIX_GIGA, "giga (x10^9)" }, - { RDM_PREFIX_TERRA, "terra (x10^12)" }, - { RDM_PREFIX_PETA, "peta (x10^15)" }, - { RDM_PREFIX_EXA, "exa (x10^18)" }, - { RDM_PREFIX_ZETTA, "zetta (x10^21)" }, - { RDM_PREFIX_YOTTA, "yotta (x10^24)" }, - { 0, NULL }, + { RDM_PREFIX_NONE, "NONE (x1)" }, + { RDM_PREFIX_DECI, "deci (x10^-1)" }, + { RDM_PREFIX_CENTI, "centi (x10^-2)" }, + { RDM_PREFIX_MILLI, "milli (x10^-3)" }, + { RDM_PREFIX_MICRO, "micro (x10^-6)" }, + { RDM_PREFIX_NANO, "nano (x10^-9)" }, + { RDM_PREFIX_PICO, "pico (x10^-12)" }, + { RDM_PREFIX_FEMPTO, "fempto (x10^-15)" }, + { RDM_PREFIX_ATTO, "atto (x10^-18)" }, + { RDM_PREFIX_ZEPTO, "zepto (x10^-21)" }, + { RDM_PREFIX_YOCTO, "yocto (x10^-24)" }, + { RDM_PREFIX_DECA, "deca (x10^1)" }, + { RDM_PREFIX_HECTO, "hecto (x10^2)" }, + { RDM_PREFIX_KILO, "kilo (x10^3)" }, + { RDM_PREFIX_MEGA, "mega (x10^6)" }, + { RDM_PREFIX_GIGA, "giga (x10^9)" }, + { RDM_PREFIX_TERRA, "terra (x10^12)" }, + { RDM_PREFIX_PETA, "peta (x10^15)" }, + { RDM_PREFIX_EXA, "exa (x10^18)" }, + { RDM_PREFIX_ZETTA, "zetta (x10^21)" }, + { RDM_PREFIX_YOTTA, "yotta (x10^24)" }, + { 0, NULL }, }; static value_string_ext rdm_prefix_vals_ext = VALUE_STRING_EXT_INIT(rdm_prefix_vals); -#define RDM_UNITS_NONE 0x00 -#define RDM_UNITS_CENTIGRADE 0x01 -#define RDM_UNITS_VOLTS_DC 0x02 -#define RDM_UNITS_VOLTS_AC_PEAK 0x03 -#define RDM_UNITS_VOLTS_AC_RMS 0x04 -#define RDM_UNITS_AMPERE_DC 0x05 -#define RDM_UNITS_AMPERE_AC_PEAK 0x06 -#define RDM_UNITS_AMPERE_AC_RMS 0x07 -#define RDM_UNITS_HERTZ 0x08 -#define RDM_UNITS_OHM 0x09 -#define RDM_UNITS_WATT 0x0A -#define RDM_UNITS_KILOGRAM 0x0B -#define RDM_UNITS_METERS 0x0C -#define RDM_UNITS_METERS_SQUARED 0x0D -#define RDM_UNITS_METERS_CUBED 0x0E -#define RDM_UNITS_KILOGRAMMES_PER_METER_CUBED 0x0F -#define RDM_UNITS_METERS_PER_SECOND 0x10 -#define RDM_UNITS_METERS_PER_SECOND_SQUARED 0x11 -#define RDM_UNITS_NEWTON 0x12 -#define RDM_UNITS_JOULE 0x13 -#define RDM_UNITS_PASCAL 0x14 -#define RDM_UNITS_SECOND 0x15 -#define RDM_UNITS_DEGREE 0x16 -#define RDM_UNITS_STERADIAN 0x17 -#define RDM_UNITS_CANDELA 0x18 -#define RDM_UNITS_LUMEN 0x19 -#define RDM_UNITS_LUX 0x1A -#define RDM_UNITS_IRE 0x1B -#define RDM_UNITS_BYTE 0x1C +#define RDM_UNITS_NONE 0x00 +#define RDM_UNITS_CENTIGRADE 0x01 +#define RDM_UNITS_VOLTS_DC 0x02 +#define RDM_UNITS_VOLTS_AC_PEAK 0x03 +#define RDM_UNITS_VOLTS_AC_RMS 0x04 +#define RDM_UNITS_AMPERE_DC 0x05 +#define RDM_UNITS_AMPERE_AC_PEAK 0x06 +#define RDM_UNITS_AMPERE_AC_RMS 0x07 +#define RDM_UNITS_HERTZ 0x08 +#define RDM_UNITS_OHM 0x09 +#define RDM_UNITS_WATT 0x0A +#define RDM_UNITS_KILOGRAM 0x0B +#define RDM_UNITS_METERS 0x0C +#define RDM_UNITS_METERS_SQUARED 0x0D +#define RDM_UNITS_METERS_CUBED 0x0E +#define RDM_UNITS_KILOGRAMMES_PER_METER_CUBED 0x0F +#define RDM_UNITS_METERS_PER_SECOND 0x10 +#define RDM_UNITS_METERS_PER_SECOND_SQUARED 0x11 +#define RDM_UNITS_NEWTON 0x12 +#define RDM_UNITS_JOULE 0x13 +#define RDM_UNITS_PASCAL 0x14 +#define RDM_UNITS_SECOND 0x15 +#define RDM_UNITS_DEGREE 0x16 +#define RDM_UNITS_STERADIAN 0x17 +#define RDM_UNITS_CANDELA 0x18 +#define RDM_UNITS_LUMEN 0x19 +#define RDM_UNITS_LUX 0x1A +#define RDM_UNITS_IRE 0x1B +#define RDM_UNITS_BYTE 0x1C static const value_string rdm_unit_vals[] = { - { RDM_UNITS_NONE, "NONE" }, - { RDM_UNITS_CENTIGRADE, "Centigrade" }, - { RDM_UNITS_VOLTS_DC, "Volts DC" }, - { RDM_UNITS_VOLTS_AC_PEAK, "Volts AC Peak" }, - { RDM_UNITS_VOLTS_AC_RMS, "Volts AC RMS" }, - { RDM_UNITS_AMPERE_DC, "Ampere DC" }, - { RDM_UNITS_AMPERE_AC_PEAK, "Ampere AC Peak" }, - { RDM_UNITS_AMPERE_AC_RMS, "Ampere AC RMS" }, - { RDM_UNITS_HERTZ, "Hertz" }, - { RDM_UNITS_OHM, "Ohm" }, - { RDM_UNITS_WATT, "Watt" }, - { RDM_UNITS_KILOGRAM, "Kilogram" }, - { RDM_UNITS_METERS, "Meters" }, - { RDM_UNITS_METERS_SQUARED, "Meters Squared" }, - { RDM_UNITS_METERS_CUBED, "Meters Cubed" }, - { RDM_UNITS_KILOGRAMMES_PER_METER_CUBED, "Kilogrammes per Meter Cubed" }, - { RDM_UNITS_METERS_PER_SECOND, "Meters per Second" }, - { RDM_UNITS_METERS_PER_SECOND_SQUARED, "Meters per Second Squared" }, - { RDM_UNITS_NEWTON, "Newton" }, - { RDM_UNITS_JOULE, "Joule" }, - { RDM_UNITS_PASCAL, "Pascal" }, - { RDM_UNITS_SECOND, "Second" }, - { RDM_UNITS_DEGREE, "Degree" }, - { RDM_UNITS_STERADIAN, "Steradian" }, - { RDM_UNITS_CANDELA, "Candela" }, - { RDM_UNITS_LUMEN, "Lumen" }, - { RDM_UNITS_LUX, "Lux" }, - { RDM_UNITS_IRE, "Ire" }, - { RDM_UNITS_BYTE, "Byte" }, - { 0, NULL }, + { RDM_UNITS_NONE, "NONE" }, + { RDM_UNITS_CENTIGRADE, "Centigrade" }, + { RDM_UNITS_VOLTS_DC, "Volts DC" }, + { RDM_UNITS_VOLTS_AC_PEAK, "Volts AC Peak" }, + { RDM_UNITS_VOLTS_AC_RMS, "Volts AC RMS" }, + { RDM_UNITS_AMPERE_DC, "Ampere DC" }, + { RDM_UNITS_AMPERE_AC_PEAK, "Ampere AC Peak" }, + { RDM_UNITS_AMPERE_AC_RMS, "Ampere AC RMS" }, + { RDM_UNITS_HERTZ, "Hertz" }, + { RDM_UNITS_OHM, "Ohm" }, + { RDM_UNITS_WATT, "Watt" }, + { RDM_UNITS_KILOGRAM, "Kilogram" }, + { RDM_UNITS_METERS, "Meters" }, + { RDM_UNITS_METERS_SQUARED, "Meters Squared" }, + { RDM_UNITS_METERS_CUBED, "Meters Cubed" }, + { RDM_UNITS_KILOGRAMMES_PER_METER_CUBED, "Kilogrammes per Meter Cubed" }, + { RDM_UNITS_METERS_PER_SECOND, "Meters per Second" }, + { RDM_UNITS_METERS_PER_SECOND_SQUARED, "Meters per Second Squared" }, + { RDM_UNITS_NEWTON, "Newton" }, + { RDM_UNITS_JOULE, "Joule" }, + { RDM_UNITS_PASCAL, "Pascal" }, + { RDM_UNITS_SECOND, "Second" }, + { RDM_UNITS_DEGREE, "Degree" }, + { RDM_UNITS_STERADIAN, "Steradian" }, + { RDM_UNITS_CANDELA, "Candela" }, + { RDM_UNITS_LUMEN, "Lumen" }, + { RDM_UNITS_LUX, "Lux" }, + { RDM_UNITS_IRE, "Ire" }, + { RDM_UNITS_BYTE, "Byte" }, + { 0, NULL }, }; static value_string_ext rdm_unit_vals_ext = VALUE_STRING_EXT_INIT(rdm_unit_vals); -#define RDM_SENS_TEMPERATURE 0x00 -#define RDM_SENS_VOLTAGE 0x01 -#define RDM_SENS_CURRENT 0x02 -#define RDM_SENS_FREQUENCY 0x03 -#define RDM_SENS_RESISTANCE 0x04 -#define RDM_SENS_POWER 0x05 -#define RDM_SENS_MASS 0x06 -#define RDM_SENS_LENGTH 0x07 -#define RDM_SENS_AREA 0x08 -#define RDM_SENS_VOLUME 0x09 -#define RDM_SENS_DENSITY 0x0A -#define RDM_SENS_VELOCITY 0x0B -#define RDM_SENS_ACCELERATION 0x0C -#define RDM_SENS_FORCE 0x0D -#define RDM_SENS_ENERGY 0x0E -#define RDM_SENS_PRESSURE 0x0F -#define RDM_SENS_TIME 0x10 -#define RDM_SENS_ANGLE 0x11 -#define RDM_SENS_POSITION_X 0x12 -#define RDM_SENS_POSITION_Y 0x13 -#define RDM_SENS_POSITION_Z 0x14 -#define RDM_SENS_ANGULAR_VELOCITY 0x15 -#define RDM_SENS_LUMINOUS_INTENSITY 0x16 -#define RDM_SENS_LUMINOUS_FLUX 0x17 -#define RDM_SENS_ILLUMINANCE 0x18 -#define RDM_SENS_CHROMINANCE_RED 0x19 -#define RDM_SENS_CHROMINANCE_GREEN 0x1A -#define RDM_SENS_CHROMINANCE_BLUE 0x1B -#define RDM_SENS_CONTACTS 0x1C -#define RDM_SENS_MEMORY 0x1D -#define RDM_SENS_ITEMS 0x1E -#define RDM_SENS_HUMIDITY 0x1F -#define RDM_SENS_COUNTER_16BIT 0x20 -#define RDM_SENS_OTHER 0x7F +#define RDM_SENS_TEMPERATURE 0x00 +#define RDM_SENS_VOLTAGE 0x01 +#define RDM_SENS_CURRENT 0x02 +#define RDM_SENS_FREQUENCY 0x03 +#define RDM_SENS_RESISTANCE 0x04 +#define RDM_SENS_POWER 0x05 +#define RDM_SENS_MASS 0x06 +#define RDM_SENS_LENGTH 0x07 +#define RDM_SENS_AREA 0x08 +#define RDM_SENS_VOLUME 0x09 +#define RDM_SENS_DENSITY 0x0A +#define RDM_SENS_VELOCITY 0x0B +#define RDM_SENS_ACCELERATION 0x0C +#define RDM_SENS_FORCE 0x0D +#define RDM_SENS_ENERGY 0x0E +#define RDM_SENS_PRESSURE 0x0F +#define RDM_SENS_TIME 0x10 +#define RDM_SENS_ANGLE 0x11 +#define RDM_SENS_POSITION_X 0x12 +#define RDM_SENS_POSITION_Y 0x13 +#define RDM_SENS_POSITION_Z 0x14 +#define RDM_SENS_ANGULAR_VELOCITY 0x15 +#define RDM_SENS_LUMINOUS_INTENSITY 0x16 +#define RDM_SENS_LUMINOUS_FLUX 0x17 +#define RDM_SENS_ILLUMINANCE 0x18 +#define RDM_SENS_CHROMINANCE_RED 0x19 +#define RDM_SENS_CHROMINANCE_GREEN 0x1A +#define RDM_SENS_CHROMINANCE_BLUE 0x1B +#define RDM_SENS_CONTACTS 0x1C +#define RDM_SENS_MEMORY 0x1D +#define RDM_SENS_ITEMS 0x1E +#define RDM_SENS_HUMIDITY 0x1F +#define RDM_SENS_COUNTER_16BIT 0x20 +#define RDM_SENS_OTHER 0x7F static const value_string rdm_sensor_type_vals[] = { - { RDM_SENS_TEMPERATURE, "Temperature" }, - { RDM_SENS_VOLTAGE, "Voltage" }, - { RDM_SENS_CURRENT, "Current" }, - { RDM_SENS_FREQUENCY, "Frequency" }, - { RDM_SENS_RESISTANCE, "Resistance" }, - { RDM_SENS_POWER, "Power" }, - { RDM_SENS_MASS, "Mass" }, - { RDM_SENS_LENGTH, "Length" }, - { RDM_SENS_AREA, "Area" }, - { RDM_SENS_VOLUME, "Volume" }, - { RDM_SENS_DENSITY, "Density" }, - { RDM_SENS_VELOCITY, "Velocity" }, - { RDM_SENS_ACCELERATION, "Acceleration" }, - { RDM_SENS_FORCE, "Force" }, - { RDM_SENS_ENERGY, "Energy" }, - { RDM_SENS_PRESSURE, "Pressure" }, - { RDM_SENS_TIME, "Time" }, - { RDM_SENS_ANGLE, "Angle" }, - { RDM_SENS_POSITION_X, "Position X" }, - { RDM_SENS_POSITION_Y, "Position Y" }, - { RDM_SENS_POSITION_Z, "Position Z" }, - { RDM_SENS_ANGULAR_VELOCITY, "Angular Velocity" }, - { RDM_SENS_LUMINOUS_INTENSITY, "Luminous Intensity" }, - { RDM_SENS_LUMINOUS_FLUX, "Luminous Flux" }, - { RDM_SENS_ILLUMINANCE, "Illuminance" }, - { RDM_SENS_CHROMINANCE_RED, "Chrominance Red" }, - { RDM_SENS_CHROMINANCE_GREEN, "Chrominance Green" }, - { RDM_SENS_CHROMINANCE_BLUE, "Chrominance Blue" }, - { RDM_SENS_CONTACTS, "Contacts" }, - { RDM_SENS_MEMORY, "Memory" }, - { RDM_SENS_ITEMS, "Items" }, - { RDM_SENS_HUMIDITY, "Humidity" }, - { RDM_SENS_COUNTER_16BIT, "Counter 16bit" }, - { RDM_SENS_OTHER, "Other" }, - { 0, NULL} , + { RDM_SENS_TEMPERATURE, "Temperature" }, + { RDM_SENS_VOLTAGE, "Voltage" }, + { RDM_SENS_CURRENT, "Current" }, + { RDM_SENS_FREQUENCY, "Frequency" }, + { RDM_SENS_RESISTANCE, "Resistance" }, + { RDM_SENS_POWER, "Power" }, + { RDM_SENS_MASS, "Mass" }, + { RDM_SENS_LENGTH, "Length" }, + { RDM_SENS_AREA, "Area" }, + { RDM_SENS_VOLUME, "Volume" }, + { RDM_SENS_DENSITY, "Density" }, + { RDM_SENS_VELOCITY, "Velocity" }, + { RDM_SENS_ACCELERATION, "Acceleration" }, + { RDM_SENS_FORCE, "Force" }, + { RDM_SENS_ENERGY, "Energy" }, + { RDM_SENS_PRESSURE, "Pressure" }, + { RDM_SENS_TIME, "Time" }, + { RDM_SENS_ANGLE, "Angle" }, + { RDM_SENS_POSITION_X, "Position X" }, + { RDM_SENS_POSITION_Y, "Position Y" }, + { RDM_SENS_POSITION_Z, "Position Z" }, + { RDM_SENS_ANGULAR_VELOCITY, "Angular Velocity" }, + { RDM_SENS_LUMINOUS_INTENSITY, "Luminous Intensity" }, + { RDM_SENS_LUMINOUS_FLUX, "Luminous Flux" }, + { RDM_SENS_ILLUMINANCE, "Illuminance" }, + { RDM_SENS_CHROMINANCE_RED, "Chrominance Red" }, + { RDM_SENS_CHROMINANCE_GREEN, "Chrominance Green" }, + { RDM_SENS_CHROMINANCE_BLUE, "Chrominance Blue" }, + { RDM_SENS_CONTACTS, "Contacts" }, + { RDM_SENS_MEMORY, "Memory" }, + { RDM_SENS_ITEMS, "Items" }, + { RDM_SENS_HUMIDITY, "Humidity" }, + { RDM_SENS_COUNTER_16BIT, "Counter 16bit" }, + { RDM_SENS_OTHER, "Other" }, + { 0, NULL} , }; static value_string_ext rdm_sensor_type_vals_ext = VALUE_STRING_EXT_INIT(rdm_sensor_type_vals); -#define RDM_PRODUCT_CATEGORY_NOT_DECLARED 0x0000 -#define RDM_PRODUCT_CATEGORY_FIXTURE 0x0100 -#define RDM_PRODUCT_CATEGORY_FIXTURE_FIXED 0x0101 -#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE 0x0102 -#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR 0x0103 -#define RDM_PRODUCT_CATEGORY_FIXTURE_OTHER 0x01FF -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY 0x0200 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR 0x0201 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE 0x0202 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR 0x0203 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT 0x0204 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM 0x0205 -#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER 0x02FF -#define RDM_PRODUCT_CATEGORY_PROJECTOR 0x0300 -#define RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED 0x0301 -#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE 0x0302 -#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR 0x0303 -#define RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER 0x03FF -#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC 0x0400 -#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT 0x0401 -#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO 0x0402 -#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER 0x04FF -#define RDM_PRODUCT_CATEGORY_DIMMER 0x0500 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT 0x0501 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT 0x0502 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE 0x0503 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM 0x0504 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV 0x0505 -#define RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER 0x0506 -#define RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL 0x0507 -#define RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM 0x0508 -#define RDM_PRODUCT_CATEGORY_DIMMER_CS_LED 0x0509 -#define RDM_PRODUCT_CATEGORY_DIMMER_OTHER 0x05FF -#define RDM_PRODUCT_CATEGORY_POWER 0x0600 -#define RDM_PRODUCT_CATEGORY_POWER_CONTROL 0x0601 -#define RDM_PRODUCT_CATEGORY_POWER_SOURCE 0x0602 -#define RDM_PRODUCT_CATEGORY_POWER_OTHER 0x06FF -#define RDM_PRODUCT_CATEGORY_SCENIC 0x0700 -#define RDM_PRODUCT_CATEGORY_SCENIC_DRIVE 0x0701 -#define RDM_PRODUCT_CATEGORY_SCENIC_OTHER 0x07FF -#define RDM_PRODUCT_CATEGORY_DATA 0x0800 -#define RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION 0x0801 -#define RDM_PRODUCT_CATEGORY_DATA_CONVERSION 0x0802 -#define RDM_PRODUCT_CATEGORY_DATA_OTHER 0x08FF -#define RDM_PRODUCT_CATEGORY_AV 0x0900 -#define RDM_PRODUCT_CATEGORY_AV_AUDIO 0x0901 -#define RDM_PRODUCT_CATEGORY_AV_VIDEO 0x0902 -#define RDM_PRODUCT_CATEGORY_AV_OTHER 0x09FF -#define RDM_PRODUCT_CATEGORY_MONITOR 0x0A00 -#define RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER 0x0A01 -#define RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER 0x0A02 -#define RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL 0x0A03 -#define RDM_PRODUCT_CATEGORY_MONITOR_OTHER 0x0AFF -#define RDM_PRODUCT_CATEGORY_CONTROL 0x7000 -#define RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER 0x7001 -#define RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE 0x7002 -#define RDM_PRODUCT_CATEGORY_CONTROL_OTHER 0x70FF -#define RDM_PRODUCT_CATEGORY_TEST 0x7100 -#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT 0x7101 -#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER 0x71FF -#define RDM_PRODUCT_CATEGORY_OTHER 0x7FFF +#define RDM_PRODUCT_CATEGORY_NOT_DECLARED 0x0000 +#define RDM_PRODUCT_CATEGORY_FIXTURE 0x0100 +#define RDM_PRODUCT_CATEGORY_FIXTURE_FIXED 0x0101 +#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE 0x0102 +#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR 0x0103 +#define RDM_PRODUCT_CATEGORY_FIXTURE_OTHER 0x01FF +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY 0x0200 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR 0x0201 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE 0x0202 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR 0x0203 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT 0x0204 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM 0x0205 +#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER 0x02FF +#define RDM_PRODUCT_CATEGORY_PROJECTOR 0x0300 +#define RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED 0x0301 +#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE 0x0302 +#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR 0x0303 +#define RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER 0x03FF +#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC 0x0400 +#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT 0x0401 +#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO 0x0402 +#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER 0x04FF +#define RDM_PRODUCT_CATEGORY_DIMMER 0x0500 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT 0x0501 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT 0x0502 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE 0x0503 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM 0x0504 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV 0x0505 +#define RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER 0x0506 +#define RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL 0x0507 +#define RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM 0x0508 +#define RDM_PRODUCT_CATEGORY_DIMMER_CS_LED 0x0509 +#define RDM_PRODUCT_CATEGORY_DIMMER_OTHER 0x05FF +#define RDM_PRODUCT_CATEGORY_POWER 0x0600 +#define RDM_PRODUCT_CATEGORY_POWER_CONTROL 0x0601 +#define RDM_PRODUCT_CATEGORY_POWER_SOURCE 0x0602 +#define RDM_PRODUCT_CATEGORY_POWER_OTHER 0x06FF +#define RDM_PRODUCT_CATEGORY_SCENIC 0x0700 +#define RDM_PRODUCT_CATEGORY_SCENIC_DRIVE 0x0701 +#define RDM_PRODUCT_CATEGORY_SCENIC_OTHER 0x07FF +#define RDM_PRODUCT_CATEGORY_DATA 0x0800 +#define RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION 0x0801 +#define RDM_PRODUCT_CATEGORY_DATA_CONVERSION 0x0802 +#define RDM_PRODUCT_CATEGORY_DATA_OTHER 0x08FF +#define RDM_PRODUCT_CATEGORY_AV 0x0900 +#define RDM_PRODUCT_CATEGORY_AV_AUDIO 0x0901 +#define RDM_PRODUCT_CATEGORY_AV_VIDEO 0x0902 +#define RDM_PRODUCT_CATEGORY_AV_OTHER 0x09FF +#define RDM_PRODUCT_CATEGORY_MONITOR 0x0A00 +#define RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER 0x0A01 +#define RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER 0x0A02 +#define RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL 0x0A03 +#define RDM_PRODUCT_CATEGORY_MONITOR_OTHER 0x0AFF +#define RDM_PRODUCT_CATEGORY_CONTROL 0x7000 +#define RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER 0x7001 +#define RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE 0x7002 +#define RDM_PRODUCT_CATEGORY_CONTROL_OTHER 0x70FF +#define RDM_PRODUCT_CATEGORY_TEST 0x7100 +#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT 0x7101 +#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER 0x71FF +#define RDM_PRODUCT_CATEGORY_OTHER 0x7FFF static const value_string rdm_product_cat_vals[] = { - { RDM_PRODUCT_CATEGORY_NOT_DECLARED, "Not Declared" }, - { RDM_PRODUCT_CATEGORY_FIXTURE, "Fixture" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_FIXED, "Fixture Fixed" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE, "Fixture Moving Yoke" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR, "Fixture Moving Mirror" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_OTHER, "Fixture Other" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY, "Fixture Accessory" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR, "Fixture Accessory Color" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE, "Fixture Accessory Yoke" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR, "Fixture Accessory Mirror" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT, "Fixture Accessory Effect" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM, "Fixture Accessory Beam" }, - { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER, "Fixture Accessory Other" }, - { RDM_PRODUCT_CATEGORY_PROJECTOR, "Projector" }, - { RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED, "Projector Fixed" }, - { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE, "Projector Moving Yoke" }, - { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR, "Projector Moving Mirror" }, - { RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER, "Projector Other" }, - { RDM_PRODUCT_CATEGORY_ATMOSPHERIC, "Atmospheric" }, - { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT, "Atmospheric Effect" }, - { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO, "Atmospheric Pyro" }, - { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER, "Atmospheric Other" }, - { RDM_PRODUCT_CATEGORY_DIMMER, "Dimmer" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT, "Dimmer AC Incandescent" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT, "Dimmer AC Fluorescent" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE, "Dimmer AC Coldcathode" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM, "Dimmer AC Nondim" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV, "Dimmer AC ELV" }, - { RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER, "Dimmer AC Other" }, - { RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL, "Dimmer DC Level" }, - { RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM, "Dimmer DC PWM" }, - { RDM_PRODUCT_CATEGORY_DIMMER_CS_LED, "Dimmer CS LED" }, - { RDM_PRODUCT_CATEGORY_DIMMER_OTHER, "Dimmer Other" }, - { RDM_PRODUCT_CATEGORY_POWER, "Power" }, - { RDM_PRODUCT_CATEGORY_POWER_CONTROL, "Power Control" }, - { RDM_PRODUCT_CATEGORY_POWER_SOURCE, "Power Source" }, - { RDM_PRODUCT_CATEGORY_POWER_OTHER, "Power Other" }, - { RDM_PRODUCT_CATEGORY_SCENIC, "Scenic" }, - { RDM_PRODUCT_CATEGORY_SCENIC_DRIVE, "Scenic Drive" }, - { RDM_PRODUCT_CATEGORY_SCENIC_OTHER, "Scenic Other" }, - { RDM_PRODUCT_CATEGORY_DATA, "Data" }, - { RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION, "Data Distribution" }, - { RDM_PRODUCT_CATEGORY_DATA_CONVERSION, "Data Conversion" }, - { RDM_PRODUCT_CATEGORY_DATA_OTHER, "Data Other" }, - { RDM_PRODUCT_CATEGORY_AV, "AV" }, - { RDM_PRODUCT_CATEGORY_AV_AUDIO, "AV Audio" }, - { RDM_PRODUCT_CATEGORY_AV_VIDEO, "AV Video" }, - { RDM_PRODUCT_CATEGORY_AV_OTHER, "AV Other" }, - { RDM_PRODUCT_CATEGORY_MONITOR, "Monitor" }, - { RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER, "Monitor AC Line Power" }, - { RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER, "Monitor DC Power" }, - { RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL, "Monitor Environmental" }, - { RDM_PRODUCT_CATEGORY_MONITOR_OTHER, "Monitor Other" }, - { RDM_PRODUCT_CATEGORY_CONTROL, "Control" }, - { RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER, "Control Controller" }, - { RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE, "Control Backup Device" }, - { RDM_PRODUCT_CATEGORY_CONTROL_OTHER, "Control Other" }, - { RDM_PRODUCT_CATEGORY_TEST, "Test" }, - { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT, "Test Equipment" }, - { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER, "Test Equipment Other" }, - { RDM_PRODUCT_CATEGORY_OTHER, "Other" }, - { 0, NULL }, + { RDM_PRODUCT_CATEGORY_NOT_DECLARED, "Not Declared" }, + { RDM_PRODUCT_CATEGORY_FIXTURE, "Fixture" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_FIXED, "Fixture Fixed" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE, "Fixture Moving Yoke" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR, "Fixture Moving Mirror" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_OTHER, "Fixture Other" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY, "Fixture Accessory" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR, "Fixture Accessory Color" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE, "Fixture Accessory Yoke" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR, "Fixture Accessory Mirror" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT, "Fixture Accessory Effect" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM, "Fixture Accessory Beam" }, + { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER, "Fixture Accessory Other" }, + { RDM_PRODUCT_CATEGORY_PROJECTOR, "Projector" }, + { RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED, "Projector Fixed" }, + { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE, "Projector Moving Yoke" }, + { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR, "Projector Moving Mirror" }, + { RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER, "Projector Other" }, + { RDM_PRODUCT_CATEGORY_ATMOSPHERIC, "Atmospheric" }, + { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT, "Atmospheric Effect" }, + { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO, "Atmospheric Pyro" }, + { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER, "Atmospheric Other" }, + { RDM_PRODUCT_CATEGORY_DIMMER, "Dimmer" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT, "Dimmer AC Incandescent" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT, "Dimmer AC Fluorescent" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE, "Dimmer AC Coldcathode" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM, "Dimmer AC Nondim" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV, "Dimmer AC ELV" }, + { RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER, "Dimmer AC Other" }, + { RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL, "Dimmer DC Level" }, + { RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM, "Dimmer DC PWM" }, + { RDM_PRODUCT_CATEGORY_DIMMER_CS_LED, "Dimmer CS LED" }, + { RDM_PRODUCT_CATEGORY_DIMMER_OTHER, "Dimmer Other" }, + { RDM_PRODUCT_CATEGORY_POWER, "Power" }, + { RDM_PRODUCT_CATEGORY_POWER_CONTROL, "Power Control" }, + { RDM_PRODUCT_CATEGORY_POWER_SOURCE, "Power Source" }, + { RDM_PRODUCT_CATEGORY_POWER_OTHER, "Power Other" }, + { RDM_PRODUCT_CATEGORY_SCENIC, "Scenic" }, + { RDM_PRODUCT_CATEGORY_SCENIC_DRIVE, "Scenic Drive" }, + { RDM_PRODUCT_CATEGORY_SCENIC_OTHER, "Scenic Other" }, + { RDM_PRODUCT_CATEGORY_DATA, "Data" }, + { RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION, "Data Distribution" }, + { RDM_PRODUCT_CATEGORY_DATA_CONVERSION, "Data Conversion" }, + { RDM_PRODUCT_CATEGORY_DATA_OTHER, "Data Other" }, + { RDM_PRODUCT_CATEGORY_AV, "AV" }, + { RDM_PRODUCT_CATEGORY_AV_AUDIO, "AV Audio" }, + { RDM_PRODUCT_CATEGORY_AV_VIDEO, "AV Video" }, + { RDM_PRODUCT_CATEGORY_AV_OTHER, "AV Other" }, + { RDM_PRODUCT_CATEGORY_MONITOR, "Monitor" }, + { RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER, "Monitor AC Line Power" }, + { RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER, "Monitor DC Power" }, + { RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL, "Monitor Environmental" }, + { RDM_PRODUCT_CATEGORY_MONITOR_OTHER, "Monitor Other" }, + { RDM_PRODUCT_CATEGORY_CONTROL, "Control" }, + { RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER, "Control Controller" }, + { RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE, "Control Backup Device" }, + { RDM_PRODUCT_CATEGORY_CONTROL_OTHER, "Control Other" }, + { RDM_PRODUCT_CATEGORY_TEST, "Test" }, + { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT, "Test Equipment" }, + { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER, "Test Equipment Other" }, + { RDM_PRODUCT_CATEGORY_OTHER, "Other" }, + { 0, NULL }, }; static value_string_ext rdm_product_cat_vals_ext = VALUE_STRING_EXT_INIT(rdm_product_cat_vals); +/* E1.37-1 */ +#define RDM_PRESET_NOT_PROGRAMMED 0x00 +#define RDM_PRESET_PROGRAMMED 0x01 +#define RDM_PRESET_PROGRAMMED_READ_ONLY 0x02 + +static const value_string rdm_preset_programmed_vals[] = { + { RDM_PRESET_NOT_PROGRAMMED, "Preset Not Programmed" }, + { RDM_PRESET_PROGRAMMED, "Preset Programmed" }, + { RDM_PRESET_PROGRAMMED_READ_ONLY, "Preset Programmed Read Only" }, + { 0, NULL }, +}; + +/* E1.37-1 */ +#define RDM_MERGEMODE_DEFAULT 0x00 +#define RDM_MERGEMODE_HTP 0x01 +#define RDM_MERGEMODE_LTP 0x02 +#define RDM_MERGEMODE_DMX_ONLY 0x03 +#define RDM_MERGEMODE_OTHER 0xFF + +static const value_string rdm_mergemode_vals[] = { + { RDM_MERGEMODE_DEFAULT, "Mergemode Default" }, + { RDM_MERGEMODE_HTP, "Mergemode Highest Takes Precedence" }, + { RDM_MERGEMODE_LTP, "Mergemode Last Takes Precedence" }, + { RDM_MERGEMODE_DMX_ONLY, "Mergemode DMX Only" }, + { RDM_MERGEMODE_OTHER, "Mergemode Other" }, + { 0, NULL }, +}; + +/* E1.37-2 */ +#define RDM_DHCP_STATUS_INACTIVE 0x00 +#define RDM_DHCP_STATUS_ACTIVE 0x01 +#define RDM_DHCP_STATUS_UNKNOWN 0x02 + +static const value_string rdm_dhcp_status_vals[] = { + { RDM_DHCP_STATUS_INACTIVE, "DHCP Status Inactive" }, + { RDM_DHCP_STATUS_ACTIVE, "DHCP Status Active" }, + { RDM_DHCP_STATUS_UNKNOWN, "DHCP Status Unknown" }, + { 0, NULL }, +}; + +/* E1.37-7 */ +#define RDM_DISCOVERY_STATE_INCOMPLETE 0x00 +#define RDM_DISCOVERY_STATE_INCREMENTAL 0x01 +#define RDM_DISCOVERY_STATE_FULL 0x02 + /* skip 0x03 */ +#define RDM_DISCOVERY_STATE_NOT_ACTIVE 0x04 + +static const value_string rdm_discovery_state_vals[] = { + { RDM_DISCOVERY_STATE_INCOMPLETE, "Incomplete" }, + { RDM_DISCOVERY_STATE_INCREMENTAL, "Incremental" }, + { RDM_DISCOVERY_STATE_FULL, "Full" }, + { RDM_DISCOVERY_STATE_NOT_ACTIVE, "Not Active" }, + { 0, NULL }, +}; + +/* E1.37-7 */ +#define RDM_ENDPOINT_MODE_DISABLED 0x00 +#define RDM_ENDPOINT_MODE_INPUT 0x01 +#define RDM_ENDPOINT_MODE_OUTPUT 0x02 + +static const value_string rdm_endpoint_mode_vals[] = { + { RDM_ENDPOINT_MODE_DISABLED, "Disabled" }, + { RDM_ENDPOINT_MODE_INPUT, "Input" }, + { RDM_ENDPOINT_MODE_OUTPUT, "Output" }, + { 0, NULL }, +}; + +/* E1.37-7 */ +#define RDM_ENDPOINT_TYPE_VIRTUAL 0x00 +#define RDM_ENDPOINT_TYPE_PHYSICAL 0x01 + +static const value_string rdm_endpoint_type_vals[] = { + { RDM_ENDPOINT_TYPE_VIRTUAL, "Virtual" }, + { RDM_ENDPOINT_TYPE_PHYSICAL, "Physical" }, + { 0, NULL }, +}; + +/* E1.33 Table A-17 Static Config Types for Component Scope Messages */ +#define RDMNET_COMPONENT_SCOPE_NO_STATIC_CONFIG 0x00 +#define RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV4 0x01 +#define RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV6 0x02 + +static const value_string rdmnet_component_scope_static_config_type_vals[] = { + { RDMNET_COMPONENT_SCOPE_NO_STATIC_CONFIG, "No Static Config" }, + { RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV4, "Static Config IPv4" }, + { RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV6, "Static Config IPv6" }, + { 0, NULL } +}; +/* E1.33 Table A-18 Broker States for Broker Status Messages */ +#define RDMNET_BROKER_STATE_DISABLED 0x00 +#define RDMNET_BROKER_STATE_ACTIVE 0x01 +#define RDMNET_BROKER_STATE_STANDBY 0x02 + +static const value_string rdmnet_broker_status_states_vals[] = { + { RDMNET_BROKER_STATE_DISABLED, "Broker State Disabled" }, + { RDMNET_BROKER_STATE_ACTIVE, "Broker State Active" }, + { RDMNET_BROKER_STATE_STANDBY, "Broker State Standby" }, + { 0, NULL } +}; + +static const value_string true_false_vals[] = { + { 0x00, "False" }, + { 0x01, "True" }, + { 0, NULL }, +}; + +static const value_string enabled_disabled_vals[] = { + { 0x00, "Disabled" }, + { 0x01, "Enabled" }, + { 0, NULL }, +}; + +static const value_string on_off_vals[] = { + { 0x00, "Off" }, + { 0x01, "On" }, + { 0, NULL }, +}; + static int proto_rdm = -1; static int hf_rdm_sub_start_code = -1; @@ -669,2207 +947,5972 @@ static int hf_rdm_pd_status_id_description = -1; static int hf_rdm_pd_sub_device_status_report_threshold_status_type = -1; static int hf_rdm_pd_product_detail_id_list = -1; static int hf_rdm_pd_factory_defaults = -1; +static int hf_rdm_pd_background_discovery_endpoint_id = -1; +static int hf_rdm_pd_background_discovery_enabled = -1; +static int hf_rdm_pd_background_queued_status_policy_current_policy = -1; +static int hf_rdm_pd_background_queued_status_policy_number_of_policies = -1; +static int hf_rdm_pd_background_queued_status_policy_description_policy = -1; +static int hf_rdm_pd_background_queued_status_policy_description_description = -1; +static int hf_rdm_pd_binding_control_fields_endpoint_id = -1; +static int hf_rdm_pd_binding_control_fields_uid = -1; +static int hf_rdm_pd_binding_control_fields_control_field = -1; +static int hf_rdm_pd_binding_control_fields_binding_uid = -1; +static int hf_rem_pd_broker_status_set_allowed = -1; +static int hf_rem_pd_broker_status_state = -1; +static int hf_rdm_pd_burn_in = -1; +static int hf_rdm_pd_component_scope_scope_slot = -1; +static int hf_rdm_pd_component_scope_scope_string = -1; +static int hf_rdm_pd_component_scope_scope_static_config_type = -1; +static int hf_rdm_pd_component_scope_scope_static_ipv4_address = -1; +static int hf_rdm_pd_component_scope_scope_static_ipv6_address = -1; +static int hf_rdm_pd_component_scope_scope_static_port = -1; +static int hf_rdm_pd_current_address_interface_identifier = -1; +static int hf_rdm_pd_current_address_ipv4_address = -1; +static int hf_rdm_pd_current_address_netmask = -1; +static int hf_rdm_pd_current_address_dhcp_status = -1; +static int hf_rdm_pd_curve_curve = -1; +static int hf_rdm_pd_curve_number_of_curves = -1; +static int hf_rdm_pd_curve_description_curve = -1; +static int hf_rdm_pd_curve_description_text = -1; +static int hf_rdm_pd_dhcp_mode_interface_identifier = -1; +static int hf_rdm_pd_dhcp_mode_enabled = -1; +static int hf_rdm_pd_dimmer_info_minimum_level_lower_limit = -1; +static int hf_rdm_pd_dimmer_info_minimum_level_upper_limit = -1; +static int hf_rdm_pd_dimmer_info_maximum_level_lower_limit = -1; +static int hf_rdm_pd_dimmer_info_maximum_level_upper_limit = -1; +static int hf_rdm_pd_dimmer_info_number_of_supported_curves = -1; +static int hf_rdm_pd_dimmer_info_levels_resolution = -1; +static int hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported = -1; +static int hf_rdm_pd_discovery_state_endpoint_id = -1; +static int hf_rdm_pd_discovery_state_device_count = -1; +static int hf_rdm_pd_discovery_state_discovery_state = -1; +static int hf_rdm_pd_dmx_block_address_base_dmx_address = -1; +static int hf_rdm_pd_dmx_block_address_subdevice_footprint = -1; +static int hf_rdm_pd_dmx_fail_mode_scene_number = -1; +static int hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay = -1; +static int hf_rdm_pd_dmx_fail_mode_hold_time = -1; +static int hf_rdm_pd_dmx_fail_mode_level = -1; static int hf_rdm_pd_dmx_pers_nr = -1; static int hf_rdm_pd_dmx_pers_count = -1; static int hf_rdm_pd_dmx_pers_requested = -1; static int hf_rdm_pd_dmx_pers_slots = -1; static int hf_rdm_pd_dmx_pers_text = -1; +static int hf_rdm_pd_dmx_startup_mode_scene_number = -1; +static int hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay = -1; +static int hf_rdm_pd_dmx_startup_mode_hold_time = -1; +static int hf_rdm_pd_dmx_startup_mode_level = -1; +static int hf_rdm_pd_dns_domain_name = -1; +static int hf_rdm_pd_dns_hostname = -1; +static int hf_rdm_pd_dns_ipv4_name_server_index = -1; +static int hf_rdm_pd_dns_ipv4_name_server_address = -1; +static int hf_rdm_pd_endpoint_label_endpoint_id = -1; +static int hf_rdm_pd_endpoint_label_label = -1; +static int hf_rdm_pd_endpoint_list_change_number = -1; +static int hf_rdm_pd_endpoint_list_endpoint_id = -1; +static int hf_rdm_pd_endpoint_list_endpoint_type = -1; +static int hf_rdm_pd_endpoint_list_change_change_number = -1; +static int hf_rdm_pd_endpoint_mode_endpoint_id = -1; +static int hf_rdm_pd_endpoint_mode_endpoint_mode = -1; +static int hf_rdm_pd_endpoint_responder_list_change_endpoint_id = -1; +static int hf_rdm_pd_endpoint_responder_list_change_change_number = -1; +static int hf_rdm_pd_endpoint_responders_endpoint_id = -1; +static int hf_rdm_pd_endpoint_responders_change_number = -1; +static int hf_rdm_pd_endpoint_responders_uid = -1; +static int hf_rdm_pd_endpoint_timing_endpoint_id = -1; +static int hf_rdm_pd_endpoint_timing_setting = -1; +static int hf_rdm_pd_endpoint_timing_number_of_settings = -1; +static int hf_rdm_pd_endpoint_timing_description_setting = -1; +static int hf_rdm_pd_endpoint_timing_description_description = -1; +static int hf_rdm_pd_endpoint_to_universe_endpoint_id = -1; +static int hf_rdm_pd_endpoint_to_universe_universe_number = -1; +static int hf_rdm_pd_hardware_address_type1_interface_identifier = -1; +static int hf_rdm_pd_hardware_address_type1_hardware_address = -1; +static int hf_rdm_pd_identify_endpoint_endpoint_id = -1; +static int hf_rdm_pd_identify_endpoint_identify_state = -1; +static int hf_rdm_pd_identify_mode = -1; +static int hf_rdm_pd_interface_apply_configuration_interface_identifier = -1; +static int hf_rdm_pd_interface_label_interface_identifier = -1; +static int hf_rdm_pd_interface_label_label = -1; +static int hf_rdm_pd_interface_release_dhcp_interface_identifier = -1; +static int hf_rdm_pd_interface_renew_dhcp_interface_identifier = -1; +static int hf_rdm_pd_ipv4_default_route_interface_identifier = -1; +static int hf_rdm_pd_ipv4_default_route_ipv4_default_route = -1; +static int hf_rdm_pd_list_interfaces_interface_identifier = -1; +static int hf_rdm_pd_list_interfaces_interface_hardware_type = -1; +static int hf_rdm_pd_lock_pin_pin_code = -1; +static int hf_rdm_pd_lock_pin_new_pin_code = -1; +static int hf_rdm_pd_lock_state_lock_state = -1; +static int hf_rdm_pd_lock_state_number_of_lock_states = -1; +static int hf_rdm_pd_lock_state_pin_code = -1; +static int hf_rdm_pd_lock_state_description_lock_state = -1; +static int hf_rdm_pd_lock_state_description_text = -1; +static int hf_rdm_pd_maximum_level_level = -1; +static int hf_rdm_pd_preset_mergemode = -1; +static int hf_rdm_pd_power_on_self_test = -1; +static int hf_rdm_pd_minimum_level_increasing = -1; +static int hf_rdm_pd_minimum_level_decreasing = -1; +static int hf_rdm_pd_minimum_level_on_below_minimum = -1; +static int hf_rdm_pd_modulation_frequency_modulation_frequency = -1; +static int hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies = -1; +static int hf_rdm_pd_modulation_frequency_description_modulation_frequency = -1; +static int hf_rdm_pd_modulation_frequency_description_text = -1; +static int hf_rdm_pd_output_response_time_response_time = -1; +static int hf_rdm_pd_output_response_time_number_of_response_times = -1; +static int hf_rdm_pd_output_response_time_description_output_response_time = -1; +static int hf_rdm_pd_output_response_time_description_text = -1; +static int hf_rdm_pd_preset_info_level_field_supported = -1; +static int hf_rdm_pd_preset_info_preset_sequence_supported = -1; +static int hf_rdm_pd_preset_info_split_times_supported = -1; +static int hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported = -1; +static int hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported = -1; +static int hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_scene_number = -1; +static int hf_rdm_pd_preset_info_minimum_preset_fade_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_preset_fade_time_supported = -1; +static int hf_rdm_pd_preset_info_minimum_preset_wait_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_preset_wait_time_supported = -1; +static int hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported = -1; +static int hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported = -1; +static int hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported = -1; +static int hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported = -1; +static int hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported = -1; +static int hf_rdm_pd_preset_status_scene_number = -1; +static int hf_rdm_pd_preset_status_up_fade_time = -1; +static int hf_rdm_pd_preset_status_down_fade_time = -1; +static int hf_rdm_pd_preset_status_wait_time = -1; +static int hf_rdm_pd_preset_status_programmed = -1; +static int hf_rdm_pd_preset_status_clear_preset = -1; +static int hf_rdm_pd_rdm_traffic_enable_endpoint_id = -1; +static int hf_rdm_pd_rdm_traffic_enable_rdm_enabled = -1; +static int hf_rdm_pd_search_domain_dns_domain_name = -1; static int hf_rdm_pd_slot_offset = -1; static int hf_rdm_pd_slot_type = -1; static int hf_rdm_pd_slot_label_id = -1; static int hf_rdm_pd_slot_nr = -1; static int hf_rdm_pd_slot_description = -1; static int hf_rdm_pd_slot_value = -1; +static int hf_rdm_pd_static_address_interface_identifier = -1; +static int hf_rdm_pd_static_address_ipv4_address = -1; +static int hf_rdm_pd_static_address_netmask = -1; +static int hf_rdm_pd_tcp_comms_status_scope_string = -1; +static int hf_rdm_pd_tcp_comms_status_broker_ipv4_address = -1; +static int hf_rdm_pd_tcp_comms_status_broker_ipv6_address = -1; +static int hf_rdm_pd_tcp_comms_status_broker_port = -1; +static int hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events = -1; +static int hf_rdm_pd_zeroconf_mode_interface_identifier = -1; +static int hf_rdm_pd_zeroconf_mode_enabled = -1; static int hf_rdm_pd_rec_value_support = -1; static int ett_rdm = -1; static expert_field ei_rdm_checksum = EI_INIT; +/* begin manufacturer-specific constants and variables */ +/* begin ETC */ + +/* ETC manufacturer-specific PIDs */ +#define ETC_PARAM_ID_LED_CURVE 0x8101 +#define ETC_PARAM_ID_LED_CURVE_DESCRIPTION 0x8102 +#define ETC_PARAM_ID_LED_STROBE 0x8103 +#define ETC_PARAM_ID_LED_OUTPUT_MODE 0x8104 +#define ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION 0x8105 +#define ETC_PARAM_ID_LED_RED_SHIFT 0x8106 +#define ETC_PARAM_ID_LED_WHITE_POINT 0x8107 +#define ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION 0x8108 +#define ETC_PARAM_ID_LED_FREQUENCY 0x8109 +#define ETC_PARAM_ID_DMX_LOSS_BEHAVIOR 0x810A +#define ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION 0x810B +#define ETC_PARAM_ID_LED_PLUS_SEVEN 0x810C +#define ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS 0x810D +#define ETC_PARAM_ID_BACKLIGHT_TIMEOUT 0x810E +#define ETC_PARAM_ID_STATUS_INDICATORS 0x810F +#define ETC_PARAM_ID_RECALIBRATE_FIXTURE 0x8110 +#define ETC_PARAM_ID_OVERTEMPMODE 0x8111 +#define ETC_PARAM_ID_SIMPLESETUPMODE 0x8112 +#define ETC_PARAM_ID_LED_STROBE_DESCRIPTION 0x8113 +#define ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION 0x8114 +#define ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION 0x8115 +#define ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION 0x8116 +#define ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION 0x8117 +#define ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION 0x8118 +#define ETC_PARAM_ID_LED_REQUESTED_XY 0x8119 +#define ETC_PARAM_ID_LED_CURRENT_XY 0x811A +#define ETC_PARAM_ID_LED_CURRENT_PWM 0x811B +#define ETC_PARAM_ID_LED_TRISTIMULUS 0x811C +#define ETC_PARAM_ID_LED_INFORMATION 0x811D +#define ETC_PARAM_ID_PRESETCONFIG 0x811E +#define ETC_PARAM_ID_SEQUENCE_PLAYBACK 0x811F +#define ETC_PARAM_ID_SEQUENCE_CONFIG 0x8120 +#define ETC_PARAM_ID_LOW_POWER_TIMEOUT 0x8121 +#define ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION 0x8122 +#define ETC_PARAM_ID_LED_ENUM_FREQUENCY 0x8123 +#define ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION 0x8124 +#define ETC_PARAM_ID_RGBI_PRESETCONFIG 0x8125 +#define ETC_PARAM_ID_CCT_PRESETCONFIG 0x8126 +#define ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION 0x8130 +/* do not display +#define ETC_PARAM_ID_START_UWB_DISCOVER 0x8150 +#define ETC_PARAM_ID_START_UWB_MEASURE 0x8151 +#define ETC_PARAM_ID_POSITION 0x8152 +*/ +#define ETC_PARAM_ID_S4DIM_CALIBRATE 0x9000 +#define ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION 0x9001 +#define ETC_PARAM_ID_S4DIM_TEST_MODE 0x9002 +#define ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION 0x9003 +#define ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE 0x9004 +#define ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION 0x9005 +#define ETC_PARAM_ID_POWER_COMMAND 0xA000 +#define ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION 0xA001 +#define ETC_PARAM_ID_THRESHOLD_COMMAND 0xA002 +#define ETC_PARAM_ID_TURNON_DELAY_COMMAND 0xA003 +#define ETC_PARAM_ID_SET_DALI_SHORTADDRESS 0xA004 +#define ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP 0xA005 +#define ETC_PARAM_ID_AUTOBIND 0xA006 +#define ETC_PARAM_ID_DELETE_SUBDEVICE 0xA007 +#define ETC_PARAM_ID_PACKET_DELAY 0xB000 +#define ETC_PARAM_ID_HAS_ENUM_TEXT 0xE000 +#define ETC_PARAM_ID_GET_ENUM_TEXT 0xE001 +#define ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD 0xF000 + +static const value_string etc_param_id_vals[] = { + { ETC_PARAM_ID_LED_CURVE, "LED Curve" }, + { ETC_PARAM_ID_LED_CURVE_DESCRIPTION, "LED Curve Description" }, + { ETC_PARAM_ID_LED_STROBE, "LED Strobe" }, + { ETC_PARAM_ID_LED_OUTPUT_MODE, "LED Output Mode" }, + { ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION, "LED Output Mode Description" }, + { ETC_PARAM_ID_LED_RED_SHIFT, "LED Red Shift" }, + { ETC_PARAM_ID_LED_WHITE_POINT, "LED White Point" }, + { ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION, "LED White Point Description" }, + { ETC_PARAM_ID_LED_FREQUENCY, "LED Frequency" }, + { ETC_PARAM_ID_DMX_LOSS_BEHAVIOR, "DMX Loss Behavior" }, + { ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION, "DMX Loss Behavior Description" }, + { ETC_PARAM_ID_LED_PLUS_SEVEN, "LED Plus Seven" }, + { ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS, "Backlight Brightness" }, + { ETC_PARAM_ID_BACKLIGHT_TIMEOUT, "Backlight Timeout" }, + { ETC_PARAM_ID_STATUS_INDICATORS, "Status Indicators" }, + { ETC_PARAM_ID_RECALIBRATE_FIXTURE, "Recalibrate Fixture" }, + { ETC_PARAM_ID_OVERTEMPMODE, "Overtemp Mode" }, + { ETC_PARAM_ID_SIMPLESETUPMODE, "Simple Setup Mode" }, + { ETC_PARAM_ID_LED_STROBE_DESCRIPTION, "LED Strobe Description" }, + { ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION, "LED Red Shift Description" }, + { ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION, "LED Plus Seven Description" }, + { ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION, "Backlight Timeout Description" }, + { ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION, "Simple Setup Mode Description" }, + { ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION, "Overtemp Mode Description" }, + { ETC_PARAM_ID_LED_REQUESTED_XY, "LED Requested XY" }, + { ETC_PARAM_ID_LED_CURRENT_XY, "LED Current XY" }, + { ETC_PARAM_ID_LED_CURRENT_PWM, "LED Current PWM" }, + { ETC_PARAM_ID_LED_TRISTIMULUS, "LED Tristimulus" }, + { ETC_PARAM_ID_LED_INFORMATION, "LED Information" }, + { ETC_PARAM_ID_PRESETCONFIG, "Preset Config" }, + { ETC_PARAM_ID_SEQUENCE_PLAYBACK, "Sequence Playback" }, + { ETC_PARAM_ID_SEQUENCE_CONFIG, "Sequence Config" }, + { ETC_PARAM_ID_LOW_POWER_TIMEOUT, "Low Power Timeout" }, + { ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION, "Low Power Timeout Description" }, + { ETC_PARAM_ID_LED_ENUM_FREQUENCY, "LED Enum Frequency" }, + { ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION, "LED Enum Frequency Description" }, + { ETC_PARAM_ID_RGBI_PRESETCONFIG, "RGBI Preset Config" }, + { ETC_PARAM_ID_CCT_PRESETCONFIG, "CCT Preset Config" }, + { ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION, "Supplementary Device Version" }, + /* do not display + { ETC_PARAM_ID_START_UWB_DISCOVER, "Start UWB Discover" }, + { ETC_PARAM_ID_START_UWB_MEASURE, "Start UWB Measure" }, + { ETC_PARAM_ID_POSITION, "Position" }, + */ + { ETC_PARAM_ID_S4DIM_CALIBRATE, "S4Dimmer Calibrate" }, + { ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION, "S4Dimmer Calibrate Description" }, + { ETC_PARAM_ID_S4DIM_TEST_MODE, "S4Dimmer Test Mode" }, + { ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION, "S4Dimmer Test Mode Description" }, + { ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE, "S4Dimmer Max Output Voltage" }, + { ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION, "S4Dimmer Max Output Voltage Description" }, + { ETC_PARAM_ID_POWER_COMMAND, "Power Command" }, + { ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION, "Power Command Description" }, + { ETC_PARAM_ID_THRESHOLD_COMMAND, "Threshold Command" }, + { ETC_PARAM_ID_TURNON_DELAY_COMMAND, "Turn On Delay Command" }, + { ETC_PARAM_ID_SET_DALI_SHORTADDRESS, "Set DALI Short Address" }, + { ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP, "DALI Group Membership" }, + { ETC_PARAM_ID_AUTOBIND, "Auto Bind" }, + { ETC_PARAM_ID_DELETE_SUBDEVICE, "Delete Subdevice" }, + { ETC_PARAM_ID_PACKET_DELAY, "Packet Delay" }, + { ETC_PARAM_ID_HAS_ENUM_TEXT, "Has Enum Text" }, + { ETC_PARAM_ID_GET_ENUM_TEXT, "Get Enum Text" }, + { ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD, "Prepare For Software Load" }, + { 0, NULL }, +}; + +value_string_ext etc_param_id_vals_ext = VALUE_STRING_EXT_INIT(etc_param_id_vals); + +#define ETC_LED_CURVE_STANDARD 0x00 +#define ETC_LED_CURVE_INCANDESCENT 0x01 +#define ETC_LED_CURVE_LINEAR 0x02 +#define ETC_LED_CURVE_QUICK 0x03 + +static const value_string etc_led_curve_vals[] = { + { ETC_LED_CURVE_STANDARD, "Standard" }, + { ETC_LED_CURVE_INCANDESCENT, "Incandescent" }, + { ETC_LED_CURVE_LINEAR, "Linear" }, + { ETC_LED_CURVE_QUICK, "Quick" }, + { 0, NULL }, +}; + +#define ETC_LED_OUTPUT_MODE_REGULATED 0x00 +#define ETC_LED_OUTPUT_MODE_BOOST 0x01 +#define ETC_LED_OUTPUT_MODE_PROTECTED 0x02 + +static const value_string etc_led_output_mode_vals[] = { + { ETC_LED_OUTPUT_MODE_REGULATED, "Regulated" }, + { ETC_LED_OUTPUT_MODE_BOOST, "Boost" }, + { ETC_LED_OUTPUT_MODE_PROTECTED, "Protected" }, + { 0, NULL }, +}; + +#define ETC_LED_WHITE_POINT_2950K 0x00 +#define ETC_LED_WHITE_POINT_3200K 0x01 +#define ETC_LED_WHITE_POINT_5600K 0x02 +#define ETC_LED_WHITE_POINT_6500K 0x03 + +static const value_string etc_led_white_point_vals[] = { + { ETC_LED_WHITE_POINT_2950K, "2950 K" }, + { ETC_LED_WHITE_POINT_3200K, "3200 K" }, + { ETC_LED_WHITE_POINT_5600K, "5600 K" }, + { ETC_LED_WHITE_POINT_6500K, "6500 K" }, + { 0, NULL }, +}; + +#define ETC_DMX_LOSS_BEHAVIOR_INSTANT 0x00 +#define ETC_DMX_LOSS_BEHAVIOR_WAIT2MIN 0x01 +#define ETC_DMX_LOSS_BEHAVIOR_HLL 0x02 + +static const value_string etc_dmx_data_loss_vals[] = { + { ETC_DMX_LOSS_BEHAVIOR_INSTANT, "Instant" }, + { ETC_DMX_LOSS_BEHAVIOR_WAIT2MIN, "Hold Last Look 2 Minutes" }, + { ETC_DMX_LOSS_BEHAVIOR_HLL, "Hold Last Look Forever" }, + { 0, NULL }, +}; + +#define ETC_DMX_BACKLIGHT_TIMEOUT_NEVER 0x00 +#define ETC_DMX_BACKLIGHT_TIMEOUT_30SEC 0x01 +#define ETC_DMX_BACKLIGHT_TIMEOUT_1MIN 0x02 +#define ETC_DMX_BACKLIGHT_TIMEOUT_5MIN 0x03 +#define ETC_DMX_BACKLIGHT_TIMEOUT_15MIN 0x04 + +static const value_string etc_backlight_timeout_vals[] = { + { ETC_DMX_BACKLIGHT_TIMEOUT_NEVER, "Never" }, + { ETC_DMX_BACKLIGHT_TIMEOUT_30SEC, "30 Seconds" }, + { ETC_DMX_BACKLIGHT_TIMEOUT_1MIN, "1 Minute" }, + { ETC_DMX_BACKLIGHT_TIMEOUT_5MIN, "5 Minute" }, + { ETC_DMX_BACKLIGHT_TIMEOUT_15MIN, "15 Minute" }, + { 0, NULL }, +}; + +#define ETC_OVERTEMP_MODE_DARK 0x00 +#define ETC_OVERTEMP_MODE_VISIBLE 0x01 + +static const value_string etc_overtemp_mode_vals[] = { + { ETC_OVERTEMP_MODE_DARK, "Dark When Overtemp" }, + { ETC_OVERTEMP_MODE_VISIBLE, "Red When Overtemp" }, + { 0, NULL }, +}; + +#define ETC_EASY_MODE_GENERAL 0x00 +#define ETC_EASY_MODE_STAGE 0x01 +#define ETC_EASY_MODE_ARCH 0x02 +#define ETC_EASY_MODE_EFFECTS 0x03 +#define ETC_EASY_MODE_STUDIO 0x04 +#define ETC_EASY_MODE_ADVANCED 0x05 + +static const value_string etc_simple_setup_mode_vals[] = { + { ETC_EASY_MODE_GENERAL, "General Use" }, + { ETC_EASY_MODE_STAGE, "Stage Setup" }, + { ETC_EASY_MODE_ARCH, "Arch Setup" }, + { ETC_EASY_MODE_EFFECTS, "Effects Setup" }, + { ETC_EASY_MODE_STUDIO, "Studio Setup" }, + { ETC_EASY_MODE_ADVANCED, "Advanced Setup" }, + { 0, NULL }, +}; + +#define ETC_LOW_POWER_TIMEOUT_NEVER 0x00 +#define ETC_LOW_POWER_TIMEOUT_15MIN 0x01 +#define ETC_LOW_POWER_TIMEOUT_30MIN 0x02 +#define ETC_LOW_POWER_TIMEOUT_1HOUR 0x03 +#define ETC_LOW_POWER_TIMEOUT_4HOURS 0x04 +#define ETC_LOW_POWER_TIMEOUT_8HOURS 0x05 + +static const value_string etc_low_power_timeout_vals[] = { + { ETC_LOW_POWER_TIMEOUT_NEVER, "Never" }, + { ETC_LOW_POWER_TIMEOUT_15MIN, "15 Minutes" }, + { ETC_LOW_POWER_TIMEOUT_30MIN, "30 Minutes" }, + { ETC_LOW_POWER_TIMEOUT_1HOUR, "1 Hour" }, + { ETC_LOW_POWER_TIMEOUT_4HOURS, "4 Hours" }, + { ETC_LOW_POWER_TIMEOUT_8HOURS, "8 Hours" }, + { 0, NULL }, +}; + +#define ETC_LED_FREQ_ENUM_1200HZ 0x00 +#define ETC_LED_FREQ_ENUM_25000HZ 0x01 + +static const value_string etc_led_frequency_enum_vals[] = { + { ETC_LED_FREQ_ENUM_1200HZ, "1.2 kHz" }, + { ETC_LED_FREQ_ENUM_25000HZ, "25 kHz" }, + { 0, NULL }, +}; + +#define ETC_MODEL_ID_SMARTBAR 0x0001 +#define ETC_MODEL_ID_SOURCE_4_LED_LUSTR_PLUS 0x0101 +#define ETC_MODEL_ID_DESIRE_ICE_40_LED 0x0102 +#define ETC_MODEL_ID_DESIRE_FIRE_40_LED 0x0103 +#define ETC_MODEL_ID_SOURCE_4_LED_TUNGSTEN 0x0107 +#define ETC_MODEL_ID_SOURCE_4_LED_DAYLIGHT 0x0108 +#define ETC_MODEL_ID_DESIRE_VIVID_40_LED 0x0109 +#define ETC_MODEL_ID_DESIRE_LUSTR_60_LED_OBS 0x0111 +#define ETC_MODEL_ID_DESIRE_ICE_60_LED 0x0112 +#define ETC_MODEL_ID_DESIRE_FIRE_60_LED 0x0113 +#define ETC_MODEL_ID_DESIRE_VIVID_60_LED 0x0119 +#define ETC_MODEL_ID_DESIRE_STUDIO_40_LED 0x0121 +#define ETC_MODEL_ID_DESIRE_STUDIO_60_LED 0x0129 +#define ETC_MODEL_ID_DESIRE_LUSTR_40_LED 0x0131 +#define ETC_MODEL_ID_DESIRE_LUSTR_60_LED 0x0139 +#define ETC_MODEL_ID_DESIRE_DAYLIGHT_40_LED 0x0141 +#define ETC_MODEL_ID_DESIRE_TUNGSTEN_40_LED 0x0142 +#define ETC_MODEL_ID_DESIRE_DAYLIGHT_60_LED 0x0149 +#define ETC_MODEL_ID_DESIRE_TUNGSTEN_60_LED 0x014A +#define ETC_MODEL_ID_DESIRE_D22_LUSTR_PLUS_LED 0x0151 +#define ETC_MODEL_ID_DESIRE_D22_DAYLIGHT_LED 0x0159 +#define ETC_MODEL_ID_DESIRE_D22_TUNGSTEN_LED 0x015A +#define ETC_MODEL_ID_SOURCE_4_LED_STUDIO_HD 0x0179 +#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_LUSTR 0x0181 +#define ETC_MODEL_ID_DESIRE_D22_STUDIO_HD 0x0189 +#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_TUNGSTEN_HD 0x0191 +#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_DAYLIGHT_HD 0x0199 +#define ETC_MODEL_ID_COLORSOURCE_BOOTLOADER 0x0200 +#define ETC_MODEL_ID_COLORSOURCE_PAR 0x0201 +#define ETC_MODEL_ID_COLORSOURCE_PAR_DEEP_BLUE 0x0202 +#define ETC_MODEL_ID_COLORSOURCE_PAR_PEARL 0x0203 +#define ETC_MODEL_ID_COLORSOURCE_SPOT 0x0205 +#define ETC_MODEL_ID_COLORSOURCE_SPOT_DEEP_BLUE 0x0206 +#define ETC_MODEL_ID_COLORSOURCE_SPOT_PEARL 0x0207 +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1 0x0209 +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1_DEEP_BLUE 0x020A +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1_PEARL 0x020B +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2 0x020D +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2_DEEP_BLUE 0x020E +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2_PEARL 0x020F +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4 0x0211 +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4_DEEP_BLUE 0x0212 +#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4_PEARL 0x0213 +#define ETC_MODEL_ID_COLORSOURCE_CYC 0x0215 +#define ETC_MODEL_ID_SOURCE_FORWARD_120V 0x0800 +#define ETC_MODEL_ID_SOURCE_FORWARD_230V 0x0801 +#define ETC_MODEL_ID_IRIDEON_FPZ 0x0900 +#define ETC_MODEL_ID_SOURCE_FOUR_DIMMER 0x1001 +#define ETC_MODEL_ID_KILLSWITCH_WIRELESS 0x1002 +#define ETC_MODEL_ID_KILLSWITCH_DMX 0x1003 +#define ETC_MODEL_ID_KILLSWITCH_ETHERNET 0x1004 +#define ETC_MODEL_ID_KILLSWITCH_TRANSMITTER 0x1005 +#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER_SINGLE_DIMMER 0x1006 +#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER_RELAY 0x1007 +#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER__4_8_CH 0x1008 +#define ETC_MODEL_ID_COLORSOURCE_THRUPOWER_DIMMER 0x1101 +#define ETC_MODEL_ID_DMX_DALI_GATEWAY_DIN_RAIL 0x1110 + +static const value_string etc_model_id_vals[] = { + { ETC_MODEL_ID_SMARTBAR, "Smartbar" }, + { ETC_MODEL_ID_SOURCE_4_LED_LUSTR_PLUS, "Source 4 LED Lustr+" }, + { ETC_MODEL_ID_DESIRE_ICE_40_LED, "Desire Ice 40 LED" }, + { ETC_MODEL_ID_DESIRE_FIRE_40_LED, "Desire Fire 40 LED" }, + { ETC_MODEL_ID_SOURCE_4_LED_TUNGSTEN, "Source 4 LED Tungsten" }, + { ETC_MODEL_ID_SOURCE_4_LED_DAYLIGHT, "Source 4 LED Daylight" }, + { ETC_MODEL_ID_DESIRE_VIVID_40_LED, "Desire Vivid 40 LED" }, + { ETC_MODEL_ID_DESIRE_LUSTR_60_LED_OBS, "Desire Lustr 60 LED (obsolete)" }, + { ETC_MODEL_ID_DESIRE_ICE_60_LED, "Desire Ice 60 LED" }, + { ETC_MODEL_ID_DESIRE_FIRE_60_LED, "Desire Fire 60 LED" }, + { ETC_MODEL_ID_DESIRE_VIVID_60_LED, "Desire Vivid 60 LED" }, + { ETC_MODEL_ID_DESIRE_STUDIO_40_LED, "Desire Studio 40 LED" }, + { ETC_MODEL_ID_DESIRE_STUDIO_60_LED, "Desire Studio 60 LED" }, + { ETC_MODEL_ID_DESIRE_LUSTR_40_LED, "Desire Lustr 40 LED" }, + { ETC_MODEL_ID_DESIRE_LUSTR_60_LED, "Desire Lustr 60 LED" }, + { ETC_MODEL_ID_DESIRE_DAYLIGHT_40_LED, "Desire Daylight 40 LED" }, + { ETC_MODEL_ID_DESIRE_TUNGSTEN_40_LED, "Desire Tungsten 40 LED" }, + { ETC_MODEL_ID_DESIRE_DAYLIGHT_60_LED, "Desire Daylight 60 LED" }, + { ETC_MODEL_ID_DESIRE_TUNGSTEN_60_LED, "Desire Tungsten 60 LED" }, + { ETC_MODEL_ID_DESIRE_D22_LUSTR_PLUS_LED, "Desire D22 Lustr+ LED" }, + { ETC_MODEL_ID_DESIRE_D22_DAYLIGHT_LED, "Desire D22 Daylight LED" }, + { ETC_MODEL_ID_DESIRE_D22_TUNGSTEN_LED, "Desire D22 Tungsten LED" }, + { ETC_MODEL_ID_SOURCE_4_LED_STUDIO_HD, "Source 4 LED Studio HD" }, + { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_LUSTR, "Source 4 LED Series 2 Lustr" }, + { ETC_MODEL_ID_DESIRE_D22_STUDIO_HD, "Desire D22 Studio HD" }, + { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_TUNGSTEN_HD, "Source 4 LED Series 2 Tungsten HD" }, + { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_DAYLIGHT_HD, "Source 4 LED Series 2 Daylight HD" }, + { ETC_MODEL_ID_COLORSOURCE_BOOTLOADER, "ColorSource Bootloader" }, + { ETC_MODEL_ID_COLORSOURCE_PAR, "ColorSource Par" }, + { ETC_MODEL_ID_COLORSOURCE_PAR_DEEP_BLUE, "ColorSource Par DeepBlue" }, + { ETC_MODEL_ID_COLORSOURCE_PAR_PEARL, "ColorSource Par Pearl" }, + { ETC_MODEL_ID_COLORSOURCE_SPOT, "ColorSource Spot" }, + { ETC_MODEL_ID_COLORSOURCE_SPOT_DEEP_BLUE, "ColorSource Spot DeepBlue" }, + { ETC_MODEL_ID_COLORSOURCE_SPOT_PEARL, "ColorSource Spot Pearl" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_1, "ColorSource Linear 1" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_1_DEEP_BLUE, "ColorSource Linear 1 DeepBlue" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_1_PEARL, "ColorSource Linear 1 Pearl" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_2, "ColorSource Linear 2" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_2_DEEP_BLUE, "ColorSource Linear 2 DeepBlue" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_2_PEARL, "ColorSource Linear 2 Pearl" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_4, "ColorSource Linear 4" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_4_DEEP_BLUE, "ColorSource Linear 4 DeepBlue" }, + { ETC_MODEL_ID_COLORSOURCE_LINEAR_4_PEARL, "ColorSource Linear 4 Pearl" }, + { ETC_MODEL_ID_COLORSOURCE_CYC, "ColorSource Cyc" }, + { ETC_MODEL_ID_SOURCE_FORWARD_120V, "Source Forward 120v" }, + { ETC_MODEL_ID_SOURCE_FORWARD_230V, "Source Forward 230v" }, + { ETC_MODEL_ID_IRIDEON_FPZ, "Irideon FPZ" }, + { ETC_MODEL_ID_SOURCE_FOUR_DIMMER, "Source Four Dimmer" }, + { ETC_MODEL_ID_KILLSWITCH_WIRELESS, "Killswitch Wireless" }, + { ETC_MODEL_ID_KILLSWITCH_DMX, "Killswitch DMX" }, + { ETC_MODEL_ID_KILLSWITCH_ETHERNET, "Killswitch Etherner" }, + { ETC_MODEL_ID_KILLSWITCH_TRANSMITTER, "Killswitch Transmitter" }, + { ETC_MODEL_ID_DMX_ZONE_CONTROLLER_SINGLE_DIMMER, "DMX Zone Controller, Single Dimmer" }, + { ETC_MODEL_ID_DMX_ZONE_CONTROLLER_RELAY, "DMX Zone Controller, Relay" }, + { ETC_MODEL_ID_DMX_ZONE_CONTROLLER__4_8_CH, "DMX Zone Controller, 4-8 Channel Room Controller" }, + { ETC_MODEL_ID_COLORSOURCE_THRUPOWER_DIMMER, "ColorSource Thrupower Dimmer" }, + { ETC_MODEL_ID_DMX_DALI_GATEWAY_DIN_RAIL, "DMX-DALI Gateway, DIN Rail" }, + { 0, NULL }, +}; + +static int hf_etc_parameter_id = -1; /* every manufacturer needs one of these */ +static int hf_etc_pd_parameter_id = -1; /* every manufacturer needs one of these */ +static int hf_etc_pd_device_model_id = -1; +static int hf_etc_pd_led_curve = -1; +static int hf_etc_pd_led_curve_description_curve = -1; +static int hf_etc_pd_led_curve_description_text = -1; +static int hf_etc_pd_led_strobe = -1; +static int hf_etc_pd_led_output_mode = -1; +static int hf_etc_pd_led_output_mode_description_mode = -1; +static int hf_etc_pd_led_output_mode_description_text = -1; +static int hf_etc_pd_led_red_shift = -1; +static int hf_etc_pd_led_white_point = -1; +static int hf_etc_pd_led_white_point_description_white_point = -1; +static int hf_etc_pd_led_white_point_description_text = -1; +static int hf_etc_pd_led_frequency = -1; +static int hf_etc_pd_dmx_data_loss_behavior = -1; +static int hf_etc_pd_dmx_data_loss_behavior_description_behavior = -1; +static int hf_etc_pd_dmx_data_loss_behavior_description_text = -1; +static int hf_etc_pd_led_plus_seven = -1; +static int hf_etc_pd_backlight_brightness = -1; +static int hf_etc_pd_backlight_timeout = -1; +static int hf_etc_pd_status_indicators = -1; +static int hf_etc_pd_overtemp_mode = -1; +static int hf_etc_pd_simple_setup_mode = -1; +static int hf_etc_pd_led_strobe_description_strobe = -1; +static int hf_etc_pd_led_strobe_description_text = -1; +static int hf_etc_pd_red_shift_description_red_shift = -1; +static int hf_etc_pd_red_shift_description_text = -1; +static int hf_etc_pd_plus_seven_description_plus_seven = -1; +static int hf_etc_pd_plus_seven_description_text = -1; +static int hf_etc_pd_backlight_timeout_description_timeout = -1; +static int hf_etc_pd_backlight_timeout_description_text = -1; +static int hf_etc_pd_simple_setup_mode_description_mode = -1; +static int hf_etc_pd_simple_setup_mode_description_text = -1; +static int hf_etc_pd_overtemp_mode_description_mode = -1; +static int hf_etc_pd_overtemp_mode_description_text = -1; +static int hf_etc_pd_led_requested_xy_x = -1; +static int hf_etc_pd_led_requested_xy_y = -1; +static int hf_etc_pd_led_current_xy_x = -1; +static int hf_etc_pd_led_current_xy_y = -1; +static int hf_etc_pd_current_pwm_led_number = -1; +static int hf_etc_pd_current_pwm_channel_duty_cycle = -1; +static int hf_etc_pd_tristimulus_led_number = -1; +static int hf_etc_pd_tristimulus_x = -1; +static int hf_etc_pd_tristimulus_y = -1; +static int hf_etc_pd_tristimulus_z = -1; +static int hf_etc_pd_led_information_led_number = -1; +static int hf_etc_pd_led_information_type = -1; +static int hf_etc_pd_led_information_dmx_control_channel = -1; +static int hf_etc_pd_led_information_drive_current = -1; +static int hf_etc_pd_led_information_gamut_polygon_order = -1; +static int hf_etc_pd_led_information_quantity = -1; +static int hf_etc_pd_preset_config_preset_number = -1; +static int hf_etc_pd_preset_config_fade_time = -1; +static int hf_etc_pd_preset_config_delay_time = -1; +static int hf_etc_pd_preset_config_hue = -1; +static int hf_etc_pd_preset_config_saturation = -1; +static int hf_etc_pd_preset_config_intensity = -1; +static int hf_etc_pd_preset_config_strobe = -1; +static int hf_etc_pd_sequence_playback_sequence_number = -1; +static int hf_etc_pd_sequence_config_sequence_number = -1; +static int hf_etc_pd_sequence_config_preset_steps = -1; +static int hf_etc_pd_sequence_config_preset_step = -1; +static int hf_etc_pd_sequence_config_step_link_times = -1; +static int hf_etc_pd_sequence_config_step_link_time = -1; +static int hf_etc_pd_sequence_config_rate = -1; +static int hf_etc_pd_sequence_config_end_state = -1; +static int hf_etc_pd_low_power_timeout = -1; +static int hf_etc_pd_low_power_timeout_description_timeout = -1; +static int hf_etc_pd_low_power_timeout_description_text = -1; +static int hf_etc_pd_led_enum_frequency = -1; +static int hf_etc_pd_led_enum_frequency_description_frequency = -1; +static int hf_etc_pd_led_enum_frequency_description_text = -1; +static int hf_etc_pd_rgbi_preset_config_preset_number = -1; +static int hf_etc_pd_rgbi_preset_config_fade_time = -1; +static int hf_etc_pd_rgbi_preset_config_delay_time = -1; +static int hf_etc_pd_rgbi_preset_config_red = -1; +static int hf_etc_pd_rgbi_preset_config_green = -1; +static int hf_etc_pd_rgbi_preset_config_blue = -1; +static int hf_etc_pd_rgbi_preset_config_intensity = -1; +static int hf_etc_pd_rgbi_preset_config_strobe = -1; +static int hf_etc_pd_cct_preset_config_preset_number = -1; +static int hf_etc_pd_cct_preset_config_fade_time = -1; +static int hf_etc_pd_cct_preset_config_delay_time = -1; +static int hf_etc_pd_cct_preset_config_white_point = -1; +static int hf_etc_pd_cct_preset_config_tint = -1; +static int hf_etc_pd_cct_preset_config_strobe = -1; +static int hf_etc_pd_cct_preset_config_intensity = -1; +static int hf_etc_pd_cct_preset_config_tone = -1; +static int hf_etc_pd_cct_preset_config_reserved = -1; +static int hf_etc_pd_supplementary_device_version_param_index = -1; +static int hf_etc_pd_supplementary_device_version_param_description = -1; +static int hf_etc_pd_power_command = -1; +static int hf_etc_pd_power_command_description_state = -1; +static int hf_etc_pd_power_command_description_text = -1; +static int hf_etc_pd_dali_short_address = -1; +static int hf_etc_pd_dali_group_membership = -1; +static int hf_etc_pd_auto_bind = -1; +static int hf_etc_pd_packet_delay = -1; +static int hf_etc_pd_has_enum_text_pid = -1; +static int hf_etc_pd_has_enum_text_true_false = -1; +static int hf_etc_pd_get_enum_text_pid = -1; +static int hf_etc_pd_get_enum_text_enum = -1; +static int hf_etc_pd_get_enum_text_description = -1; + +static int ett_etc_sequence_config_steps = -1; +static int ett_etc_sequence_config_times = -1; + +/* end ETC */ +/* end manufacturer-specific constants and variables */ + static guint16 rdm_checksum(tvbuff_t *tvb, guint length) { - guint16 sum = RDM_SC_RDM; - guint i; - for (i = 0; i < length; i++) - sum += tvb_get_guint8(tvb, i); - return sum; + guint16 sum = RDM_SC_RDM; + guint i; + for (i = 0; i < length; i++) + sum += tvb_get_guint8(tvb, i); + return sum; +} + +static void +rdm_proto_tree_add_numeric_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, guint8 len) +{ + guint offset = *offset_ptr; + proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_BIG_ENDIAN); + *offset_ptr += len; +} + +static void +rdm_proto_tree_add_ascii_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, gint len) +{ + guint offset = *offset_ptr; + proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_ASCII|ENC_NA); + *offset_ptr += len; +} + +static void +rdm_proto_tree_add_bytes_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, gint len) +{ + guint offset = *offset_ptr; + proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_NA); + *offset_ptr += len; } static guint dissect_rdm_pd_queued_message(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_queued_message_status, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_queued_message_status, tvb, &offset, 1); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_dmx_start_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_dmx_start_address, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_start_address, tvb, &offset, 2); + break; + } + + return offset; } static guint -dissect_rdm_pd_device_info(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc, guint8 len _U_) +dissect_rdm_pd_device_info(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc, guint8 len _U_, guint16 device_manufacturer_id) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_proto_vers, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_device_model_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_product_cat, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_software_vers_id, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - - proto_tree_add_item(tree, hf_rdm_pd_dmx_footprint, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_current, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_total, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_dmx_start_address, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_sub_device_count, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - proto_tree_add_item(tree, hf_rdm_pd_sensor_count, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proto_vers, tvb, &offset, 2); + switch(device_manufacturer_id) { + case RDM_MANUFACTURER_ID_ETC: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_device_model_id, tvb, &offset, 2); + break; + default: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_model_id, tvb, &offset, 2); + break; + } + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_product_cat, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_software_vers_id, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_footprint, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_current, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_total, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_start_address, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sub_device_count, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_count, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_device_model_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_device_model_description, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_device_model_description, tvb, &offset, len); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_device_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_device_label, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_device_label, tvb, &offset, len); + break; + } + + return offset; } static guint dissect_rdm_pd_device_hours(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_device_hours, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_hours, tvb, &offset, 4); + break; + } + + return offset; } static guint dissect_rdm_pd_lamp_hours(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_lamp_hours, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_hours, tvb, &offset, 4); + break; + } + + return offset; } static guint dissect_rdm_pd_lamp_strikes(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_lamp_strikes, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_strikes, tvb, &offset, 4); + break; + } + + return offset; } static guint dissect_rdm_pd_sensor_definition(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_sensor_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_sensor_unit, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_sensor_prefix, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_unit, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_prefix, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_recorded_value_support, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_sensor_description, tvb, &offset, len); + break; + } + + return offset; +} - proto_tree_add_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; +static guint +dissect_rdm_pd_sensor_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + guint8 original_len = len; - proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + break; - proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_pres, tvb, &offset, 2); - proto_tree_add_item(tree, hf_rdm_pd_sensor_recorded_value_support, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; + if (original_len == 7 || original_len == 9) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_low, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_high, tvb, &offset, 2); + } - proto_tree_add_item(tree, hf_rdm_pd_sensor_description, tvb, - offset, len - 13, ENC_ASCII|ENC_NA); - offset += (len - 13); - break; - } + if (original_len == 5 || original_len == 9) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_rec, tvb, &offset, 2); + } - return offset; -} + break; + } -static guint -dissect_rdm_pd_sensor_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) -{ - switch(cc) { - case RDM_CC_GET_COMMAND: - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - case RDM_CC_SET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_value_pres, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - if (len == 7 || len == 9) { - proto_tree_add_item(tree, hf_rdm_pd_sensor_value_low, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_sensor_value_high, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - } - - if (len == 5 || len == 9) { - proto_tree_add_item(tree, hf_rdm_pd_sensor_value_rec, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - } - - break; - } - - return offset; + return offset; } static guint dissect_rdm_pd_manufacturer_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_manu_label, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_manu_label, tvb, &offset, len); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_disc_unique_branch(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_DISCOVERY_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_disc_unique_branch_lb_uid, tvb, - offset, 6, ENC_NA); - offset += 6; - - proto_tree_add_item(tree, hf_rdm_pd_disc_unique_branch_ub_uid, tvb, - offset, 6, ENC_NA); - offset += 6; - break; - } - - return offset; + switch(cc) { + case RDM_CC_DISCOVERY_COMMAND: + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unique_branch_lb_uid, tvb, &offset, 6); + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unique_branch_ub_uid, tvb, &offset, 6); + break; + } + + return offset; } static guint dissect_rdm_pd_disc_mute(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_DISCOVERY_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_disc_mute_control_field, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - if (len > 2) { - proto_tree_add_item(tree, hf_rdm_pd_disc_mute_binding_uid, tvb, - offset, 6, ENC_NA); - offset += 6; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_DISCOVERY_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_disc_mute_control_field, tvb, &offset, 2); + if (len > 2) { + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_mute_binding_uid, tvb, &offset, 6); + } + break; + } + + return offset; } static guint dissect_rdm_pd_disc_un_mute(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_DISCOVERY_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_disc_unmute_control_field, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - if (len > 2) { - proto_tree_add_item(tree, hf_rdm_pd_disc_unmute_binding_uid, tvb, - offset, 6, ENC_NA); - offset += 6; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_DISCOVERY_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_disc_unmute_control_field, tvb, &offset, 2); + if (len > 2) { + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unmute_binding_uid, tvb, &offset, 6); + } + break; + } + + return offset; } static guint dissect_rdm_pd_proxied_devices(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 6) { - proto_tree_add_item(tree, hf_rdm_pd_proxied_devices_uid, tvb, - offset, 6, ENC_NA); - offset += 6; - len -= 6; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 6) { + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_proxied_devices_uid, tvb, &offset, 6); + } + break; + } + + return offset; } static guint dissect_rdm_pd_proxied_device_count(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_proxied_device_count, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_proxied_device_list_change, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proxied_device_count, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proxied_device_list_change, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_comms_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_comms_status_short_msg, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_comms_status_len_mismatch, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_comms_status_csum_fail, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_short_msg, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_len_mismatch, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_csum_fail, tvb, &offset, 2); + break; + } + + return offset; } static guint dissect_rdm_pd_status_messages(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_status_messages_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 9) { - proto_tree_add_item(tree, hf_rdm_pd_status_messages_sub_device_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - proto_tree_add_item(tree, hf_rdm_pd_status_messages_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - len -= 1; - proto_tree_add_item(tree, hf_rdm_pd_status_messages_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - proto_tree_add_item(tree, hf_rdm_pd_status_messages_data_value_1, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - proto_tree_add_item(tree, hf_rdm_pd_status_messages_data_value_2, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_type, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 9) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_sub_device_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_data_value_1, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_data_value_2, tvb, &offset, 2); + } + break; + } + + return offset; } static guint dissect_rdm_pd_status_id_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_status_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_id, tvb, &offset, 2); + break; - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_status_id_description, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; - break; - } + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_status_id_description, tvb, &offset, len); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_clear_status_id(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc _U_, guint8 len _U_) { - return offset; + return offset; } static guint dissect_rdm_pd_sub_device_status_report_threshold(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_sub_device_status_report_threshold_status_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; -} - -static guint -dissect_rdm_pd_supported_parameters(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) -{ - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 2) { - proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - } - break; - } - - return offset; -} - -static guint -dissect_rdm_pd_parameter_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) -{ - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_parameter_pdl_size, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_data_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_cmd_class, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_unit, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_prefix, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_parameter_min_value, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - proto_tree_add_item(tree, hf_rdm_pd_parameter_max_value, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - proto_tree_add_item(tree, hf_rdm_pd_parameter_default_value, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - proto_tree_add_item(tree, hf_rdm_pd_parameter_description, tvb, - offset, len - 0x14, ENC_ASCII|ENC_NA); - offset += (len - 0x14); - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sub_device_status_report_threshold_status_type, tvb, &offset, 1); + break; + } + + return offset; +} + +static void +add_param_id_to_tree(guint16 param_id, proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 device_manufacturer_id) +{ + if (param_id < 0x8000) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_id, tvb, offset, 2); + } else { + switch(device_manufacturer_id) { + case RDM_MANUFACTURER_ID_ETC: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_parameter_id, tvb, offset, 2); + break; + default: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_id, tvb, offset, 2); + break; + } + } } static guint -dissect_rdm_pd_product_detail_id_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +dissect_rdm_pd_supported_parameters(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len, guint16 device_manufacturer_id) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 2) { - proto_tree_add_item(tree, hf_rdm_pd_product_detail_id_list, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - } - break; - } + guint16 param_id; + + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 2) { + param_id = tvb_get_ntohs(tvb, offset); + add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id); + len -= 2; + } + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_parameter_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len, guint16 device_manufacturer_id) +{ + guint16 param_id; + + switch(cc) { + case RDM_CC_GET_COMMAND: + param_id = tvb_get_ntohs(tvb, offset); + add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + param_id = tvb_get_ntohs(tvb, offset); + add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_pdl_size, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_data_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_cmd_class, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_unit, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_prefix, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_min_value, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_max_value, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_default_value, tvb, &offset, 4); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_parameter_description, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_product_detail_id_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 2) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_product_detail_id_list, tvb, &offset, 2); + } + break; + } + + return offset; } static guint dissect_rdm_pd_factory_defaults(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_factory_defaults, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_factory_defaults, tvb, &offset, 1); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_language_capabilities(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 2) { - proto_tree_add_item(tree, hf_rdm_pd_language_code, tvb, - offset, 2, ENC_ASCII|ENC_NA); - offset += 2; - len -= 2; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 2) { + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_language_code, tvb, &offset, 2); + len -= 2; + } + break; + } + + return offset; } static guint dissect_rdm_pd_language(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_language_code, tvb, - offset, 2, ENC_ASCII|ENC_NA); - offset += 2; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_language_code, tvb, &offset, 2); + break; + } + + return offset; } static guint dissect_rdm_pd_software_version_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_software_version_label, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_software_version_label, tvb, &offset, len); + break; + } - break; - } - - return offset; + return offset; } static guint dissect_rdm_pd_boot_software_version_id(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_boot_software_version_id, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_boot_software_version_id, tvb, &offset, 4); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_boot_software_version_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_boot_software_version_label, tvb, - offset, len, ENC_ASCII|ENC_NA); - offset += len; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_boot_software_version_label, tvb, &offset, len); + break; + } - break; - } - - return offset; + return offset; } static guint dissect_rdm_pd_dmx_personality(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_current, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_count, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_nr, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_current, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_count, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_dmx_personality_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_slots, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_text, tvb, - offset, (len - 3), ENC_ASCII|ENC_NA); - offset += (len - 3); - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_slots, tvb, &offset, 2); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dmx_pers_text, tvb, &offset, len); + break; + } + + return offset; } static guint dissect_rdm_pd_slot_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 5) { - proto_tree_add_item(tree, hf_rdm_pd_slot_offset, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - proto_tree_add_item(tree, hf_rdm_pd_slot_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - len -= 1; - proto_tree_add_item(tree, hf_rdm_pd_slot_label_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - } - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 5) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_offset, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_label_id, tvb, &offset, 2); + } + break; + } + + return offset; } static guint dissect_rdm_pd_slot_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_slot_nr, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_nr, tvb, &offset, 2); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_nr, tvb, &offset, 2); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_slot_description, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_slot_nr, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_slot_description, tvb, - offset, (len - 2), ENC_ASCII|ENC_NA); - offset += (len - 2); - break; - } +static guint +dissect_rdm_pd_slot_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 3) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_offset, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_value, tvb, &offset, 1); + } + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_dmx_block_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_subdevice_footprint, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_base_dmx_address, tvb, &offset, 2); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_base_dmx_address, tvb, &offset, 2); + break; + } + + return offset; } static guint -dissect_rdm_pd_slot_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +dissect_rdm_pd_dmx_fail_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - while (len >= 3) { - proto_tree_add_item(tree, hf_rdm_pd_slot_offset, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - len -= 2; - proto_tree_add_item(tree, hf_rdm_pd_slot_value, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - len -= 1; - } - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_scene_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_hold_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_level, tvb, &offset, 1); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_dmx_startup_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_scene_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_hold_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_level, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_record_sensors(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_unit, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_prefix, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_rec_value_support, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_sensor_description, tvb, - offset, (len - 13), ENC_ASCII|ENC_NA); - offset += (len - 13); - - break; - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_unit, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_prefix, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rec_value_support, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_sensor_description, tvb, &offset, len); + break; + } + + return offset; } static guint -dissect_rdm_pd_lamp_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +dissect_rdm_pd_dimmer_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_lamp_state, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_lower_limit, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_upper_limit, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_maximum_level_lower_limit, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_maximum_level_upper_limit, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_number_of_supported_curves, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_levels_resolution, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported, tvb, &offset, 1); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_minimum_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_increasing, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_decreasing, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_on_below_minimum, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_pd_lamp_on_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +dissect_rdm_pd_maximum_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_maximum_level_level, tvb, &offset, 2); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_curve(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_curve, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_number_of_curves, tvb, &offset, 1); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_curve, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_curve_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_description_curve, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_description_curve, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_curve_description_text, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_output_response_time(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_response_time, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_number_of_response_times, tvb, &offset, 1); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_response_time, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_output_response_time_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_lamp_on_mode, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_description_output_response_time, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_description_output_response_time, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_output_response_time_description_text, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_modulation_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_modulation_frequency, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies, tvb, &offset, 1); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_modulation_frequency, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_modulation_frequency_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_description_modulation_frequency, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_description_modulation_frequency, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_modulation_frequency_description_text, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_lamp_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_state, tvb, &offset, 1); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_lamp_on_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_on_mode, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_device_power_cycles(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_device_power_cycles, tvb, - offset, 4, ENC_BIG_ENDIAN); - offset += 4; - break; - } + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_power_cycles, tvb, &offset, 4); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_burn_in(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_burn_in, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_display_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_display_invert, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_display_invert, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_display_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_display_level, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_display_level, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_pan_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_pan_invert, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_pan_invert, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_tilt_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_tilt_invert, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tilt_invert, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_pan_tilt_swap(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_tilt_swap, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tilt_swap, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_real_time_clock(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_year, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_month, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_day, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_hour, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_minute, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_second, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_year, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_month, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_day, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_hour, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_minute, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_second, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_lock_pin(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_pin_code, tvb, &offset, 2); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_new_pin_code, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_pin_code, tvb, &offset, 2); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_lock_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_lock_state, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_number_of_lock_states, tvb, &offset, 1); + break; + + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_pin_code, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_lock_state, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_lock_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_description_lock_state, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_description_lock_state, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_lock_state_description_text, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_list_interfaces(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 6) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_list_interfaces_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_list_interfaces_interface_hardware_type, tvb, &offset, 2); + } + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_interface_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_label_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_label_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_interface_label_label, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_hardware_address_type1(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_hardware_address_type1_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_hardware_address_type1_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_hardware_address_type1_hardware_address, tvb, &offset, 6); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_dhcp_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_enabled, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_zeroconf_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_enabled, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_current_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_ipv4_address, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_netmask, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_dhcp_status, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_static_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_interface_identifier, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_ipv4_address, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_netmask, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_interface_renew_dhcp(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_renew_dhcp_interface_identifier, tvb, &offset, 4); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_interface_release_dhcp(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_release_dhcp_interface_identifier, tvb, &offset, 4); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_interface_apply_configuration(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_apply_configuration_interface_identifier, tvb, &offset, 4); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_ipv4_default_route(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_ipv4_default_route_interface_identifier, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_ipv4_default_route_ipv4_default_route, tvb, &offset, 4); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_dns_ipv4_name_server(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_index, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_index, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_address, tvb, &offset, 4); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_dns_hostname(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dns_hostname, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_rdm_pd_dns_domain_name(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dns_domain_name, tvb, &offset, len); + break; + } + + return offset; } static guint dissect_rdm_pd_identify_device(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_identify_device, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_device, tvb, &offset, 1); + break; - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_identify_device_state, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_device_state, tvb, &offset, 1); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_reset_device(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_reset_device, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_reset_device, tvb, &offset, 1); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_power_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_power_state, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } - - return offset; + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_power_state, tvb, &offset, 1); + break; + } + + return offset; } static guint dissect_rdm_pd_perform_selftest(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) { - switch(cc) { - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1); + break; - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_selftest_state, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_state, tvb, &offset, 1); + break; + } - return offset; + return offset; } static guint dissect_rdm_pd_self_test_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - switch(cc) { - case RDM_CC_GET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1); + break; + + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_selftest_description, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_tree_add_item(tree, hf_rdm_pd_selftest_description, tvb, - offset, (len - 1), ENC_ASCII|ENC_NA); - offset += (len - 1); - break; - } +static guint +dissect_rdm_pd_capture_preset(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_scene_nr, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_up_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_down_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_wait_time, tvb, &offset, 2); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_preset_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +{ + switch(cc) { + case RDM_CC_SET_COMMAND: + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_playback_mode, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_playback_level, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_pd_capture_preset(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +dissect_rdm_pd_identify_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - switch(cc) { - case RDM_CC_SET_COMMAND: - proto_tree_add_item(tree, hf_rdm_pd_capture_preset_scene_nr, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_capture_preset_up_fade_time, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_capture_preset_down_fade_time, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_capture_preset_wait_time, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_mode, tvb, &offset, 1); + break; + } + + return offset; +} - break; - } +static guint +dissect_rdm_pd_preset_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_level_field_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_preset_sequence_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_split_times_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_scene_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_preset_fade_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_preset_fade_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_preset_wait_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_preset_wait_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported, tvb, &offset, 2); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_preset_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_up_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_down_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_wait_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_programmed, tvb, &offset, 1); + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_up_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_down_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_wait_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_clear_preset, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_pd_preset_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_) +dissect_rdm_pd_preset_mergemode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - switch(cc) { - case RDM_CC_SET_COMMAND: - case RDM_CC_GET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_preset_playback_mode, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - proto_tree_add_item(tree, hf_rdm_pd_preset_playback_level, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - break; - } + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_mergemode, tvb, &offset, 1); + break; + } + + return offset; +} - return offset; +static guint +dissect_rdm_pd_power_on_self_test(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_power_on_self_test, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_mdb_param_data(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl) +dissect_rdm_pd_background_queued_status_policy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - switch(param_id) { - case RDM_PARAM_ID_SENSOR_VALUE: - offset = dissect_rdm_pd_sensor_value(tvb, offset, tree, cc, pdl); - break; + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_current_policy, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_number_of_policies, tvb, &offset, 1); + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_current_policy, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_QUEUED_MESSAGE: - offset = dissect_rdm_pd_queued_message(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_background_queued_status_policy_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_description_policy, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_description_policy, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_background_queued_status_policy_description_description, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_DMX_START_ADDRESS: - offset = dissect_rdm_pd_dmx_start_address(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_change_number, tvb, &offset, 4); + while (len >= 3) { + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_endpoint_type, tvb, &offset, 1); + } + break; + } + + return offset; +} - case RDM_PARAM_ID_DEVICE_INFO: - offset = dissect_rdm_pd_device_info(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_search_domain(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_search_domain_dns_domain_name, tvb, &offset, len); + break; + } + return offset; +} - case RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION: - offset = dissect_rdm_pd_device_model_description(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_to_universe(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_universe_number, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_DEVICE_LABEL: - offset = dissect_rdm_pd_device_label(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_rdm_traffic_enable(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_rdm_enabled, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_DEVICE_HOURS: - offset = dissect_rdm_pd_device_hours(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_mode, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_LAMP_HOURS: - offset = dissect_rdm_pd_lamp_hours(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_label_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_label_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_endpoint_label_label, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_LAMP_STRIKES: - offset = dissect_rdm_pd_lamp_strikes(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_discovery_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_device_count, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_discovery_state, tvb, &offset, 1); + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_discovery_state, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SENSOR_DEFINITION: - offset = dissect_rdm_pd_sensor_definition(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_timing(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_setting, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_number_of_settings, tvb, &offset, 1); + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_setting, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_MANUFACTURER_LABEL: - offset = dissect_rdm_pd_manufacturer_label(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_timing_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_description_setting, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_description_setting, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_endpoint_timing_description_description, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_DISC_UNIQUE_BRANCH: - offset = dissect_rdm_pd_disc_unique_branch(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_binding_control_fields(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_uid, tvb, &offset, 6); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_uid, tvb, &offset, 6); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_control_field, tvb, &offset, 2); + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_binding_uid, tvb, &offset, 6); + break; + } + + return offset; +} - case RDM_PARAM_ID_DISC_MUTE: - offset = dissect_rdm_pd_disc_mute(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_identify_endpoint(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_identify_state, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_DISC_UN_MUTE: - offset = dissect_rdm_pd_disc_un_mute(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_background_discovery(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + case RDM_CC_SET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_enabled, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_PROXIED_DEVICES: - offset = dissect_rdm_pd_proxied_devices(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_responder_list_change(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_change_number, tvb, &offset, 4); + break; + } + + return offset; +} - case RDM_PARAM_ID_PROXIED_DEVICE_COUNT: - offset = dissect_rdm_pd_proxied_device_count(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_responders(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_endpoint_id, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_endpoint_id, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_change_number, tvb, &offset, 4); + while (len >= 6) { + rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_endpoint_responders_uid, tvb, &offset, 6); + } + break; + } + + return offset; +} - case RDM_PARAM_ID_COMMS_STATUS: - offset = dissect_rdm_pd_comms_status(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_tcp_comms_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + while (len >= 87) { + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_tcp_comms_status_scope_string, tvb, &offset, 63); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_ipv4_address, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_ipv6_address, tvb, &offset, 16); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_port, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events, tvb, &offset, 2); + } + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_tcp_comms_status_scope_string, tvb, &offset, 63); + break; + } + + return offset; +} - case RDM_PARAM_ID_STATUS_MESSAGES: - offset = dissect_rdm_pd_status_messages(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_endpoint_list_change(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_change_change_number, tvb, &offset, 4); + break; + } - case RDM_PARAM_ID_STATUS_ID_DESCRIPTION: - offset = dissect_rdm_pd_status_id_description(tvb, offset, tree, cc, pdl); - break; + return offset; +} - case RDM_PARAM_ID_CLEAR_STATUS_ID: - offset = dissect_rdm_pd_clear_status_id(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_component_scope(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_slot, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_slot, tvb, &offset, 2); + rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_component_scope_scope_string, tvb, &offset, 63); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_config_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_ipv4_address, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_ipv6_address, tvb, &offset, 16); + rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_port, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD: - offset = dissect_rdm_pd_sub_device_status_report_threshold(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_rdm_pd_broker_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_set_allowed, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_state, tvb, &offset, 1); + break; + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_state, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SUPPORTED_PARAMETERS: - offset = dissect_rdm_pd_supported_parameters(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_curve(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_PARAMETER_DESCRIPTION: - offset = dissect_rdm_pd_parameter_description(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_curve_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve_description_curve, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve_description_curve, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_curve_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST: - offset = dissect_rdm_pd_product_detail_id_list(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_strobe(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_FACTORY_DEFAULTS: - offset = dissect_rdm_pd_factory_defaults(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_output_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_LANGUAGE_CAPABILITIES: - offset = dissect_rdm_pd_language_capabilities(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_output_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode_description_mode, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode_description_mode, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_output_mode_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_LANGUAGE: - offset = dissect_rdm_pd_language(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_red_shift(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_red_shift, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SOFTWARE_VERSION_LABEL: - offset = dissect_rdm_pd_software_version_label(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_white_point(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID: - offset = dissect_rdm_pd_boot_software_version_id(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_white_point_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point_description_white_point, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point_description_white_point, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_white_point_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL: - offset = dissect_rdm_pd_boot_software_version_label(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_frequency, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_DMX_PERSONALITY: - offset = dissect_rdm_pd_dmx_personality(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_dmx_data_loss_behavior(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION: - offset = dissect_rdm_pd_dmx_personality_description(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_dmx_data_loss_behavior_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_behavior, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_behavior, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_text, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_led_plus_seven(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_plus_seven, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SLOT_INFO: - offset = dissect_rdm_pd_slot_info(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_backlight_brightness(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_brightness, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SLOT_DESCRIPTION: - offset = dissect_rdm_pd_slot_description(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_backlight_timeout(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_DEFAULT_SLOT_VALUE: - offset = dissect_rdm_pd_slot_value(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_status_indicators(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_status_indicators, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_RECORD_SENSORS: - offset = dissect_rdm_pd_record_sensors(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_recalibrate_fixture(guint offset) +{ + /* set-only, no data */ + return offset; +} - case RDM_PARAM_ID_LAMP_STATE: - offset = dissect_rdm_pd_lamp_state(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_overtemp_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_LAMP_ON_MODE: - offset = dissect_rdm_pd_lamp_on_mode(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_simple_setup_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_DEVICE_POWER_CYCLES: - offset = dissect_rdm_pd_device_power_cycles(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_strobe_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe_description_strobe, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe_description_strobe, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_strobe_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_DISPLAY_INVERT: - offset = dissect_rdm_pd_display_invert(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_red_shift_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_red_shift_description_red_shift, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_red_shift_description_red_shift, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_red_shift_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_DISPLAY_LEVEL: - offset = dissect_rdm_pd_display_level(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_plus_seven_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_plus_seven_description_plus_seven, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_plus_seven_description_plus_seven, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_plus_seven_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_PAN_INVERT: - offset = dissect_rdm_pd_pan_invert(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_backlight_timeout_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout_description_timeout, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout_description_timeout, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_backlight_timeout_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_TILT_INVERT: - offset = dissect_rdm_pd_tilt_invert(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_simple_setup_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode_description_mode, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode_description_mode, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_simple_setup_mode_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_PAN_TILT_SWAP: - offset = dissect_rdm_pd_pan_tilt_swap(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_overtemp_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode_description_mode, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode_description_mode, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_overtemp_mode_description_text, tvb, &offset, len); + break; + } + + return offset; +} - case RDM_PARAM_ID_REAL_TIME_CLOCK: - offset = dissect_rdm_pd_real_time_clock(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_requested_xy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_requested_xy_x, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_requested_xy_y, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_IDENTIFY_DEVICE: - offset = dissect_rdm_pd_identify_device(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_current_xy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_current_xy_x, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_current_xy_y, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_RESET_DEVICE: - offset = dissect_rdm_pd_reset_device(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_current_pwm(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_led_number, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_led_number, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_channel_duty_cycle, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_POWER_STATE: - offset = dissect_rdm_pd_power_state(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_tristimulus(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_led_number, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_led_number, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_x, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_y, tvb, &offset, 4); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_z, tvb, &offset, 4); + break; + } + + return offset; +} - case RDM_PARAM_ID_PERFORM_SELFTEST: - offset = dissect_rdm_pd_perform_selftest(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_led_information(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_led_number, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_led_number, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_type, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_dmx_control_channel, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_drive_current, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_gamut_polygon_order, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_quantity, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_SELF_TEST_DESCRIPTION: - offset = dissect_rdm_pd_self_test_description(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_preset_number, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_preset_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_delay_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_hue, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_saturation, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_intensity, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_strobe, tvb, &offset, 1); + break; + } + + return offset; +} - case RDM_PARAM_ID_CAPTURE_PRESET: - offset = dissect_rdm_pd_capture_preset(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_sequence_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_playback_sequence_number, tvb, &offset, 2); + break; + } + + return offset; +} - case RDM_PARAM_ID_PRESET_PLAYBACK: - offset = dissect_rdm_pd_preset_playback(tvb, offset, tree, cc, pdl); - break; +static guint +dissect_etc_pd_sequence_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + guint i; + proto_tree *preset_steps_tree, *preset_steps_sub_item; + proto_tree *step_link_times_tree, *step_link_times_sub_item; + + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_sequence_number, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_sequence_number, tvb, &offset, 2); + + preset_steps_tree = proto_tree_add_item(tree, hf_etc_pd_sequence_config_preset_steps, tvb, offset, 24, ENC_NA); + preset_steps_sub_item = proto_item_add_subtree(preset_steps_tree, ett_etc_sequence_config_steps); + for (i = 0; i < 24; i++) { + rdm_proto_tree_add_numeric_item(preset_steps_sub_item, hf_etc_pd_sequence_config_preset_step, tvb, &offset, 1); + } + + step_link_times_tree = proto_tree_add_item(tree, hf_etc_pd_sequence_config_step_link_times, tvb, offset, 48, ENC_NA); + step_link_times_sub_item = proto_item_add_subtree(step_link_times_tree, ett_etc_sequence_config_times); + for (i = 0; i < 24; i++) { + rdm_proto_tree_add_numeric_item(step_link_times_sub_item, hf_etc_pd_sequence_config_step_link_time, tvb, &offset, 2); + } + + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_rate, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_end_state, tvb, &offset, 1); + break; + } + + return offset; +} - default: - proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, - offset, pdl, ENC_NA); - offset += pdl; - break; - } - return offset; +static guint +dissect_etc_pd_low_power_timeout(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_pd_ack_overflow(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl) +dissect_etc_pd_low_power_timeout_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - if (pdl > 0) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - case RDM_CC_SET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_ack_overflow_raw_data, tvb, offset, pdl, ENC_NA); - offset += pdl; - break; - } - } + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout_description_timeout, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout_description_timeout, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_low_power_timeout_description_text, tvb, &offset, len); + break; + } + + return offset; +} - return offset; +static guint +dissect_etc_pd_led_enum_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency, tvb, &offset, 1); + break; + } + + return offset; } static guint -dissect_rdm_pd_ack_timer(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl) +dissect_etc_pd_led_enum_frequency_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) { - if (pdl == 2) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - case RDM_CC_SET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_ack_timer_estimated_response_time, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; - } - } - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency_description_frequency, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency_description_frequency, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_enum_frequency_description_text, tvb, &offset, len); + break; + } + + return offset; } static guint -dissect_rdm_pd_nack_reason(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl _U_) +dissect_etc_pd_rgbi_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - if (pdl == 2) { - switch(cc) { - case RDM_CC_GET_COMMAND_RESPONSE: - case RDM_CC_SET_COMMAND_RESPONSE: - proto_tree_add_item(tree, hf_rdm_pd_nack_reason_code, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - break; - } - } - - return offset; -} - -static guint -dissect_rdm_mdb(tvbuff_t *tvb, guint offset, proto_tree *tree) -{ - guint8 cc; - guint8 rt; - guint16 param_id; - guint8 parameter_data_length; - proto_tree *hi,*si, *mdb_tree; - - rt = tvb_get_guint8(tvb, offset); - cc = tvb_get_guint8(tvb, offset + 4); - - if ((cc & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) { - proto_tree_add_item(tree, hf_rdm_response_type, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - } else { - proto_tree_add_item(tree, hf_rdm_port_id, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - } - - proto_tree_add_item(tree, hf_rdm_message_count, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - proto_tree_add_item(tree, hf_rdm_sub_device, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - hi = proto_tree_add_item(tree, hf_rdm_mdb, tvb, - offset, -1, ENC_NA); - mdb_tree = proto_item_add_subtree(hi,ett_rdm); - - proto_tree_add_item(mdb_tree, hf_rdm_command_class, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - - param_id = tvb_get_ntohs(tvb, offset); - proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb, - offset, 2, ENC_BIG_ENDIAN); - offset += 2; - - parameter_data_length = tvb_get_guint8(tvb, offset); - proto_tree_add_item(mdb_tree, hf_rdm_parameter_data_length, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; - proto_item_set_len( mdb_tree, parameter_data_length + 4); - - if (parameter_data_length > 0) { - - hi = proto_tree_add_item(mdb_tree, hf_rdm_parameter_data, tvb, - offset, parameter_data_length, ENC_NA); - si = proto_item_add_subtree(hi,ett_rdm); - - if ((cc & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) { - - switch(rt) { - case RDM_RESPONSE_TYPE_ACK: - offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length); - break; - case RDM_RESPONSE_TYPE_ACK_TIMER: - offset = dissect_rdm_pd_ack_timer(tvb, offset, si, cc, param_id, parameter_data_length); - break; - case RDM_RESPONSE_TYPE_NACK_REASON: - offset = dissect_rdm_pd_nack_reason(tvb, offset, si, cc, param_id, parameter_data_length); - break; - case RDM_RESPONSE_TYPE_ACK_OVERFLOW: - offset = dissect_rdm_pd_ack_overflow(tvb, offset, si, cc, param_id, parameter_data_length); - break; - } - - } else { - offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length); - } - } - - return offset; + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_preset_number, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_preset_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_delay_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_red, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_green, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_blue, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_intensity, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_strobe, tvb, &offset, 1); + break; + } + + return offset; } -static int -dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) +static guint +dissect_etc_pd_cct_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) { - col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDM"); - col_clear(pinfo->cinfo, COL_INFO); + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_preset_number, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_preset_number, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_fade_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_delay_time, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_white_point, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_tint, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_strobe, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_intensity, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_tone, tvb, &offset, 1); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_reserved, tvb, &offset, 4); + break; + } + + return offset; +} - if (tree) { - gint padding_size; - guint16 man_id; - guint32 dev_id; - guint message_length, offset = 0; +static guint +dissect_etc_pd_supplementary_device_version(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_supplementary_device_version_param_index, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_supplementary_device_version_param_index, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_supplementary_device_version_param_description, tvb, &offset, len); + break; + } + + return offset; +} - proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb, - offset, -1, ENC_NA); - proto_tree *rdm_tree = proto_item_add_subtree(ti, ett_rdm); +static guint +dissect_etc_pd_power_command(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command, tvb, &offset, 1); + break; + } + + return offset; +} - proto_tree_add_item(rdm_tree, hf_rdm_sub_start_code, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; +static guint +dissect_etc_pd_power_command_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command_description_state, tvb, &offset, 1); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command_description_state, tvb, &offset, 1); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_power_command_description_text, tvb, &offset, len); + break; + } + + return offset; +} - message_length = tvb_get_guint8(tvb, offset); - proto_tree_add_item(rdm_tree, hf_rdm_message_length, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; +static guint +dissect_etc_pd_dali_short_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dali_short_address, tvb, &offset, 1); + break; + } + + return offset; +} - man_id = tvb_get_ntohs(tvb, offset); - dev_id = tvb_get_ntohl(tvb, offset + 2); - proto_item_append_text(ti, ", Dst UID: %04x:%08x", man_id, dev_id); - proto_tree_add_item(rdm_tree, hf_rdm_dest_uid, tvb, - offset, 6, ENC_NA); - offset += 6; +static guint +dissect_etc_pd_dali_group_membership(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dali_group_membership, tvb, &offset, 2); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_auto_bind(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_auto_bind, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_delete_subdevice(guint offset) +{ + /* set-only, no data */ + return offset; +} + +static guint +dissect_etc_pd_packet_delay(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_packet_delay, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_has_enum_text(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_pid, tvb, &offset, 2); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_pid, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_true_false, tvb, &offset, 1); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_get_enum_text(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len) +{ + switch(cc) { + case RDM_CC_GET_COMMAND: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_pid, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_enum, tvb, &offset, 4); + break; + case RDM_CC_GET_COMMAND_RESPONSE: + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_pid, tvb, &offset, 2); + rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_enum, tvb, &offset, 4); + rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_get_enum_text_description, tvb, &offset, len); + break; + } + + return offset; +} + +static guint +dissect_etc_pd_prepare_for_software_download(guint offset) +{ + /* set-only, no data */ + return offset; +} + +static guint +dissect_etc_pid(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl) +{ + switch(param_id) { + case ETC_PARAM_ID_LED_CURVE: + offset = dissect_etc_pd_led_curve(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_CURVE_DESCRIPTION: + offset = dissect_etc_pd_led_curve_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_STROBE: + offset = dissect_etc_pd_led_strobe(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_OUTPUT_MODE: + offset = dissect_etc_pd_led_output_mode(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION: + offset = dissect_etc_pd_led_output_mode_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_RED_SHIFT: + offset = dissect_etc_pd_led_red_shift(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_WHITE_POINT: + offset = dissect_etc_pd_led_white_point(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION: + offset = dissect_etc_pd_led_white_point_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_FREQUENCY: + offset = dissect_etc_pd_led_frequency(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_DMX_LOSS_BEHAVIOR: + offset = dissect_etc_pd_dmx_data_loss_behavior(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION: + offset = dissect_etc_pd_dmx_data_loss_behavior_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_PLUS_SEVEN: + offset = dissect_etc_pd_led_plus_seven(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS: + offset = dissect_etc_pd_backlight_brightness(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_BACKLIGHT_TIMEOUT: + offset = dissect_etc_pd_backlight_timeout(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_STATUS_INDICATORS: + offset = dissect_etc_pd_status_indicators(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_RECALIBRATE_FIXTURE: + offset = dissect_etc_pd_recalibrate_fixture(offset); + break; + case ETC_PARAM_ID_OVERTEMPMODE: + offset = dissect_etc_pd_overtemp_mode(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_SIMPLESETUPMODE: + offset = dissect_etc_pd_simple_setup_mode(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_STROBE_DESCRIPTION: + offset = dissect_etc_pd_led_strobe_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION: + offset = dissect_etc_pd_red_shift_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION: + offset = dissect_etc_pd_plus_seven_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION: + offset = dissect_etc_pd_backlight_timeout_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION: + offset = dissect_etc_pd_simple_setup_mode_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION: + offset = dissect_etc_pd_overtemp_mode_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_REQUESTED_XY: + offset = dissect_etc_pd_led_requested_xy(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_CURRENT_XY: + offset = dissect_etc_pd_led_current_xy(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_CURRENT_PWM: + offset = dissect_etc_pd_current_pwm(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_TRISTIMULUS: + offset = dissect_etc_pd_tristimulus(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_INFORMATION: + offset = dissect_etc_pd_led_information(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_PRESETCONFIG: + offset = dissect_etc_pd_preset_config(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_SEQUENCE_PLAYBACK: + offset = dissect_etc_pd_sequence_playback(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_SEQUENCE_CONFIG: + offset = dissect_etc_pd_sequence_config(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LOW_POWER_TIMEOUT: + offset = dissect_etc_pd_low_power_timeout(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION: + offset = dissect_etc_pd_low_power_timeout_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_LED_ENUM_FREQUENCY: + offset = dissect_etc_pd_led_enum_frequency(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION: + offset = dissect_etc_pd_led_enum_frequency_description(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_RGBI_PRESETCONFIG: + offset = dissect_etc_pd_rgbi_preset_config(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_CCT_PRESETCONFIG: + offset = dissect_etc_pd_cct_preset_config(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION: + offset = dissect_etc_pd_supplementary_device_version(tvb, offset, tree, cc, pdl); + break; +/* do not display + case ETC_PARAM_ID_START_UWB_DISCOVER: + break; + case ETC_PARAM_ID_START_UWB_MEASURE: + break; + case ETC_PARAM_ID_POSITION: + break; +*/ +/* TODO: begin need descriptions */ + case ETC_PARAM_ID_S4DIM_CALIBRATE: + break; + case ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION: + break; + case ETC_PARAM_ID_S4DIM_TEST_MODE: + break; + case ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION: + break; + case ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE: + break; + case ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION: + break; +/* TODO: end need descriptions */ + case ETC_PARAM_ID_POWER_COMMAND: + offset = dissect_etc_pd_power_command(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION: + offset = dissect_etc_pd_power_command_description(tvb, offset, tree, cc, pdl); + break; +/* TODO: begin need descriptions */ + case ETC_PARAM_ID_THRESHOLD_COMMAND: + break; + case ETC_PARAM_ID_TURNON_DELAY_COMMAND: + break; +/* TODO: end need descriptions */ + case ETC_PARAM_ID_SET_DALI_SHORTADDRESS: + offset = dissect_etc_pd_dali_short_address(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP: + offset = dissect_etc_pd_dali_group_membership(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_AUTOBIND: + offset = dissect_etc_pd_auto_bind(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_DELETE_SUBDEVICE: + offset = dissect_etc_pd_delete_subdevice(offset); + break; + case ETC_PARAM_ID_PACKET_DELAY: + offset = dissect_etc_pd_packet_delay(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_HAS_ENUM_TEXT: + offset = dissect_etc_pd_has_enum_text(tvb, offset, tree, cc); + break; + case ETC_PARAM_ID_GET_ENUM_TEXT: + offset = dissect_etc_pd_get_enum_text(tvb, offset, tree, cc, pdl); + break; + case ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD: + offset = dissect_etc_pd_prepare_for_software_download(offset); + break; + default: + proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, offset, pdl, ENC_NA); + offset += pdl; + } + + return offset; +} + +static guint +dissect_manufacturer_specific_pid(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl, guint16 device_manufacturer_id) +{ + switch(device_manufacturer_id) { + case RDM_MANUFACTURER_ID_ETC: + offset = dissect_etc_pid(tvb, offset, tree, cc, param_id, pdl); + break; + default: + proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, offset, pdl, ENC_NA); + offset += pdl; + break; + } + + return offset; +} + +static guint +dissect_rdm_mdb_param_data(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl, guint16 device_manufacturer_id) +{ + if (param_id >= 0x8000) { + offset = dissect_manufacturer_specific_pid(tvb, offset, tree, cc, param_id, pdl, device_manufacturer_id); + } else { + switch(param_id) { + case RDM_PARAM_ID_SENSOR_VALUE: + offset = dissect_rdm_pd_sensor_value(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_QUEUED_MESSAGE: + offset = dissect_rdm_pd_queued_message(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DMX_START_ADDRESS: + offset = dissect_rdm_pd_dmx_start_address(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DEVICE_INFO: + offset = dissect_rdm_pd_device_info(tvb, offset, tree, cc, pdl, device_manufacturer_id); + break; + + case RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION: + offset = dissect_rdm_pd_device_model_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DEVICE_LABEL: + offset = dissect_rdm_pd_device_label(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DEVICE_HOURS: + offset = dissect_rdm_pd_device_hours(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LAMP_HOURS: + offset = dissect_rdm_pd_lamp_hours(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LAMP_STRIKES: + offset = dissect_rdm_pd_lamp_strikes(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SENSOR_DEFINITION: + offset = dissect_rdm_pd_sensor_definition(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_MANUFACTURER_LABEL: + offset = dissect_rdm_pd_manufacturer_label(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DISC_UNIQUE_BRANCH: + offset = dissect_rdm_pd_disc_unique_branch(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DISC_MUTE: + offset = dissect_rdm_pd_disc_mute(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DISC_UN_MUTE: + offset = dissect_rdm_pd_disc_un_mute(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PROXIED_DEVICES: + offset = dissect_rdm_pd_proxied_devices(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PROXIED_DEVICE_COUNT: + offset = dissect_rdm_pd_proxied_device_count(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_COMMS_STATUS: + offset = dissect_rdm_pd_comms_status(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_STATUS_MESSAGES: + offset = dissect_rdm_pd_status_messages(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_STATUS_ID_DESCRIPTION: + offset = dissect_rdm_pd_status_id_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_CLEAR_STATUS_ID: + offset = dissect_rdm_pd_clear_status_id(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD: + offset = dissect_rdm_pd_sub_device_status_report_threshold(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SUPPORTED_PARAMETERS: + offset = dissect_rdm_pd_supported_parameters(tvb, offset, tree, cc, pdl, device_manufacturer_id); + break; + + case RDM_PARAM_ID_PARAMETER_DESCRIPTION: + offset = dissect_rdm_pd_parameter_description(tvb, offset, tree, cc, pdl, device_manufacturer_id); + break; + + case RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST: + offset = dissect_rdm_pd_product_detail_id_list(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_FACTORY_DEFAULTS: + offset = dissect_rdm_pd_factory_defaults(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LANGUAGE_CAPABILITIES: + offset = dissect_rdm_pd_language_capabilities(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LANGUAGE: + offset = dissect_rdm_pd_language(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SOFTWARE_VERSION_LABEL: + offset = dissect_rdm_pd_software_version_label(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID: + offset = dissect_rdm_pd_boot_software_version_id(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL: + offset = dissect_rdm_pd_boot_software_version_label(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DMX_PERSONALITY: + offset = dissect_rdm_pd_dmx_personality(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION: + offset = dissect_rdm_pd_dmx_personality_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SLOT_INFO: + offset = dissect_rdm_pd_slot_info(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SLOT_DESCRIPTION: + offset = dissect_rdm_pd_slot_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DEFAULT_SLOT_VALUE: + offset = dissect_rdm_pd_slot_value(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DMX_BLOCK_ADDRESS: + offset = dissect_rdm_pd_dmx_block_address(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_DMX_FAIL_MODE: + offset = dissect_rdm_pd_dmx_fail_mode(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_DMX_STARTUP_MODE: + offset = dissect_rdm_pd_dmx_startup_mode(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_RECORD_SENSORS: + offset = dissect_rdm_pd_record_sensors(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DIMMER_INFO: + offset = dissect_rdm_pd_dimmer_info(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_MINIMUM_LEVEL: + offset = dissect_rdm_pd_minimum_level(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_MAXIMUM_LEVEL: + offset = dissect_rdm_pd_maximum_level(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_CURVE: + offset = dissect_rdm_pd_curve(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_CURVE_DESCRIPTION: + offset = dissect_rdm_pd_curve_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_OUTPUT_RESPONSE_TIME: + offset = dissect_rdm_pd_output_response_time(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION: + offset = dissect_rdm_pd_output_response_time_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_MODULATION_FREQUENCY: + offset = dissect_rdm_pd_modulation_frequency(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION: + offset = dissect_rdm_pd_modulation_frequency_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LAMP_STATE: + offset = dissect_rdm_pd_lamp_state(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LAMP_ON_MODE: + offset = dissect_rdm_pd_lamp_on_mode(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DEVICE_POWER_CYCLES: + offset = dissect_rdm_pd_device_power_cycles(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_BURN_IN: + offset = dissect_rdm_pd_burn_in(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_DISPLAY_INVERT: + offset = dissect_rdm_pd_display_invert(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DISPLAY_LEVEL: + offset = dissect_rdm_pd_display_level(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PAN_INVERT: + offset = dissect_rdm_pd_pan_invert(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_TILT_INVERT: + offset = dissect_rdm_pd_tilt_invert(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PAN_TILT_SWAP: + offset = dissect_rdm_pd_pan_tilt_swap(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_REAL_TIME_CLOCK: + offset = dissect_rdm_pd_real_time_clock(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LOCK_PIN: + offset = dissect_rdm_pd_lock_pin(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_LOCK_STATE: + offset = dissect_rdm_pd_lock_state(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_LOCK_STATE_DESCRIPTION: + offset = dissect_rdm_pd_lock_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_LIST_INTERFACES: + offset = dissect_rdm_pd_list_interfaces(tvb, offset, tree, cc, pdl); + break; + case RDM_PARAM_ID_INTERFACE_LABEL: + offset = dissect_rdm_pd_interface_label(tvb, offset, tree, cc, pdl); + break; - man_id = tvb_get_ntohs(tvb, offset); - dev_id = tvb_get_ntohl(tvb, offset + 2); - proto_item_append_text(ti, ", Src UID: %04x:%08x", man_id, dev_id); - proto_tree_add_item(rdm_tree, hf_rdm_src_uid, tvb, - offset, 6, ENC_NA); - offset += 6; + case RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1: + offset = dissect_rdm_pd_hardware_address_type1(tvb, offset, tree, cc); + break; - proto_tree_add_item(rdm_tree, hf_rdm_transaction_number, tvb, - offset, 1, ENC_BIG_ENDIAN); - offset += 1; + case RDM_PARAM_ID_IPV4_DHCP_MODE: + offset = dissect_rdm_pd_dhcp_mode(tvb, offset, tree, cc); + break; - offset = dissect_rdm_mdb(tvb, offset, rdm_tree); + case RDM_PARAM_ID_IPV4_ZEROCONF_MODE: + offset = dissect_rdm_pd_zeroconf_mode(tvb, offset, tree, cc); + break; - padding_size = offset - (message_length - 1); - if (padding_size > 0) { - proto_tree_add_item(rdm_tree, hf_rdm_intron, tvb, - offset, padding_size, ENC_NA); - offset += padding_size; - } + case RDM_PARAM_ID_IPV4_CURRENT_ADDRESS: + offset = dissect_rdm_pd_current_address(tvb, offset, tree, cc); + break; - proto_tree_add_checksum(rdm_tree, tvb, offset, hf_rdm_checksum, hf_rdm_checksum_status, &ei_rdm_checksum, pinfo, rdm_checksum(tvb, offset), - ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY); - offset += 2; + case RDM_PARAM_ID_IPV4_STATIC_ADDRESS: + offset = dissect_rdm_pd_static_address(tvb, offset, tree, cc); + break; - if (offset < tvb_reported_length(tvb)) - proto_tree_add_item(rdm_tree, hf_rdm_trailer, tvb, - offset, -1, ENC_NA); - } - return tvb_captured_length(tvb); + case RDM_PARAM_ID_INTERFACE_RENEW_DHCP: + offset = dissect_rdm_pd_interface_renew_dhcp(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_INTERFACE_RELEASE_DHCP: + offset = dissect_rdm_pd_interface_release_dhcp(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION: + offset = dissect_rdm_pd_interface_apply_configuration(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_IPV4_DEFAULT_ROUTE: + offset = dissect_rdm_pd_ipv4_default_route(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_DNS_IPV4_NAME_SERVER: + offset = dissect_rdm_pd_dns_ipv4_name_server(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_DNS_HOSTNAME: + offset = dissect_rdm_pd_dns_hostname(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DNS_DOMAIN_NAME: + offset = dissect_rdm_pd_dns_domain_name(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_IDENTIFY_DEVICE: + offset = dissect_rdm_pd_identify_device(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_RESET_DEVICE: + offset = dissect_rdm_pd_reset_device(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_POWER_STATE: + offset = dissect_rdm_pd_power_state(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PERFORM_SELFTEST: + offset = dissect_rdm_pd_perform_selftest(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SELF_TEST_DESCRIPTION: + offset = dissect_rdm_pd_self_test_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_CAPTURE_PRESET: + offset = dissect_rdm_pd_capture_preset(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_PRESET_PLAYBACK: + offset = dissect_rdm_pd_preset_playback(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_IDENTIFY_MODE: + offset = dissect_rdm_pd_identify_mode(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_PRESET_INFO: + offset = dissect_rdm_pd_preset_info(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_PRESET_STATUS: + offset = dissect_rdm_pd_preset_status(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_PRESET_MERGEMODE: + offset = dissect_rdm_pd_preset_mergemode(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_POWER_ON_SELF_TEST: + offset = dissect_rdm_pd_power_on_self_test(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY: + offset = dissect_rdm_pd_background_queued_status_policy(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION: + offset = dissect_rdm_pd_background_queued_status_policy_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_ENDPOINT_LIST: + offset = dissect_rdm_pd_endpoint_list(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_SEARCH_DOMAIN: + offset = dissect_rdm_pd_search_domain(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE: + offset = dissect_rdm_pd_endpoint_to_universe(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_RDM_TRAFFIC_ENABLE: + offset = dissect_rdm_pd_rdm_traffic_enable(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_MODE: + offset = dissect_rdm_pd_endpoint_mode(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_LABEL: + offset = dissect_rdm_pd_endpoint_label(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_DISCOVERY_STATE: + offset = dissect_rdm_pd_discovery_state(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_TIMING: + offset = dissect_rdm_pd_endpoint_timing(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION: + offset = dissect_rdm_pd_endpoint_timing_description(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_BINDING_CONTROL_FIELDS: + offset = dissect_rdm_pd_binding_control_fields(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_IDENTIFY_ENDPOINT: + offset = dissect_rdm_pd_identify_endpoint(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_BACKGROUND_DISCOVERY: + offset = dissect_rdm_pd_background_discovery(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE: + offset = dissect_rdm_pd_endpoint_responder_list_change(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_ENDPOINT_RESPONDERS: + offset = dissect_rdm_pd_endpoint_responders(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_TCP_COMMS_STATUS: + offset = dissect_rdm_pd_tcp_comms_status(tvb, offset, tree, cc, pdl); + break; + + case RDM_PARAM_ID_ENDPOINT_LIST_CHANGE: + offset = dissect_rdm_pd_endpoint_list_change(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_COMPONENT_SCOPE: + offset = dissect_rdm_pd_component_scope(tvb, offset, tree, cc); + break; + + case RDM_PARAM_ID_BROKER_STATUS: + offset = dissect_rdm_pd_broker_status(tvb, offset, tree, cc); + break; + + default: + proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, + offset, pdl, ENC_NA); + offset += pdl; + break; + } + } + + return offset; +} + +static guint +dissect_rdm_pd_ack_overflow(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl) +{ + if (pdl > 0) { + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND_RESPONSE: + proto_tree_add_item(tree, hf_rdm_pd_ack_overflow_raw_data, tvb, offset, pdl, ENC_NA); + offset += pdl; + break; + } + } + + return offset; +} + +static guint +dissect_rdm_pd_ack_timer(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl) +{ + if (pdl == 2) { + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND_RESPONSE: + proto_tree_add_item(tree, hf_rdm_pd_ack_timer_estimated_response_time, tvb, + offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + } + } + return offset; +} + +static guint +dissect_rdm_pd_nack_reason(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl _U_) +{ + if (pdl == 2) { + switch(cc) { + case RDM_CC_GET_COMMAND_RESPONSE: + case RDM_CC_SET_COMMAND_RESPONSE: + proto_tree_add_item(tree, hf_rdm_pd_nack_reason_code, tvb, + offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + } + } + + return offset; +} + +static guint8 +is_response(guint8 command_class) +{ + if ((command_class & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) { + return 1; + } + return 0; +} + +static void +add_pid_to_tree(guint16 param_id, proto_tree *mdb_tree, tvbuff_t *tvb, guint offset, guint16 device_manufacturer_id) +{ + if (param_id < 0x8000) { + proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN); + } else { + switch(device_manufacturer_id) { + case RDM_MANUFACTURER_ID_ETC: + proto_tree_add_item(mdb_tree, hf_etc_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN); + break; + default: + proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN); + break; + } + } +} + +static guint +dissect_rdm_mdb(tvbuff_t *tvb, guint offset, proto_tree *tree, guint16 device_manufacturer_id) +{ + guint8 cc; + guint8 rt; + guint16 param_id; + guint8 parameter_data_length; + proto_tree *hi,*si, *mdb_tree; + + rt = tvb_get_guint8(tvb, offset); + cc = tvb_get_guint8(tvb, offset + 4); + + if (is_response(cc)) { + proto_tree_add_item(tree, hf_rdm_response_type, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + } else { + proto_tree_add_item(tree, hf_rdm_port_id, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + } + + proto_tree_add_item(tree, hf_rdm_message_count, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_rdm_sub_device, tvb, + offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + hi = proto_tree_add_item(tree, hf_rdm_mdb, tvb, + offset, -1, ENC_NA); + mdb_tree = proto_item_add_subtree(hi,ett_rdm); + + proto_tree_add_item(mdb_tree, hf_rdm_command_class, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + param_id = tvb_get_ntohs(tvb, offset); + add_pid_to_tree(param_id, mdb_tree, tvb, offset, device_manufacturer_id); + offset += 2; + + parameter_data_length = tvb_get_guint8(tvb, offset); + proto_tree_add_item(mdb_tree, hf_rdm_parameter_data_length, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + proto_item_set_len( mdb_tree, parameter_data_length + 4); + + if (parameter_data_length > 0) { + + hi = proto_tree_add_item(mdb_tree, hf_rdm_parameter_data, tvb, + offset, parameter_data_length, ENC_NA); + si = proto_item_add_subtree(hi,ett_rdm); + + if (is_response(cc)) { + + switch(rt) { + case RDM_RESPONSE_TYPE_ACK: + offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length, device_manufacturer_id); + break; + case RDM_RESPONSE_TYPE_ACK_TIMER: + offset = dissect_rdm_pd_ack_timer(tvb, offset, si, cc, param_id, parameter_data_length); + break; + case RDM_RESPONSE_TYPE_NACK_REASON: + offset = dissect_rdm_pd_nack_reason(tvb, offset, si, cc, param_id, parameter_data_length); + break; + case RDM_RESPONSE_TYPE_ACK_OVERFLOW: + offset = dissect_rdm_pd_ack_overflow(tvb, offset, si, cc, param_id, parameter_data_length); + break; + } + + } else { + offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length, device_manufacturer_id); + } + } + + return offset; +} + +static guint16 +get_device_manufacturer_id(guint8 command_class, guint16 source_manufacturer_id, guint16 destination_manufacturer_id) +{ + if ((command_class == RDM_CC_GET_COMMAND) || + (command_class == RDM_CC_SET_COMMAND)) { + return destination_manufacturer_id; + } + if ((command_class == RDM_CC_GET_COMMAND_RESPONSE) || + (command_class == RDM_CC_SET_COMMAND_RESPONSE)) { + return source_manufacturer_id; + } + return 0; +} + +static int +dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) +{ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDM"); + col_clear(pinfo->cinfo, COL_INFO); + + if (tree) { + gint padding_size; + guint8 command_class; + guint16 destination_manufacturer_id; + guint16 source_manufacturer_id; + guint16 device_manufacturer_id; + guint32 destination_device_id; + guint32 source_device_id; + guint message_length, offset = 0; + + proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb, + offset, -1, ENC_NA); + proto_tree *rdm_tree = proto_item_add_subtree(ti, ett_rdm); + + proto_tree_add_item(rdm_tree, hf_rdm_sub_start_code, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + message_length = tvb_get_guint8(tvb, offset); + proto_tree_add_item(rdm_tree, hf_rdm_message_length, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + destination_manufacturer_id = tvb_get_ntohs(tvb, offset); + destination_device_id = tvb_get_ntohl(tvb, offset + 2); + proto_item_append_text(ti, ", Dst UID: %04x:%08x", + destination_manufacturer_id, destination_device_id); + proto_tree_add_item(rdm_tree, hf_rdm_dest_uid, tvb, + offset, 6, ENC_NA); + offset += 6; + + source_manufacturer_id = tvb_get_ntohs(tvb, offset); + source_device_id = tvb_get_ntohl(tvb, offset + 2); + proto_item_append_text(ti, ", Src UID: %04x:%08x", + source_manufacturer_id, source_device_id); + proto_tree_add_item(rdm_tree, hf_rdm_src_uid, tvb, + offset, 6, ENC_NA); + offset += 6; + + proto_tree_add_item(rdm_tree, hf_rdm_transaction_number, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + command_class = tvb_get_guint8(tvb, offset + 4); + device_manufacturer_id = get_device_manufacturer_id(command_class, source_manufacturer_id, destination_manufacturer_id); + offset = dissect_rdm_mdb(tvb, offset, rdm_tree, device_manufacturer_id); + + padding_size = offset - (message_length - 1); + if (padding_size > 0) { + proto_tree_add_item(rdm_tree, hf_rdm_intron, tvb, + offset, padding_size, ENC_NA); + offset += padding_size; + } + + proto_tree_add_checksum(rdm_tree, tvb, offset, hf_rdm_checksum, hf_rdm_checksum_status, &ei_rdm_checksum, pinfo, rdm_checksum(tvb, offset), + ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY); + offset += 2; + + if (offset < tvb_reported_length(tvb)) { + proto_tree_add_item(rdm_tree, hf_rdm_trailer, tvb, + offset, -1, ENC_NA); + } + } + return tvb_captured_length(tvb); } void proto_register_rdm(void) { - static hf_register_info hf[] = { - { &hf_rdm_sub_start_code, - { "Sub-start code", "rdm.ssc", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_message_length, - { "Message length", "rdm.len", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_dest_uid, - { "Destination UID", "rdm.dst", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_src_uid, - { "Source UID", "rdm.src", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_transaction_number, - { "Transaction number", "rdm.tn", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_port_id, - { "Port ID", "rdm.port_id", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_response_type, - { "Response type", "rdm.rt", - FT_UINT8, BASE_HEX, VALS(rdm_rt_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_message_count, - { "Message count", "rdm.mc", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_sub_device, - { "Sub-device", "rdm.sd", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_mdb, - { "Message Data Block", "rdm.mdb", - FT_NONE, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_command_class, - { "Command class", "rdm.cc", - FT_UINT8, BASE_HEX, VALS(rdm_cc_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_parameter_id, - { "Parameter ID", "rdm.pid", - FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_param_id_vals_ext, 0x0, - NULL, HFILL }}, - - { &hf_rdm_parameter_data_length, - { "Parameter data length", "rdm.pdl", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_parameter_data, - { "Parameter data", "rdm.pd", - FT_NONE, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_parameter_data_raw, - { "Raw Data", "rdm.pd.raw", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_intron, - { "Intron", "rdm.intron", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_checksum, - { "Checksum", "rdm.checksum", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_checksum_status, - { "Checksum Status", "rdm.checksum.status", - FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_trailer, - { "Trailer", "rdm.trailer", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_ack_overflow_raw_data, - { "Raw Data", "rdm.pd.ack_overflow.raw_data", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_ack_timer_estimated_response_time, - { "Estimated Response Time", "rdm.pd.ack_timer.estimated_response_time", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_nack_reason_code, - { "NACK Reason Code", "rdm.pd.nack_reason.code", - FT_UINT16, BASE_HEX, VALS(rdm_nr_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_queued_message_status, - { "Status", "rdm.pd.queued_message.status", - FT_UINT8, BASE_HEX, VALS(rdm_status_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_nr, - { "Sensor Nr.", "rdm.pd.sensor.nr", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_value_pres, - { "Sensor Present Value", "rdm.pd.sensor.value.present", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_value_low, - { "Sensor Lowest Value", "rdm.pd.sensor.value.lowest", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_value_high, - { "Sensor Highest Value", "rdm.pd.sensor.value.highest", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_value_rec, - { "Sensor Recorded Value", "rdm.pd.sensor.value.recorded", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_range_min_value, - { "Sensor Range Min. Value", "rdm.pd.sensor.range.min_value", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_range_max_value, - { "Sensor Range Max. Value", "rdm.pd.sensor.range.max_value", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_normal_min_value, - { "Sensor Normal Min. Value", "rdm.pd.sensor.normal.min_value", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_normal_max_value, - { "Sensor Normal Max. Value", "rdm.pd.sensor.normal.max_value", - FT_INT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_recorded_value_support, - { "Sensor Recorded Value Support", "rdm.pd.sensor.recorded_value_support", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_type, - { "Sensor Type", "rdm.pd.sensor_type", - FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_sensor_type_vals_ext, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_unit, - { "Sensor Unit", "rdm.pd.sensor_unit", - FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_unit_vals_ext, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_prefix, - { "Sensor Prefix", "rdm.pd.sensor_prefix", - FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_prefix_vals_ext, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_description, - { "Sensor Description", "rdm.pd.sensor.description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_manu_label, - { "Manufacturer Label", "rdm.pd.manu_label", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - - { &hf_rdm_pd_device_label, - { "Device Label", "rdm.pd.device_label", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_start_address, - { "DMX Start Address", "rdm.pd.dmx_start_address", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_device_hours, - { "Device Hours", "rdm.pd.device_hours", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_lamp_hours, - { "Lamp Hours", "rdm.pd.lamp_hours", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_lamp_strikes, - { "Lamp Strikes", "rdm.pd.lamp_strikes", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_proto_vers, - { "RDM Protocol Version", "rdm.pd.proto_vers", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_device_model_id, - { "Device Model ID", "rdm.pd.device_model_id", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_product_cat, - { "Product Category", "rdm.pd.product_cat", - FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_product_cat_vals_ext, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_software_vers_id, - { "Software Version ID", "rdm.pd.software_version_id", - FT_UINT32, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_footprint, - { "DMX Footprint", "rdm.pd.dmx_footprint", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_current, - { "Current DMX Personality", "rdm.pd.dmx_pers_current", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_total, - { "Total nr. DMX Personalities", "rdm.pd.dmx_pers_total", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sub_device_count, - { "Sub-Device Count", "rdm.pd.sub_device_count", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sensor_count, - { "Sensor Count", "rdm.pd.sensor_count", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_device_model_description, - { "Device Model Description", "rdm.pd.device_model_description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_unique_branch_lb_uid, - { "Lower Bound UID", "rdm.pd.disc_unique_branch.lb_uid", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_unique_branch_ub_uid, - { "Upper Bound UID", "rdm.pd.disc_unique_branch.ub_uid", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_mute_control_field, - { "Control Field", "rdm.pd.disc_mute.control_field", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_mute_binding_uid, - { "Binding UID", "rdm.pd.disc_mute.binding_uid", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_unmute_control_field, - { "Control Field", "rdm.pd.disc_unmute.control_field", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_disc_unmute_binding_uid, - { "Binding UID", "rdm.pd.disc_unmute.binding_uid", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_proxied_devices_uid, - { "UID", "rdm.pd.proxied_devices.uid", - FT_BYTES, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_proxied_device_count, - { "Device Count", "rdm.pd.device_count", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_proxied_device_list_change, - { "List Change", "rdm.pd.list_change", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_year, - { "Year", "rdm.pd.real_time_clock.year", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_month, - { "Month", "rdm.pd.real_time_clock.month", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_day, - { "Day", "rdm.pd.real_time_clock.day", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_hour, - { "Hour", "rdm.pd.real_time_clock.hour", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_minute, - { "Minute", "rdm.pd.real_time_clock.minute", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_real_time_clock_second, - { "Second", "rdm.pd.real_time_clock.second", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_lamp_state, - { "Lamp State", "rdm.pd.lamp_state", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_lamp_on_mode, - { "Lamp On Mode", "rdm.pd.lamp_on_mode", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_device_power_cycles, - { "Device Power Cycles", "rdm.pd.device_power_cycles", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_display_invert, - { "Display Invert", "rdm.pd.display_invert", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_display_level, - { "Display Level", "rdm.pd.display_level", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_pan_invert, - { "Pan Invert", "rdm.pd.pan_invert", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_tilt_invert, - { "Tilt Invert", "rdm.pd.tilt_invert", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_tilt_swap, - { "Tilt Swap", "rdm.pd.tilt_swap", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_selftest_nr, - { "Selftest Nr.", "rdm.pd.selftest.nr", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_selftest_state, - { "Selftest State", "rdm.pd.selftest.state", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_selftest_description, - { "Selftest Description", "rdm.pd.selftest.description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_language_code, - { "Language Code", "rdm.pd.language_code", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_identify_device, - { "Identify Device", "rdm.pd.identify_device", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_identify_device_state, - { "Identify Device State", "rdm.pd.identify_device.state", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_reset_device, - { "Reset Device", "rdm.pd.reset_device", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_power_state, - { "Power State", "rdm.pd.power_state", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_capture_preset_scene_nr, - { "Scene Nr.", "rdm.pd.capture_preset.scene_nr", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_capture_preset_up_fade_time, - { "Up Fade Time", "rdm.pd.capture_preset.up_fade_time", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_capture_preset_down_fade_time, - { "Down Fade Time", "rdm.pd.capture_preset.down_fade_time", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_capture_preset_wait_time, - { "Wait Time", "rdm.pd.capture_preset.wait_time", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_preset_playback_mode, - { "Mode", "rdm.pd.preset_playback.mode", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_preset_playback_level, - { "Level", "rdm.pd.preset_playback.level", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_id, - { "ID", "rdm.pd.parameter.id", - FT_UINT16, BASE_HEX, VALS(rdm_param_id_vals), 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_pdl_size, - { "PDL Size", "rdm.pd.parameter.pdl_size", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_data_type, - { "Data Type", "rdm.pd.parameter.data_type", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_cmd_class, - { "Command Class", "rdm.pd.parameter.cmd_class", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_type, - { "Type", "rdm.pd.parameter.type", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_unit, - { "Unit", "rdm.pd.parameter.unit", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_prefix, - { "Prefix", "rdm.pd.parameter.prefix", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_min_value, - { "Min. Value", "rdm.pd.parameter.min_value", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_max_value, - { "Max. Value", "rdm.pd.parameter.max_value", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_default_value, - { "Default Value", "rdm.pd.parameter.default_value", - FT_UINT32, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_parameter_description, - { "Description", "rdm.pd.parameter.description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_software_version_label, - { "Version Label", "rdm.pd.software_version.label", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_boot_software_version_id, - { "Version ID", "rdm.pd.boot_software_version.id", - FT_UINT32, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_boot_software_version_label, - { "Version Label", "rdm.pd.boot_software_version.label", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_comms_status_short_msg, - { "Short Msg", "rdm.pd.comms_status.short_msg", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_comms_status_len_mismatch, - { "Len Mismatch", "rdm.pd.comms_status.len_mismatch", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_comms_status_csum_fail, - { "Checksum Fail", "rdm.pd.comms_status.csum_fail", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_messages_type, - { "Type", "rdm.pd.status_messages.type", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_messages_sub_device_id, - { "Sub. Device ID", "rdm.pd.status_messages.sub_devices_id", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_messages_id, - { "ID", "rdm.pd.status_messages.id", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_messages_data_value_1, - { "Data Value 1", "rdm.pd.status_messages.data_value_1", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_messages_data_value_2, - { "Data Value 2", "rdm.pd.status_messages.data_value_2", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_id, - { "ID", "rdm.pd.status_id", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_status_id_description, - { "Description", "rdm.pd.status_id.description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_sub_device_status_report_threshold_status_type, - { "Status Type", "rdm.pd.sub_device_status_report_threshold.status_type", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_product_detail_id_list, - { "Sensor Count", "rdm.pd.product_detail_id_list", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_factory_defaults, - { "Factory Defaults", "rdm.pd.factory_defaults", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_nr, - { "DMX Pers. Nr.", "rdm.pd.dmx_pers.nr", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_count, - { "DMX Pers. Count", "rdm.pd.dmx_pers.count", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_requested, - { "DMX Pers. Requested", "rdm.pd.dmx_pers.requested", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_slots, - { "DMX Pers. Slots", "rdm.pd.dmx_pers.slots", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_dmx_pers_text, - { "DMX Pers. Text", "rdm.pd.dmx_pers.text", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_offset, - { "Slot Offset", "rdm.pd.slot_offset", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_type, - { "Slot Type", "rdm.pd.slot_type", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_label_id, - { "Slot Label ID", "rdm.pd.slot_label_id", - FT_UINT16, BASE_HEX, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_nr, - { "Slot Nr.", "rdm.pd.slot_nr", - FT_UINT16, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_description, - { "Slot Description", "rdm.pd.slot_description", - FT_STRING, BASE_NONE, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_slot_value, - { "Slot Value", "rdm.pd.slot_value", - FT_UINT8, BASE_DEC, NULL, 0x0, - NULL, HFILL }}, - - { &hf_rdm_pd_rec_value_support, - { "Rec. Value Support", "rdm.pd.rec_value_support", - FT_UINT8, BASE_HEX, NULL, 0x0, - NULL, HFILL }} - }; - - static gint *ett[] = { - &ett_rdm - }; - - static ei_register_info ei[] = { - { &ei_rdm_checksum, { "rdm.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }}, - }; - - expert_module_t* expert_rdm; - - proto_rdm = proto_register_protocol("Remote Device Management", "RDM", "rdm"); - proto_register_field_array(proto_rdm, hf, array_length(hf)); - proto_register_subtree_array(ett, array_length(ett)); - register_dissector("rdm", dissect_rdm, proto_rdm); - expert_rdm = expert_register_protocol(proto_rdm); - expert_register_field_array(expert_rdm, ei, array_length(ei)); + static hf_register_info hf[] = { + { &hf_rdm_sub_start_code, + { "Sub-start code", "rdm.ssc", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_message_length, + { "Message length", "rdm.len", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_dest_uid, + { "Destination UID", "rdm.dst", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_src_uid, + { "Source UID", "rdm.src", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_transaction_number, + { "Transaction number", "rdm.tn", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_port_id, + { "Port ID", "rdm.port_id", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_response_type, + { "Response type", "rdm.rt", + FT_UINT8, BASE_HEX, VALS(rdm_rt_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_message_count, + { "Message count", "rdm.mc", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_sub_device, + { "Sub-device", "rdm.sd", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_mdb, + { "Message Data Block", "rdm.mdb", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_command_class, + { "Command class", "rdm.cc", + FT_UINT8, BASE_HEX, VALS(rdm_cc_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_parameter_id, + { "Parameter ID", "rdm.pid", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_param_id_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_rdm_parameter_data_length, + { "Parameter data length", "rdm.pdl", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_parameter_data, + { "Parameter data", "rdm.pd", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_parameter_data_raw, + { "Raw Data", "rdm.pd.raw", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_intron, + { "Intron", "rdm.intron", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_checksum, + { "Checksum", "rdm.checksum", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_checksum_status, + { "Checksum Status", "rdm.checksum.status", + FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_trailer, + { "Trailer", "rdm.trailer", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_ack_overflow_raw_data, + { "Raw Data", "rdm.pd.ack_overflow.raw_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_ack_timer_estimated_response_time, + { "Estimated Response Time", "rdm.pd.ack_timer.estimated_response_time", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_nack_reason_code, + { "NACK Reason Code", "rdm.pd.nack_reason.code", + FT_UINT16, BASE_HEX, VALS(rdm_nr_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_queued_message_status, + { "Status", "rdm.pd.queued_message.status", + FT_UINT8, BASE_HEX, VALS(rdm_status_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_nr, + { "Sensor Nr.", "rdm.pd.sensor.nr", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_value_pres, + { "Sensor Present Value", "rdm.pd.sensor.value.present", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_value_low, + { "Sensor Lowest Value", "rdm.pd.sensor.value.lowest", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_value_high, + { "Sensor Highest Value", "rdm.pd.sensor.value.highest", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_value_rec, + { "Sensor Recorded Value", "rdm.pd.sensor.value.recorded", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_range_min_value, + { "Sensor Range Min. Value", "rdm.pd.sensor.range.min_value", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_range_max_value, + { "Sensor Range Max. Value", "rdm.pd.sensor.range.max_value", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_normal_min_value, + { "Sensor Normal Min. Value", "rdm.pd.sensor.normal.min_value", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_normal_max_value, + { "Sensor Normal Max. Value", "rdm.pd.sensor.normal.max_value", + FT_INT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_recorded_value_support, + { "Sensor Recorded Value Support", "rdm.pd.sensor.recorded_value_support", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_type, + { "Sensor Type", "rdm.pd.sensor_type", + FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_sensor_type_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_unit, + { "Sensor Unit", "rdm.pd.sensor_unit", + FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_unit_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_prefix, + { "Sensor Prefix", "rdm.pd.sensor_prefix", + FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_prefix_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_description, + { "Sensor Description", "rdm.pd.sensor.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_manu_label, + { "Manufacturer Label", "rdm.pd.manu_label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + + { &hf_rdm_pd_device_label, + { "Device Label", "rdm.pd.device_label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_start_address, + { "DMX Start Address", "rdm.pd.dmx_start_address", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_device_hours, + { "Device Hours", "rdm.pd.device_hours", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lamp_hours, + { "Lamp Hours", "rdm.pd.lamp_hours", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lamp_strikes, + { "Lamp Strikes", "rdm.pd.lamp_strikes", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_proto_vers, + { "RDM Protocol Version", "rdm.pd.proto_vers", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_device_model_id, + { "Device Model ID", "rdm.pd.device_model_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_product_cat, + { "Product Category", "rdm.pd.product_cat", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_product_cat_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_software_vers_id, + { "Software Version ID", "rdm.pd.software_version_id", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_footprint, + { "DMX Footprint", "rdm.pd.dmx_footprint", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_current, + { "Current DMX Personality", "rdm.pd.dmx_pers_current", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_total, + { "Total nr. DMX Personalities", "rdm.pd.dmx_pers_total", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sub_device_count, + { "Sub-Device Count", "rdm.pd.sub_device_count", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sensor_count, + { "Sensor Count", "rdm.pd.sensor_count", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_device_model_description, + { "Device Model Description", "rdm.pd.device_model_description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_unique_branch_lb_uid, + { "Lower Bound UID", "rdm.pd.disc_unique_branch.lb_uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_unique_branch_ub_uid, + { "Upper Bound UID", "rdm.pd.disc_unique_branch.ub_uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_mute_control_field, + { "Control Field", "rdm.pd.disc_mute.control_field", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_mute_binding_uid, + { "Binding UID", "rdm.pd.disc_mute.binding_uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_unmute_control_field, + { "Control Field", "rdm.pd.disc_unmute.control_field", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_disc_unmute_binding_uid, + { "Binding UID", "rdm.pd.disc_unmute.binding_uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_proxied_devices_uid, + { "UID", "rdm.pd.proxied_devices.uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_proxied_device_count, + { "Device Count", "rdm.pd.device_count", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_proxied_device_list_change, + { "List Change", "rdm.pd.list_change", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_year, + { "Year", "rdm.pd.real_time_clock.year", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_month, + { "Month", "rdm.pd.real_time_clock.month", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_day, + { "Day", "rdm.pd.real_time_clock.day", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_hour, + { "Hour", "rdm.pd.real_time_clock.hour", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_minute, + { "Minute", "rdm.pd.real_time_clock.minute", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_real_time_clock_second, + { "Second", "rdm.pd.real_time_clock.second", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lamp_state, + { "Lamp State", "rdm.pd.lamp_state", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lamp_on_mode, + { "Lamp On Mode", "rdm.pd.lamp_on_mode", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_device_power_cycles, + { "Device Power Cycles", "rdm.pd.device_power_cycles", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_display_invert, + { "Display Invert", "rdm.pd.display_invert", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_display_level, + { "Display Level", "rdm.pd.display_level", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_pan_invert, + { "Pan Invert", "rdm.pd.pan_invert", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tilt_invert, + { "Tilt Invert", "rdm.pd.tilt_invert", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tilt_swap, + { "Tilt Swap", "rdm.pd.tilt_swap", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_selftest_nr, + { "Selftest Nr.", "rdm.pd.selftest.nr", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_selftest_state, + { "Selftest State", "rdm.pd.selftest.state", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_selftest_description, + { "Selftest Description", "rdm.pd.selftest.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_language_code, + { "Language Code", "rdm.pd.language_code", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_identify_device, + { "Identify Device", "rdm.pd.identify_device", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_identify_device_state, + { "Identify Device State", "rdm.pd.identify_device.state", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_reset_device, + { "Reset Device", "rdm.pd.reset_device", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_power_state, + { "Power State", "rdm.pd.power_state", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_capture_preset_scene_nr, + { "Scene Nr.", "rdm.pd.capture_preset.scene_nr", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_capture_preset_up_fade_time, + { "Up Fade Time", "rdm.pd.capture_preset.up_fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_capture_preset_down_fade_time, + { "Down Fade Time", "rdm.pd.capture_preset.down_fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_capture_preset_wait_time, + { "Wait Time", "rdm.pd.capture_preset.wait_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_playback_mode, + { "Mode", "rdm.pd.preset_playback.mode", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_playback_level, + { "Level", "rdm.pd.preset_playback.level", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_id, + { "ID", "rdm.pd.parameter.id", + FT_UINT16, BASE_HEX, VALS(rdm_param_id_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_pdl_size, + { "PDL Size", "rdm.pd.parameter.pdl_size", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_data_type, + { "Data Type", "rdm.pd.parameter.data_type", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_cmd_class, + { "Command Class", "rdm.pd.parameter.cmd_class", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_type, + { "Type", "rdm.pd.parameter.type", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_unit, + { "Unit", "rdm.pd.parameter.unit", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_prefix, + { "Prefix", "rdm.pd.parameter.prefix", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_min_value, + { "Min. Value", "rdm.pd.parameter.min_value", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_max_value, + { "Max. Value", "rdm.pd.parameter.max_value", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_default_value, + { "Default Value", "rdm.pd.parameter.default_value", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_parameter_description, + { "Description", "rdm.pd.parameter.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_software_version_label, + { "Version Label", "rdm.pd.software_version.label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_boot_software_version_id, + { "Version ID", "rdm.pd.boot_software_version.id", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_boot_software_version_label, + { "Version Label", "rdm.pd.boot_software_version.label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_comms_status_short_msg, + { "Short Msg", "rdm.pd.comms_status.short_msg", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_comms_status_len_mismatch, + { "Len Mismatch", "rdm.pd.comms_status.len_mismatch", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_comms_status_csum_fail, + { "Checksum Fail", "rdm.pd.comms_status.csum_fail", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_messages_type, + { "Type", "rdm.pd.status_messages.type", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_messages_sub_device_id, + { "Sub. Device ID", "rdm.pd.status_messages.sub_devices_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_messages_id, + { "ID", "rdm.pd.status_messages.id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_messages_data_value_1, + { "Data Value 1", "rdm.pd.status_messages.data_value_1", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_messages_data_value_2, + { "Data Value 2", "rdm.pd.status_messages.data_value_2", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_id, + { "ID", "rdm.pd.status_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_status_id_description, + { "Description", "rdm.pd.status_id.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_sub_device_status_report_threshold_status_type, + { "Status Type", "rdm.pd.sub_device_status_report_threshold.status_type", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_product_detail_id_list, + { "Sensor Count", "rdm.pd.product_detail_id_list", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_factory_defaults, + { "Factory Defaults", "rdm.pd.factory_defaults", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_discovery_endpoint_id, + { "Endpoint ID", "rdm.pd.background_discovery.endpoint_id", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_discovery_enabled, + { "Enabled", "rdm.pd.background_discovery.enabled", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_queued_status_policy_current_policy, + { "Current Policy", "rdm.pd.background_queued_status_policy.current_policy", + FT_UINT8, BASE_DEC, VALS(rdm_status_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_queued_status_policy_number_of_policies, + { "Number Of Policies", "rdm.pd.background_queued_status_policy.number_of_policies", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_queued_status_policy_description_policy, + { "Policy", "rdm.pd.background_queued_status_policy_description.policy", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_background_queued_status_policy_description_description, + { "Description", "rdm.pd.background_queued_status_policy_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_search_domain_dns_domain_name, + { "DNS Domain Name", "rdm.pd.search_domain.dns_domain_name", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_binding_control_fields_endpoint_id, + { "Endpoint ID", "rdm.pd.binding_control_fields.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_binding_control_fields_uid, + { "UID", "rdm.pd.binding_control_fields.uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_binding_control_fields_control_field, + { "Control Field", "rdm.pd.binding_control_fields.control_field", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_binding_control_fields_binding_uid, + { "Binding UID", "rdm.pd.binding_control_fields.binding_uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rem_pd_broker_status_set_allowed, + { "Set Allowed", "rdm.pd.broker_status.set_allowed", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rem_pd_broker_status_state, + { "State", "rdm.pd.broker_status.state", + FT_UINT8, BASE_DEC, VALS(rdmnet_broker_status_states_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_burn_in, + { "Burn In", "rdm.pd.burn_in", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_slot, + { "Scope Slot", "rdm.pd.component_scope.scope_slot", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_string, + { "Scope String", "rdm.pd.component_scope.scope_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_static_config_type, + { "Static Config. Type", "rdm.pd.component_scope.static_config_type", + FT_UINT8, BASE_DEC, VALS(rdmnet_component_scope_static_config_type_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_static_ipv4_address, + { "Static IPv4 Address", "rdm.pd.component_scope.static_ipv4_address", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_static_ipv6_address, + { "Static IPv6 Address", "rdm.pd.component_scope.static_ipv6_address", + FT_IPv6, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_component_scope_scope_static_port, + { "Static Port", "rdm.pd.component_scope.static_port", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_current_address_interface_identifier, + { "Interface Identifier", "rdm.pd.current_address.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_current_address_ipv4_address, + { "IPv4 Address", "rdm.pd.current_address.ipv4_address", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_current_address_netmask, + { "Netmask", "rdm.pd.current_address.netmask", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_current_address_dhcp_status, + { "DHCP Status", "rdm.pd.current_address.dhcp_status", + FT_UINT8, BASE_DEC, VALS(rdm_dhcp_status_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_curve_curve, + { "Curve", "rdm.pd.curve.curve", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_curve_number_of_curves, + { "Number Of Curves", "rdm.pd.curve.number_of_curves", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_curve_description_curve, + { "Curve", "rdm.pd.curve_description.curve", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_curve_description_text, + { "Description", "rdm.pd.curve_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dhcp_mode_interface_identifier, + { "Interface Identifier", "rdm.pd.dhcp_mode.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dhcp_mode_enabled, + { "Enabled", "rdm.pd.dhcp_mode.enabled", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_minimum_level_lower_limit, + { "Minimum Level Lower Limit", "rdm.pd.dimmer_info.minimum_level_lower_limit", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_minimum_level_upper_limit, + { "Minimum Level Upper Limit", "rdm.pd.dimmer_info.minimum_level_upper_limit", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_maximum_level_lower_limit, + { "Maximum Level Lower Limit", "rdm.pd.dimmer_info.maximum_level_lower_limit", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_maximum_level_upper_limit, + { "Maximum Level Upper Limit", "rdm.pd.dimmer_info.maximum_level_upper_limit", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_number_of_supported_curves, + { "Number Of Supported Curves", "rdm.pd.dimmer_info.number_of_supported_curves", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_levels_resolution, + { "Levels Resolution", "rdm.pd.dimmer_info.levels_resolution", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported, + { "Minimum Level Split Levels Supported", "rdm.pd.dimmer_info.minimum_level_split_levels_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_discovery_state_endpoint_id, + { "Endpoint ID", "rdm.pd.discovery_state.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_discovery_state_device_count, + { "Device Count", "rdm.pd.discovery_state.device_count", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_discovery_state_discovery_state, + { "State", "rdm.pd.discovery_state.state", + FT_UINT8, BASE_DEC, VALS(rdm_discovery_state_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_block_address_base_dmx_address, + { "Base DMX Address", "rdm.pd.dmx_block_address.base_dmx_address", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_block_address_subdevice_footprint, + { "Sub-Device Footprint", "rdm.pd.dmx_block_address.subdevice_footprint", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_fail_mode_scene_number, + { "Scene Number", "rdm.pd.dmx_fail_mode.scene_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay, + { "Loss Of Signal Delay", "rdm.pd.dmx_fail_mode.loss_of_signal_delay", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_fail_mode_hold_time, + { "Hold Time", "rdm.pd.dmx_fail_mode.hold_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_fail_mode_level, + { "Level", "rdm.pd.dmx_fail_mode.level", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_nr, + { "DMX Pers. Nr.", "rdm.pd.dmx_pers.nr", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_count, + { "DMX Pers. Count", "rdm.pd.dmx_pers.count", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_requested, + { "DMX Pers. Requested", "rdm.pd.dmx_pers.requested", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_slots, + { "DMX Pers. Slots", "rdm.pd.dmx_pers.slots", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_pers_text, + { "DMX Pers. Text", "rdm.pd.dmx_pers.text", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_startup_mode_scene_number, + { "Scene Number", "rdm.pd.dmx_startup_mode.scene_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay, + { "Startup Delay Time", "rdm.pd.dmx_startup_mode.startup_delay_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_startup_mode_hold_time, + { "Hold Time", "rdm.pd.dmx_startup_mode.hold_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dmx_startup_mode_level, + { "Level", "rdm.pd.dmx_startup_mode.level", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dns_domain_name, + { "Domain Name", "rdm.pd.dns_domain_name", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dns_hostname, + { "Host Name", "rdm.pd.dns_hostname", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dns_ipv4_name_server_index, + { "Index", "rdm.pd.dns_ipv4_name_server.index", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_dns_ipv4_name_server_address, + { "Index", "rdm.pd.dns_ipv4_name_server.address", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_label_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_label.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_label_label, + { "Label", "rdm.pd.endpoint_label.label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_list_change_number, + { "List Change Number", "rdm.pd.endpoint_list.change_number", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_list_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_list.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_list_endpoint_type, + { "Endpoint Type", "rdm.pd.endpoint_list.endpoint_type", + FT_UINT8, BASE_DEC, VALS(rdm_endpoint_type_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_list_change_change_number, + { "List Change Number", "rdm.pd.endpoint_list_change.change_number", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_mode_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_mode.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_mode_endpoint_mode, + { "Endpoint ID", "rdm.pd.endpoint_mode.endpoint_mode", + FT_UINT8, BASE_DEC, VALS(rdm_endpoint_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_responder_list_change_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_responder_list_change.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_responder_list_change_change_number, + { "Change Number", "rdm.pd.endpoint_responder_list_change.change_number", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_responders_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_responders.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_responders_change_number, + { "Change Number", "rdm.pd.endpoint_responders.change_number", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_responders_uid, + { "UID", "rdm.pd.endpoint_responders.uid", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_timing_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_timing.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_timing_setting, + { "Setting", "rdm.pd.endpoint_timing.setting", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_timing_number_of_settings, + { "Number Of Settings", "rdm.pd.endpoint_timing.number_of_settings", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_timing_description_setting, + { "Setting", "rdm.pd.endpoint_timing_description.setting", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_timing_description_description, + { "Description", "rdm.pd.endpoint_timing_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_to_universe_endpoint_id, + { "Endpoint ID", "rdm.pd.endpoint_to_universe.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_endpoint_to_universe_universe_number, + { "Universe Number", "rdm.pd.endpoint_to_universe.universe_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_hardware_address_type1_interface_identifier, + { "Interface Identifier", "rdm.pd.hardware_address_type1.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_hardware_address_type1_hardware_address, + { "Hardware Address", "rdm.pd.hardware_address_type1.hardware_address", + FT_BYTES, SEP_COLON, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_identify_endpoint_endpoint_id, + { "Endpoint ID", "rdm.pd.identify_endpoint.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_identify_endpoint_identify_state, + { "Identify State", "rdm.pd.identify_endpoint.identify_state", + FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_identify_mode, + { "Identify Mode", "rdm.pd.identify_mode.identify_mode", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_interface_apply_configuration_interface_identifier, + { "Interface Identifier", "rdm.pd.interface_apply_configuration.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_interface_label_interface_identifier, + { "Interface Identifier", "rdm.pd.interface_label.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_interface_label_label, + { "Label", "rdm.pd.interface_label.label", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_interface_release_dhcp_interface_identifier, + { "Interface Identifier", "rdm.pd.interface_release_dhcp.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_interface_renew_dhcp_interface_identifier, + { "Interface Identifier", "rdm.pd.interface_renew_dhcp.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_ipv4_default_route_interface_identifier, + { "Interface Identifier", "rdm.pd.ipv4_default_route.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_ipv4_default_route_ipv4_default_route, + { "Interface Identifier", "rdm.pd.ipv4_default_route.default_route", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_list_interfaces_interface_identifier, + { "Interface Identifier", "rdm.pd.list_interfaces.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_list_interfaces_interface_hardware_type, + { "Interface Hardware Type", "rdm.pd.list_interfaces.interface_hardware_type", + FT_UINT16, BASE_DEC, VALS(arp_hrd_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_pin_pin_code, + { "PIN Code", "rdm.pd.lock_pin.pin_code", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_rdm_pd_lock_pin_new_pin_code, + { "New PIN Code", "rdm.pd.lock_pin.new_pin_code", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_state_lock_state, + { "Lock State", "rdm.pd.lock_state.lock_state", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_state_number_of_lock_states, + { "Number Of Lock States", "rdm.pd.lock_state.number_of_lock_states", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_state_pin_code, + { "PIN Code", "rdm.pd.lock_state.pin_code", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_state_description_lock_state, + { "Lock State", "rdm.pd.lock_state_description.lock_state", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_lock_state_description_text, + { "Description", "rdm.pd.lock_state_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_maximum_level_level, + { "Level", "rdm.pd.maximum_level.level", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_mergemode, + { "Merge Mode", "rdm.pd.preset_mergemode", + FT_UINT8, BASE_DEC, VALS(rdm_mergemode_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_power_on_self_test, + { "Power On Self Test", "rdm.pd.power_on_self_test", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_minimum_level_increasing, + { "Increasing", "rdm.pd.minimum_level.increasing", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_minimum_level_decreasing, + { "Decreasing", "rdm.pd.minimum_level.decreasing", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_minimum_level_on_below_minimum, + { "On Below Minimum", "rdm.pd.minimum_level.on_below_minimum", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_modulation_frequency_modulation_frequency, + { "Modulation Frequency", "rdm.pd.modulation_frequency.modulation_frequency", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies, + { "Number Of Modulation Frequencies", "rdm.pd.modulation_frequency.number_of_modulation_frequencies", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_modulation_frequency_description_modulation_frequency, + { "Modulation Frequency", "rdm.pd.modulation_frequency_description.modulation_frequency", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_modulation_frequency_description_text, + { "Description", "rdm.pd.modulation_frequency_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_output_response_time_response_time, + { "Response Time", "rdm.pd.response_time.response_time", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_output_response_time_number_of_response_times, + { "Number Of Response Times", "rdm.pd.response_time.number_of_response_times", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_output_response_time_description_output_response_time, + { "Output Response Time", "rdm.pd.output_response_time_description.output_response_time", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_output_response_time_description_text, + { "Description", "rdm.pd.output_response_time_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_level_field_supported, + { "Level Field Supported", "rdm.pd.preset_info.level_field_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_preset_sequence_supported, + { "Preset Sequence Supported", "rdm.pd.preset_info.preset_sequence_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_split_times_supported, + { "Split Times Supported", "rdm.pd.preset_info.split_times_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported, + { "DMX Fail Infinite Delay Time Supported", "rdm.pd.preset_info.dmx_fail_infinite_delay_time_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported, + { "DMX Fail Infinite Hold Time Supported", "rdm.pd.preset_info.dmx_fail_infinite_hold_time_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported, + { "Start Up_ Infinite Hold Time Supported", "rdm.pd.preset_info.start_up_infinite_hold_time_supported", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_scene_number, + { "Maximum Scene Number", "rdm.pd.preset_info.maximum_scene_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_preset_fade_time_supported, + { "Minimum Preset Fade Time Supported", "rdm.pd.preset_info.minimum_preset_fade_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_preset_fade_time_supported, + { "Maximum Preset Fade Time Supported", "rdm.pd.preset_info.maximum_preset_fade_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_preset_wait_time_supported, + { "Minimum Preset Wait Time Supported", "rdm.pd.preset_info.minimum_preset_wait_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_preset_wait_time_supported, + { "Maximum Preset Wait Time Supported", "rdm.pd.preset_info.maximum_preset_wait_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported, + { "Minimum DMX Fail Delay Time Supported", "rdm.pd.preset_info.minimum_dmx_fail_delay_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported, + { "Maximum DMX Fail Delay Time Supported", "rdm.pd.preset_info.maximum_dmx_fail_delay_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported, + { "Minimum DMX Fail Hold Time Supported", "rdm.pd.preset_info.minimum_dmx_fail_hold_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported, + { "Maximum DMX Fail Hold Time Supported", "rdm.pd.preset_info.maximum_dmx_fail_hold_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported, + { "Minimum Start Up Delay Time Supported", "rdm.pd.preset_info.minimum_start_up_delay_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported, + { "Maximum Start Up Delay Time Supported", "rdm.pd.preset_info.maximum_start_up_delay_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported, + { "Minimum Start Up Hold Time Supported", "rdm.pd.preset_info.minimum_start_up_hold_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported, + { "Maximum Start Up Hold Time Supported", "rdm.pd.preset_info.maximum_start_up_hold_time_supported", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_scene_number, + { "Scene Number", "rdm.pd.preset_status.scene_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_up_fade_time, + { "Up Fade Time", "rdm.pd.preset_status.up_fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_down_fade_time, + { "Down Fade Time", "rdm.pd.preset_status.down_fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_wait_time, + { "Wait Time", "rdm.pd.preset_status.wait_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_programmed, + { "Programmed", "rdm.pd.preset_status.programmed", + FT_UINT8, BASE_DEC, VALS(rdm_preset_programmed_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_preset_status_clear_preset, + { "Clear Preset", "rdm.pd.preset_status.clear_preset", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_rdm_traffic_enable_endpoint_id, + { "Endpoint ID", "rdm.pd.rdm_traffic_enable.endpoint_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_rdm_traffic_enable_rdm_enabled, + { "Enabled", "rdm.pd.rdm_traffic_enable.endpoint_id", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_offset, + { "Slot Offset", "rdm.pd.slot_offset", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_type, + { "Slot Type", "rdm.pd.slot_type", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_label_id, + { "Slot Label ID", "rdm.pd.slot_label_id", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_nr, + { "Slot Nr.", "rdm.pd.slot_nr", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_description, + { "Slot Description", "rdm.pd.slot_description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_slot_value, + { "Slot Value", "rdm.pd.slot_value", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_static_address_interface_identifier, + { "Interface Identifier", "rdm.pd.static_address.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_static_address_ipv4_address, + { "IPv4 Address", "rdm.pd.static_address.ipv4_address", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_static_address_netmask, + { "Netmask", "rdm.pd.static_address.netmask", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tcp_comms_status_scope_string, + { "Scope String", "rdm.pd.tcp_comms_status.scope_string", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tcp_comms_status_broker_ipv4_address, + { "Broker IPV4 Address", "rdm.pd.tcp_comms_status.broker_ipv4_address", + FT_IPv4, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tcp_comms_status_broker_ipv6_address, + { "Broker IPV6 Address", "rdm.pd.tcp_comms_status.broker_ipv6_address", + FT_IPv6, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tcp_comms_status_broker_port, + { "Broker Port", "rdm.pd.tcp_comms_status.broker_port", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events, + { "Unhealthy TCP Events", "rdm.pd.tcp_comms_status.unhealthy_tcp_events", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_zeroconf_mode_interface_identifier, + { "Interface Identifier", "rdm.pd.zeroconf_mode.interface_identifier", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_zeroconf_mode_enabled, + { "Enabled", "rdm.pd.zeroconf_mode.enabled", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_rdm_pd_rec_value_support, + { "Rec. Value Support", "rdm.pd.rec_value_support", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_parameter_id, + { "Parameter ID", "rdm.pid", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &etc_param_id_vals_ext, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_parameter_id, + { "ID", "rdm.pd.parameter.id", + FT_UINT16, BASE_HEX, VALS(etc_param_id_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_device_model_id, + { "Device Model ID", "rdm.pd.device_model_id", + FT_UINT16, BASE_HEX, VALS(etc_model_id_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_curve, + { "Curve", "rdm.pd.led_curve.curve", + FT_UINT8, BASE_DEC, VALS(etc_led_curve_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_curve_description_curve, + { "Curve", "rdm.pd.led_curve_description.curve", + FT_UINT8, BASE_DEC, VALS(etc_led_curve_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_curve_description_text, + { "Description", "rdm.pd.led_curve_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_strobe, + { "Strobe", "rdm.pd.led_strobe", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_output_mode, + { "Output Mode", "rdm.pd.led_output_mode", + FT_UINT8, BASE_DEC, VALS(etc_led_output_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_output_mode_description_mode, + { "Output Mode", "rdm.pd.led_output_mode_description.output_mode", + FT_UINT8, BASE_DEC, VALS(etc_led_output_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_output_mode_description_text, + { "Description", "rdm.pd.lled_output_mode_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_red_shift, + { "Red Shift", "rdm.pd.led_red_shift", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_white_point, + { "White Point", "rdm.pd.led_white_point", + FT_UINT8, BASE_DEC, VALS(etc_led_white_point_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_white_point_description_white_point, + { "White Point", "rdm.pd.led_white_point_description.white_point", + FT_UINT8, BASE_DEC, VALS(etc_led_white_point_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_white_point_description_text, + { "Description", "rdm.pd.led_white_point_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_frequency, + { "LED Frequency (Hz)", "rdm.pd.led_frequency", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_dmx_data_loss_behavior, + { "DMX Data Loss Behavior", "rdm.pd.dmx_data_loss_behavior", + FT_UINT8, BASE_DEC, VALS(etc_dmx_data_loss_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_dmx_data_loss_behavior_description_behavior, + { "DMX Data Loss Behavior", "rdm.pd.dmx_data_loss_behavior_description.behavior", + FT_UINT8, BASE_DEC, VALS(etc_dmx_data_loss_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_dmx_data_loss_behavior_description_text, + { "Description", "rdm.pd.dmx_data_loss_behavior_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_plus_seven, + { "LED Plus Seven", "rdm.pd.led_plus_seven", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_backlight_brightness, + { "Backlight Brightness", "rdm.pd.backlight_brightness", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_backlight_timeout, + { "Backlight Timeout", "rdm.pd.backlight_timeout", + FT_UINT8, BASE_DEC, VALS(etc_backlight_timeout_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_status_indicators, + { "Status Indicators", "rdm.pd.status_indicators", + FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_overtemp_mode, + { "Overtemp Mode", "rdm.pd.overtemp_mode", + FT_UINT8, BASE_DEC, VALS(etc_overtemp_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_simple_setup_mode, + { "Simple Setup Mode", "rdm.pd.simple_setup_mode", + FT_UINT8, BASE_DEC, VALS(etc_simple_setup_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_strobe_description_strobe, + { "Strobe", "rdm.pd.led_strobe_description.led_strobe", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_strobe_description_text, + { "Description", "rdm.pd.led_strobe_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_red_shift_description_red_shift, + { "Red Shift", "rdm.pd.red_shift_description.red_shift", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_red_shift_description_text, + { "Description", "rdm.pd.red_shift_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_plus_seven_description_plus_seven, + { "Plus Seven", "rdm.pd.plus_seven_description.plus_seven", + FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_plus_seven_description_text, + { "Description", "rdm.pd.plus_seven_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_backlight_timeout_description_timeout, + { "Backlight Timeout", "rdm.pd.backlight_timeout_description.backlight_timeout", + FT_UINT8, BASE_DEC, VALS(etc_backlight_timeout_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_backlight_timeout_description_text, + { "Description", "rdm.pd.backlight_timeout_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_simple_setup_mode_description_mode, + { "Simple Setup Mode", "rdm.pd.simple_setup_mode_description.mode", + FT_UINT8, BASE_DEC, VALS(etc_simple_setup_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_simple_setup_mode_description_text, + { "Description", "rdm.pd.simple_setup_mode_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_overtemp_mode_description_mode, + { "Overtemp Mode", "rdm.pd.overtemp_mode_description.mode", + FT_UINT8, BASE_DEC, VALS(etc_overtemp_mode_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_overtemp_mode_description_text, + { "Description", "rdm.pd.overtemp_mode_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_requested_xy_x, + { "X Coordinate", "rdm.pd.led_requested_xy.x", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_requested_xy_y, + { "Y Coordinate", "rdm.pd.led_requested_xy.y", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_current_xy_x, + { "X Coordinate", "rdm.pd.led_current_xy.x", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_current_xy_y, + { "Y Coordinate", "rdm.pd.led_current_xy.y", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_current_pwm_led_number, + { "LED Number", "rdm.pd.current_pwm.led_number", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_current_pwm_channel_duty_cycle, + { "Channel Duty Cycle", "rdm.pd.current_pwm.channel_duty_cycle", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_tristimulus_led_number, + { "LED Number", "rdm.pd.tristimulus.led_number", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_tristimulus_x, + { "X", "rdm.pd.tristimulus.x", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_tristimulus_y, + { "Y", "rdm.pd.tristimulus.y", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_tristimulus_z, + { "Z", "rdm.pd.tristimulus.z", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_led_number, + { "LED Number", "rdm.pd.led_information.led_number", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_type, + { "Type", "rdm.pd.led_information.type", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_dmx_control_channel, + { "DMX Control Channel", "rdm.pd.led_information.dmx_control_channel", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_drive_current, + { "Drive Current (ma)", "rdm.pd.led_information.drive_current", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_gamut_polygon_order, + { "Gamut Polygon Order", "rdm.pd.led_information.gamut_polygon_order", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_information_quantity, + { "Quantity", "rdm.pd.led_information.quantity", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_preset_number, + { "Preset Number", "rdm.pd.preset_config.preset_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_fade_time, + { "Fade Time (seconds)", "rdm.pd.preset_config.fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_delay_time, + { "Delay Time (seconds)", "rdm.pd.preset_config.delay_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_hue, + { "Hue", "rdm.pd.preset_config.hue", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_saturation, + { "Saturation", "rdm.pd.preset_config.saturation", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_intensity, + { "Intensity", "rdm.pd.preset_config.intensity", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_preset_config_strobe, + { "Strobe", "rdm.pd.preset_config.strobe", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_playback_sequence_number, + { "Sequence Number", "rdm.pd.sequence_playback.sequence_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_sequence_number, + { "Sequence Number", "rdm.pd.sequence_config.sequence_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_preset_steps, + { "Preset Steps", "rdm.pd.sequence_config.preset_steps", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_preset_step, + { "Preset Step", "rdm.pd.sequence_config.preset_step", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_step_link_times, + { "Step Link Times (seconds)", "rdm.pd.sequence_config.step_link_times", + FT_NONE, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_step_link_time, + { "Step Link Time", "rdm.pd.sequence_config.step_link_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_rate, + { "Rate", "rdm.pd.sequence_config.rate", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_sequence_config_end_state, + { "End State", "rdm.pd.sequence_config.end_state", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_low_power_timeout, + { "Low Power Timeout", "rdm.pd.low_power_timeout", + FT_UINT8, BASE_DEC, VALS(etc_low_power_timeout_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_low_power_timeout_description_timeout, + { "Low Power Timeout", "rdm.pd.low_power_timeout_description.timeout", + FT_UINT8, BASE_DEC, VALS(etc_low_power_timeout_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_low_power_timeout_description_text, + { "Description", "rdm.pd.low_power_timeout_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_enum_frequency, + { "Frequency", "rdm.pd.led_enum_frequency", + FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_enum_frequency_description_frequency, + { "Frequency", "rdm.pd.led_enum_frequency_description.frequency", + FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_led_enum_frequency_description_text, + { "Description", "rdm.pd.led_enum_frequency_description.description", + FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_preset_number, + { "Preset Number", "rdm.pd.rgbi_preset_config.preset_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_fade_time, + { "Fade Time (seconds)", "rdm.pd.rgbi_preset_config.fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_delay_time, + { "Delay Time (seconds)", "rdm.pd.rgbi_preset_config.delay_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_red, + { "Red", "rdm.pd.rgbi_preset_config.red", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_green, + { "Green", "rdm.pd.rgbi_preset_config.green", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_blue, + { "Blue", "rdm.pd.rgbi_preset_config.blue", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_intensity, + { "Intensity", "rdm.pd.rgbi_preset_config.intensity", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_rgbi_preset_config_strobe, + { "Strobe", "rdm.pd.rgbi_preset_config.strobe", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_preset_number, + { "Preset Number", "rdm.pd.cct_preset_config.preset_number", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_fade_time, + { "Fade Time (seconds)", "rdm.pd.cct_preset_config.fade_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_delay_time, + { "Delay Time (seconds)", "rdm.pd.cct_preset_config.delay_time", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_white_point, + { "White Point", "rdm.pd.cct_preset_config.white_point", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_tint, + { "Tint", "rdm.pd.cct_preset_config.tint", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_strobe, + { "Strobe", "rdm.pd.cct_preset_config.strobe", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_intensity, + { "Intensity", "rdm.pd.cct_preset_config.intensity", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_tone, + { "Tone", "rdm.pd.cct_preset_config.tone", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_cct_preset_config_reserved, + { "Reserved", "rdm.pd.cct_preset_config.reserved", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_supplementary_device_version_param_index, + { "Param Index", "rdm.pd.supplementary_device_version.param_index", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_supplementary_device_version_param_description, + { "Param Description", "rdm.pd.supplementary_device_version.param_description", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_power_command, + { "State", "rdm.pd.power_command", + FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_power_command_description_state, + { "State", "rdm.pd.power_command_description.state", + FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_power_command_description_text, + { "Description", "rdm.pd.power_command_description.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_dali_short_address, + { "Short Address", "rdm.pd.dali_short_address", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_dali_group_membership, + { "Group Membership", "rdm.pd.dali_group_membership", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_auto_bind, + { "Auto Bind", "rdm.pd.auto_bind", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_packet_delay, + { "Packet Delay", "rdm.pd.packet_delay", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_has_enum_text_pid, + { "PID", "rdm.pd.has_enum_text.pid", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_has_enum_text_true_false, + { "Value", "rdm.pd.has_enum_text.value", + FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_get_enum_text_pid, + { "PID", "rdm.pd.get_enum_text.pid", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_get_enum_text_enum, + { "Enum", "rdm.pd.get_enum_text.enum", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + { &hf_etc_pd_get_enum_text_description, + { "Description", "rdm.pd.get_enum_text.description", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + }; + + static gint *ett[] = { + &ett_rdm, + &ett_etc_sequence_config_steps, + &ett_etc_sequence_config_times + }; + + static ei_register_info ei[] = { + { &ei_rdm_checksum, { "rdm.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }}, + }; + + expert_module_t* expert_rdm; + + proto_rdm = proto_register_protocol("Remote Device Management", "RDM", "rdm"); + proto_register_field_array(proto_rdm, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_dissector("rdm", dissect_rdm, proto_rdm); + expert_rdm = expert_register_protocol(proto_rdm); + expert_register_field_array(expert_rdm, ei, array_length(ei)); } void proto_reg_handoff_rdm(void) { - dissector_add_uint("dmx", 0xCC, create_dissector_handle(dissect_rdm, proto_rdm)); + dissector_add_uint("dmx", 0xCC, create_dissector_handle(dissect_rdm, proto_rdm)); } /* |