summaryrefslogtreecommitdiffstats
path: root/plugins/epan/profinet/packet-pn-dcp.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-10 20:34:10 +0000
commite4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc (patch)
tree68cb5ef9081156392f1dd62a00c6ccc1451b93df /plugins/epan/profinet/packet-pn-dcp.c
parentInitial commit. (diff)
downloadwireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.tar.xz
wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.zip
Adding upstream version 4.2.2.upstream/4.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'plugins/epan/profinet/packet-pn-dcp.c')
-rw-r--r--plugins/epan/profinet/packet-pn-dcp.c2096
1 files changed, 2096 insertions, 0 deletions
diff --git a/plugins/epan/profinet/packet-pn-dcp.c b/plugins/epan/profinet/packet-pn-dcp.c
new file mode 100644
index 00000000..456c79c9
--- /dev/null
+++ b/plugins/epan/profinet/packet-pn-dcp.c
@@ -0,0 +1,2096 @@
+/* packet-pn-dcp.c
+ * Routines for PN-DCP (PROFINET Discovery and basic Configuration Protocol)
+ * packet dissection.
+ *
+ * IEC 61158-6-10 section 4.3
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1999 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+/*
+ * Cyclic PNIO RTC1 Data Dissection:
+ *
+ * Added new functions to packet-pn-dcp.c. The profinet plug-in will now save
+ * the information (Stationname, -type, -id) of "Ident OK" frames. Those
+ * informations will later be used for detailled dissection of cyclic PNIO RTC1
+ * dataframes.
+ *
+ * The declaration of the new added structures are within packet-pn.h to
+ * use the information within packet-pn-rtc-one.c
+ *
+ * Overview for cyclic PNIO RTC1 data dissection functions:
+ * -> dissect_PNDCP_Suboption_Device (Save Stationname, -type, -id)
+ */
+
+
+#include "config.h"
+
+#include <string.h>
+
+#include <glib.h>
+
+#include <epan/packet.h>
+#include <epan/exceptions.h>
+#include <epan/to_str.h>
+#include <epan/wmem_scopes.h>
+#include <epan/expert.h>
+#include <epan/conversation.h>
+
+#include "packet-pn.h"
+
+
+void proto_register_pn_dcp(void);
+void proto_reg_handoff_pn_dcp(void);
+
+int proto_pn_dcp = -1;
+
+static int hf_pn_dcp_service_id = -1;
+static int hf_pn_dcp_service_type = -1;
+static int hf_pn_dcp_xid = -1;
+static int hf_pn_dcp_reserved8 = -1;
+static int hf_pn_dcp_reserved16 = -1;
+static int hf_pn_dcp_response_delay = -1;
+static int hf_pn_dcp_data_length = -1;
+static int hf_pn_dcp_block_length = -1;
+
+static int hf_pn_dcp_block = -1;
+
+static int hf_pn_dcp_block_error = -1;
+
+static int hf_pn_dcp_option = -1;
+static int hf_pn_dcp_block_info = -1;
+static int hf_pn_dcp_block_qualifier = -1;
+static int hf_pn_dcp_blockqualifier = -1;
+static int hf_pn_dcp_blockqualifier_r2f = -1;
+
+static int hf_pn_dcp_suboption_ip = -1;
+static int hf_pn_dcp_suboption_ip_block_info = -1;
+static int hf_pn_dcp_suboption_ip_ip = -1;
+static int hf_pn_dcp_suboption_ip_subnetmask = -1;
+static int hf_pn_dcp_suboption_ip_standard_gateway = -1;
+static int hf_pn_dcp_suboption_ip_mac_address = -1;
+
+static int hf_pn_dcp_suboption_device = -1;
+static int hf_pn_dcp_suboption_device_typeofstation = -1;
+static int hf_pn_dcp_suboption_device_nameofstation = -1;
+static int hf_pn_dcp_suboption_vendor_id = -1;
+static int hf_pn_dcp_suboption_device_id = -1;
+static int hf_pn_dcp_suboption_device_role = -1;
+static int hf_pn_dcp_suboption_device_aliasname = -1;
+static int hf_pn_dcp_suboption_device_instance_high = -1;
+static int hf_pn_dcp_suboption_device_instance_low = -1;
+static int hf_pn_dcp_suboption_device_oem_ven_id = -1;
+static int hf_pn_dcp_suboption_device_oem_dev_id = -1;
+
+static int hf_pn_dcp_rsi_properties_value = -1;
+static int hf_pn_dcp_rsi_properties_value_bit0 = -1;
+static int hf_pn_dcp_rsi_properties_value_bit1 = -1;
+static int hf_pn_dcp_rsi_properties_value_bit2 = -1;
+static int hf_pn_dcp_rsi_properties_value_bit3 = -1;
+static int hf_pn_dcp_rsi_properties_value_bit4 = -1;
+static int hf_pn_dcp_rsi_properties_value_bit5 = -1;
+static int hf_pn_dcp_rsi_properties_value_otherbits = -1;
+
+static int hf_pn_dcp_suboption_tsn = -1;
+static int hf_pn_dcp_suboption_tsn_domain_name = -1;
+static int hf_pn_dcp_suboption_tsn_domain_uuid = -1;
+static int hf_pn_dcp_suboption_tsn_nme_prio = -1;
+static int hf_pn_dcp_suboption_tsn_nme_parameter_uuid = -1;
+static int hf_pn_dcp_suboption_tsn_nme_agent = -1;
+
+static int hf_pn_dcp_suboption_dhcp = -1;
+static int hf_pn_dcp_suboption_dhcp_option_code = -1;
+static int hf_pn_dcp_suboption_dhcp_parameter_length = -1;
+static int hf_pn_dcp_suboption_dhcp_parameter_data = -1;
+static int hf_pn_dcp_suboption_dhcp_arbitrary_client_id = -1;
+static int hf_pn_dcp_suboption_dhcp_control_parameter_data = -1;
+
+static int hf_pn_dcp_suboption_control = -1;
+static int hf_pn_dcp_suboption_control_option = -1;
+static int hf_pn_dcp_suboption_control_signal_value = -1;
+
+static int hf_pn_dcp_suboption_deviceinitiative = -1;
+static int hf_pn_dcp_deviceinitiative_value = -1;
+
+static int hf_pn_dcp_suboption_all = -1;
+
+static int hf_pn_dcp_suboption_manuf = -1;
+
+static int hf_pn_dcp_vendor_id_high = -1;
+static int hf_pn_dcp_vendor_id_low = -1;
+static int hf_pn_dcp_device_id_high = -1;
+static int hf_pn_dcp_device_id_low = -1;
+static int hf_pn_dcp_instance_id_high = -1;
+static int hf_pn_dcp_instance_id_low = -1;
+static gint ett_pn_dcp = -1;
+static gint ett_pn_dcp_block = -1;
+
+static gint ett_pn_dcp_rsi_properties_value = -1;
+
+static expert_field ei_pn_dcp_block_parse_error = EI_INIT;
+static expert_field ei_pn_dcp_block_error_unknown = EI_INIT;
+static expert_field ei_pn_dcp_ip_conflict = EI_INIT;
+
+#define PNDCP_SERVICE_ID_GET 0x03
+#define PNDCP_SERVICE_ID_SET 0x04
+#define PNDCP_SERVICE_ID_IDENTIFY 0x05
+#define PNDCP_SERVICE_ID_HELLO 0x06
+
+static const value_string pn_dcp_service_id[] = {
+ { 0x00, "reserved" },
+ { 0x01, "Manufacturer specific" },
+ { 0x02, "Manufacturer specific" },
+ { PNDCP_SERVICE_ID_GET, "Get" },
+ { PNDCP_SERVICE_ID_SET, "Set" },
+ { PNDCP_SERVICE_ID_IDENTIFY,"Identify" },
+ { PNDCP_SERVICE_ID_HELLO, "Hello" },
+ /* 0x07 - 0xff reserved */
+ { 0, NULL }
+};
+
+#define PNDCP_SERVICE_TYPE_REQUEST 0
+#define PNDCP_SERVICE_TYPE_RESPONSE_SUCCESS 1
+#define PNDCP_SERVICE_TYPE_RESPONSE_UNSUPPORTED 5
+
+static const value_string pn_dcp_service_type[] = {
+ { PNDCP_SERVICE_TYPE_REQUEST, "Request" },
+ { PNDCP_SERVICE_TYPE_RESPONSE_SUCCESS, "Response Success" },
+ { PNDCP_SERVICE_TYPE_RESPONSE_UNSUPPORTED, "Response - Request not supported" },
+ /* all others reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_block_error[] = {
+ { 0x00, "Ok" },
+ { 0x01, "Option unsupp." },
+ { 0x02, "Suboption unsupp. or no DataSet avail." },
+ { 0x03, "Suboption not set" },
+ { 0x04, "Resource Error" },
+ { 0x05, "SET not possible by local reasons" },
+ { 0x06, "In operation, SET not possible" },
+ /* all others reserved */
+ { 0, NULL }
+};
+
+static const range_string pn_dcp_block_info[] = {
+ { 0x0000, 0xFFFF, "Reserved" },
+ { 0, 0, NULL }
+};
+
+static const value_string pn_dcp_block_qualifier[] = {
+ { 0x0000, "Use the value temporary" },
+ { 0x0001, "Save the value permanent" },
+ /*0x0002 - 0xffff reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_BlockQualifier[] = {
+ { 0x0002, "Reset application data" },
+ { 0x0003, "Reset application data" },
+ { 0x0004, "Reset communication parameter" },
+ { 0x0005, "Reset communication parameter" },
+ { 0x0006, "Reset engineering parameter" },
+ { 0x0007, "Reset engineering parameter" },
+ { 0x0008, "Resets all stored data" },
+ { 0x0009, "Resets all stored data" },
+ { 0x000A, "Reset engineering parameter" },
+ { 0x000B, "Reset engineering parameter" },
+ { 0x000C, "Reserved" },
+ { 0x000D, "Reserved" },
+ { 0x000E, "Reserved" },
+ { 0x0010, "Resets all stored data in the IOD or IOC to its factory values" },
+ { 0x0011, "Resets all stored data in the IOD or IOC to its factory values" },
+ { 0x0012, "Reset and restore data" },
+ { 0x0013, "Reset and restore data" },
+ { 0x0014, "Reserved" },
+ { 0x0015, "Reserved" },
+ { 0x0016, "Reserved" },
+ { 0, NULL }
+};
+
+#define PNDCP_OPTION_IP 0x01
+#define PNDCP_OPTION_DEVICE 0x02
+#define PNDCP_OPTION_DHCP 0x03
+#define PNDCP_OPTION_RESERVED 0x04
+#define PNDCP_OPTION_CONTROL 0x05
+#define PNDCP_OPTION_DEVICEINITIATIVE 0x06
+#define PNDCP_OPTION_TSN 0x07
+#define PNDCP_OPTION_MANUF_X80 0x80
+#define PNDCP_OPTION_MANUF_XFE 0xFE
+#define PNDCP_OPTION_ALLSELECTOR 0xFF
+
+static const range_string pn_dcp_option[] = {
+ { 0x00, 0x00, "Reserved" },
+ { PNDCP_OPTION_IP , PNDCP_OPTION_IP , "IP" },
+ { PNDCP_OPTION_DEVICE , PNDCP_OPTION_DEVICE , "Device properties" },
+ { PNDCP_OPTION_DHCP , PNDCP_OPTION_DHCP , "DHCP" },
+ { PNDCP_OPTION_RESERVED , PNDCP_OPTION_RESERVED , "Reserved" },
+ { PNDCP_OPTION_CONTROL , PNDCP_OPTION_CONTROL , "Control" },
+ { PNDCP_OPTION_DEVICEINITIATIVE, PNDCP_OPTION_DEVICEINITIATIVE, "Device Initiative" },
+ { PNDCP_OPTION_TSN , PNDCP_OPTION_TSN , "TSN Domain"},
+ /*0x07 - 0x7F reserved */
+ /*0x80 - 0xFE manufacturer specific */
+ { PNDCP_OPTION_MANUF_X80 , PNDCP_OPTION_MANUF_XFE , "Manufacturer specific" },
+ { PNDCP_OPTION_ALLSELECTOR, PNDCP_OPTION_ALLSELECTOR, "All Selector" },
+ { 0, 0, NULL }
+};
+
+#define PNDCP_SUBOPTION_IP_MAC 0x01
+#define PNDCP_SUBOPTION_IP_IP 0x02
+#define PNDCP_SUBOPTION_IP_FULL_IP_SUITE 0x03
+
+static const value_string pn_dcp_suboption_ip[] = {
+ { 0x00, "Reserved" },
+ { PNDCP_SUBOPTION_IP_MAC, "MAC address" },
+ { PNDCP_SUBOPTION_IP_IP, "IP parameter" },
+ { PNDCP_SUBOPTION_IP_FULL_IP_SUITE, "Full IP suite" },
+ /*0x03 - 0xff reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_ip_block_info[] = {
+ { 0x0000, "IP not set" },
+ { 0x0001, "IP set" },
+ { 0x0002, "IP set by DHCP" },
+ { 0x0080, "IP not set (address conflict detected)" },
+ { 0x0081, "IP set (address conflict detected)" },
+ { 0x0082, "IP set by DHCP (address conflict detected)" },
+ /*0x0003 - 0xffff reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_control_signal_value[] = {
+ {0x0100, "Flash Once"},
+ {0, NULL}
+};
+
+#define PNDCP_SUBOPTION_DEVICE_MANUF 0x01
+#define PNDCP_SUBOPTION_DEVICE_NAMEOFSTATION 0x02
+#define PNDCP_SUBOPTION_DEVICE_DEV_ID 0x03
+#define PNDCP_SUBOPTION_DEVICE_DEV_ROLE 0x04
+#define PNDCP_SUBOPTION_DEVICE_DEV_OPTIONS 0x05
+#define PNDCP_SUBOPTION_DEVICE_ALIAS_NAME 0x06
+#define PNDCP_SUBOPTION_DEVICE_DEV_INSTANCE 0x07
+#define PNDCP_SUBOPTION_DEVICE_OEM_DEV_ID 0x08
+#define PNDCP_SUBOPTION_DEVICE_RSI_PROPERTIES 0x0A
+
+static const value_string pn_dcp_suboption_device[] = {
+ { 0x00, "Reserved" },
+ { PNDCP_SUBOPTION_DEVICE_MANUF, "Manufacturer specific (Type of Station)" },
+ { PNDCP_SUBOPTION_DEVICE_NAMEOFSTATION, "Name of Station" },
+ { PNDCP_SUBOPTION_DEVICE_DEV_ID, "Device ID" },
+ { PNDCP_SUBOPTION_DEVICE_DEV_ROLE, "Device Role" },
+ { PNDCP_SUBOPTION_DEVICE_DEV_OPTIONS, "Device Options" },
+ { PNDCP_SUBOPTION_DEVICE_ALIAS_NAME, "Alias Name" },
+ { PNDCP_SUBOPTION_DEVICE_DEV_INSTANCE, "Device Instance" },
+ { PNDCP_SUBOPTION_DEVICE_OEM_DEV_ID, "OEM Device ID"},
+ { PNDCP_SUBOPTION_DEVICE_RSI_PROPERTIES,"RSI Properties" },
+ /*0x09 - 0xff reserved */
+ { 0, NULL }
+};
+
+static const true_false_string pn_dcp_rsi_properties_value_bit =
+ { "Available", "Not available" } ;
+
+#define PNDCP_SUBOPTION_TSN_DOMAIN_NAME 0x01
+#define PNDCP_SUBOPTION_TSN_NME_MANAGER 0x02
+#define PNDCP_SUBOPTION_TSN_NME_PARAMETER_UUID 0x03
+#define PNDCP_SUBOPTION_TSN_NME_AGENT 0x04
+#define PNDCP_SUBOPTION_TSN_CIM_INTERFACE 0x05
+
+static const value_string pn_dcp_suboption_tsn[] = {
+ { 0x00, "Reserved" },
+ { PNDCP_SUBOPTION_TSN_DOMAIN_NAME, "TSN Domain Name" },
+ { PNDCP_SUBOPTION_TSN_NME_MANAGER, "NME Manager" },
+ { PNDCP_SUBOPTION_TSN_NME_PARAMETER_UUID, "NME Paramater UUID" },
+ { PNDCP_SUBOPTION_TSN_NME_AGENT, "NME Agent" },
+ { PNDCP_SUBOPTION_TSN_CIM_INTERFACE, "CIM Interface" },
+ { 0, NULL }
+};
+
+static const range_string pn_dcp_suboption_tsn_nme_prio[] =
+{
+ { 0x0000, 0x0000, "Highest priority NME manager" },
+ { 0x0001, 0x3000, "High priorities for NME manager" },
+ { 0x3001, 0x9FFF, "Low priorities for NME manager" },
+ { 0xA000, 0xA000, "Lowest priority for NME manager / Default priority for NME manager" },
+ { 0xA001, 0xFFFF, "Reserved" },
+ { 0, 0, NULL }
+};
+
+#define PNDCP_SUBOPTION_DHCP_CLIENT_ID 61
+#define PNDCP_SUBOPTION_DHCP_CONTROL_FOR_ADDRESS_RES 255
+
+static const value_string pn_dcp_suboption_dhcp[] = {
+ { 12, "Host name" },
+ { 43, "Vendor specific" },
+ { 54, "Server identifier" },
+ { 55, "Parameter request list" },
+ { 60, "Class identifier" },
+ { PNDCP_SUBOPTION_DHCP_CLIENT_ID, "DHCP client identifier" },
+ { 81, "FQDN, Fully Qualified Domain Name" },
+ { 97, "UUID/GUID-based Client" },
+ { PNDCP_SUBOPTION_DHCP_CONTROL_FOR_ADDRESS_RES, "Control DHCP for address resolution" },
+ /*all others reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_dhcp_control_parameter_data[] = {
+ { 0x00, "Don't use DHCP (Default)" },
+ { 0x01, "Don't use DHCP, all DHCPOptions set to Reset to Factory value" },
+ { 0x02, "Use DHCP with the given set of DHCPOptions" },
+ { 0, NULL }
+};
+
+#define PNDCP_SUBOPTION_CONTROL_START_TRANS 0x01
+#define PNDCP_SUBOPTION_CONTROL_END_TRANS 0x02
+#define PNDCP_SUBOPTION_CONTROL_SIGNAL 0x03
+#define PNDCP_SUBOPTION_CONTROL_RESPONSE 0x04
+#define PNDCP_SUBOPTION_CONTROL_FACT_RESET 0x05
+#define PNDCP_SUBOPTION_CONTROL_RESET_TO_FACT 0x06
+
+static const value_string pn_dcp_suboption_control[] = {
+ { 0x00, "Reserved" },
+ { PNDCP_SUBOPTION_CONTROL_START_TRANS, "Start Transaction" },
+ { PNDCP_SUBOPTION_CONTROL_END_TRANS, "End Transaction" },
+ { PNDCP_SUBOPTION_CONTROL_SIGNAL, "Signal" },
+ { PNDCP_SUBOPTION_CONTROL_RESPONSE, "Response" },
+ { PNDCP_SUBOPTION_CONTROL_FACT_RESET, "Reset Factory Settings" },
+ { PNDCP_SUBOPTION_CONTROL_RESET_TO_FACT,"Reset to Factory" },
+ /*0x07 - 0xff reserved */
+ { 0, NULL }
+};
+
+#define PNDCP_SUBOPTION_DEVICEINITIATIVE 0x01
+
+static const value_string pn_dcp_suboption_deviceinitiative[] = {
+ { 0x00, "Reserved" },
+ { PNDCP_SUBOPTION_DEVICEINITIATIVE, "Device Initiative" },
+ /*0x00 - 0xff reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_deviceinitiative_value[] = {
+ { 0x00, "Device does not issue a DCP-Hello-ReqPDU after power on" },
+ { 0x01, "Device does issue a DCP-Hello-ReqPDU after power on" },
+ /*0x02 - 0xff reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_all[] = {
+ { 0xff, "ALL Selector" },
+ /* all other reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_other[] = {
+ { 0x00, "Default" },
+ /* all other reserved */
+ { 0, NULL }
+};
+
+static const value_string pn_dcp_suboption_manuf[] = {
+ /* none known */
+ { 0, NULL }
+};
+
+
+
+
+
+/* dissect the option field */
+static int
+dissect_PNDCP_Option(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, int hfindex, gboolean append_col)
+{
+ guint8 option;
+ guint8 suboption;
+ const value_string *val_str;
+
+ offset = dissect_pn_uint8 (tvb, offset, pinfo, tree, hfindex, &option);
+ switch (option) {
+ case PNDCP_OPTION_IP:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip, &suboption);
+ val_str = pn_dcp_suboption_ip;
+ break;
+ case PNDCP_OPTION_DEVICE:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device, &suboption);
+ val_str = pn_dcp_suboption_device;
+ break;
+ case PNDCP_OPTION_DHCP:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp, &suboption);
+ val_str = pn_dcp_suboption_dhcp;
+ break;
+ case PNDCP_OPTION_CONTROL:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_control, &suboption);
+ val_str = pn_dcp_suboption_control;
+ break;
+ case PNDCP_OPTION_DEVICEINITIATIVE:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_deviceinitiative, &suboption);
+ val_str = pn_dcp_suboption_deviceinitiative;
+ break;
+ case PNDCP_OPTION_TSN:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn, &suboption);
+ val_str = pn_dcp_suboption_tsn;
+ break;
+ case PNDCP_OPTION_ALLSELECTOR:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_all, &suboption);
+ val_str = pn_dcp_suboption_all;
+ break;
+ default:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_manuf, &suboption);
+ val_str = pn_dcp_suboption_manuf;
+ }
+
+ proto_item_append_text(block_item, ", Status from %s - %s",
+ rval_to_str_const(option, pn_dcp_option, "Unknown"),
+ val_to_str_const(suboption, val_str, "Unknown"));
+
+ if (append_col) {
+ col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str_const(suboption, val_str, "Unknown"));
+ }
+
+ return offset;
+}
+
+
+/* dissect the "IP" suboption */
+static int
+dissect_PNDCP_Suboption_IP(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id, gboolean is_response)
+{
+ guint8 suboption;
+ guint16 block_length;
+ guint16 block_info;
+ guint16 block_qualifier;
+ gboolean have_block_info = FALSE;
+ gboolean have_block_qualifier = FALSE;
+ guint8 mac[6];
+ guint32 ip;
+ proto_item *item = NULL;
+ address addr;
+
+
+ /* SuboptionIPParameter */
+ offset = dissect_pn_uint8 (tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip, &suboption);
+ /* DCPBlockLength */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ switch (suboption) {
+ case PNDCP_SUBOPTION_IP_MAC:
+ /* MACAddressValue? */
+ pn_append_info(pinfo, dcp_item, ", MAC");
+ proto_item_append_text(block_item, "IP/MAC");
+
+ /* BlockInfo? */
+ if (((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ have_block_info = TRUE;
+ block_length -= 2;
+ }
+
+ /* BlockQualifier? */
+ if ((service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ have_block_qualifier = TRUE;
+ block_length -= 2;
+ }
+
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+
+ offset = dissect_pn_mac(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_mac_address, mac);
+ set_address(&addr, AT_ETHER, 6, mac);
+ proto_item_append_text(block_item, ", MACAddress: %s", address_to_str(pinfo->pool, &addr));
+ break;
+ case PNDCP_SUBOPTION_IP_IP:
+ pn_append_info(pinfo, dcp_item, ", IP");
+ proto_item_append_text(block_item, "IP/IP");
+
+ /* BlockInfo? */
+ if (((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ block_info = tvb_get_ntohs(tvb, offset);
+ if (tree) {
+ item = proto_tree_add_uint(tree, hf_pn_dcp_suboption_ip_block_info, tvb, offset, 2, block_info);
+ }
+ offset += 2;
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ val_to_str_const(block_info, pn_dcp_suboption_ip_block_info, "Undecoded"));
+ block_length -= 2;
+ if (block_info & 0x80) {
+ expert_add_info(pinfo, item, &ei_pn_dcp_ip_conflict);
+ }
+ }
+
+ /* BlockQualifier? */
+ if ( (service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ block_length -= 2;
+ }
+
+ /* IPParameterValue ... */
+
+ /* IPAddress */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_ip, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", IP: %s", address_to_str(pinfo->pool, &addr));
+
+ /* Subnetmask */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_subnetmask, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", Subnet: %s", address_to_str(pinfo->pool, &addr));
+
+ /* StandardGateway */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_standard_gateway, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", Gateway: %s", address_to_str(pinfo->pool, &addr));
+ break;
+ case PNDCP_SUBOPTION_IP_FULL_IP_SUITE:
+ pn_append_info(pinfo, dcp_item, ", MAC");
+ proto_item_append_text(block_item, "IP/MAC");
+
+ /* BlockInfo? */
+ if (((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ have_block_info = TRUE;
+ block_length -= 2;
+ }
+
+ /* BlockQualifier? */
+ if ((service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ have_block_qualifier = TRUE;
+ block_length -= 2;
+ }
+
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+
+ /* IPAddress */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_ip, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", IP: %s", address_to_str(pinfo->pool, &addr));
+
+ /* Subnetmask */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_subnetmask, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", Subnet: %s", address_to_str(pinfo->pool, &addr));
+
+ /* StandardGateway */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_standard_gateway, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", Gateway: %s", address_to_str(pinfo->pool, &addr));
+
+ /* IPAddress_1 */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_ip, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", DNSServerIP1: %s", address_to_str(pinfo->pool, &addr));
+
+ /* IPAddress_2 */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_subnetmask, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", DNSServerIP2: %s", address_to_str(pinfo->pool, &addr));
+
+ /* IPAddress_3 */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_standard_gateway, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", DNSServerIP3: %s", address_to_str(pinfo->pool, &addr));
+
+ /* IPAddress_4 */
+ offset = dissect_pn_ipv4(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_ip_standard_gateway, &ip);
+ set_address(&addr, AT_IPv4, 4, &ip);
+ proto_item_append_text(block_item, ", DNSServerIP4: %s", address_to_str(pinfo->pool, &addr));
+
+ break;
+ default:
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+
+ return offset;
+}
+
+
+/* dissect the "device" suboption */
+static int
+dissect_PNDCP_Suboption_Device(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id, gboolean is_response)
+{
+ guint8 suboption;
+ guint16 block_length;
+ gchar *info_str;
+ guint8 device_role;
+ guint16 vendor_id;
+ guint16 device_id;
+ char *typeofstation;
+ char *nameofstation;
+ char *aliasname;
+ guint16 block_info = 0;
+ guint16 block_qualifier = 0;
+ gboolean have_block_info = FALSE;
+ gboolean have_block_qualifier = FALSE;
+ guint8 device_instance_high;
+ guint8 device_instance_low;
+ guint16 oem_vendor_id;
+ guint16 oem_device_id;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
+ conversation_t *conversation;
+ stationInfo *station_info;
+
+ /* SuboptionDevice... */
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device, &suboption);
+ /* DCPBlockLength */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ /* BlockInfo? */
+ if ( ((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ have_block_info = TRUE;
+ block_length -= 2;
+ }
+
+ /* BlockQualifier? */
+ if ( (service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ have_block_qualifier = TRUE;
+ block_length -= 2;
+ }
+
+ switch (suboption) {
+ case PNDCP_SUBOPTION_DEVICE_MANUF:
+ /*
+ * XXX - IEC 61158-6-10 Edition 4.0, section 4.3, says this field
+ * "shall be coded as data type VisibleString", and that VisibleString
+ * is "ISO/IEC 646 - International Reference Version without the "del"
+ * (coding 0x7F) character", i.e. ASCII.
+ *
+ * However, at least one capture has a packet where 0xAE is used in
+ * a place where a registered trademark symbol would be appropriate,
+ * so the host sending it apparently extended ASCII to ISO 8859-n
+ * for some value of n. That may have just been an error on their
+ * part, not realizing that they should have done "(R)" or something
+ * such as that.
+ */
+ proto_tree_add_item_ret_display_string (tree, hf_pn_dcp_suboption_device_typeofstation, tvb, offset, block_length, ENC_ASCII, pinfo->pool, &typeofstation);
+ pn_append_info(pinfo, dcp_item, ", DeviceVendorValue");
+ proto_item_append_text(block_item, "Device/Manufacturer specific");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info){
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", DeviceVendorValue: \"%s\"", typeofstation);
+
+
+ if (PINFO_FD_VISITED(pinfo) == FALSE) {
+ /* Create a conversation between the MAC addresses */
+ conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ if (conversation == NULL) {
+ /* Create new conversation, need to switch dl_src & dl_dst if not a response
+ * All conversations are based on Device MAC as addr1 */
+ if (is_response) {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ }
+ else {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_dst, &pinfo->dl_src, CONVERSATION_NONE, 0, 0, 0);
+ }
+ }
+
+ station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
+ if (station_info == NULL) {
+ station_info = wmem_new0(wmem_file_scope(), stationInfo);
+ init_pnio_rtc1_station(station_info);
+ conversation_add_proto_data(conversation, proto_pn_dcp, station_info);
+ }
+
+ station_info->typeofstation = wmem_strdup(wmem_file_scope(), typeofstation);
+ }
+
+ offset += block_length;
+ break;
+
+ case PNDCP_SUBOPTION_DEVICE_NAMEOFSTATION:
+ /*
+ * XXX - IEC 61158-6-10 Edition 4.0 says, in section 4.3.1.4.15
+ * "Coding of the field NameOfStationValue", that "This field shall
+ * be coded as data type OctetString with 1 to 240 octets. The
+ * definition of IETF RFC 5890 and the following syntax applies: ..."
+ *
+ * RFC 5890 means Punycode; should we translate the domain name to
+ * UTF-8 and show both the untranslated and translated domain name?
+ *
+ * They don't mention anything about the RFC 1035 encoding of
+ * domain names as mentioned in section 3.1 "Name space definitions",
+ * with the labels being counted strings; does that mean that this
+ * is just an ASCII string to be interpreted as a Punycode Unicode
+ * domain name?
+ */
+ proto_tree_add_item_ret_display_string (tree, hf_pn_dcp_suboption_device_nameofstation, tvb, offset, block_length, ENC_ASCII, pinfo->pool, &nameofstation);
+ pn_append_info(pinfo, dcp_item, wmem_strdup_printf(pinfo->pool, ", NameOfStation:\"%s\"", nameofstation));
+ proto_item_append_text(block_item, "Device/NameOfStation");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", \"%s\"", nameofstation);
+
+
+ if (PINFO_FD_VISITED(pinfo) == FALSE) {
+ /* Create a conversation between the MAC addresses */
+ conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ if (conversation == NULL) {
+ /* Create new conversation, need to switch dl_src & dl_dst if not a response
+ * All conversations are based on Device MAC as addr1 */
+ if (is_response) {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ }
+ else {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_dst, &pinfo->dl_src, CONVERSATION_NONE, 0, 0, 0);
+ }
+ }
+
+ station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
+ if (station_info == NULL) {
+ station_info = wmem_new0(wmem_file_scope(), stationInfo);
+ init_pnio_rtc1_station(station_info);
+ conversation_add_proto_data(conversation, proto_pn_dcp, station_info);
+ }
+
+ station_info->nameofstation = wmem_strdup(wmem_file_scope(), nameofstation);
+ }
+
+ offset += block_length;
+ break;
+
+ case PNDCP_SUBOPTION_DEVICE_DEV_ID:
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_vendor_id, &vendor_id);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_id, &device_id);
+
+ if (PINFO_FD_VISITED(pinfo) == FALSE) {
+ /* Create a conversation between the MAC addresses */
+ conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ if (conversation == NULL) {
+ /* Create new conversation, need to switch dl_src & dl_dst if not a response
+ * All conversations are based on Device MAC as addr1 */
+ if (is_response) {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ }
+ else {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_dst, &pinfo->dl_src, CONVERSATION_NONE, 0, 0, 0);
+ }
+ }
+
+ station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
+ if (station_info == NULL) {
+ station_info = wmem_new0(wmem_file_scope(), stationInfo);
+ init_pnio_rtc1_station(station_info);
+ conversation_add_proto_data(conversation, proto_pn_dcp, station_info);
+ }
+
+ station_info->u16Vendor_id = vendor_id;
+ station_info->u16Device_id = device_id;
+ }
+
+
+ pn_append_info(pinfo, dcp_item, ", Dev-ID");
+ proto_item_append_text(block_item, "Device/Device ID");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", VendorID: 0x%04x / DeviceID: 0x%04x", vendor_id, device_id);
+ break;
+ case PNDCP_SUBOPTION_DEVICE_DEV_ROLE:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_role, &device_role);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_reserved8, NULL);
+ pn_append_info(pinfo, dcp_item, ", Dev-Role");
+ proto_item_append_text(block_item, "Device/Device Role");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info)
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ if (device_role & 0x01)
+ proto_item_append_text(block_item, ", IO-Device");
+ if (device_role & 0x02)
+ proto_item_append_text(block_item, ", IO-Controller");
+ if (device_role & 0x04)
+ proto_item_append_text(block_item, ", IO-Multidevice");
+ if (device_role & 0x08)
+ proto_item_append_text(block_item, ", PN-Supervisor");
+ break;
+ case PNDCP_SUBOPTION_DEVICE_DEV_OPTIONS:
+ info_str = wmem_strdup_printf(pinfo->pool, ", Dev-Options(%u)", block_length/2);
+ pn_append_info(pinfo, dcp_item, info_str);
+ proto_item_append_text(block_item, "Device/Device Options");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", %u options", block_length/2);
+ for( ; block_length != 0; block_length -= 2) {
+ offset = dissect_PNDCP_Option(tvb, offset, pinfo, tree, NULL /*block_item*/, hf_pn_dcp_option,
+ FALSE /* append_col */);
+ }
+ break;
+ case PNDCP_SUBOPTION_DEVICE_ALIAS_NAME:
+ /*
+ * XXX - IEC 61158-6-10 Edition 4.0, section 4.3.1.4.17 "Coding of
+ * the field AliasNameValue", says this field "shall be coded as
+ * OctetString. The content shall be the concatenation of the content
+ * of the fields NameOfPort and NameOfStation.
+ *
+ * AliasNameValue = NameOfPort + "." + NameOfStation
+ *
+ * " and:
+ *
+ * It says in section 4.3.1.4.16 "Coding of the field NameOfPort"
+ * that "This field shall be coded as OctetString[8] or
+ * OctetString[14] as "port-xyz" or "port-xyz-rstuv" where x, y,
+ * z is in the range "0"-"9" from 001 up to 255 and r, s, t, u, v
+ * is in the range "0"-"9" from 00000 up to 65535. ...
+ * Furthermore, the definition of IETF RFC 5890 shall be applied."
+ *
+ * That suggests that the Octets are probably just ASCII characters;
+ * IETF RFC 5890 means Punycode, but there isn't anything in those
+ * string formats that requires non-ASCII characters - they're
+ * just literally "port-" followed by numbers and hyphens.
+ *
+ * It says in section 4.3.1.4.15 "Coding of the field
+ * NameOfStationValue" that it's a domain name, complete with
+ * RFC 5890 Punycode.
+ */
+ proto_tree_add_item_ret_display_string (tree, hf_pn_dcp_suboption_device_aliasname, tvb, offset, block_length, ENC_ASCII, pinfo->pool, &aliasname);
+ pn_append_info(pinfo, dcp_item, wmem_strdup_printf(pinfo->pool, ", AliasName:\"%s\"", aliasname));
+ proto_item_append_text(block_item, "Device/AliasName");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", \"%s\"", aliasname);
+ offset += block_length;
+ break;
+ case PNDCP_SUBOPTION_DEVICE_DEV_INSTANCE:
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_instance_high, &device_instance_high);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_instance_low, &device_instance_low);
+ pn_append_info(pinfo, dcp_item, ", Dev-Instance");
+ proto_item_append_text(block_item, "Device/Device Instance");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", InstanceHigh: %d, Instance Low: %d",
+ device_instance_high, device_instance_low);
+ break;
+ case PNDCP_SUBOPTION_DEVICE_OEM_DEV_ID:
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_oem_ven_id, &oem_vendor_id);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_oem_dev_id, &oem_device_id);
+ pn_append_info(pinfo, dcp_item, ", OEM-Dev-ID");
+ proto_item_append_text(block_item, "Device/OEM Device ID");
+ if(have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if(have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ proto_item_append_text(block_item, ", OEMVendorID: 0x%04x / OEMDeviceID: 0x%04x", oem_vendor_id, oem_device_id);
+ break;
+ case PNDCP_SUBOPTION_DEVICE_RSI_PROPERTIES:
+ sub_item = proto_tree_add_item(tree, hf_pn_dcp_rsi_properties_value, tvb, offset, 2, ENC_BIG_ENDIAN);
+ sub_tree = proto_item_add_subtree(sub_item, ett_pn_dcp_rsi_properties_value);
+
+ static int* const flags[] = {
+ &hf_pn_dcp_rsi_properties_value_bit0,
+ &hf_pn_dcp_rsi_properties_value_bit1,
+ &hf_pn_dcp_rsi_properties_value_bit2,
+ &hf_pn_dcp_rsi_properties_value_bit3,
+ &hf_pn_dcp_rsi_properties_value_bit4,
+ &hf_pn_dcp_rsi_properties_value_bit5,
+ &hf_pn_dcp_rsi_properties_value_otherbits,
+ NULL
+ };
+
+ proto_tree_add_bitmask(sub_tree, tvb, offset, hf_pn_dcp_rsi_properties_value, ett_pn_dcp_rsi_properties_value, flags, ENC_BIG_ENDIAN);
+
+ offset = offset + 2;
+
+ if (pinfo->fd->visited == FALSE) {
+ /* Create a conversation between the MAC addresses */
+ conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ if (conversation == NULL) {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ }
+
+ station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
+ if (station_info == NULL) {
+ station_info = wmem_new0(wmem_file_scope(), stationInfo);
+ init_pnio_rtc1_station(station_info);
+ conversation_add_proto_data(conversation, proto_pn_dcp, station_info);
+ }
+ }
+
+ pn_append_info(pinfo, dcp_item, ", RSI-Properties");
+ proto_item_append_text(block_item, "Device/RSI Properties");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ break;
+ default:
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+
+ return offset;
+}
+
+/* dissect the "tsn" suboption */
+static int
+dissect_PNDCP_Suboption_TSN(tvbuff_t* tvb, int offset, packet_info* pinfo,
+ proto_tree* tree, proto_item* block_item, proto_item* dcp_item,
+ guint8 service_id, gboolean is_response)
+{
+ guint8 suboption;
+ guint16 block_length;
+ char *domain_name;
+ guint16 nme_prio;
+ e_guid_t tsn_domain_uuid;
+ e_guid_t nme_parameter_uuid;
+ e_guid_t nme_name_uuid;
+ guint16 vendor_id;
+ guint16 device_id;
+ guint16 block_info = 0;
+ guint16 block_qualifier = 0;
+ gboolean have_block_info = FALSE;
+ gboolean have_block_qualifier = FALSE;
+ guint8 instance_id_high;
+ guint8 instance_id_low;
+ conversation_t* conversation;
+ stationInfo* station_info;
+ gboolean is_zeros = TRUE;
+
+ /* SuboptionTSN... */
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn, &suboption);
+
+ /* DCPBlockLength */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ /* BlockInfo? */
+ if (((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ have_block_info = TRUE;
+ block_length -= 2;
+ }
+
+ /* BlockQualifier? */
+ if ((service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ have_block_qualifier = TRUE;
+ block_length -= 2;
+ }
+
+ switch (suboption) {
+ case PNDCP_SUBOPTION_TSN_DOMAIN_NAME:
+
+ offset = dissect_pn_uuid(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn_domain_uuid, &tsn_domain_uuid);
+ proto_tree_add_item_ret_display_string(tree, hf_pn_dcp_suboption_tsn_domain_name, tvb, offset, (block_length-16), ENC_ASCII | ENC_NA, pinfo->pool, &domain_name);
+
+ pn_append_info(pinfo, dcp_item, ", TSN-Domain Name");
+ proto_item_append_text(block_item, "TSN/TSN-Domain Name");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info)
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+
+ pn_append_info(pinfo, dcp_item, wmem_strdup_printf(pinfo->pool, ", DomainName:\"%s\"", domain_name));
+ proto_item_append_text(block_item, ", \"%s\"", domain_name);
+ offset += (block_length-16);
+ is_zeros = TRUE;
+
+ for (int i = 0; i < 8; i++)
+ {
+ if (tsn_domain_uuid.data4[i] != 0)
+ {
+ is_zeros = FALSE;
+ break;
+ }
+ }
+
+ if ((tsn_domain_uuid.data1 == 0) && (tsn_domain_uuid.data2 == 0) && (tsn_domain_uuid.data3 == 0) && (is_zeros))
+ proto_item_append_text(block_item, ", No TSN domain assigned");
+ else
+ proto_item_append_text(block_item, ", UUID identifying a TSN domain using SNMP/ LLDP/ DCP");
+
+ break;
+
+ case PNDCP_SUBOPTION_TSN_NME_MANAGER:
+
+ pn_append_info(pinfo, dcp_item, ", NME-Manager");
+ proto_item_append_text(block_item, "TSN/NME-Manager");
+
+ if (have_block_qualifier)
+ {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+
+ if (have_block_info)
+ {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn_nme_prio, &nme_prio);
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+
+ if (nme_prio == 0x0000)
+ proto_item_append_text(block_item, ", Highest priority NME manager");
+ else if ((0x0001 <= nme_prio) && (nme_prio <= 0x3000))
+ proto_item_append_text(block_item, ", High priorities for NME manager");
+ else if ((0x3001 <= nme_prio) && (nme_prio <= 0x9FFF))
+ proto_item_append_text(block_item, ", Low priorities for NME manager");
+ else if (0xA000 == nme_prio)
+ proto_item_append_text(block_item, ", Lowest priority for NME manager / Default priority for NME manager");
+ else
+ proto_item_append_text(block_item, ", Reserved");
+ }
+
+ break;
+
+ case PNDCP_SUBOPTION_TSN_NME_PARAMETER_UUID:
+
+ pn_append_info(pinfo, dcp_item, ", NME-Parameter UUID");
+ proto_item_append_text(block_item, "TSN/NME-Parameter UUID");
+
+ if (block_length > 0)
+ {
+ offset = dissect_pn_uuid(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn_nme_parameter_uuid, &nme_parameter_uuid);
+
+ if (have_block_qualifier)
+ {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info)
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+
+ is_zeros = TRUE;
+
+ for (int i = 0; i < 8; i++)
+ {
+ if (nme_parameter_uuid.data4[i] != 0)
+ {
+ is_zeros = FALSE;
+ break;
+ }
+ }
+ if ((nme_parameter_uuid.data1 == 0) && (nme_parameter_uuid.data2 == 0) && (nme_parameter_uuid.data3 == 0) && (is_zeros))
+ proto_item_append_text(block_item, ", Unconfigured");
+ else
+ proto_item_append_text(block_item, ", UUID identifying an NME parameter set within the TSN domain.");
+ }
+ break;
+
+ case PNDCP_SUBOPTION_TSN_NME_AGENT:
+
+ pn_append_info(pinfo, dcp_item, ", NME-Agent");
+ proto_item_append_text(block_item, "TSN/NME-Agent");
+
+ if (have_block_qualifier)
+ {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+
+ if (have_block_info)
+ {
+ offset = dissect_pn_uuid(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_tsn_nme_agent, &nme_name_uuid);
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+
+ is_zeros = TRUE;
+ for (int i = 0; i < 8; i++)
+ {
+ if (nme_name_uuid.data4[i] != 0)
+ {
+ is_zeros = FALSE;
+ break;
+ }
+ }
+
+ if ((nme_name_uuid.data1 == 0) && (nme_name_uuid.data2 == 0) && (nme_name_uuid.data3 == 0) && (is_zeros))
+ proto_item_append_text(block_item, ", No NME assigned");
+ else
+ proto_item_append_text(block_item, ", UUID identifying an NME using SNMP / LLDP / DCP");
+ }
+ break;
+
+ case PNDCP_SUBOPTION_TSN_CIM_INTERFACE:
+
+ pn_append_info(pinfo, dcp_item, ", CIM-Interface");
+ proto_item_append_text(block_item, "TSN/CIM-Interface");
+
+ if (have_block_qualifier)
+ {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info)
+ {
+ // CIMVDIValue
+ dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_vendor_id_high, &vendor_id);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_vendor_id_low, &vendor_id);
+
+ dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_device_id_high, &device_id);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_device_id_low, &device_id);
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_instance_id_high, &instance_id_high);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_instance_id_low, &instance_id_low);
+
+ if (pinfo->fd->visited == FALSE) {
+ /* Create a conversation between the MAC addresses */
+ conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ if (conversation == NULL) {
+ conversation = conversation_new(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, CONVERSATION_NONE, 0, 0, 0);
+ }
+
+ station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
+ if (station_info == NULL) {
+ station_info = wmem_new0(wmem_file_scope(), stationInfo);
+ init_pnio_rtc1_station(station_info);
+ conversation_add_proto_data(conversation, proto_pn_dcp, station_info);
+ }
+
+ station_info->u16Vendor_id = vendor_id;
+ station_info->u16Device_id = device_id;
+ }
+
+ proto_item_append_text(block_item, ", BlockInfo: %s", rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+
+ proto_item_append_text(block_item, ", VendorID: 0x%04x / DeviceID: 0x%04x / InstanceIDHigh: 0x%04x / InstanceIDLow: 0x%04x", vendor_id, device_id, instance_id_high, instance_id_low);
+ }
+ break;
+
+ default:
+ pn_append_info(pinfo, dcp_item, ", TSN/Reserved");
+ proto_item_append_text(block_item, "TSN/Reserved");
+ }
+
+ return offset;
+}
+
+/* dissect the "DHCP" suboption */
+static int
+dissect_PNDCP_Suboption_DHCP(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id _U_, gboolean is_response _U_)
+{
+ guint8 suboption;
+ guint8 option_code = 0;
+ guint16 block_length;
+ guint16 block_info = 0;
+ guint16 block_qualifier = 0;
+ guint8 dhcpparameterlength = 0;
+ guint8 dhcpparameterdata = 0;
+ guint8 dhcpcontrolparameterdata = 0;
+ gboolean have_block_info = FALSE;
+ gboolean have_block_qualifier = FALSE;
+ int expected_offset;
+
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp, &suboption);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ expected_offset = offset + block_length;
+
+ /* BlockInfo? */
+ if ( ((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ have_block_info=TRUE;
+ block_length -= 2;
+ }
+ /* BlockQualifier? */
+ if ( (service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ have_block_qualifier=TRUE;
+ block_length -= 2;
+ }
+
+ switch (suboption) {
+ case PNDCP_SUBOPTION_DHCP_CLIENT_ID:
+ pn_append_info(pinfo, dcp_item, ", DHCP client identifier");
+ proto_item_append_text(block_item, "DHCP/Client-ID");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_option_code, &option_code);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_parameter_length, &dhcpparameterlength);
+ if (dhcpparameterlength > 0) {
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_parameter_data, &dhcpparameterdata);
+ if (dhcpparameterlength == 1) {
+ if (dhcpparameterdata == 1) {
+ proto_item_append_text(block_item, ", Client-ID: MAC Address");
+ }
+ else {
+ proto_item_append_text(block_item, ", Client-ID: Name of Station");
+ }
+ }
+ else {
+ proto_item_append_text(block_item, ", Client-ID: Arbitrary");
+ /*
+ * XXX - IEC 61158-6-10 Edition 4.0, section 4.3.1.4.21.5
+ * "Use of arbitrary client identifier", that this is an
+ * OctetString to be used as a client identifier with DHCP.
+ *
+ * Does that mean it should be FT_BYTES, possibly with
+ * the BASE_SHOW_ASCII_PRINTABLE flag to show it as ASCII
+ * iff it's printable? Or should packet-dhcp.c export
+ * dissect_dhcpopt_client_identifier(), so that we can
+ * use its heuristics?
+ */
+ proto_tree_add_item(tree, hf_pn_dcp_suboption_dhcp_arbitrary_client_id, tvb, offset, dhcpparameterlength - 1, ENC_ASCII);
+ offset += (dhcpparameterlength-1);
+ }
+ }
+ break;
+ case PNDCP_SUBOPTION_DHCP_CONTROL_FOR_ADDRESS_RES:
+ pn_append_info(pinfo, dcp_item, ", Control DHCP for address resolution");
+ proto_item_append_text(block_item, "DHCP/Control DHCP for address resolution");
+ if (have_block_qualifier) {
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ }
+ if (have_block_info) {
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ }
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_option_code, &option_code);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_parameter_length, &dhcpparameterlength);
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_dhcp_control_parameter_data, &dhcpcontrolparameterdata);
+ break;
+ default:
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+
+ if (expected_offset > offset) {
+ offset = dissect_pn_user_data(tvb, offset, pinfo, tree, expected_offset - offset, "Undefined");
+ }
+
+ return offset;
+}
+
+
+/* dissect the "control" suboption */
+static int
+dissect_PNDCP_Suboption_Control(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id _U_, gboolean is_response _U_)
+{
+ guint8 suboption;
+ guint16 block_length;
+ guint16 block_qualifier;
+ guint16 BlockQualifier;
+ guint16 u16SignalValue;
+ gchar *info_str;
+ guint8 block_error;
+ proto_item *item = NULL;
+
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_control, &suboption);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ if (service_id == PNDCP_SERVICE_ID_SET && block_length == 0) {
+ pn_append_info(pinfo, dcp_item, ", Erroneous DCPSet block");
+ proto_item_append_text(block_item, "Control/Erroneous DCPSet block");
+ }
+ else {
+ switch (suboption) {
+ case PNDCP_SUBOPTION_CONTROL_START_TRANS:
+ pn_append_info(pinfo, dcp_item, ", Start-Trans");
+ proto_item_append_text(block_item, "Control/Start-Transaction");
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ break;
+ case PNDCP_SUBOPTION_CONTROL_END_TRANS:
+ pn_append_info(pinfo, dcp_item, ", End-Trans");
+ proto_item_append_text(block_item, "Control/End-Transaction");
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ break;
+ case PNDCP_SUBOPTION_CONTROL_SIGNAL:
+ pn_append_info(pinfo, dcp_item, ", Signal");
+ proto_item_append_text(block_item, "Control/Signal");
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ block_length -= 2;
+
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_control_signal_value, &u16SignalValue);
+ break;
+ case PNDCP_SUBOPTION_CONTROL_RESPONSE:
+ proto_item_append_text(block_item, "Control/Response");
+ offset = dissect_PNDCP_Option(tvb, offset, pinfo, tree, block_item, hf_pn_dcp_suboption_control_option,
+ FALSE /* append_col */);
+ block_error = tvb_get_guint8(tvb, offset);
+ if (tree) {
+ item = proto_tree_add_uint(tree, hf_pn_dcp_block_error, tvb, offset, 1, block_error);
+ }
+ offset += 1;
+ if (block_error != 0) {
+ expert_add_info_format(pinfo, item, &ei_pn_dcp_block_error_unknown, "%s",
+ val_to_str_const(block_error, pn_dcp_block_error, "Unknown"));
+ }
+ info_str = wmem_strdup_printf(pinfo->pool, ", Response(%s)",
+ val_to_str_const(block_error, pn_dcp_block_error, "Unknown"));
+ pn_append_info(pinfo, dcp_item, info_str);
+ proto_item_append_text(block_item, ", BlockError: %s",
+ val_to_str_const(block_error, pn_dcp_block_error, "Unknown"));
+
+ break;
+ case PNDCP_SUBOPTION_CONTROL_FACT_RESET:
+ pn_append_info(pinfo, dcp_item, ", Reset FactorySettings");
+ proto_item_append_text(block_item, "Control/Reset FactorySettings");
+ block_length -= 2;
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_blockqualifier, &BlockQualifier);
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(BlockQualifier, pn_dcp_suboption_other, "reserved"));
+ block_length -= 2;
+ break;
+
+ case PNDCP_SUBOPTION_CONTROL_RESET_TO_FACT:
+ pn_append_info(pinfo, dcp_item, ", Reset to Factory");
+ proto_item_append_text(block_item, "Reset to FactorySettings");
+
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_blockqualifier_r2f, &BlockQualifier);
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(BlockQualifier, pn_dcp_BlockQualifier, "reserved"));
+ block_length -= 2;
+
+ break;
+ default:
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+ }
+
+ return offset;
+}
+
+
+/* dissect the "deviceinitaitve" suboption */
+static int
+dissect_PNDCP_Suboption_DeviceInitiative(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id, gboolean is_response)
+{
+ guint8 suboption;
+ guint16 block_length;
+ guint16 block_info;
+ guint16 block_qualifier;
+ guint16 value;
+
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_deviceinitiative, &suboption);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ pn_append_info(pinfo, dcp_item, ", DeviceInitiative");
+ proto_item_append_text(block_item, "DeviceInitiative/DeviceInitiative");
+
+ /* BlockInfo? */
+ if ( ((service_id == PNDCP_SERVICE_ID_IDENTIFY) && is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_HELLO) && !is_response) ||
+ ((service_id == PNDCP_SERVICE_ID_GET) && is_response)) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_info, &block_info);
+ proto_item_append_text(block_item, ", BlockInfo: %s",
+ rval_to_str_const(block_info, pn_dcp_block_info, "Unknown"));
+ block_length -= 2;
+ }
+
+ /* BlockQualifier? */
+ if ( (service_id == PNDCP_SERVICE_ID_SET) && !is_response) {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_qualifier, &block_qualifier);
+ proto_item_append_text(block_item, ", BlockQualifier: %s",
+ val_to_str_const(block_qualifier, pn_dcp_block_qualifier, "Unknown"));
+ block_length -= 2;
+ }
+
+ /* DeviceInitiativeValue */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_deviceinitiative_value, &value);
+
+ return offset;
+}
+
+
+/* dissect the "all" suboption */
+static int
+dissect_PNDCP_Suboption_All(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id _U_, gboolean is_response _U_)
+{
+ guint8 suboption;
+ guint16 block_length;
+
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_all, &suboption);
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+
+ switch (suboption) {
+ case 255: /* All */
+ pn_append_info(pinfo, dcp_item, ", All");
+ proto_item_append_text(block_item, "All/All");
+ break;
+ default:
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+
+ return offset;
+}
+
+
+/* dissect the "manufacturer" suboption */
+static int
+dissect_PNDCP_Suboption_Manuf(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *block_item, proto_item *dcp_item,
+ guint8 service_id _U_, gboolean is_response _U_)
+{
+ guint16 block_length;
+
+ offset = dissect_pn_uint8( tvb, offset, pinfo, tree, hf_pn_dcp_suboption_manuf, NULL);
+
+ pn_append_info(pinfo, dcp_item, ", Manufacturer Specific");
+ proto_item_append_text(block_item, "Manufacturer Specific");
+
+ if (tvb_reported_length_remaining(tvb, offset)>0)
+ {
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_block_length, &block_length);
+ offset = dissect_pn_undecoded(tvb, offset, pinfo, tree, block_length);
+ }
+ return offset;
+}
+
+
+/* dissect one DCP block */
+static int
+dissect_PNDCP_Block(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, proto_item *dcp_item,
+ guint8 service_id, gboolean is_response)
+{
+ guint8 option;
+ proto_item *block_item;
+ proto_tree *block_tree;
+ int ori_offset = offset;
+
+ /* subtree for block */
+ block_item = proto_tree_add_none_format(tree, hf_pn_dcp_block,
+ tvb, offset, 0, "Block: ");
+ block_tree = proto_item_add_subtree(block_item, ett_pn_dcp_block);
+
+
+ offset = dissect_pn_uint8(tvb, offset, pinfo, block_tree, hf_pn_dcp_option, &option);
+
+ if (option == PNDCP_OPTION_IP)
+ {
+ offset = dissect_PNDCP_Suboption_IP(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_DEVICE)
+ {
+ offset = dissect_PNDCP_Suboption_Device(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_DHCP)
+ {
+ offset = dissect_PNDCP_Suboption_DHCP(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_CONTROL)
+ {
+ offset = dissect_PNDCP_Suboption_Control(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_DEVICEINITIATIVE)
+ {
+ offset = dissect_PNDCP_Suboption_DeviceInitiative(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_TSN)
+ {
+ offset = dissect_PNDCP_Suboption_TSN(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (option == PNDCP_OPTION_ALLSELECTOR)
+ {
+ offset = dissect_PNDCP_Suboption_All(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else if (PNDCP_OPTION_MANUF_X80 <= option && option <= PNDCP_OPTION_MANUF_XFE)
+ {
+ offset = dissect_PNDCP_Suboption_Manuf(tvb, offset, pinfo, block_tree, block_item, dcp_item, service_id, is_response);
+ }
+ else
+ {
+ pn_append_info(pinfo, dcp_item, ", Reserved");
+ proto_item_append_text(block_item, "Reserved");
+ /* there isn't a predefined suboption type for reserved option, rest of the block will be seen as padding */
+ }
+
+ proto_item_set_len(block_item, offset-ori_offset);
+
+ if (((offset-ori_offset) & 1) && (tvb_reported_length_remaining(tvb, offset) > 0)) {
+ /* we have an odd number of bytes in this block, add a padding byte */
+ offset = dissect_pn_padding(tvb, offset, pinfo, tree, 1);
+ }
+
+ return offset;
+}
+
+
+/* dissect a whole DCP PDU */
+static void
+dissect_PNDCP_PDU(tvbuff_t *tvb,
+ packet_info *pinfo, proto_tree *tree, proto_item *dcp_item)
+{
+ guint8 service_id;
+ guint8 service_type;
+ guint32 xid;
+ guint16 response_delay;
+ guint16 data_length;
+ int offset = 0;
+ gchar *xid_str;
+ gboolean is_response = FALSE;
+
+
+ offset = dissect_pn_uint8 (tvb, offset, pinfo, tree, hf_pn_dcp_service_id, &service_id);
+ offset = dissect_pn_uint8 (tvb, offset, pinfo, tree, hf_pn_dcp_service_type, &service_type);
+ proto_tree_add_item_ret_uint(tree, hf_pn_dcp_xid, tvb, offset, 4, ENC_BIG_ENDIAN, &xid);
+ offset += 4;
+ if (service_id == PNDCP_SERVICE_ID_IDENTIFY && service_type == PNDCP_SERVICE_TYPE_REQUEST) {
+ /* multicast header */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_response_delay, &response_delay);
+ } else {
+ /* unicast header */
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_reserved16, NULL);
+ }
+ offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_data_length, &data_length);
+
+ switch (service_id) {
+ case PNDCP_SERVICE_ID_GET:
+ pn_append_info(pinfo, dcp_item, "Get");
+ break;
+ case PNDCP_SERVICE_ID_SET:
+ pn_append_info(pinfo, dcp_item, "Set");
+ break;
+ case PNDCP_SERVICE_ID_IDENTIFY:
+ pn_append_info(pinfo, dcp_item, "Ident");
+ break;
+ case PNDCP_SERVICE_ID_HELLO:
+ pn_append_info(pinfo, dcp_item, "Hello");
+ break;
+ default:
+ dissect_pn_undecoded(tvb, offset, pinfo, tree, tvb_captured_length_remaining(tvb, offset));
+ return;
+ }
+
+ switch (service_type) {
+ case PNDCP_SERVICE_TYPE_REQUEST:
+ pn_append_info(pinfo, dcp_item, " Req");
+ break;
+ case PNDCP_SERVICE_TYPE_RESPONSE_SUCCESS:
+ pn_append_info(pinfo, dcp_item, " Ok ");
+ is_response = TRUE;
+ break;
+ case PNDCP_SERVICE_TYPE_RESPONSE_UNSUPPORTED:
+ pn_append_info(pinfo, dcp_item, " unsupported");
+ is_response = TRUE;
+ break;
+ default:
+ dissect_pn_undecoded(tvb, offset, pinfo, tree, tvb_captured_length_remaining(tvb, offset));
+ return;
+ }
+
+ xid_str = wmem_strdup_printf(pinfo->pool, ", Xid:0x%x", xid);
+ pn_append_info(pinfo, dcp_item, xid_str);
+
+ /* dissect a number of blocks (depending on the remaining length) */
+ while(data_length) {
+ int ori_offset = offset;
+
+ if (service_id == PNDCP_SERVICE_ID_GET && service_type == PNDCP_SERVICE_TYPE_REQUEST) {
+ /* Selectors */
+ offset = dissect_PNDCP_Option(tvb, offset, pinfo,
+ tree, dcp_item, hf_pn_dcp_option, TRUE /* append_col */);
+ } else {
+ offset = dissect_PNDCP_Block(tvb, offset, pinfo, tree, dcp_item, service_id, is_response);
+ }
+ /* prevent an infinite loop */
+ if (offset <= ori_offset || data_length < (offset - ori_offset)) {
+ proto_tree_add_expert(tree, pinfo, &ei_pn_dcp_block_parse_error,
+ tvb, ori_offset, tvb_captured_length_remaining(tvb, ori_offset));
+ break;
+ }
+ data_length -= (offset - ori_offset);
+ }
+}
+
+
+/* possibly dissect a PN-RT packet (frame ID must be in the appropriate range) */
+static gboolean
+dissect_PNDCP_Data_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ void *data)
+{
+ /* the tvb will NOT contain the frame_id here, so get it from dissection data! */
+ guint16 u16FrameID = GPOINTER_TO_UINT(data);
+ proto_item *item;
+ proto_tree *dcp_tree;
+
+
+ /* frame id must be in valid range (acyclic Real-Time, DCP) */
+ if (u16FrameID < FRAME_ID_DCP_HELLO || u16FrameID > FRAME_ID_DCP_IDENT_RES) {
+ /* we are not interested in this packet */
+ return FALSE;
+ }
+
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "PN-DCP");
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ /* subtree for DCP */
+ item = proto_tree_add_protocol_format(tree, proto_pn_dcp, tvb, 0, tvb_get_ntohs(tvb, 8) + 10,
+ "PROFINET DCP, ");
+ dcp_tree = proto_item_add_subtree(item, ett_pn_dcp);
+
+ /* dissect this PDU */
+ dissect_PNDCP_PDU(tvb, pinfo, dcp_tree, item);
+
+ return TRUE;
+}
+
+
+void
+proto_register_pn_dcp (void)
+{
+ static hf_register_info hf[] = {
+ { &hf_pn_dcp_service_id,
+ { "ServiceID", "pn_dcp.service_id",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_service_id), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_service_type,
+ { "ServiceType", "pn_dcp.service_type",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_service_type), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_xid,
+ { "Xid", "pn_dcp.xid",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_reserved8,
+ { "Reserved", "pn_dcp.reserved8",
+ FT_UINT8, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_reserved16,
+ { "Reserved", "pn_dcp.reserved16",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_response_delay,
+ { "ResponseDelay", "pn_dcp.response_delay",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_data_length,
+ { "DCPDataLength", "pn_dcp.data_length",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_block_length,
+ { "DCPBlockLength", "pn_dcp.block_length",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_option,
+ { "Option", "pn_dcp.option",
+ FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(pn_dcp_option), 0x0,
+ NULL, HFILL }},
+
+#if 0
+ { &hf_pn_dcp_suboption,
+ { "Suboption", "pn_dcp.suboption",
+ FT_UINT8, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
+#endif
+
+ { &hf_pn_dcp_block_error,
+ { "BlockError", "pn_dcp.block_error",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_block_error), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_block,
+ { "Block", "pn_dcp.block",
+ FT_NONE, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_block_info,
+ { "BlockInfo", "pn_dcp.block_info",
+ FT_UINT16, BASE_DEC|BASE_RANGE_STRING, RVALS(pn_dcp_block_info), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_block_qualifier,
+ { "BlockQualifier", "pn_dcp.block_qualifier",
+ FT_UINT16, BASE_DEC, VALS(pn_dcp_block_qualifier), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_blockqualifier_r2f,
+ { "BlockQualifier: ResettoFactory", "pn_dcp.block_qualifier_reset",
+ FT_UINT16, BASE_DEC, VALS(pn_dcp_BlockQualifier), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_blockqualifier,
+ { "BlockQualifier: ResetFactorySettings", "pn_dcp.block_qualifier_reset",
+ FT_UINT16, BASE_DEC, VALS(pn_dcp_suboption_other), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip,
+ { "Suboption", "pn_dcp.suboption_ip",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_ip), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip_block_info,
+ { "BlockInfo", "pn_dcp.suboption_ip_block_info",
+ FT_UINT16, BASE_DEC, VALS(pn_dcp_suboption_ip_block_info), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip_mac_address,
+ { "MAC Address", "pn_dcp.suboption_ip_mac_address",
+ FT_ETHER, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip_ip,
+ { "IPaddress", "pn_dcp.suboption_ip_ip",
+ FT_IPv4, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip_subnetmask,
+ { "Subnetmask", "pn_dcp.suboption_ip_subnetmask",
+ FT_IPv4, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_ip_standard_gateway,
+ { "StandardGateway", "pn_dcp.suboption_ip_standard_gateway",
+ FT_IPv4, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device,
+ { "Suboption", "pn_dcp.suboption_device",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_device), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_typeofstation,
+ { "DeviceVendorValue", "pn_dcp.suboption_device_devicevendorvalue",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_nameofstation,
+ { "NameOfStation", "pn_dcp.suboption_device_nameofstation",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_vendor_id,
+ { "VendorID", "pn_dcp.suboption_vendor_id",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_id,
+ { "DeviceID", "pn_dcp.suboption_device_id",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_role,
+ { "DeviceRoleDetails", "pn_dcp.suboption_device_role",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_aliasname,
+ { "AliasName", "pn_dcp.suboption_device_aliasname",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_instance_high,
+ { "DeviceInstanceHigh", "pn_dcp.suboption_device_instance",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_instance_low,
+ { "DeviceInstanceLow", "pn_dcp.suboption_device_instance",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_oem_ven_id,
+ { "OEMVendorID", "pn_dcp.suboption_device_oem_ven_id",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_device_oem_dev_id,
+ { "OEMDeviceID", "pn_dcp.suboption_device_oem_dev_id",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_rsi_properties_value,
+ { "RsiPropertiesValue", "pn_dcp.suboption_device_rsi_properties_value",
+ FT_UINT16, BASE_HEX, 0, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit0,
+ { "IP Stack", "pn_dcp.suboption_device_rsi_properties_value.bit0",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0001,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit1,
+ { "CLRPC Interface", "pn_dcp.suboption_device_rsi_properties_value.bit1",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0002,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit2,
+ { "RSI AR Interface", "pn_dcp.suboption_device_rsi_properties_value.bit2",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0004,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit3,
+ { "RSI AR Read Implicit Interface", "pn_dcp.suboption_device_rsi_properties_value.bit3",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0008,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit4,
+ { "RSI CIM Interface", "pn_dcp.suboption_device_rsi_properties_value.bit4",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0010,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_bit5,
+ { "RSI CIM Read Implicit Interface", "pn_dcp.suboption_device_rsi_properties_value.bit5",
+ FT_BOOLEAN, 16, TFS(&pn_dcp_rsi_properties_value_bit), 0x0020,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_rsi_properties_value_otherbits,
+ { "RsiPropertiesValue.Bit6-15", "pn_dcp.suboption_device_rsi_properties_value.otherbits",
+ FT_UINT16, BASE_HEX, NULL, 0xFFC0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_vendor_id_high,
+ { "VendorIDHigh", "pn_dcp.vendor_id_high",
+ FT_UINT16, BASE_HEX, NULL, 0xFF00,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_vendor_id_low,
+ { "VendorIDLow", "pn_dcp.vendor_id_low",
+ FT_UINT16, BASE_HEX, NULL, 0x00FF,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_device_id_high,
+ { "DeviceIDHigh", "pn_dcp.device_id_high",
+ FT_UINT16, BASE_HEX, NULL, 0xFF00,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_device_id_low,
+ { "DeviceIDLow", "pn_dcp.device_id_low",
+ FT_UINT16, BASE_HEX, NULL, 0x00FF,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_instance_id_high,
+ { "InstanceHigh", "pn_dcp.instance_id_high",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_instance_id_low,
+ { "InstanceLow", "pn_dcp.instance_id_low",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_dhcp,
+ { "Suboption", "pn_dcp.suboption_dhcp",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_dhcp), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_dhcp_option_code,
+ { "Option-Code", "pn_dcp.suboption_dhcp_option_code",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_dhcp), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_dhcp_arbitrary_client_id,
+ { "Client ID", "pn_dcp.suboption_dhcp_client_id",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_dhcp_parameter_length,
+ { "DHCP Parameter Length", "pn_dcp.suboption_dhcp_parameter_length",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_dhcp_parameter_data,
+ { "DHCP Parameter Data", "pn_dcp.suboption_dhcp_parameter_data",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_dhcp_control_parameter_data,
+ { "DHCP Parameter Data", "pn_dcp.suboption_dhcp_parameter_data",
+ FT_UINT8, BASE_HEX, VALS(pn_dcp_suboption_dhcp_control_parameter_data), 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_control,
+ { "Suboption", "pn_dcp.suboption_control",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_control), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_control_option,
+ { "Option", "pn_dcp.suboption_control_option",
+ FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(pn_dcp_option), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_control_signal_value,
+ { "SignalValue", "pn_dcp.suboption_control_signal_value",
+ FT_UINT16, BASE_HEX, VALS(pn_dcp_suboption_control_signal_value), 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_deviceinitiative,
+ { "Suboption", "pn_dcp.suboption_deviceinitiative",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_deviceinitiative), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_deviceinitiative_value,
+ { "DeviceInitiativeValue", "pn_dcp.deviceinitiative_value",
+ FT_UINT16, BASE_DEC, VALS(pn_dcp_deviceinitiative_value), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_tsn,
+ { "Suboption", "pn_dcp.suboption_tsn",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_tsn), 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_tsn_domain_name,
+ { "TSNDomainName", "pn_dcp.suboption_tsn_domain_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_tsn_domain_uuid,
+ { "TSNDomainUUID", "pn_dcp.tsn_domain_uuid",
+ FT_GUID, BASE_NONE, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_tsn_nme_prio,
+ { "NMEPrio", "pn_dcp.suboption_tsn_nme_prio",
+ FT_UINT16, BASE_DEC | BASE_RANGE_STRING, RVALS(pn_dcp_suboption_tsn_nme_prio), 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_tsn_nme_parameter_uuid,
+ { "NMEParameterUUID", "pn_dcp.suboption_tsn_nme_parameter_uuid",
+ FT_GUID, BASE_NONE, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_tsn_nme_agent,
+ { "NMEAgent", "pn_dcp.suboption_tsn_nme_agent",
+ FT_GUID, BASE_NONE, NULL, 0x0,
+ NULL, HFILL } },
+
+ { &hf_pn_dcp_suboption_all,
+ { "Suboption", "pn_dcp.suboption_all",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_all), 0x0,
+ NULL, HFILL }},
+
+ { &hf_pn_dcp_suboption_manuf,
+ { "Suboption", "pn_dcp.suboption_manuf",
+ FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_manuf), 0x0,
+ NULL, HFILL }},
+
+ };
+
+ static gint *ett[] = {
+ &ett_pn_dcp,
+ &ett_pn_dcp_block,
+ &ett_pn_dcp_rsi_properties_value
+ };
+
+ static ei_register_info ei[] = {
+ { &ei_pn_dcp_block_parse_error, { "pn_dcp.block_error.parse", PI_PROTOCOL, PI_ERROR, "parse error", EXPFILL }},
+ { &ei_pn_dcp_block_error_unknown, { "pn_dcp.block_error.unknown", PI_RESPONSE_CODE, PI_CHAT, "Unknown", EXPFILL }},
+ { &ei_pn_dcp_ip_conflict, { "pn_dcp.ip_conflict", PI_RESPONSE_CODE, PI_NOTE, "IP address conflict detected!", EXPFILL }},
+ };
+
+ expert_module_t* expert_pn_dcp;
+
+ proto_pn_dcp = proto_register_protocol ("PROFINET DCP", "PN-DCP", "pn_dcp");
+ proto_register_field_array (proto_pn_dcp, hf, array_length (hf));
+ proto_register_subtree_array (ett, array_length (ett));
+ expert_pn_dcp = expert_register_protocol(proto_pn_dcp);
+ expert_register_field_array(expert_pn_dcp, ei, array_length(ei));
+}
+
+void
+proto_reg_handoff_pn_dcp (void)
+{
+ /* register ourself as an heuristic pn-rt payload dissector */
+ heur_dissector_add("pn_rt", dissect_PNDCP_Data_heur, "PROFINET DCP IO", "pn_dcp_pn_rt", proto_pn_dcp, HEURISTIC_ENABLE);
+}
+
+/*
+ * Editor modelines - https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-08 13:39:26 +0000