/* packet-ecmp.c

 *

 * Copyright 2014, James Lynch <lynch007@gmail.com>, Control Techniques

 * Copyright 2015, Luke Orehawa <lukeorehawa@gmail.com>, Control Techniques

 *

 * Revisions:

 * - James Lynch 2014-07-22

 *   - Initial plugin development

 * - Luke Orehawa 2015-11-26

 *   - Removed commands not yet in released specification

 *   - All commands implemented are as V0.26 of ECMP Specification

 *   - Modifications of code to meet Wireshark coding style and current APIs

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <epan/unit_strings.h>

#include "packet-mbtcp.h"

#define ECMP_TCP_PORT   6160

void proto_reg_handoff_ecmp(void);

void proto_register_ecmp (void);

static dissector_handle_t ecmp_tcp_handle, ecmp_udp_handle;

/* Wireshark ID of the ECMP protocol */

static int proto_ecmp;

/* Used to set Modbus protocol data */

static int proto_modbus;

/* These are the handles of our subdissectors */

static dissector_handle_t modbus_handle;

/*smallest size of a packet, number of bytes*/

static const int ecmp_min_packet_size  = 6;

/* ECMP request codes  */

#define ECMP_COMMAND_IDENTIFY   0x00

#define ECMP_COMMAND_INFO   0x01

#define ECMP_COMMAND_INTERROGATE  0x02

#define ECMP_COMMAND_READ   0x10

#define ECMP_COMMAND_READWITHTYPE 0x11

#define ECMP_COMMAND_WRITE    0x12

#define ECMP_COMMAND_OBJECTINFO   0x13

#define ECMP_COMMAND_GETNEXTOBJECTS 0x14

#define ECMP_COMMAND_FILEOPEN   0x20

#define ECMP_COMMAND_FILEREAD   0x21

#define ECMP_COMMAND_FILEWRITE    0x22

#define ECMP_COMMAND_FILECLOSE    0x23

#define ECMP_COMMAND_FILEINFO   0x24

#define ECMP_COMMAND_FILEDELETE   0x25

#define ECMP_COMMAND_FILESTATE    0x26

#define ECMP_COMMAND_FILEPOS    0x27

#define ECMP_COMMAND_FILELIST   0x28

#define ECMP_COMMAND_FILEEXISTS   0x2a

#define ECMP_COMMAND_CYCLICLINK   0x31

#define ECMP_COMMAND_PROGRAMCONTROL 0x60

#define ECMP_COMMAND_PROGRAMSTATUS  0x61

#define ECMP_COMMAND_CYCLICFRAME  0x70

#define ECMP_COMMAND_TUNNELFRAME  0x73

#define ECMP_COMMAND_MODBUSPDU    0x74

/* cyclic display formats */

static const uint8_t cyclic_display_byte_format;

static const uint8_t cyclic_display_word_format = 1;

static const uint8_t cyclic_display_long_format = 2;

/* Addressing scheme Structure */

static const value_string address_scheme [] = {

  { 0, "No Route" },

  { 1, "Intercept" },

  { 2, "Default Route" },

  { 3, "Diagnostics" },

  { 4, "Named" },

  { 0, NULL }

  /*other commands to be added */

};

/* Address Structure */

static const value_string diagnostic [] = {

  { 0, "Status" },

  { 1, "Alarm" },

  { 2, "Network" },

  { 3, "Application" },

  { 0, NULL }

  /*other commands to be added*/

};

/* Command Structure*/

static const value_string command_vals [] = {

  { 0x00, "Identify"},

  { 0x01, "Info"},

  { 0x02, "Interrogate"},

  { 0x10, "Read"},

  { 0x11, "ReadWithType"},

  { 0x12, "Write"},

  { 0x13, "ObjectInfo"},

  { 0x14, "GetNextObjects"},

  { 0x20, "FileOpen"},

  { 0x21, "FileRead"},

  { 0x22, "FileWrite"},

  { 0x23, "FileClose"},

  { 0x24, "FileInfo"},

  { 0x25, "FileDelete"},

  { 0x26, "FileState"},

  { 0x27, "FilePos"},

  { 0x28, "FileList"},

  { 0x2A, "FileExists"},

  { 0x31, "CyclicSetup"},

  { 0x60, "ProgramControl"},

  { 0x61, "ProgramStatus"},

  { 0x70, "CyclicFrame"},

  { 0x73, "TunnelFrame"},

  { 0x74, "ModbusPDU"},

  { 0, NULL }

  /*other commands to be added*/

};

/* Option Code structure*/

static const value_string option_code [] = {

  { 0, "End of Options"},

  { 1, "Dummy" },

  { 2, "Process At" },

  { 3, "Route to Custom Target"},

  { 0, NULL }

  /* other - "Unknown" */

};

/* Attribute type Structure */

static const value_string attribute [] = {

  { 0, "Manufacturer Name" },

  { 1, "Product Family" },

  { 2, "Product Model" },

  { 3, "Serial Number" },

  { 4, "Order Number" },

  { 5, "Date Code" },

  { 6, "Device Name" },

  { 7, "Version Summary" },

  { 8, "Colour Codes" },

  { 0, NULL }

  /* other - Unknown*/

};

/* Status type Structure */

static const value_string status [] = {

  { 0, "OK (no errors detected in request)" },

  { 1, "OK, chunks follow" },

  { 2, "Processing Request" },

  { -1, "Error - Slave not ready" },

  { -2, "Error - Request Too Long" },

  { -3, "Error - Chunking Error" },

  { 0, NULL }

  /* other - Unknown*/

};

/* Category (device) structure*/

static const value_string category [] = {

  { 0, "Drive" },

  { 1, "Option Module" },

  { 0, NULL }

};

/* Cyclic data alignment */

static const value_string cyclic_align [] = {

  { 0, "8bit" },

  { 1, "8bit" },   /* TODO: is this correct? */

  { 2, "16bit" },

  { 4, "32bit" },

  { 8, "64bit" },

  { 0, NULL }

};

/* Cyclic data scheme */

static const value_string cyclic_scheme [] = {

  { 0, "Standard" },

  { 1, "Synchronised" },

  { 0, NULL }

};

/* Parameter addressing scheme */

static const value_string parameter_address_scheme [] = {

  { 0, "Standard" },

  { 1, "Slot Specific" },

  { 3, "Variable" },

  { 0, NULL }

};

#if 0

static const value_string route_address_scheme [] = {

  { 1, "Intercept" },

  { 2, "DefaultRoute" },

  { 0, NULL }

};

#endif

/* Parameter access status */

static const value_string parameter_access_status [] = {

  { 0, "OK" },

  { 1, "OK - Converted"},

  { 2, "OK - Clamped"},

  { -1, "ERROR - Address Type"},

  { -2, "ERROR - Timeout"},

  { -3, "ERROR - Access Denied"},

  { -4, "ERROR - Does not exist"},

  { -5, "ERROR - Data Type"},

  { -6, "ERROR - Failed Read"},

  { -7, "ERROR - Failed Write"},

  { -8, "ERROR - Not Readable"},

  { -9, "ERROR - Not Writeable"},

  { -10, "ERROR - Over Range"},

  { -11, "ERROR - Request Invalid"},

  { -12, "ERROR - Response Too Big"},

  { -13, "ERROR - Decimal Place"},

  { 0, NULL}

};

/* Parameter data types */

static const value_string parameter_data_types [] = {

  { 0, "Boolean"},

  { 1, "INT8"},

  { 2, "UINT8"},

  { 3, "INT16"},

  { 4, "UINT16"},

  { 5, "INT32"},

  { 6, "UINT32"},

  { 7, "INT64"},

  { 8, "UINT64"},

  { 9, "INT128"},

  { 10, "UINT128"},

  { 20, "SINGLE"},

  { 21, "DOUBLE"},

  { 30, "String ID"},

  { 31, "String"},

  { 0, NULL}

};

/* Info types */

static const value_string info_type [] = {

  { 0, "No Information"},

  { 1, "Lowest Numbered Parameter in Menu"},

  { 2, "Highest Numbered Parameter in Menu"},

  { 3, "Parameter Format"},

  { 4, "Minimum Value allowed for Parameter"},

  { 5, "Maximum Value allowed for Parameter"},

  { 6, "Object Unit Information"},

  { 7, "Data Type of Parameter"},

  { 0, NULL }

};

/* Display formats */

static const value_string display_format [] = {

  { 0, "Standard format"},

  { 1, "Date format (xx,yy,zz)"},

  { 2, "Time with seconds format (xx.yy.zz)"},

  { 3, "Character format"},

  { 4, "Binary format"},

  { 5, "IP address format (www.xxx.yyy.zzz)"},

  { 6, "MAC address format (AA:BB:CC:DD:EE:FF)"},

  { 7, "Version number (ww.xx.yy.zz)"},

  { 8, "Slot menu parameter format (x,yy,zzz)"},

  { 0, NULL}

};

/* Format units */

static const value_string format_units [] = {

  { 0, "No units"},

  { 1, "Custom units"},

  { 2, "Millimetres (mm)"},

  { 3, "Metres (m)"},

  { 4, "User units (UU)"},

  { 5, "Revolutions (revs)"},

  { 6, "Degrees (')"},

/*  { 7, ""}, */

  { 8, "General position unit"},

  { 9, "Millimetres per second (mm/s)"},

  { 10, "User units per millisecond (UU/ms)"},

  { 11, "Revolutions per minute (Rpm)"},

  { 12, "Hertz (Hz)"},

  { 13, "Kilohertz (kHz)"},

  { 14, "Megahertz (MHz)"},

  { 15, "General speed unit (Hz, rpm, mm/s)"},

  { 16, "Closed loop speed unit (rpm, mm/s)"},

  { 17, "Seconds per one thousand millimetres per seconds (s/m/s)"},

  { 18, "User units per millimetre per second (UU/mm/s)"},

  { 19, "Seconds per one thousand revolution per minute (s/1000rpm)"},

  { 20, "Seconds per one hundred hertz (s/100Hz)"},

  { 21, "General acceleration unit"},

  { 22, "Closed loop acceleration unit"},

  { 23, "Seconds squared per one thousand millimetres per second (s^2/1000ms/s)"},

  { 24, "Seconds squared per user units per millisecond (s^2/UU/ms"},

  { 25, "Seconds squared per one thousand revolutions per minute (s^2/1000rpm)"},

  { 26, "Seconds squared per one hundred hertz (s^2/100Hz)"},

  { 27, "General jerk unit"},

  { 28, "Closed loop jerk unit"},

  { 29, "Messages per second (Msg/s)"},

  { 30, "Hours (Hours)"},

  { 31, "Minutes (Mins)"},

  { 32, "Seconds (s)"},

  { 33, "Milliseconds (ms)"},

  { 34, "Microseconds (us)"},

  { 35, "Nanoseconds (ns)"},

  { 36, "Volts (V)"},

  { 37, "Amperes (A)"},

  { 38, "Ohms (Ohms)"},

  { 39, "Millihenrys (mH)"},

  { 40, "Kilowatts (kW)"},

  { 41, "Kilo-Volt-Amps-Reactive (kVAr)"},

  { 42, "Megawatt hours (MWh)"},

  { 43, "Kilowatt hours (kWh)"},

  { 44, "Degrees Celsius ('C)"},

  { 45, "Reciprocal of degrees Celsius (/'C)"},

  { 46, "Kilogram-metres squared (kgm^2)"},

  { 47, "Newton metres (Nm)"},

  { 48, "Newton metres per ampere (Nm/A)"},

  { 49, "open-circuit volts per 1000rpm (V/1000rpm)"},

  { 50, "Bits (Bits)"},

  { 51, "Bytes (Bytes)"},

  { 52, "Kilobytes (kB)"},

  { 53, "Megabytes (MB)"},

  { 54, "Bits per second (Bit/s)"},

  { 55, "Baud (Baud)"},

  { 56, "Kilobaud (kBaud)"},

  { 57, "Megabaud (MBaud)"},

  { 58, "Poles (Poles)"},

  { 59, "Percent (%)"},

  { 60, "Volts per millisecond (V/ms)"},

  { 0, NULL}

};

/* File status */

static const value_string file_status [] = {

  { 0, "Processing"},

  { 1, "OK"},

  { 2, "OK - More Data"},

  { 3, "OK - EOF"},

  { -1, "ERROR - File Handle"},

  { -2, "ERROR - Blocked"},

  { -3, "ERROR - Blocking Mode"},

  { -4, "ERROR - Not in Progress"},

  { -5, "ERROR - Not Found"},

  { -6, "ERROR - Read Only"},

  { -7, "ERROR - Write Only"},

  { -8, "ERROR - Not Created"},

  { -9, "ERROR - No Data"},

  { -10, "ERROR - Wrong Mode"},

  { -11, "ERROR - Too Big"},

  { -12, "ERROR - Protected"},

  { -13, "ERROR - CRC"},

  { -14, "ERROR - Length"},

  { -15, "ERROR - Too Many Open"},

  { -16, "ERROR - Invalid File"},

  { -17, "ERROR - Invalid Request"},

  { -18, "ERROR - No Append"},

  { -19, "ERROR - Invalid State"},

  { -20, "ERROR - Incompatible"},

  { -21, "ERROR - Uninitialized"},

  { 0, NULL}

};

/* File status mode */

static const value_string file_status_mode [] = {

  { 0, "Information"},

  { 1, "Read"},

  { 2, "Create"},

  { 3, "Append"},

  { 4, "New Directory"},

  { 0, NULL}

};

/* File attributes */

static const value_string file_attributes [] = {

  { 0, "File Length"},

  { 1, "File Integrity"},

  { 2, "Calculate CRC32"},

  { 3, "File Attributes"},

  { 4, "Creation Date and Time"},

  { 5, "Modification Date and Time"},

  { 0, NULL}

};

/* File reference position */

static const value_string file_ref_point [] = {

  { 0, "SoF - Start of file"},

  { 1, "EoF - End of file"},

  { 2, "Current - Use current file pointer"},

  { 0, NULL}

};

static const value_string cyclic_setup_mode [] = {

  { 0, "Create"},

  { 1, "Edit"},

  { 2, "Finalise"},

  { 3, "Delete"},

  { 4, "Exist"},

  { 5, "List"},

  { 6, "Info"},

  { 10, "Set"},

  { 11, "Get"},

  { 12, "Get mappings"},

  { 0, NULL}

};

static const value_string cyclic_attributes [] = {

  { 0, "State"},

  { 1, "Rx/Tx"},

  { 2, "Synchronised"},

  { 3, "MEC Offset"},

  { 4, "Sample Period"},

  { 5, "MEC Delay"},

  { 6, "Data Change"},

  { 7, "Rx Timeout Handler"},

  { 8, "Rx Data Late Handler"},

  { 9, "Transport Address"},

  { 10, "Max Mappings"},

  { 11, "Number Of Mappings"},

  { 12, "Mapping Item"},

  { 13, "Saveable"},

  { 128, "Max RX Links"},

  { 129, "Max TX Links"},

  { 130, "Max Mappings Per Link"},

  { 131, "Max Sync RX Links"},

  { 132, "Max Sync TX Links"},

  { 133, "Max Mappings Per Sync Link"},

  { 134, "'Process At' Queue Depth"},

  { 135, "MEC Period"},

  { 0, NULL}

};

static const value_string cyclic_setup_link_dir [] = {

  { 0, "Rx"},

  { 1, "Tx"},

  { 0, NULL}

};

static const value_string cyclic_setup_link_exists [] = {

  { 0, "Does not exist"},

  { 1, "Exists"},

  { 0, NULL}

};

static const value_string additional_scheme_vals [] = {

  { 0, "None"},

  { 1, "Generic"},

  { 0, NULL}

};

/* Program Control - command codes  */

static const value_string command_code_list [] = {

  { 0, "Stop"},

  { 1, "Start"},

  { 2, "Reset"},

  { 0, NULL }

  /*other commands to be added*/

};

/* Program Control - sub command codes  */

static const value_string sub_command_code_list [] = {

  { 0, "Default"},

  { 1, "User1"},

  { 2, "User2"},

  { 0, NULL }

  /*other sub commands to be added*/

};

/* Program Control - status codes  */

static const value_string status_list [] = {

  { 0,   "OK"},

  { -1,  "Error"},

  { 0,   NULL }

  /*other status to be added*/

};

  /* Program Status - running state codes  */

static const value_string running_state_list [] = {

  { 0,   "Stopped"},

  { 1,   "Running"},

  { 2,   "Exception"},

  { 3,   "None (no program found in device)"},

  { 0,   NULL }

  /*other status to be added*/

};

  /* Interrogate - command support states  */

static const value_string Interrogate_support_state [] = {

  { 0,  "Not Supported"},

  { 1,  "Supported"},

  { 0,   NULL }

  /*other status to be added*/

};

  /* Interrogate - command / option states  */

static const value_string Interrogate_command_option_state [] = {

  { 0,  "Command"},

  { 1,  "Option"},

  { 0,   NULL }

  /*other status to be added*/

};

static const value_string item_type_vals[] = {

  { 0,  "File"},

  { 1,  "Directory"},

  { 0,   NULL }

};

/* The following hf_* variables are used to hold the Wireshark IDs of

* our header fields; they are filled out when we call

* proto_register_field_array() in proto_register_ecmp()

*/

static int hf_ecmp_command;

static int hf_ecmp_destination_address;

static int hf_ecmp_source_address;

static int hf_ecmp_diagnostic;

static int hf_ecmp_type_rr;

static int hf_ecmp_chunking;

static int hf_ecmp_max_response_size;

static int hf_ecmp_category;

static int hf_ecmp_option;

static int hf_ecmp_attribute;

static int hf_ecmp_no_of_attributes;

static int hf_ecmp_chunk_id;

static int hf_ecmp_transaction_id;

static int hf_ecmp_status;

static int hf_ecmp_drive_type;

static int hf_ecmp_drive_derivative;

static int hf_ecmp_drive_factory_fit_category_id;

static int hf_ecmp_category_id;

static int hf_ecmp_attribute_string;

static int hf_ecmp_file_name;

static int hf_ecmp_info_command;

static int hf_ecmp_directory;

static int hf_ecmp_names_scheme;

static int hf_ecmp_variable_name;

static int hf_ecmp_unit_id_string;

static int hf_ecmp_ecmp_string;

static int hf_ecmp_process_time;

static int hf_ecmp_cyclic_frame_time;

static int hf_ecmp_grandmaster;

static int hf_ecmp_data;

static int hf_ecmp_response_data;

static int hf_ecmp_cyclic_link_num;

static int hf_ecmp_cyclic_align;

static int hf_ecmp_cyclic_scheme;

static int hf_ecmp_cyclic_link_number_display;

/* Cyclic setup */

static int hf_ecmp_cyclic_setup_mode;

static int hf_ecmp_cyclic_setup_linkno;

static int hf_ecmp_cyclic_setup_dir;

static int hf_ecmp_cyclic_setup_attrib_count;

static int hf_ecmp_cyclic_setup_rsp_status;

static int hf_ecmp_cyclic_setup_rsp_err_idx;

static int hf_ecmp_cyclic_setup_attrib;

static int hf_ecmp_cyclic_setup_link_exists;

static int hf_ecmp_cyclic_link_req_resp;

/*for info command */

static int hf_ecmp_buffer_size;

static int hf_ecmp_max_response;

static int hf_ecmp_max_handle;

static int hf_ecmp_info_address;

/*for parameter access commands*/

static int hf_ecmp_parameter_address;

static int hf_ecmp_number_of_parameter_definitions;

static int hf_ecmp_number_of_parameter_responses;

static int hf_ecmp_parameter_status;

static int hf_ecmp_data_type;

static int hf_ecmp_info_type;

/* for file access commands */

static int hf_ecmp_file_status;

static int hf_ecmp_file_handle;

static int hf_ecmp_file_attributes;

static int hf_ecmp_file_ref_point;

/* for tunnel frame command */

#define TUNNEL_START_FLAG   0x01

#define TUNNEL_END_FLAG     0x02

#define TUNNEL_CHECK_OUTPUT_FLAG  0x04

static int hf_ecmp_tunnel_control;

static int hf_ecmp_tunnel_start_flag;

static int hf_ecmp_tunnel_end_flag;

static int hf_ecmp_tunnel_check_output_flag;

static int hf_ecmp_tunnel_size;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_ecmp_physical_address;

static int hf_ecmp_logical_address;

static int hf_ecmp_primary_colour;

static int hf_ecmp_secondary_colour;

static int hf_ecmp_number_of_subsequent_object_requests;

static int hf_ecmp_number_of_decimal_places;

static int hf_ecmp_no_information_available;

static int hf_ecmp_param_format_bit_default_unipolar;

static int hf_ecmp_param_format_write_allowed;

static int hf_ecmp_param_format_read_not_allowed;

static int hf_ecmp_param_format_protected_from_destinations;

static int hf_ecmp_param_format_parameter_not_visible;

static int hf_ecmp_param_format_not_clonable;

static int hf_ecmp_param_format_voltage_or_current_rating_dependent;

static int hf_ecmp_param_format_parameter_has_no_default;

static int hf_ecmp_param_format_number_of_decimal_places;

static int hf_ecmp_param_format_variable_maximum_and_minimum;

static int hf_ecmp_param_format_string_parameter;

static int hf_ecmp_param_format_destination_set_up_parameter;

static int hf_ecmp_param_format_filtered_when_displayed;

static int hf_ecmp_param_format_pseudo_read_only;

static int hf_ecmp_param_format_display_format;

static int hf_ecmp_param_format_floating_point_value;

static int hf_ecmp_param_format_units;

static int hf_ecmp_string_id;

static int hf_ecmp_address_scheme_menu;

static int hf_ecmp_address_scheme_parameter;

static int hf_ecmp_address_scheme_slot;

static int hf_ecmp_address_scheme_null_byte_size;

static int hf_ecmp_display_unit_id;

static int hf_ecmp_data_boolean;

static int hf_ecmp_data_int8;

static int hf_ecmp_data_uint8;

static int hf_ecmp_data_int16;

static int hf_ecmp_data_uint16;

static int hf_ecmp_data_int32;

static int hf_ecmp_data_uint32;

static int hf_ecmp_data_int64;

static int hf_ecmp_data_uint64;

static int hf_ecmp_data_float;

static int hf_ecmp_data_double;

static int hf_ecmp_access_mode;

static int hf_ecmp_open_in_non_blocking_mode;

static int hf_ecmp_open_file_relative_to_specified_directory_handle;

static int hf_ecmp_file_access_mode;

static int hf_ecmp_additional_scheme;

static int hf_ecmp_scheme_data_length;

static int hf_ecmp_number_of_requested_bytes;

static int hf_ecmp_number_of_bytes_transferred;

static int hf_ecmp_crc;

static int hf_ecmp_ref_offset;

static int hf_ecmp_number_of_files_to_list;

static int hf_ecmp_file_hash;

static int hf_ecmp_item_type;

static int hf_ecmp_file_integrity;

static int hf_ecmp_display_attr_read_only;

static int hf_ecmp_display_attr_hidden;

static int hf_ecmp_display_attr_system;

static int hf_ecmp_display_attr_volume_label;

static int hf_ecmp_display_attr_subdirectory;

static int hf_ecmp_display_attr_archive;

static int hf_ecmp_display_creation;

static int hf_ecmp_display_modification;

static int hf_ecmp_interrogate_item_type;

static int hf_ecmp_interrogate_count;

static int hf_ecmp_modbus_pdu_size;

/* static int hf_ecmp_destination_scheme; */

static int hf_ecmp_program_control_target;

static int hf_ecmp_program_control_command;

static int hf_ecmp_program_control_sub_command;

static int hf_ecmp_program_control_status;

static int hf_ecmp_program_status_target;

static int hf_ecmp_program_status_status;

static int hf_ecmp_program_status_additional_items;

static int hf_ecmp_cyclic_setup_max_mappings;

static int hf_ecmp_cyclic_setup_start_offset;

static int hf_ecmp_cyclic_setup_tx_count;

static int hf_ecmp_cyclic_setup_rx_count;

static int hf_ecmp_udp_alignment;

static int hf_ecmp_udp_scheme;

static int hf_ecmp_cyclic_data;

static int hf_ecmp_version_summary;

static int hf_ecmp_min_param_menu;

static int hf_ecmp_max_param_menu;

static int hf_ecmp_file_length;

static int hf_ecmp_mec_offset;

static int hf_ecmp_sample_period;

static int hf_ecmp_rx_timeout;

static int hf_ecmp_rx_action;

static int hf_ecmp_rx_event_destination;

static int hf_ecmp_rx_event;

static int hf_ecmp_rx_late_handler_action;

static int hf_ecmp_rx_late_handler_event_destination;

static int hf_ecmp_rx_late_handler_event;

static int hf_ecmp_transport_addr_scheme;

static int hf_ecmp_transport_addr;

static int hf_ecmp_mapping_item_offset;

static int hf_ecmp_mapping_item_scheme;

static int hf_ecmp_setup_attribute;

static int hf_ecmp_mec_period;

static int hf_ecmp_interrogate_command;

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

/* These are the ids of the subtrees that we may be creating */

static int ett_ecmp;

static int ett_ecmp_address;

static int ett_ecmp_response_size;

static int ett_ecmp_command;

static int ett_ecmp_category;

static int ett_ecmp_option;

static int ett_ecmp_option_data;

static int ett_ecmp_attribute;

static int ett_ecmp_attribute_data;

static int ett_ecmp_cyclic_scheme;

static int ett_ecmp_info_type;

static int ett_ecmp_info_count;

static int ett_ecmp_interrogate_message;

static int ett_ecmp_param_address;

static int ett_ecmp_access_mode;

static int ett_ecmp_access_file;

static int ett_ecmp_file_read;

static int ett_ecmp_file_write;

static int ett_ecmp_file_info;

static int ett_ecmp_file_info_att;

static int ett_ecmp_file_position;

static int ett_ecmp_file_list_no;

static int ett_ecmp_file_list;

static int ett_ecmp_tunnel_3s_goodframe;

static int ett_ecmp_tunnel_3s_size;

static int ett_ecmp_tunnel_3s_service;

static int ett_cyclic_setup_attribs;

static int ett_cyclic_setup_attrib_item;

static int ett_cyclic_setup_transport_addr;

static int ett_ecmp_cyclic_data_32_bit_display;

static int ett_ecmp_cyclic_data_16_bit_display;

static int ett_ecmp_cyclic_data_8_bit_display;

static int ett_ecmp_modbus_pdu_message;

static int ett_ecmp_program_control_message;

static int ett_ecmp_program_status_message;

static expert_field ei_ecmp_unknown_command;

static expert_field ei_ecmp_color;

static expert_field ei_ecmp_option;

static expert_field ei_ecmp_item_type;

static expert_field ei_ecmp_options_not_implemented;

static expert_field ei_ecmp_info_type;

static expert_field ei_ecmp_attribute_type;

static expert_field ei_ecmp_parameter_addressing_scheme;

static expert_field ei_ecmp_data_type;

/*--------------------------------------------------------------------*/

/* General Commands and Framing Dissectors                            */

/*--------------------------------------------------------------------*/

/*a function to add the initial information about the transport layer (the first bits)*/

static int add_transport_layer_frame(unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree, int addr_type)

{

  proto_item *ecmp_address_item = NULL;

  proto_tree *ecmp_address_tree = NULL;

  uint8_t byte_test;

  ecmp_address_item = proto_tree_add_item(ecmp_tree, addr_type, tvb, offset, 1, ENC_BIG_ENDIAN);

  byte_test = tvb_get_uint8(tvb, offset);

  if ((byte_test != 0) && (byte_test != 1)) {

    /* tree to display the data in the address*/

    ecmp_address_tree = proto_item_add_subtree(ecmp_address_item, ett_ecmp_address);

    switch (byte_test)

    {

    case 2: /*  default route scheme*/

      offset++;

      /* displays the values of the addresses*/

      proto_tree_add_item(ecmp_address_tree, hf_ecmp_physical_address, tvb, offset, 1, ENC_NA);

      proto_tree_add_item(ecmp_address_tree, hf_ecmp_logical_address, tvb, offset, 1, ENC_NA);

      break;

    case 3:/*  diagnostic scheme*/

      proto_tree_add_item(ecmp_address_tree, hf_ecmp_diagnostic, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset++;

      break;

    case 4: /* Names scheme */

      /* Calls a function to display the UTF-8 string data*/

      proto_tree_add_item(ecmp_address_tree, hf_ecmp_names_scheme, tvb, offset, 2, ENC_BIG_ENDIAN|ENC_ASCII);

      offset += (tvb_get_ntohs(tvb, offset) + 2);

      break;

    }

  }

  offset++;

  return offset;

}

/* a function to display option codes */

static int add_option_codes(unsigned offset, packet_info *pinfo, tvbuff_t *tvb, proto_tree* ecmp_tree)

{

  proto_item* ecmp_option_number_item = NULL;

  proto_item* ecmp_option_item;

  proto_tree* ecmp_option_tree;

  proto_tree* ecmp_option_data_tree = NULL;

  uint8_t option_code_display = 0;

  uint16_t count = 0; /* number of times the loop iterates*/

  int start_offset;

  bool more_options = true;

  offset++;

  start_offset = offset;

  ecmp_option_tree = proto_tree_add_subtree(ecmp_tree, tvb, offset, 1, ett_ecmp_option, &ecmp_option_number_item, "Options" );

  /* Loop to display all options */

  while(more_options) /* loops until option code is 0*/

  {

    option_code_display = tvb_get_uint8(tvb, offset);

    ecmp_option_item = proto_tree_add_item(ecmp_option_tree, hf_ecmp_option, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    switch(option_code_display)

    {

    case 0:/* end of options*/

      proto_item_append_text(ecmp_option_number_item, ": %d", count);

      proto_item_set_len(ecmp_option_number_item, offset-start_offset);

      more_options = false;

      break;

    case 1:/* dummy - 0 bytes of data */

      break;

    case 2:/* process at - 8 bytes of data */

      ecmp_option_data_tree = proto_item_add_subtree(ecmp_option_item, ett_ecmp_option_data);

      proto_tree_add_item(ecmp_option_data_tree, hf_ecmp_process_time, tvb, offset, 8, ENC_BIG_ENDIAN);

      offset += 8;

      break;

    default: /* Option that is not recognised*/

      proto_item_append_text(ecmp_option_number_item, "%d ", count);

      expert_add_info(pinfo, ecmp_option_number_item, &ei_ecmp_option);

      break;

    }

    count++;

  }

  return offset;

}

/* a function to display attributes */

static void add_attributes(packet_info* pinfo, unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree, bool request)

{

  proto_item* ecmp_attribute_number_item = NULL;

  proto_item* ecmp_attribute_item = NULL, *color_item;

  proto_tree* ecmp_attribute_tree = NULL;

  proto_tree* ecmp_attribute_data_tree = NULL;

  uint8_t no_of_attributes = 0;

  uint8_t a = 0; /*values used for looping*/

  uint8_t b = 0;

  uint8_t c = 0;

  uint8_t check = 0;

  uint16_t att_length = 0;

  uint32_t color;

  wmem_strbuf_t* pStr = NULL; /*char array for version string output*/

  int start_offset = offset;

  /*display the number of attributes*/

  ecmp_attribute_number_item = proto_tree_add_item(ecmp_tree, hf_ecmp_no_of_attributes, tvb, offset, 1, ENC_BIG_ENDIAN);

  ecmp_attribute_tree = proto_item_add_subtree(ecmp_attribute_number_item, ett_ecmp_attribute);

  no_of_attributes = tvb_get_uint8(tvb, offset);

  offset++;

  for (a = 0; a < no_of_attributes; a++, offset++) {

    /*attribute header*/

    ecmp_attribute_item = proto_tree_add_item(ecmp_attribute_tree, hf_ecmp_attribute, tvb, offset, 1, ENC_BIG_ENDIAN );

    ecmp_attribute_data_tree = proto_item_add_subtree(ecmp_attribute_item, ett_ecmp_attribute_data);

    if (!request) {

      /*code for dissecting the colour codes attribute*/

      switch(tvb_get_uint8(tvb, offset))

      {

      case 8:

        offset+= 1;

        /*get length of attribute for error checking*/

        offset+= 2;

        /*output primary colour codes- the two bytes representing each colour are output as integers*/

        color = tvb_get_ntohl(tvb, offset);

        color_item = proto_tree_add_uint_format_value(ecmp_attribute_data_tree, hf_ecmp_primary_colour, tvb, offset, 4, color, "(red) %d (green) %d (blue) %d", tvb_get_uint8(tvb, offset+1), tvb_get_uint8(tvb, offset+2), tvb_get_uint8(tvb, offset+3));

        if ((color & 0xFF000000) != 0) {

          /*error check for correct colour code format */

          expert_add_info(pinfo, color_item, &ei_ecmp_color);

        }

        offset+= 4;

        /*output secondary colour codes- the two bytes representing each colour are output as integers*/

        color = tvb_get_ntohl(tvb, offset);

        color_item = proto_tree_add_uint_format_value(ecmp_attribute_data_tree, hf_ecmp_secondary_colour, tvb, offset, 4, color, "(red) %d (green) %d (blue) %d", tvb_get_uint8(tvb, offset+1), tvb_get_uint8(tvb, offset+2), tvb_get_uint8(tvb, offset+3));

        if ((color & 0xFF000000) != 0) {

          /*error check for correct colour code format */

          expert_add_info(pinfo, color_item, &ei_ecmp_color);

        }

        offset+= 4;

        break;

      /*code for dissecting the version summary attribute*/

      case 7:

        offset++;

        att_length = tvb_get_ntohs(tvb, offset);

        pStr = wmem_strbuf_create(pinfo->pool);

        offset+= 2;

        if (pStr != NULL) {

          for (c = 0; c < att_length; c++, offset++) {

            check = tvb_get_uint8(tvb,offset);

            if (check == 'V' || check == '#' || check == '@') {

              wmem_strbuf_append_c(pStr, ' ');

            } else if (check == ';') {

              /*display version summary parameter, e.g 'FW', 'BL', 'HW'*/

              proto_tree_add_string(ecmp_attribute_data_tree, hf_ecmp_version_summary, tvb, offset-b, b, wmem_strbuf_get_str(pStr));

              wmem_strbuf_truncate(pStr, 0);

            } else if (check <= 0x7f) {

              wmem_strbuf_append_c(pStr, check);

            }

            else {

              wmem_strbuf_append_hex(pStr, check);

            }

          }

          /*display last version summary parameter, e.g 'FW', 'BL', 'HW' as no delimiter to check for, just prints out rest of version string*/

          proto_tree_add_string(ecmp_attribute_data_tree, hf_ecmp_version_summary, tvb, offset-b, b, wmem_strbuf_get_str(pStr));

          offset-= 1;

        }

        break;

      default:

        /* displays the data inside the attribute*/

        proto_tree_add_item(ecmp_attribute_data_tree, hf_ecmp_attribute_string, tvb, offset+1, 2, ENC_BIG_ENDIAN|ENC_ASCII);

        offset += (tvb_get_ntohs(tvb, offset+1) + 2);

        break;

      }

    }

  }

  proto_item_set_len(ecmp_attribute_number_item, offset-start_offset);

}

/* a function to display the category codes */

static int add_category_codes(unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree)

{

  proto_item *ecmp_category_item = NULL;

  proto_tree *ecmp_category_tree = NULL;

  uint8_t category_size = 0;

  int start_offset = offset;

  uint8_t category_value = tvb_get_uint8(tvb, offset);

  /* displays the category and creates a tree to display further data*/

  ecmp_category_item = proto_tree_add_item(ecmp_tree, hf_ecmp_category, tvb, offset, 1, ENC_BIG_ENDIAN);

  ecmp_category_tree = proto_item_add_subtree(ecmp_category_item, ett_ecmp_category);

  offset++;

  category_size = tvb_get_uint8(tvb, offset);

  offset++;

  if(category_size==2 && category_value == 1) {

    /*display "option module" and its ID*/

    proto_tree_add_item(ecmp_category_tree, hf_ecmp_category_id, tvb, offset, 2, ENC_BIG_ENDIAN);

    offset+=category_size;

  } else if(category_size == 4 && category_value == 0) {

    /*display "drive" and its data (product type, drive derivative and ID*/

    proto_tree_add_item(ecmp_category_tree, hf_ecmp_drive_type, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(ecmp_category_tree, hf_ecmp_drive_derivative, tvb, offset+1, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(ecmp_category_tree, hf_ecmp_drive_factory_fit_category_id, tvb, offset+2, 2, ENC_BIG_ENDIAN);

    offset+=category_size;

  } else {

    /* Display unknown and its hex data */

    proto_tree_add_item(ecmp_category_tree, hf_ecmp_data, tvb, offset, category_size, ENC_NA);

    offset += category_size;

  }

  proto_item_set_len(ecmp_category_item, offset-start_offset);

  return offset;

}

/* a function to display response size data */

static int get_response_size(unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree)

{

  proto_item* ecmp_max_response_item = NULL;

  proto_tree* ecmp_response_size_tree = NULL;

  uint8_t chunks = 0;

  uint16_t max_response_size = 0;

  /*get values for number of chunks and max response size*/

  chunks = tvb_get_uint8(tvb, offset)>>4&0x0F;

  max_response_size = tvb_get_ntohs(tvb, offset) & 0x0FFF;

  /*display response subtree */

  ecmp_response_size_tree = proto_tree_add_subtree_format(ecmp_tree, tvb, offset, 2, ett_ecmp_response_size, &ecmp_max_response_item, "Response Size: %X, %X (%d)", chunks, max_response_size, max_response_size);

  /*display chunks and max response size in response subtree*/

  proto_tree_add_item(ecmp_response_size_tree, hf_ecmp_chunking, tvb, offset, 2, ENC_BIG_ENDIAN);

  proto_tree_add_item(ecmp_response_size_tree, hf_ecmp_max_response_size, tvb, offset, 2, ENC_BIG_ENDIAN);

  offset+= 2;

  return offset;

}

/* a function to display the command code and type (request/response) */

static int add_command_codes(packet_info* pinfo, unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree, uint8_t transaction_id_value, uint8_t* command_value)

{

  proto_tree *ecmp_command_tree;

  const char* command_str;

  uint8_t command = tvb_get_uint8(tvb, offset);

  *command_value = command & 0x7F;

  command_str = val_to_str(pinfo->pool, *command_value, command_vals, "Unknown Type (0x%02x)");

  /*display command subtree*/

  ecmp_command_tree = proto_tree_add_subtree_format(ecmp_tree, tvb, offset, 1, ett_ecmp_command, NULL, "Request Response Code: %s", command_str);

  /* Displays the command */

  proto_tree_add_item(ecmp_command_tree, hf_ecmp_command, tvb, offset, 1, ENC_BIG_ENDIAN);

  /* Displays the type (request/response) */

  proto_tree_add_item(ecmp_command_tree, hf_ecmp_type_rr, tvb, offset, 1, ENC_BIG_ENDIAN);

  /* Information displayed in the Info column*/

  col_add_fstr(pinfo->cinfo, COL_INFO, "%s, %s. Transaction ID: %d",

        command_str, tfs_get_string(((command & 0x80) >> 7), &tfs_response_request),

        transaction_id_value);

  return offset;

}

/* a function to add a cyclic frame query */

static int add_cyclic_frame_query(unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree )

{

  /* display the cyclic link number  */

  proto_tree_add_item(ecmp_tree, hf_ecmp_cyclic_link_num, tvb, offset++, 1, ENC_BIG_ENDIAN);

  return offset;

}

/* a function to add a cyclic frame */

static int add_cyclic_frame(unsigned offset, tvbuff_t *tvb, proto_tree* ecmp_tree )

{

  uint32_t scheme;

  proto_item *ecmp_scheme_item = NULL;

  proto_tree *ecmp_scheme_tree = NULL;

  proto_tree_add_item(ecmp_tree, hf_ecmp_cyclic_link_num, tvb, offset++, 1, ENC_BIG_ENDIAN);

  proto_tree_add_item(ecmp_tree, hf_ecmp_cyclic_align, tvb, offset++, 1, ENC_BIG_ENDIAN);

  ecmp_scheme_item = proto_tree_add_item_ret_uint(ecmp_tree, hf_ecmp_cyclic_scheme, tvb, offset++, 1, ENC_BIG_ENDIAN, &scheme);

  if (scheme == 1) {

    /* Create a new sub tree spawning off the scheme byte for the synchronisation scheme data to be placed. */

    ecmp_scheme_tree = proto_item_add_subtree(ecmp_scheme_item, ett_ecmp_cyclic_scheme);

    /* grandmaster */

    proto_tree_add_item( ecmp_scheme_tree, hf_ecmp_grandmaster, tvb, offset, 8, ENC_BIG_ENDIAN);

    offset += 8;

    proto_tree_add_item(ecmp_scheme_tree, hf_ecmp_cyclic_frame_time, tvb, offset, 8, ENC_BIG_ENDIAN);

    offset += 8;

  }

  proto_tree_add_item(ecmp_tree, hf_ecmp_data, tvb, offset, -1, ENC_NA);

  return tvb_reported_length(tvb);

}

/* a function to display cyclic tvb data in byte (8-bit), word (16-bit), and long (32-bit) unsigned formats  */

static int display_raw_cyclic_data(uint8_t display, unsigned offset, uint16_t buffer_size, tvbuff_t *tvb, packet_info *pinfo, proto_tree* ecmp_current_tree )

{

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

  /*                                                                                      */

  /*     display_raw_cyclic_data - display the cyclic data in various formats.            */

  /*                                                                                      */

  /*     Parameters:   display = selects desired display format.                          */

  /*                             0  =  BYTE_FORMAT (8-bits  1F 20 37 BC ...               */

  /*                             1  =  WORD_FORMAT (16-bits 1F20 37BC 77F1 ...            */

  /*                             2  =  LONG_FORMAT (32-bits  1F2037BC 0013F5CD ...        */

  /*                                                                                      */

  /*                   offset  =  offset within tvb buffer where this data starts.        */

  /*                                                                                      */

  /*                   buffer_size = number of bytes to be converted and displayed.       */

  /*                                                                                      */

  /*                   tvb  =  buffer structure within Wireshark holding this frame.      */

  /*                                                                                      */

  /*                   pinfo  =  packet info for this frame.                              */

  /*                                                                                      */

  /*                   ecmp_current_tree  =  the tree where the data is to be displayed.  */

  /*                                                                                      */

  /*                                                                                      */

  /*   Notes: we only display so many elements on a line (before continuing on next line) */

  /*                                                                                      */

  /*          16 elements per line for byte (8-bit) and word (16-bit)                     */

  /*           8 elements per line for long (32-bit)                                      */

  /*                                                                                      */