/* packet-cola.c

 * Routines for SICK CoLA A and CoLA B protocols

 *

 * Copyright 2024 Michael Mann

 *

 * 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/prefs.h>

#include <epan/expert.h>

#include <epan/to_str.h>

#include <wsutil/strtoi.h>

#include <epan/tfs.h>

#include <epan/unit_strings.h>

#include <wsutil/utf8_entities.h>

#include <epan/dissectors/packet-tcp.h>

void proto_register_sick_cola(void);

void proto_reg_handoff_sick_cola(void);

static int proto_sick_cola_a;

static int proto_sick_cola_b;

static int hf_sick_cola_b_magic_number;

static int hf_sick_cola_b_length;

static int hf_sick_cola_b_checksum;

static int hf_sick_cola_b_checksum_status;

static int hf_sick_cola_command;

static int hf_sick_cola_method_name;

static int hf_sick_cola_set_access_mode_user_level;

static int hf_sick_cola_set_access_mode_password;

static int hf_sick_cola_answer_name;

static int hf_sick_cola_set_access_mode_change_level;

static int hf_sick_cola_set_scan_cfg_scan_frequency;

static int hf_sick_cola_set_scan_cfg_num_active_scanners;

static int hf_sick_cola_set_scan_cfg_angular_resolution;

static int hf_sick_cola_set_scan_cfg_start_angle;

static int hf_sick_cola_set_scan_cfg_stop_angle;

static int hf_sick_cola_set_scan_cfg_status_code;

static int hf_sick_cola_set_scan_cfg_mode;

static int hf_sick_cola_read_name;

static int hf_sick_cola_write_name;

static int hf_sick_cola_mm_alignment_node_layer_activation;

static int hf_sick_cola_standby_status_code;

static int hf_sick_cola_startmeas_status_code;

static int hf_sick_cola_stopmeas_status_code;

static int hf_sick_cola_autostartmeas_enable;

static int hf_sick_cola_clapplication_mode;

static int hf_sick_cola_set_active_app_count;

static int hf_sick_cola_set_active_app_id;

static int hf_sick_cola_set_active_app_active;

static int hf_sick_cola_set_password_user_level;

static int hf_sick_cola_set_password_hash;

static int hf_sick_cola_set_password_status_code;

static int hf_sick_cola_check_password_user_level;

static int hf_sick_cola_check_password_hash;

static int hf_sick_cola_check_password_status_code;

static int hf_sick_cola_lcm_cfg_strategy;

static int hf_sick_cola_lcm_cfg_response_time;

static int hf_sick_cola_lcm_cfg_threshold_warning;

static int hf_sick_cola_lcm_cfg_threshold_error;

static int hf_sick_cola_cm_cont_lvlm_availability;

static int hf_sick_cola_ee_write_all_status_code;

static int hf_sick_cola_run_status_code;

static int hf_sick_cola_scan_data_cfg_data_channel;

static int hf_sick_cola_scan_data_cfg_remission;

static int hf_sick_cola_scan_data_cfg_resolution;

static int hf_sick_cola_scan_data_cfg_unit;

static int hf_sick_cola_scan_data_cfg_encoder;

static int hf_sick_cola_scan_data_cfg_position;

static int hf_sick_cola_scan_data_cfg_device_name;

static int hf_sick_cola_scan_data_cfg_comment;

static int hf_sick_cola_scan_data_cfg_time;

static int hf_sick_cola_scan_data_cfg_output_rate;

static int hf_sick_cola_change_output_range_status_code;

static int hf_sick_cola_change_output_range_angular_resolution;

static int hf_sick_cola_change_output_range_start_angle;

static int hf_sick_cola_change_output_range_stop;

static int hf_sick_cola_output_range_num_sectors;

static int hf_sick_cola_output_range_angular_resolution;

static int hf_sick_cola_output_range_start_angle;

static int hf_sick_cola_output_range_stop;

static int hf_sick_cola_event_name;

static int hf_sick_cola_scan_data_start_stop;

static int hf_sick_cola_scan_data_version;

static int hf_sick_cola_scan_data_device_number;

static int hf_sick_cola_scan_data_serial_number;

static int hf_sick_cola_scan_data_device_status;

static int hf_sick_cola_scan_data_telegram_counter;

static int hf_sick_cola_scan_data_scan_counter;

static int hf_sick_cola_scan_data_time_since_startup;

static int hf_sick_cola_scan_data_transmission_time;

static int hf_sick_cola_scan_data_di_status;

static int hf_sick_cola_scan_data_do_status;

static int hf_sick_cola_scan_data_layer_angle;

static int hf_sick_cola_scan_data_scan_frequency;

static int hf_sick_cola_scan_data_measurement_frequency;

static int hf_sick_cola_scan_data_encoder_amount;

static int hf_sick_cola_scan_data_encoder_position;

static int hf_sick_cola_scan_data_encoder_speed;

static int hf_sick_cola_scan_data_num_16bit_channels;

static int hf_sick_cola_scan_data_output_channel_content;

static int hf_sick_cola_scan_data_output_channel_scale_factor;

static int hf_sick_cola_scan_data_output_channel_scale_factor_offset;

static int hf_sick_cola_scan_data_output_channel_start_angle;

static int hf_sick_cola_scan_data_output_channel_size_single_angular_step;

static int hf_sick_cola_scan_data_num_data_points;

static int hf_sick_cola_scan_data_16bit_output_channel_data;

static int hf_sick_cola_scan_data_num_8bit_channels;

static int hf_sick_cola_scan_data_8bit_output_channel_data;

static int hf_sick_cola_scan_data_position_present;

static int hf_sick_cola_scan_data_position_x;

static int hf_sick_cola_scan_data_position_y;

static int hf_sick_cola_scan_data_position_z;

static int hf_sick_cola_scan_data_rotation_x;

static int hf_sick_cola_scan_data_rotation_y;

static int hf_sick_cola_scan_data_rotation_z;

static int hf_sick_cola_scan_data_rotation_type;

static int hf_sick_cola_scan_data_transmit_device_name;

static int hf_sick_cola_scan_data_device_name_present;

static int hf_sick_cola_scan_data_device_name;

static int hf_sick_cola_scan_data_comment_present;

static int hf_sick_cola_scan_data_comment;

static int hf_sick_cola_scan_data_time_present;

static int hf_sick_cola_scan_data_time;

static int hf_sick_cola_scan_data_display_event_info;

static int hf_sick_cola_scan_data_event_info_type;

static int hf_sick_cola_scan_data_event_info_encoder_position;

static int hf_sick_cola_scan_data_event_info_encosder_timestamp;

static int hf_sick_cola_scan_data_event_info_encoder_angle;

static int hf_sick_cola_set_date_time;

static int hf_sick_cola_set_date_time_status_code;

static int hf_sick_cola_stims_status_code;

static int hf_sick_cola_stims_temp_out_of_range;

static int hf_sick_cola_stims_time_length;

static int hf_sick_cola_stims_time;

static int hf_sick_cola_stims_date_length;

static int hf_sick_cola_stims_date;

static int hf_sick_cola_stims_led1;

static int hf_sick_cola_stims_led2;

static int hf_sick_cola_stims_led3;

static int hf_sick_cola_stims_reserved;

static int hf_sick_cola_device_time;

static int hf_sick_cola_ntp_tsc_role;

static int hf_sick_cola_ntp_interface_data;

static int hf_sick_cola_ntp_ipaddress;

static int hf_sick_cola_ntp_gmt_timezone_offset;

static int hf_sick_cola_ntp_timesync;

static int hf_sick_cola_ntp_max_offset_time;

static int hf_sick_cola_particle_filter_status;

static int hf_sick_cola_particle_filter_threshold;

static int hf_sick_cola_mean_filter_status;

static int hf_sick_cola_mean_filter_num_scans;

static int hf_sick_cola_mean_filter_final_part;

static int hf_sick_cola_nto1_filter_status;

static int hf_sick_cola_echo_filter_status;

static int hf_sick_cola_fog_filter_status;

static int hf_sick_cola_fog_filter_enable;

static int hf_sick_cola_fog_filter_sensitivity_level;

static int hf_sick_cola_digital_nearfield_filter_status;

static int hf_sick_cola_digital_nearfield_filter_active_sector_vector;

static int hf_sick_cola_encoder_increment_source;

static int hf_sick_cola_encoder_setting;

static int hf_sick_cola_encoder_resolution;

static int hf_sick_cola_encoder_fixed_speed;

static int hf_sick_cola_encoder_speed_threshold;

static int hf_sick_cola_encoder_speed;

static int hf_sick_cola_output_do3_func;

static int hf_sick_cola_output_do1_func;

static int hf_sick_cola_output_do1_logic;

static int hf_sick_cola_output_do2_func;

static int hf_sick_cola_output_do2_logic;

static int hf_sick_cola_output_sync_mode_data;

static int hf_sick_cola_output_sync_phase_data;

static int hf_sick_cola_input_do3and4_func;

static int hf_sick_cola_input_debounce_time_data;

static int hf_sick_cola_set_output_state_number;

static int hf_sick_cola_set_output_state_state;

static int hf_sick_cola_output_state_start_stop;

static int hf_sick_cola_output_state_status_version;

static int hf_sick_cola_output_state_status_system_counter;

static int hf_sick_cola_output_state_state;

static int hf_sick_cola_output_state_count;

static int hf_sick_cola_output_state_ext_state;

static int hf_sick_cola_output_state_ext_count;

static int hf_sick_cola_output_state_time_present;

static int hf_sick_cola_output_state_time;

static int hf_sick_cola_input_sync_status_data;

static int hf_sick_cola_input_signal_frequency;

static int hf_sick_cola_set_output_state_status_code;

static int hf_sick_cola_b_sopas_command;

static int hf_sick_cola_b_sopas_command_data;

static int hf_sick_cola_a_stx;

static int hf_sick_cola_a_etx;

static int hf_sick_cola_a_sopas_command;

static int hf_sick_cola_a_sopas_command_data;

static int hf_sick_cola_sopas_error_code;

static int ett_sick_cola_a;

static int ett_sick_cola_b;

static int ett_scan_data_device;

static int ett_scan_data_status_info;

static int ett_scan_data_frequency;

static int ett_scan_data_16bit_output_channels;

static int ett_scan_data_16bit_output_channel;

static int ett_scan_data_16bit_output_data;

static int ett_scan_data_8bit_output_channels;

static int ett_scan_data_8bit_output_channel;

static int ett_scan_data_8bit_output_data;

static int ett_scan_data_position;

static int ett_scan_data_time;

static int ett_scan_data_event_info;

static int ett_output_state_status;

static int ett_output_state;

static int ett_output_state_x;

static int ett_ext_output_state;

static int ett_ext_output_state_x;

static int ett_output_state_time;

static expert_field ei_sick_cola_command;

static expert_field ei_sick_cola_command_name;

static expert_field ei_sick_cola_command_parameter;

static expert_field ei_sick_cola_b_checksum;

//Preferences

static uint32_t g_number_of_outputs = 1;

#define SICK_COLA_B_HEADER_SIZE     8

#define SICK_COLA_B_MAGIC_NUMBER    0x02020202

#define SICK_COLA_A_STX         0x02

#define SICK_COLA_A_ETX         0x03

#define SICK_COLA_DELIMITER       0x20    //space character

#define SICK_COLA_A_MIN_LENGTH      6

#define SICK_COLA_COMMAND_READ      0x73524E20  //sRN

#define SICK_COLA_COMMAND_WRITE     0x73574E20  //sWN

#define SICK_COLA_COMMAND_METHOD    0x734D4E20  //sMN

#define SICK_COLA_COMMAND_EVENT     0x73454E20  //sEN

#define SICK_COLA_COMMAND_SOPAS_BINARY  0x73524900  //sRI

#define SICK_COLA_COMMAND_SOPAS_ASCII 0x73524920  //sRI

#define SICK_COLA_COMMAND_ANSWER_sRA  0x73524120

#define SICK_COLA_COMMAND_ANSWER_sWA  0x73574120

#define SICK_COLA_COMMAND_ANSWER_sAN  0x73414E20

#define SICK_COLA_COMMAND_ANSWER_sEA  0x73454120

#define SICK_COLA_COMMAND_ANSWER_sSN  0x73534E20

#define SICK_COLA_COMMAND_ANSWER_sFA  0x73464120

#define SICK_COLA_COMMAND_ANSWER_sFA_NULL 0x73464100

#define SICK_COLA_COMMAND_ANSWER_SOPAS_BINARY 0x73524100  //sRA

static const value_string cola_command_vals[] = {

  { SICK_COLA_COMMAND_READ,   "Read" },

  { SICK_COLA_COMMAND_WRITE,   "Write" },

  { SICK_COLA_COMMAND_METHOD,   "Method" },

  { SICK_COLA_COMMAND_EVENT,   "Event" },

  { SICK_COLA_COMMAND_ANSWER_sRA,   "Answer (sRA)" },

  { SICK_COLA_COMMAND_ANSWER_sWA,   "Answer (sWA)" },

  { SICK_COLA_COMMAND_ANSWER_sAN,   "Answer (sAN)" },

  { SICK_COLA_COMMAND_ANSWER_sEA,   "Answer (sEA)" },

  { SICK_COLA_COMMAND_ANSWER_sSN,   "Answer (sSN)" },

  { SICK_COLA_COMMAND_ANSWER_sFA,   "Answer (sFA)" },

  { SICK_COLA_COMMAND_ANSWER_sFA_NULL,   "Answer (sFA)" },

  { SICK_COLA_COMMAND_SOPAS_BINARY,   "SOPAS Specific (Binary)" },

  { SICK_COLA_COMMAND_SOPAS_ASCII,   "SOPAS Specific (ASCII)" },

  { SICK_COLA_COMMAND_ANSWER_SOPAS_BINARY,   "Answer (SOPAS Binary)" },

  { 0, NULL }

};

static const value_string sick_cola_return_vals[] = {

  { 0,  "Error" },

  { 1,  "Success" },

  { 0,  NULL }

};

static const value_string access_mode_user_level_vals[] = {

  { 2,  "Maintenance" },

  { 3,  "Authorized client" },

  { 4,  "Service" },

  { 0xFFFFFFFF, "Invalid number" },

  { 0,  NULL }

};

static const value_string set_scan_cfg_status_code_vals[] = {

  { 0,  "No Error" },

  { 1,  "Frequency error" },

  { 2,  "Resolution error" },

  { 3,  "Resolution and scan area error" },

  { 4,  "Scan area error" },

  { 5,  "Other error" },

  { 0,  NULL }

};

//values are in ascii

static const value_string layer_activation_vals[] = {

  { '0',  "All layers" },

  { '1',  "Red layer -2,5" },

  { '2',  "Blue layer 0" },

  { '3',  "Green layer +2,5" },

  { '4',  "Yellow layer +5" },

  { 0,  NULL }

};

static const value_string start_stop_measure_status_code_vals[] = {

  { 0,  "No error" },

  { 1,  "Not allowed" },

  { 0,  NULL }

};

static const value_string autostartmeas_enable_vals[] = {

  { 0,  "OFF" },

  { 1,  "ON" },

  { 0,  NULL }

};

static const value_string clapplication_mode_vals[] = {

  { 0,  "Scan only" },

  { 0x11, "Field application" },

  { 0,  NULL }

};

static const value_string lcm_cfg_strategy_vals[] = {

  { 0,  "Inactive" },

  { 1,  "High available" },

  { 2,  "Available" },

  { 3,  "Sensitive" },

  { 4,  "Semi-sensitive" },

  { 0,  NULL }

};

static const value_string sick_cola_resolution_vals[] = {

  { 0,  "8 bit" },

  { 1,  "16 bit" },

  { 0, NULL }

};

static const value_string sick_cola_stop_start_vals[] = {

  { 0,  "Stop" },

  { 1,  "Start" },

  { 0, NULL }

};

static const value_string sick_cola_device_status_vals[] = {

  { 0,  "Ok" },

  { 1,  "Error" },

  { 2,  "Pollution Warning" },

  { 5,  "Pollution Error" },

  { 0, NULL }

};

static const value_string sick_cola_position_present_vals[] = {

  { 0,  "No Position Data" },

  { 1,  "Position Data" },

  { 0, NULL }

};

static const value_string sick_cola_rotation_type_vals[] = {

  { 0,  "No Rotation" },

  { 1,  "Pitch" },

  { 2,  "Roll" },

  { 3,  "Free" },

  { 0, NULL }

};

static const value_string sick_cola_name_present_vals[] = {

  { 0,  "No Name" },

  { 1,  "Name" },

  { 0, NULL }

};

static const value_string sick_cola_comment_present_vals[] = {

  { 0,  "No Comment" },

  { 1,  "Comment" },

  { 0, NULL }

};

static const value_string sick_cola_time_present_vals[] = {

  { 0,  "No Timestamp" },

  { 1,  "Timestamp" },

  { 0, NULL }

};

static const value_string sick_cola_display_event_info_vals[] = {

  { 0,  "No information" },

  { 1,  "Transmit Information" },

  { 0, NULL }

};

static const value_string stims_status_vals[] = {

  { 0,  "Undefined" },

  { 1,  "Initialization" },

  { 2,  "Configuration" },

  { 3,  "Lower case" },

  { 4,  "Rotating" },

  { 5,  "In preparation" },

  { 6,  "Ready" },

  { 7,  "Measurement active" },

  { 0, NULL }

};

static const value_string sick_cola_led_vals[] = {

  { 0,  "Inactive" },

  { 1,  "Active" },

  { 0, NULL }

};

static const value_string ntp_tsc_role_vals[] = {

  { 0,  "None" },

  { 1,  "Client" },

  { 2,  "Server" },

  { 0, NULL }

};

static const value_string ntp_interface_data_vals[] = {

  { 0,  "Ethernet" },

  { 1,  "CAN" },

  { 0, NULL }

};

static const value_string echo_filter_status_vals[] = {

  { 0,  "First echo" },

  { 1,  "All echos" },

  { 2,  "Last echo" },

  { 0, NULL }

};

static const value_string fog_filter_status_vals[] = {

  { 0,  "Glitch" },

  { 1,  "Fog" },

  { 0, NULL }

};

static const value_string encoder_increment_source_vals[] = {

  { 0,  "Fixed Speed" },

  { 1,  "Encoder" },

  { 0, NULL }

};

static const value_string encoder_setting_vals[] = {

  { 0,  "Off" },

  { 1,  "Single increment/INC1" },

  { 2,  "Direction recognition (phase)" },

  { 3,  "Direction recognition (level)" },

  { 0, NULL }

};

static const value_string sick_cola_do3_func_vals[] = {

  { 0,  "No function" },

  { 1,  "SOPAS command" },

  { 2,  "Device Ready" },

  { 3,  "Application" },

  { 4,  "Application/Device Ready" },

  { 5,  "Device Ready/Contamination" },

  { 6,  "Contamination" },

  { 7,  "Master Synchronisation" },

  { 0, NULL }

};

static const value_string sick_cola_do1_func_vals[] = {

  { 0,  "No function" },

  { 1,  "Command" },

  { 2,  "Device Ready" },

  { 3,  "Application/Device Ready" },

  { 4,  "Sync pulse" },

  { 5,  "Sync index" },

  { 0, NULL }

};

static const value_string sick_cola_logic_state_vals[] = {

  { 0,   "Active High" },

  { 1,   "Active Low" },

  { 0, NULL }

};

static const value_string sick_cola_do2_func_vals[] = {

  { 0,  "No function" },

  { 1,  "Command" },

  { 2,  "Device Ready" },

  { 3,  "Application/Device Ready" },

  { 0, NULL }

};

static const value_string sick_cola_sync_mode_data_vals[] = {

  { 0,  "No sync" },

  { 1,  "Sync by wire" },

  { 2,  "Sync by CAN" },

  { 0, NULL }

};

static const value_string sick_cola_do3and4_func_vals[] = {

  { 0,  "No function" },

  { 1,  "Encoder" },

  { 2,  "Slave sync" },

  { 3,  "Digit Input" },

  { 0, NULL }

};

static const value_string sick_cola_sync_status_vals[] = {

  { 1,  "None" },

  { 2,  "Too slow" },

  { 4,  "Good" },

  { 8,  "Too fast" },

  { 0, NULL }

};

static const value_string sick_cola_sopas_error_vals[] = {

  { 0,  "No error" },

  { 1,  "Wrong userlevel, access to method not allowed" },

  { 2,  "Trying to access a method with an unknown Sopas index" },

  { 3,  "Trying to access a variable with an unknown Sopas index" },

  { 4,  "Local condition violated" },

  { 5,  "Invalid data given for variable (DEPRECATED)" },

  { 6,  "An error with unknown reason occurred (DEPRECATED)" },

  { 7,  "The communication buffer was too small for the amount of data that should be serialised." },

  { 8,  "More data was expected, the allocated buffer could not be filled." },

  { 9,  "The variable that shall be serialised has an unknown type." },

  { 10, "It is not allowed to write values to this variable." },

  { 11, "When using names instead of indices, a command was issued that the nameserver does not understand." },

  { 12, "The CoLa protocol specification does not define the given command, command is unknown." },

  { 13, "It is not possible to issue more than one command at a time to an SRT device." },

  { 14, "An array was accessed over its maximum length." },

  { 15, "The event you wanted to register for does not exist, the index is unknown." },

  { 16, "The value does not fit into the value field, it is too large." },

  { 17, "Character is unknown, probably not alphanumeric." },

  { 18, "No operating system message could be created for GET variable" },

  { 19, "No operating system message could be created for PUT variable" },

  { 20, "Internal error in the firmware" },

  { 21, "The Sopas Hubaddress is either too short or too long" },

  { 22, "The Sopas Hubaddress is invalid, it can not be decoded (Syntax)" },

  { 23, "Too many hubs in the address" },

  { 24, "When parsing a HubAddress an expected blank was not found. The HubAddress is not valid." },

  { 25, "An asynchronous method call was made although the device was built with 'AsyncMethodsSuppressed'" },

  { 26, "Complex Arrays not supported" },

  { 0, NULL }

};

/* Copied and renamed from proto.c because global value_strings don't work for plugins */

static const value_string plugin_proto_checksum_vals[] = {

  { PROTO_CHECKSUM_E_BAD,        "Bad"  },

  { PROTO_CHECKSUM_E_GOOD,       "Good" },

  { PROTO_CHECKSUM_E_UNVERIFIED, "Unverified" },

  { PROTO_CHECKSUM_E_NOT_PRESENT, "Not present" },

  { 0,        NULL }

};

static const unit_name_string sick_cola_units_ticks_mm = { "ticks/mm", NULL };

static uint8_t get_crc8_xor(tvbuff_t *p, uint8_t len, uint8_t offset) {

  uint8_t FCS = 0x00;

  uint8_t tmp;

  while (len--) {

    tmp = tvb_get_uint8(p,offset);

    FCS ^= tmp;

    offset++;

  }

  return FCS;

}

static uint8_t*

cola_get_ascii_parameter_string(packet_info *pinfo, tvbuff_t *tvb, int offset, int* new_offset)

{

  uint8_t* str_parameter;

  int parameter_end;

  parameter_end = tvb_find_uint8(tvb, offset, -1, SICK_COLA_DELIMITER);

  if (parameter_end < 0)

  {

    *new_offset = -1;

    return NULL;

  }

  str_parameter = tvb_get_string_enc(pinfo->pool, tvb, offset, parameter_end - offset, ENC_NA | ENC_ASCII);

  *new_offset = parameter_end;

  return str_parameter;

}

static bool

cola_ascii_add_parameter_U32(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name, uint32_t scale_factor)

{

  uint8_t* str_parameter;

  int parameter_end_offset;

  unsigned paramU32;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou32(str_parameter, NULL, &paramU32))

    return false;

  proto_tree_add_uint(tree, hf_parameter, tvb, *offset, parameter_end_offset - *offset, paramU32/scale_factor);

  *offset = parameter_end_offset+1;

  return true;

}

static bool

cola_ascii_add_parameter_REAL(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name)

{

  uint8_t* str_parameter;

  int parameter_end_offset;

  unsigned paramU32;

  float paramFloat;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou32(str_parameter, NULL, &paramU32))

    return false;

  memcpy(&paramFloat, &paramU32, 4);

  proto_tree_add_float(tree, hf_parameter, tvb, *offset, parameter_end_offset - *offset, paramFloat);

  *offset = parameter_end_offset+1;

  return true;

}

static bool

cola_ascii_add_parameter_I32(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name, int scale_factor)

{

  uint8_t* str_parameter;

  int parameter_end_offset;

  unsigned paramU32;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou32(str_parameter, NULL, &paramU32))

    return false;

  proto_tree_add_int(tree, hf_parameter, tvb, *offset, parameter_end_offset - *offset, ((int32_t)paramU32)/scale_factor);

  *offset = parameter_end_offset+1;

  return true;

}

static bool

cola_ascii_add_parameter_I16(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name)

{

  uint8_t* str_parameter;

  int parameter_end_offset;

  uint16_t paramU16;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou16(str_parameter, NULL, &paramU16))

    return false;

  proto_tree_add_int(tree, hf_parameter, tvb, *offset, parameter_end_offset - *offset, (int16_t)paramU16);

  *offset = parameter_end_offset+1;

  return true;

}

static bool

cola_ascii_add_parameter_2U8(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name)

{

  uint8_t* str_parameter;

  int parameter_end_offset, start_offset = *offset;

  uint16_t param1, param2, paramU16;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou16(str_parameter, NULL, &param1))

    return false;

  *offset = parameter_end_offset+1;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  if (!ws_hexstrtou16(str_parameter, NULL, &param2))

    return false;

  paramU16 = ((param1 << 8) & 0xFF00) | (param2 & 0x00FF);

  proto_tree_add_uint(tree, hf_parameter, tvb, *offset, parameter_end_offset - start_offset, paramU16);

  *offset = parameter_end_offset+1;

  return true;

}

static bool

cola_ascii_add_parameter_string(proto_tree *tree, int hf_parameter, packet_info *pinfo, tvbuff_t *tvb, int* offset, char* field_name)

{

  uint8_t* str_parameter;

  int parameter_end_offset;

  str_parameter = cola_get_ascii_parameter_string(pinfo, tvb, *offset, &parameter_end_offset);

  if (str_parameter == NULL)

  {

    expert_add_info_format(pinfo, tree, &ei_sick_cola_command_parameter, "Parse error for %s", field_name);

    return false;

  }

  proto_tree_add_string(tree, hf_parameter, tvb, *offset, parameter_end_offset - *offset, str_parameter);

  *offset = parameter_end_offset+1;

  return true;

}

static int

diplay_timestamp_field(proto_tree *tree, tvbuff_t *tvb, int offset, int hf_field, bool binary)

{

  int time_offset = offset;

  struct tm time_info;

  time_t time_info_seconds;

  nstime_t ns_time_info;

  if (binary)

  {

    time_info.tm_year = tvb_get_ntohs(tvb, time_offset)-1900;

    time_offset += 2;

    time_info.tm_mon = tvb_get_uint8(tvb, time_offset)-1;

    time_offset += 1;

    time_info.tm_mday = tvb_get_uint8(tvb, time_offset);

    time_offset += 1;

    time_info.tm_hour = tvb_get_uint8(tvb, time_offset);

    time_offset += 1;

    time_info.tm_min = tvb_get_uint8(tvb, time_offset);

    time_offset += 1;

    time_info.tm_sec = tvb_get_uint8(tvb, time_offset);

    time_offset += 1;

    time_info_seconds = mktime(&time_info);

    ns_time_info.secs = time_info_seconds;

    ns_time_info.nsecs = tvb_get_ntohl(tvb, time_offset)*1000;

    proto_tree_add_time(tree, hf_field, tvb, offset, 11, &ns_time_info);

    offset += 11;

  }

  return offset;

}

static int

dissect_sick_cola_read(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, bool binary _U_)

{

  int offset = 0;

  const uint8_t* read_name;

  proto_tree_add_item_ret_string(tree, hf_sick_cola_read_name, tvb, offset, -1, ENC_NA | ENC_ASCII, pinfo->pool, &read_name);

  offset = tvb_reported_length(tvb);

  return offset;

}

static int

dissect_sick_cola_write(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, bool binary)

{

  int offset = 0;

  const uint8_t* write_name;

  //find the space character for method name

  int write_name_end = tvb_find_uint8(tvb, offset, -1, SICK_COLA_DELIMITER);

  if (write_name_end < 0)

  {

    expert_add_info(pinfo, tree, &ei_sick_cola_command_name);

    return tvb_reported_length(tvb);

  }

  //don't include the space delimiter in the string

  proto_tree_add_item_ret_string(tree, hf_sick_cola_write_name, tvb, offset, write_name_end - offset, ENC_NA | ENC_ASCII, pinfo->pool, &write_name);

  offset = write_name_end+1;

  if (strcmp(write_name, "MMAlignmentMode") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_mm_alignment_node_layer_activation, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "LMPautostartmeas") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_autostartmeas_enable, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "CLApplication") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_clapplication_mode, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

    }

  }

  else if (strcmp(write_name, "SetActiveApplications") == 0)

  {

    uint32_t count;

    if (binary)

    {

      proto_tree_add_item_ret_uint(tree, hf_sick_cola_set_active_app_count, tvb, offset, 1, ENC_BIG_ENDIAN, &count);

      offset += 1;

      for (uint32_t i = 0; i < count; i++)

      {

        proto_tree_add_item(tree, hf_sick_cola_set_active_app_id, tvb, offset, 4, ENC_ASCII);

        offset += 4;

        proto_tree_add_item(tree, hf_sick_cola_set_active_app_active, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

      }

    }

  }

  else if (strcmp(write_name, "LCMcfg") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_lcm_cfg_strategy, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_lcm_cfg_response_time, tvb, offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      proto_tree_add_item(tree, hf_sick_cola_lcm_cfg_threshold_warning, tvb, offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      proto_tree_add_item(tree, hf_sick_cola_lcm_cfg_threshold_error, tvb, offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

    }

  }

  else if (strcmp(write_name, "LMDscandatacfg") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_data_channel, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_remission, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_resolution, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_unit, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_encoder, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_position, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_device_name, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_comment, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_time, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_scan_data_cfg_output_rate, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

    }

  }

  else if (strcmp(write_name, "LMPoutputRange") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_change_output_range_status_code, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      float angular_resolution = tvb_get_ntohl(tvb, offset) / 10000.f;

      proto_tree_add_float(tree, hf_sick_cola_change_output_range_angular_resolution, tvb, offset, 4, angular_resolution);

      offset += 4;

      int start_angle = (int)tvb_get_ntohl(tvb, offset);

      proto_tree_add_float(tree, hf_sick_cola_change_output_range_start_angle, tvb, offset, 4, start_angle/10000.f);

      offset += 4;

      int stop_angle = (int)tvb_get_ntohl(tvb, offset);

      proto_tree_add_float(tree, hf_sick_cola_change_output_range_stop, tvb, offset, 4, stop_angle/10000.f);

      offset += 4;

    }

  }

  else if (strcmp(write_name, "TSCRole") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_ntp_tsc_role, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "TSCTCInterface") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_ntp_interface_data, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "TSCTCSrvAddr") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_ntp_ipaddress, tvb, offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

    }

  }

  else if (strcmp(write_name, "TSCTCtimezone") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_ntp_gmt_timezone_offset, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "TSCTCupdatetime") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_ntp_timesync, tvb, offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

    }

  }

  else if (strcmp(write_name, "LFPparticle") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_particle_filter_status, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_particle_filter_threshold, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

    }

  }

  else if (strcmp(write_name, "LFPmeanfilter") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_mean_filter_status, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

      proto_tree_add_item(tree, hf_sick_cola_mean_filter_num_scans, tvb, offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      proto_tree_add_item(tree, hf_sick_cola_mean_filter_final_part, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "LFPnto1filter") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_nto1_filter_status, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "FREchoFilter") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_echo_filter_status, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "MSsuppmode") == 0)

  {

    if (binary)

    {

      proto_tree_add_item(tree, hf_sick_cola_fog_filter_status, tvb, offset, 1, ENC_BIG_ENDIAN);

      offset += 1;

    }

  }

  else if (strcmp(write_name, "CLFogFilterEn") == 0)