/* packet-hartip.c

 * Routines for HART-IP packet dissection

 * Copyright 2012, Bill Schiller <bill.schiller@emerson.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * Copied from packet-mbtcp.c

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/stats_tree.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include "packet-tcp.h"

void proto_register_hartip(void);

void proto_reg_handoff_hartip(void);

static dissector_handle_t hartip_tcp_handle;

static dissector_handle_t hartip_udp_handle;

static bool hartip_desegment  = true;

static int proto_hartip;

static int hf_hartip_hdr_version;

static int hf_hartip_hdr_message_id;

static int hf_hartip_hdr_message_type;

static int hf_hartip_hdr_status;

static int hf_hartip_hdr_transaction_id;

static int hf_hartip_hdr_msg_length;

static int hf_hartip_data;

static int hf_hartip_master_type;

static int hf_hartip_inactivity_close_timer;

static int hf_hartip_error_code;

static int hf_hartip_pt_preambles;

static int hf_hartip_pt_delimiter;

static int hf_hartip_pt_delimiter_frame_type;

static int hf_hartip_pt_delimiter_physical_layer_type;

static int hf_hartip_pt_delimiter_number_of_expansion_bytes;

static int hf_hartip_pt_delimiter_address_type;

static int hf_hartip_pt_short_addr;

static int hf_hartip_pt_long_addr;

static int hf_hartip_pt_expansion_bytes;

static int hf_hartip_pt_command;

static int hf_hartip_pt_length;

static int hf_hartip_pt_response_code;

static int hf_hartip_pt_device_status;

static int hf_hartip_pt_payload;

static int hf_hartip_pt_checksum;

static int ett_hartip;

static int ett_hartip_hdr;

static int ett_hartip_body;

static int ett_hartip_pt_delimiter;

static expert_field ei_hartip_data_none;

static expert_field ei_hartip_data_unexpected;

/* Command 0 response */

static int hf_hartip_pt_rsp_expansion_code;

static int hf_hartip_pt_rsp_expanded_device_type;

static int hf_hartip_pt_rsp_req_min_preambles;

static int hf_hartip_pt_rsp_hart_protocol_major_rev;

static int hf_hartip_pt_rsp_device_rev;

static int hf_hartip_pt_rsp_software_rev;

static int hf_hartip_pt_rsp_hardware_rev_physical_signal;

static int hf_hartip_pt_rsp_flage;

static int hf_hartip_pt_rsp_device_id;

static int hf_hartip_pt_rsp_rsp_min_preambles;

static int hf_hartip_pt_rsp_max_device_variables;

static int hf_hartip_pt_rsp_configuration_change_counter;

static int hf_hartip_pt_rsp_extended_device_status;

static int hf_hartip_pt_rsp_manufacturer_Identification_code;

static int hf_hartip_pt_rsp_private_label;

static int hf_hartip_pt_rsp_device_profile;

/* Command 2 response */

static int hf_hartip_pt_rsp_pv_percent_range;

/* Command 3 response */

static int hf_hartip_pt_rsp_pv_loop_current;

static int hf_hartip_pt_rsp_pv_units;

static int hf_hartip_pt_rsp_pv;

static int hf_hartip_pt_rsp_sv_units;

static int hf_hartip_pt_rsp_sv;

static int hf_hartip_pt_rsp_tv_units;

static int hf_hartip_pt_rsp_tv;

static int hf_hartip_pt_rsp_qv_units;

static int hf_hartip_pt_rsp_qv;

/* Command 7 response*/

static int hf_hartip_pt_rsp_loop_current_mode;

/* Command 8 response*/

static int hf_hartip_pt_rsp_primary_var_classify;

static int hf_hartip_pt_rsp_secondary_var_classify;

static int hf_hartip_pt_rsp_tertiary_var_classify;

static int hf_hartip_pt_rsp_quaternary_var_classify;

/* Command 9 response */

static int hf_hartip_pt_rsp_slot0_device_var;

static int hf_hartip_pt_rsp_slot0_device_var_classify;

static int hf_hartip_pt_rsp_slot0_units;

static int hf_hartip_pt_rsp_slot0_device_var_value;

static int hf_hartip_pt_rsp_slot0_device_var_status;

static int hf_hartip_pt_rsp_slot1_device_var;

static int hf_hartip_pt_rsp_slot1_device_var_classify;

static int hf_hartip_pt_rsp_slot1_units;

static int hf_hartip_pt_rsp_slot1_device_var_value;

static int hf_hartip_pt_rsp_slot1_device_var_status;

static int hf_hartip_pt_rsp_slot2_device_var;

static int hf_hartip_pt_rsp_slot2_device_var_classify;

static int hf_hartip_pt_rsp_slot2_units;

static int hf_hartip_pt_rsp_slot2_device_var_value;

static int hf_hartip_pt_rsp_slot2_device_var_status;

static int hf_hartip_pt_rsp_slot3_device_var;

static int hf_hartip_pt_rsp_slot3_device_var_classify;

static int hf_hartip_pt_rsp_slot3_units;

static int hf_hartip_pt_rsp_slot3_device_var_value;

static int hf_hartip_pt_rsp_slot3_device_var_status;

static int hf_hartip_pt_rsp_slot4_device_var;

static int hf_hartip_pt_rsp_slot4_device_var_classify;

static int hf_hartip_pt_rsp_slot4_units;

static int hf_hartip_pt_rsp_slot4_device_var_value;

static int hf_hartip_pt_rsp_slot4_device_var_status;

static int hf_hartip_pt_rsp_slot5_device_var;

static int hf_hartip_pt_rsp_slot5_device_var_classify;

static int hf_hartip_pt_rsp_slot5_units;

static int hf_hartip_pt_rsp_slot5_device_var_value;

static int hf_hartip_pt_rsp_slot5_device_var_status;

static int hf_hartip_pt_rsp_slot6_device_var;

static int hf_hartip_pt_rsp_slot6_device_var_classify;

static int hf_hartip_pt_rsp_slot6_units;

static int hf_hartip_pt_rsp_slot6_device_var_value;

static int hf_hartip_pt_rsp_slot6_device_var_status;

static int hf_hartip_pt_rsp_slot7_device_var;

static int hf_hartip_pt_rsp_slot7_device_var_classify;

static int hf_hartip_pt_rsp_slot7_units;

static int hf_hartip_pt_rsp_slot7_device_var_value;

static int hf_hartip_pt_rsp_slot7_device_var_status;

static int hf_hartip_pt_rsp_slot0_timestamp;

/* Command 13 response */

static int hf_hartip_pt_rsp_packed_descriptor;

static int hf_hartip_pt_rsp_day;

static int hf_hartip_pt_rsp_month;

static int hf_hartip_pt_rsp_year;

/* Command 14 response */

static int hf_hartip_pt_rsp_transducer_serial_number;

static int hf_hartip_pt_rsp_transducer_limit_min_span_units;

static int hf_hartip_pt_rsp_upper_transducer_limit;

static int hf_hartip_pt_rsp_lower_transducer_limit;

static int hf_hartip_pt_rsp_minimum_span;

/* Command 15 response */

static int hf_hartip_pt_rsp_pv_alarm_selection_code;

static int hf_hartip_pt_rsp_pv_transfer_function_code;

static int hf_hartip_pt_rsp_pv_upper_and_lower_range_values_units;

static int hf_hartip_pt_rsp_pv_upper_range_value;

static int hf_hartip_pt_rsp_pv_lower_range_value;

static int hf_hartip_pt_rsp_pv_damping_value;

static int hf_hartip_pt_rsp_write_protect_code;

static int hf_hartip_pt_rsp_reserved;

static int hf_hartip_pt_rsp_pv_analog_channel_flags;

/* Command 16 and 19 response */

static int hf_hartip_pt_rsp_final_assembly_number;

/* response Tag */

static int hf_hartip_pt_rsp_tag;

/* response Message */

static int hf_hartip_pt_rsp_message;

/* Command 48 response */

static int hf_hartip_pt_rsp_device_sp_status;

static int hf_hartip_pt_rsp_device_op_mode;

static int hf_hartip_pt_rsp_standardized_status_0;

static int hf_hartip_pt_rsp_standardized_status_1;

static int hf_hartip_pt_rsp_analog_channel_saturated;

static int hf_hartip_pt_rsp_standardized_status_2;

static int hf_hartip_pt_rsp_standardized_status_3;

static int hf_hartip_pt_rsp_analog_channel_fixed;

/* Command 77 response */

static int hf_hartip_pt_rsp_io_card;

static int hf_hartip_pt_rsp_channel;

static int hf_hartip_pt_req_tx_preamble_count;

static int hf_hartip_pt_rsp_embedded_cmd_delimiter;

static int hf_hartip_pt_rsp_poll_address;

static int hf_hartip_pt_rsp_unique_id;

static int hf_hartip_pt_rsp_embedded_cmd;

/* Command 31 and 178 response */

static int hf_hartip_pt_rsp_number_of_commands;

static int hf_hartip_pt_rsp_command_number;

static int hf_hartip_pt_rsp_command_byte_count;

/* Command 31, 77 and 178 response */

static int hf_hartip_pt_rsp_data;

/*Command 203 response*/

static int hf_hartip_pt_rsp_index_of_first_discrete_var;

static int hf_hartip_pt_rsp_number_of_discrete_vars;

static int hf_hartip_pt_rsp_timestamp_for_most_recent_discrete_change;

static int hf_hartip_pt_rsp_slot0_discrete_var_state;

static int hf_hartip_pt_rsp_slot0_discrete_var_status;

static int hf_hartip_pt_rsp_slot1_discrete_var_state;

static int hf_hartip_pt_rsp_slot1_discrete_var_status;

static int hf_hartip_pt_rsp_slot2_discrete_var_state;

static int hf_hartip_pt_rsp_slot2_discrete_var_status;

static int hf_hartip_pt_rsp_slot3_discrete_var_state;

static int hf_hartip_pt_rsp_slot3_discrete_var_status;

static int hf_hartip_pt_rsp_slot4_discrete_var_state;

static int hf_hartip_pt_rsp_slot4_discrete_var_status;

static int hf_hartip_pt_rsp_slot5_discrete_var_state;

static int hf_hartip_pt_rsp_slot5_discrete_var_status;

#define HARTIP_HEADER_LENGTH     8

#define HARTIP_PORT           5094

/* HARTIP header */

typedef struct _hartip_hdr {

  uint8_t  version;

  uint8_t  message_type;

  uint8_t  message_id;

  uint8_t  status;

  uint16_t transaction_id;

  uint16_t length;

} hartip_hdr;

/* Message IDs */

#define SESSION_INITIATE_ID       0

#define SESSION_CLOSE_ID          1

#define KEEP_ALIVE_ID             2

#define PASS_THROUGH_ID           3

/* Message types */

#define REQUEST_MSG_TYPE       0

#define RESPONSE_MSG_TYPE      1

#define PUBLISH_MSG_TYPE       2

#define ERROR_MSG_TYPE         3

#define NAK_MSG_TYPE           15

static const value_string hartip_message_id_values[] = {

  { SESSION_INITIATE_ID,     "Session Initiate" },

  { SESSION_CLOSE_ID,        "Session Close" },

  { KEEP_ALIVE_ID,           "Keep Alive" },

  { PASS_THROUGH_ID,         "Pass Through" },

  { 0, NULL }

};

static const value_string hartip_message_type_values[] = {

  { REQUEST_MSG_TYPE,        "Request" },

  { RESPONSE_MSG_TYPE,       "Response" },

  { PUBLISH_MSG_TYPE,        "Publish" },

  { ERROR_MSG_TYPE,          "Error" },

  { NAK_MSG_TYPE,            "Error" },

  { 0, NULL }

};

/* Host types */

#define SECONDARY_MASTER_TYPE    0

#define PRIMARY_MASTER_TYPE      1

static const value_string hartip_master_type_values[] = {

  { SECONDARY_MASTER_TYPE,      "Secondary Host" },

  { PRIMARY_MASTER_TYPE,        "Primary Host" },

  { 0, NULL }

};

/* Error Codes */

#define SESSION_CLOSED_ERROR                0

#define PRIMARY_SESSION_UNAVAILABLE_ERROR   1

#define SERVICE_UNAVAILABLE_ERROR           2

static const value_string hartip_error_code_values[] = {

  { SESSION_CLOSED_ERROR,              "Session closed" },

  { PRIMARY_SESSION_UNAVAILABLE_ERROR, "Primary session unavailable" },

  { SERVICE_UNAVAILABLE_ERROR,         "Service unavailable" },

  { 0, NULL }

};

static const value_string hartip_pt_delimiter_frame_type_values[] = {

  { 1, "BACK (Burst Frame)" },

  { 2, "STX (Master to Field Device)" },

  { 6, "ACK (Field Device to Master)" },

  { 0, NULL }

};

static const value_string hartip_pt_delimiter_physical_layer_type_values[] = {

  { 0, "Asynchronous" },

  { 1, "Synchronous (i.e, PSK)" },

  { 0, NULL }

};

static const value_string hartip_pt_delimiter_address_type_values[] = {

  { 0, "Polling (1 Byte)" },

  { 1, "Unique (5 Bytes)" },

  { 0, NULL }

};

/* Handle for statistics tap. */

static int hartip_tap;

/* Structure used for passing data for statistics processing. */

typedef struct _hartip_tap_info {

  int8_t message_type;

  int8_t message_id;

} hartip_tap_info;

/* Names of items in statistics tree. */

static const char* st_str_packets   = "Total HART_IP Packets";

static const char* st_str_requests  = "Request Packets";

static const char* st_str_responses = "Response Packets";

static const char* st_str_publish   = "Publish Packets";

static const char* st_str_errors    = "Error Packets";

/* Handles of items in statistics tree. */

static int st_node_packets = -1;

static int st_node_requests = -1;

static int st_node_responses = -1;

static int st_node_publish = -1;

static int st_node_errors = -1;

/* Local flags for pass through dissection. */

#define HARTIP_PT_IS_RSP    0x01

static void

hartip_stats_tree_init(stats_tree* st)

{

  st_node_packets   = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, true);

  st_node_requests  = stats_tree_create_pivot(st, st_str_requests, st_node_packets);

  st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, STAT_DT_INT, true);

  st_node_publish   = stats_tree_create_node(st, st_str_publish, st_node_packets, STAT_DT_INT, true);

  st_node_errors    = stats_tree_create_node(st, st_str_errors, st_node_packets, STAT_DT_INT, true);

}

static tap_packet_status

hartip_stats_tree_packet(stats_tree* st, packet_info* pinfo _U_,

                         epan_dissect_t* edt _U_, const void* p, tap_flags_t flags _U_)

{

  const hartip_tap_info *tapinfo = (const hartip_tap_info *)p;

  const char            *message_type_node_str, *message_id_node_str;

  int                    message_type_node;

  switch (tapinfo->message_type) {

  case REQUEST_MSG_TYPE:

    message_type_node_str = st_str_requests;

    message_type_node     = st_node_requests;

    break;

  case RESPONSE_MSG_TYPE:

    message_type_node_str = st_str_responses;

    message_type_node     = st_node_responses;

    break;

  case PUBLISH_MSG_TYPE:

    message_type_node_str = st_str_publish;

    message_type_node     = st_node_publish;

    break;

  case ERROR_MSG_TYPE:

  case NAK_MSG_TYPE:

    message_type_node_str = st_str_errors;

    message_type_node     = st_node_errors;

    break;

  default:

    return TAP_PACKET_DONT_REDRAW;  /* Don't want to track invalid messages for now. */

  }

  message_id_node_str = val_to_str(pinfo->pool, tapinfo->message_id,

                                   hartip_message_id_values,

                                   "Unknown message %d");

  tick_stat_node(st, st_str_packets, 0, false);

  tick_stat_node(st, message_type_node_str, st_node_packets, false);

  tick_stat_node(st, message_id_node_str, message_type_node, false);

  return TAP_PACKET_REDRAW;

}

static int

dissect_empty_body(proto_tree *tree, packet_info* pinfo, tvbuff_t *tvb,

                   int offset, int bodylen)

{

  proto_item  *ti;

  ti = proto_tree_add_item(tree, hf_hartip_data, tvb, offset, bodylen, ENC_NA);

  if (bodylen == 0) {

    expert_add_info(pinfo, ti, &ei_hartip_data_none);

  } else {

    expert_add_info(pinfo, ti, &ei_hartip_data_unexpected);

  }

  return bodylen;

}

static int

dissect_session_init(proto_tree *body_tree, tvbuff_t *tvb, int offset,

                     int bodylen)

{

  if (bodylen == 5) {

    proto_tree_add_item(body_tree, hf_hartip_master_type, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    proto_tree_add_item(body_tree, hf_hartip_inactivity_close_timer, tvb, offset, 4, ENC_BIG_ENDIAN);

  } else {

    proto_tree_add_item(body_tree, hf_hartip_data, tvb, offset, bodylen, ENC_NA);

  }

  return bodylen;

}

static int

dissect_error(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen == 1) {

    proto_tree_add_item(body_tree, hf_hartip_error_code, tvb, offset, 1, ENC_BIG_ENDIAN);

  } else {

    proto_tree_add_item(body_tree, hf_hartip_data, tvb, offset, bodylen, ENC_NA);

  }

  return bodylen;

}

static int

dissect_session_close(proto_tree *body_tree, packet_info* pinfo, tvbuff_t *tvb,

                      int offset, int bodylen)

{

  return dissect_empty_body(body_tree, pinfo, tvb, offset, bodylen);

}

static int

dissect_keep_alive(proto_tree *body_tree, packet_info* pinfo, tvbuff_t *tvb,

                   int offset, int bodylen)

{

  return dissect_empty_body(body_tree, pinfo, tvb, offset, bodylen);

}

static int

dissect_byte(proto_tree *tree, int hf, tvbuff_t *tvb, int offset)

{

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

  return 1;

}

static int

dissect_short(proto_tree *tree, int hf, tvbuff_t *tvb, int offset)

{

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

  return 2;

}

static int

dissect_float(proto_tree *tree, int hf, tvbuff_t *tvb, int offset)

{

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

  return 4;

}

static int

dissect_packAscii(proto_tree *tree, packet_info* pinfo, int hf, tvbuff_t *tvb, int offset, int len)

{

  uint16_t    usIdx;

  uint16_t    usGroupCnt;

  uint16_t    usMaxGroups;      /* Number of 4 byte groups to pack. */

  uint16_t    usMask;

  int         iIndex;

  int         i   = 0;

  uint16_t    buf[4];

  uint8_t    *tmp;

  char       *str = NULL;

  tmp = (uint8_t *)wmem_alloc0(pinfo->pool, len);

  tvb_memcpy(tvb, tmp, offset, len);

  /* Maximum possible unpacked length = (len / 3) * 4 */

  str = (char *)wmem_alloc(pinfo->pool, ((len / 3) * 4)+1);

  iIndex = 0;

  usMaxGroups = (uint16_t)(len / 3);

  for (usGroupCnt = 0; usGroupCnt < usMaxGroups; usGroupCnt++) {

    /*

     * First unpack 3 bytes into a group of 4 bytes, clearing bits 6 & 7.

     */

    buf[0] = (uint16_t)(tmp[iIndex] >> 2);

    buf[1] = (uint16_t)(((tmp[iIndex] << 4) & 0x30) | (tmp[iIndex + 1] >> 4));

    buf[2] = (uint16_t)(((tmp[iIndex + 1] << 2) & 0x3C) | (tmp[iIndex + 2] >> 6));

    buf[3] = (uint16_t)(tmp[iIndex + 2] & 0x3F);

    iIndex += 3;

    /*

     * Now transfer to unpacked area, setting bit 6 to complement of bit 5.

     */

    for (usIdx = 0; usIdx < 4; usIdx++) {

      usMask = (uint16_t)(((buf[usIdx] & 0x20) << 1) ^ 0x40);

      DISSECTOR_ASSERT(i < 256);

      str[i++] = (char)(buf[usIdx] | usMask);

    }

  }

  str[i] = '\0';

  proto_tree_add_string(tree, hf, tvb, offset, len, str);

  return len;

}

static int

dissect_timestamp(proto_tree *tree, int hf, const char *name, int len,

                  tvbuff_t *tvb, int offset)

{

  proto_item *ti;

  uint32_t    t;

  uint32_t    hrs  = 0;

  uint32_t    mins = 0;

  uint32_t    secs = 0;

  uint32_t    ms   = 0;

  ti = proto_tree_add_item(tree, hf, tvb, offset, len, ENC_NA);

  t  = tvb_get_ntohl(tvb, offset);

  if (t > 0 ) {

    t /= 32;

    ms = t % 1000;

    t /= 1000;

    secs = t % 60;

    t /= 60;

    mins = t % 60;

    hrs = (unsigned)(t / 60);

  }

  proto_item_set_text(ti, "%s: %02d:%02d:%02d.%03d", name, hrs, mins, secs, ms);

  return len;

}

static int

dissect_cmd0(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 12) {

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_expansion_code,                   tvb, offset);

    offset += dissect_short(body_tree, hf_hartip_pt_rsp_expanded_device_type,             tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_req_min_preambles,                tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_hart_protocol_major_rev,          tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_device_rev,                       tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_software_rev,                     tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_hardware_rev_physical_signal,     tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_flage,                            tvb, offset);

    proto_tree_add_item(body_tree,     hf_hartip_pt_rsp_device_id,                        tvb, offset, 3, ENC_NA);

    offset += 3;

    if (bodylen >= 16) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_rsp_min_preambles,                tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_max_device_variables,             tvb, offset);

      offset += dissect_short(body_tree, hf_hartip_pt_rsp_configuration_change_counter,     tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_extended_device_status,           tvb, offset);

    }

    if (bodylen >= 18) {

      offset += dissect_short(body_tree, hf_hartip_pt_rsp_manufacturer_Identification_code, tvb, offset);

    }

    if (bodylen >= 22) {

      offset += dissect_short(body_tree, hf_hartip_pt_rsp_private_label,                    tvb, offset);

      /*offset += */dissect_byte(body_tree,  hf_hartip_pt_rsp_device_profile,                   tvb, offset);

    }

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd1(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 5) {

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_pv_units, tvb, offset);

    /*offset += */dissect_float(body_tree, hf_hartip_pt_rsp_pv,       tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd2(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 8) {

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv_loop_current,  tvb, offset);

    /*offset += */dissect_float(body_tree, hf_hartip_pt_rsp_pv_percent_range, tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd3(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 24) {

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv_loop_current, tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_pv_units,        tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv,              tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_sv_units,        tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_sv,              tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_tv_units,        tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_tv,              tvb, offset);

    offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_qv_units,        tvb, offset);

    /*offset += */dissect_float(body_tree, hf_hartip_pt_rsp_qv,              tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd7(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 2) {

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_poll_address,     tvb, offset);

    dissect_byte(body_tree, hf_hartip_pt_rsp_loop_current_mode,          tvb, offset);

    return bodylen;

  }

   return 0;

}

static int

dissect_cmd8(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 4) {

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_primary_var_classify,     tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_secondary_var_classify,   tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_tertiary_var_classify,    tvb, offset);

    dissect_byte(body_tree, hf_hartip_pt_rsp_quaternary_var_classify,            tvb, offset);

    return bodylen;

  }

   return 0;

}

static int

dissect_cmd9(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 13) {

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_extended_device_status,    tvb, offset);

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_device_var,          tvb, offset);

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_device_var_classify, tvb, offset);

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_units,               tvb, offset);

    offset += dissect_float(body_tree,   hf_hartip_pt_rsp_slot0_device_var_value,    tvb, offset);

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_device_var_status,   tvb, offset);

    if (bodylen >= 21) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot1_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot1_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot1_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot1_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot1_device_var_status,   tvb, offset);

    }

    if (bodylen >= 29) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot2_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot2_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot2_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot2_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot2_device_var_status,   tvb, offset);

    }

    if (bodylen >= 37) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot3_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot3_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot3_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot3_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot3_device_var_status,   tvb, offset);

    }

    if (bodylen >= 45) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot4_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot4_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot4_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot4_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot4_device_var_status,   tvb, offset);

    }

    if (bodylen >= 53) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot5_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot5_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot5_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot5_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot5_device_var_status,   tvb, offset);

    }

    if (bodylen >= 61) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot6_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot6_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot6_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot6_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot6_device_var_status,   tvb, offset);

    }

    if (bodylen >= 69) {

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot7_device_var,          tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot7_device_var_classify, tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot7_units,               tvb, offset);

      offset += dissect_float(body_tree, hf_hartip_pt_rsp_slot7_device_var_value,    tvb, offset);

      offset += dissect_byte(body_tree,  hf_hartip_pt_rsp_slot7_device_var_status,   tvb, offset);

    }

    dissect_timestamp(body_tree, hf_hartip_pt_rsp_slot0_timestamp, "Slot0 Data TimeStamp", 4, tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd13(proto_tree *body_tree, packet_info* pinfo, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 21) {

    offset += dissect_packAscii(body_tree, pinfo, hf_hartip_pt_rsp_tag, tvb, offset, 6);

    offset += dissect_packAscii(body_tree, pinfo, hf_hartip_pt_rsp_packed_descriptor, tvb, offset, 12);

    offset += dissect_byte(body_tree,      hf_hartip_pt_rsp_day,                                 tvb, offset);

    offset += dissect_byte(body_tree,      hf_hartip_pt_rsp_month,                               tvb, offset);

    /*offset += */dissect_byte(body_tree,      hf_hartip_pt_rsp_year,                                tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd14(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 16) {

    proto_tree_add_item(body_tree, hf_hartip_pt_rsp_transducer_serial_number, tvb, offset, 3, ENC_NA);

    offset += 3;

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_transducer_limit_min_span_units, tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_upper_transducer_limit,         tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_lower_transducer_limit,         tvb, offset);

    dissect_float(body_tree, hf_hartip_pt_rsp_minimum_span,                             tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd15(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 18) {

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_pv_alarm_selection_code,               tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_pv_transfer_function_code,             tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_pv_upper_and_lower_range_values_units, tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv_upper_range_value,                 tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv_lower_range_value,                 tvb, offset);

    offset += dissect_float(body_tree, hf_hartip_pt_rsp_pv_damping_value,                     tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_write_protect_code,                    tvb, offset);

    offset += dissect_byte(body_tree, hf_hartip_pt_rsp_reserved,                              tvb, offset);

    dissect_byte(body_tree, hf_hartip_pt_rsp_pv_analog_channel_flags,                         tvb, offset);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd16(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 3) {

    proto_tree_add_item(body_tree, hf_hartip_pt_rsp_final_assembly_number, tvb, offset, 3, ENC_NA);

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd33(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 6) {

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_device_var,          tvb, offset);

    offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot0_units,               tvb, offset);

    offset += dissect_float(body_tree,   hf_hartip_pt_rsp_slot0_device_var_value,    tvb, offset);

    if (bodylen >= 12) {

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot1_device_var,        tvb, offset);

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot1_units,             tvb, offset);

      offset += dissect_float(body_tree,   hf_hartip_pt_rsp_slot1_device_var_value,  tvb, offset);

    }

    if (bodylen >= 18) {

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot2_device_var,        tvb, offset);

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot2_units,             tvb, offset);

      offset += dissect_float(body_tree,   hf_hartip_pt_rsp_slot2_device_var_value,  tvb, offset);

    }

    if (bodylen >= 24) {

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot3_device_var,        tvb, offset);

      offset += dissect_byte(body_tree,    hf_hartip_pt_rsp_slot3_units,             tvb, offset);

      dissect_float(body_tree,   hf_hartip_pt_rsp_slot3_device_var_value,            tvb, offset);

    }

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd38(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 2) {

    dissect_short(body_tree, hf_hartip_pt_rsp_configuration_change_counter, tvb, offset);

   return bodylen;

  }

  return 0;

}

static int

dissect_cmd48(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

  if (bodylen >= 6) {

    proto_tree_add_item(body_tree,      hf_hartip_pt_rsp_device_sp_status,         tvb, offset, 6, ENC_NA);

    offset += 6;

    if (bodylen >= 9) {

      offset += dissect_byte(body_tree,   hf_hartip_pt_rsp_extended_device_status, tvb, offset);

      offset += dissect_byte(body_tree,   hf_hartip_pt_rsp_device_op_mode,         tvb, offset);

      offset += dissect_byte(body_tree,   hf_hartip_pt_rsp_standardized_status_0,  tvb, offset);

    }

    if (bodylen >= 13) {

      offset += dissect_byte(body_tree, hf_hartip_pt_rsp_standardized_status_1,    tvb, offset);

      offset += dissect_byte(body_tree, hf_hartip_pt_rsp_analog_channel_saturated, tvb, offset);

      offset += dissect_byte(body_tree, hf_hartip_pt_rsp_standardized_status_2,    tvb, offset);

      offset += dissect_byte(body_tree, hf_hartip_pt_rsp_standardized_status_3,    tvb, offset);

    }

    if (bodylen >= 14) {

        offset += dissect_byte(body_tree, hf_hartip_pt_rsp_analog_channel_fixed,   tvb, offset);

    }

    if (bodylen >= 24) {

      proto_tree_add_item(body_tree,    hf_hartip_pt_rsp_device_sp_status,         tvb, offset, 11, ENC_NA);

      /*offset += 11;*/

    }

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd77(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen, int flags)

{

  uint8_t byte_count;

  int     length = bodylen;

  if (length >= 6) {

     uint8_t delimiter;

     offset += dissect_byte(body_tree, hf_hartip_pt_rsp_io_card,                tvb, offset);

     offset += dissect_byte(body_tree, hf_hartip_pt_rsp_channel,                tvb, offset);

     if (!(flags & HARTIP_PT_IS_RSP)) {

       offset += dissect_byte(body_tree, hf_hartip_pt_req_tx_preamble_count, tvb, offset);

     }

     delimiter = tvb_get_uint8(tvb, offset);

     offset += dissect_byte(body_tree, hf_hartip_pt_rsp_embedded_cmd_delimiter, tvb, offset);

     if ((delimiter & 0x80) == 0) {

       uint8_t short_addr;

       short_addr = tvb_get_uint8(tvb, offset);

       short_addr &= 0x3F;

       proto_tree_add_uint(body_tree, hf_hartip_pt_rsp_poll_address, tvb, offset, 1, short_addr);

       offset += 1;

     } else {

       /* TODO  Chop off the two first bits here, too? */

       proto_tree_add_item(body_tree, hf_hartip_pt_rsp_unique_id, tvb, offset, 5, ENC_NA);

       offset += 5;

     }

     offset += dissect_byte(body_tree, hf_hartip_pt_rsp_embedded_cmd,           tvb, offset);

     proto_tree_add_item_ret_uint8(body_tree, hf_hartip_pt_rsp_command_byte_count, tvb, offset, 1, ENC_BIG_ENDIAN, &byte_count);

     offset += 1;

     length -= 6;

     if ((byte_count >= 2) && (length >= 2) && (byte_count <= length)) {

       offset += dissect_byte(body_tree, hf_hartip_pt_response_code, tvb, offset);

       offset += dissect_byte(body_tree, hf_hartip_pt_device_status, tvb, offset);

       length -= 2;

       byte_count -= 2;

       if ((byte_count > 0) && (length > 0) && (byte_count <= length)) {

         proto_tree_add_item(body_tree, hf_hartip_pt_rsp_data, tvb, offset,

                             byte_count, ENC_NA);

       }

     }

    return bodylen;

  }

  return 0;

}

static int

dissect_cmd178(proto_tree *body_tree, tvbuff_t *tvb, int offset, int bodylen)

{

   uint16_t cmd;

   uint8_t number_of_cmds;

   uint8_t cmd_byte_count;

   int     length = bodylen;

   int     result;

   if (length >= 5) {

     number_of_cmds = tvb_get_uint8(tvb, offset);

     proto_tree_add_uint(body_tree, hf_hartip_pt_rsp_number_of_commands, tvb, offset, 1, number_of_cmds);

     offset += 1;

     length -= 1;

     for (unsigned i = 0; i < number_of_cmds; i++)

     {

       if (length >= 4)

       {

         cmd = tvb_get_ntohs(tvb, offset);

         proto_tree_add_item(body_tree, hf_hartip_pt_rsp_command_number, tvb, offset, 2, ENC_BIG_ENDIAN);

         offset += 2;

         length -= 2;

         cmd_byte_count = tvb_get_uint8(tvb, offset);

         proto_tree_add_item(body_tree, hf_hartip_pt_rsp_command_byte_count, tvb, offset, 1, ENC_BIG_ENDIAN);

         offset += 1;

         length -= 1;

         offset += dissect_byte(body_tree, hf_hartip_pt_response_code, tvb, offset);

         length -= 1;

         cmd_byte_count -= 1;

         if ((cmd_byte_count > 0) && (length > 0) && (cmd_byte_count <= length))

         {

           switch(cmd)

           {

             case 3:

               result = dissect_cmd3(body_tree, tvb, offset, cmd_byte_count);

               break;

             case 9:

               result = dissect_cmd9(body_tree, tvb, offset, cmd_byte_count);

               break;

             case 48:

               result = dissect_cmd48(body_tree, tvb, offset, cmd_byte_count);

               break;

             default:

               result = 0;

               break;

           }