/* packet-sml.c

 * Routines for SML dissection

 * Copyright 2013, Alexander Gaertner <gaertner.alex@gmx.de>

 *

 * Enhancements for SML 1.05 dissection

 * Copyright 2022, Uwe Heuert <uwe.heuert@exceeding-solutions.de>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/*

SML dissector is based on v1.03 (12.11.2008) specifications of "smart message language" protocol

Link to specifications: http://www.vde.com/de/fnn/arbeitsgebiete/messwesen/Sym2/infomaterial/seiten/sml-spezifikation.aspx

Short description of the SML protocol on the SML Wireshark Wiki page:

    https://gitlab.com/wireshark/wireshark/-/wikis/SML

*/

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/crc16-tvb.h>

#include <epan/expert.h>

#include <wsutil/str_util.h>

#define ESC_SEQ_END   UINT64_C(0x1b1b1b1b1a)

#define ESC_SEQ     0x1b1b1b1b

#define OPEN_REQ    0x0100

#define OPEN_RES    0x0101

#define CLOSE_REQ   0x0200

#define CLOSE_RES   0x0201

#define PROFILEPACK_REQ   0x0300

#define PROFILEPACK_RES   0x0301

#define PROFILELIST_REQ   0x0400

#define PROFILELIST_RES   0x0401

#define GETPROCPARAMETER_REQ  0x0500

#define GETPROCPARAMETER_RES  0x0501

#define SETPROCPARAMETER_REQ  0x0600

#define GETLIST_REQ   0x0700

#define GETLIST_RES   0x0701

#define ATTENTION   0xFF01

#define PROC_VALUE    0x01

#define PROC_PERIOD   0x02

#define PROC_TUPLE    0x03

#define PROC_TIME   0x04

#define PROC_LISTENTRY  0x05

#define TIME_SECINDEX       0x01

#define TIME_TIMESTAMP        0x02

#define TIME_LOCALTIMESTAMP     0x03

#define LISTTYPE_TIME       0x01

#define LISTTYPE_TIMESTAMPEDVALUE 0x02

#define LISTTYPE_COSEMVALUE     0x03

#define COSEMVALUE_SCALER_UNIT    0x01

#define SHORT_LIST    0x70

#define LONG_LIST   0xF0

#define OPTIONAL    0x01

#define UNSIGNED8   0x62

#define UNSIGNED16    0x63

#define LIST_6_ELEMENTS   0x76

#define MSB     0x80

/* Forward declaration we need below (if using proto_reg_handoff as a prefs callback)*/

void proto_register_sml(void);

void proto_reg_handoff_sml(void);

static dissector_handle_t sml_handle;

/* Initialize the protocol and registered fields */

static int proto_sml;

static int hf_sml_esc;

static int hf_sml_version_1;

static int hf_sml_groupNo;

static int hf_sml_transactionId;

static int hf_sml_length;

static int hf_sml_datatype;

static int hf_sml_abortOnError;

static int hf_sml_MessageBody;

static int hf_sml_crc16;

static int hf_sml_crc16_status;

static int hf_sml_endOfSmlMsg;

static int hf_sml_end;

static int hf_sml_codepage;

static int hf_sml_clientId;

static int hf_sml_reqFileId;

static int hf_sml_serverId;

static int hf_sml_username;

static int hf_sml_password;

static int hf_sml_smlVersion;

static int hf_sml_listName;

static int hf_sml_globalSignature;

static int hf_sml_timetype;

static int hf_sml_objName;

static int hf_sml_status;

static int hf_sml_unit;

static int hf_sml_scaler;

static int hf_sml_value;

static int hf_sml_simplevalue;

static int hf_sml_valueSignature;

static int hf_sml_listSignature;

static int hf_sml_parameterTreePath;

static int hf_sml_attribute;

static int hf_sml_parameterName;

static int hf_sml_procParValue;

static int hf_sml_padding;

static int hf_sml_secIndex;

static int hf_sml_timestamp;

static int hf_sml_localOffset;

static int hf_sml_seasonTimeOffset;

static int hf_sml_attentionNo;

static int hf_sml_attentionMsg;

static int hf_sml_withRawdata;

static int hf_sml_object_list_Entry;

static int hf_sml_regPeriod;

static int hf_sml_rawdata;

static int hf_sml_periodSignature;

static int hf_sml_profileSignature;

static int hf_sml_signature_mA_R2_R3;

static int hf_sml_signature_pA_R1_R4;

static int hf_sml_unit_mA;

static int hf_sml_scaler_mA;

static int hf_sml_value_mA;

static int hf_sml_unit_pA;

static int hf_sml_scaler_pA;

static int hf_sml_value_pA;

static int hf_sml_unit_R1;

static int hf_sml_scaler_R1;

static int hf_sml_value_R1;

static int hf_sml_unit_R2;

static int hf_sml_scaler_R2;

static int hf_sml_value_R2;

static int hf_sml_unit_R3;

static int hf_sml_scaler_R3;

static int hf_sml_value_R3;

static int hf_sml_unit_R4;

static int hf_sml_scaler_R4;

static int hf_sml_value_R4;

static int hf_sml_file_marker;

static int hf_sml_new_file_marker;

static int hf_sml_listtype;

static int hf_sml_cosemvalue;

static const value_string datatype []={

  {0x52, "Integer 8"},

  {0x53, "Integer 16"},

  {0x54, "Integer cropped"},

  {0x55, "Integer 32"},

  {0x56, "Integer cropped"},

  {0x57, "Integer cropped"},

  {0x58, "Integer cropped"},

  {0x59, "Integer 64"},

  {0x62, "Unsigned 8"},

  {0x63, "Unsigned 16"},

  {0x64, "Unsigned cropped"},

  {0x65, "Unsigned 32"},

  {0x66, "Unsigned cropped"},

  {0x67, "Unsigned cropped"},

  {0x68, "Unsigned cropped"},

  {0x69, "Unsigned 64"},

  {0x42, "Boolean"},

  {0x72, "ListType" },

  {0, NULL}

};

static const value_string sml_abort[]={

  {0x00, "Continue"},

  {0x01, "Continue at next group"},

  {0x02, "Continue than abort"},

  {0xFF, "Abort"},

  {0, NULL}

};

static const value_string sml_body[]={

  {OPEN_REQ,         "PublicOpen.Req"},

  {OPEN_RES,         "PublicOpen.Res"},

  {CLOSE_REQ,        "PublicClose.Req"},

  {CLOSE_RES,        "PublicClose.Res"},

  {PROFILEPACK_REQ,      "GetProfilePack.Req"},

  {PROFILEPACK_RES,      "GetProfilePack.Res"},

  {PROFILELIST_REQ,      "GetProfileList.Req"},

  {PROFILELIST_RES,      "GetProfileList.Res"},

  {GETPROCPARAMETER_REQ, "GetProcParameter.Req"},

  {GETPROCPARAMETER_RES, "GetProcParameter.Res"},

  {SETPROCPARAMETER_REQ, "SetProcParameter.Req"},

  {GETLIST_REQ,        "GetList.Req"},

  {GETLIST_RES,        "GetList.Res"},

  {ATTENTION,        "Attention.Res"},

  {0, NULL}

};

static const value_string sml_timetypes[]={

  {0x01, "secIndex"},

  {0x02, "timestamp"},

  {0x03, "localTimestamp" },

  {0, NULL}

};

static const value_string procvalues[]={

  {PROC_VALUE,  "Value"},

  {PROC_PERIOD, "PeriodEntry"},

  {PROC_TUPLE,  "TupleEntry"},

  {PROC_TIME,   "Time"},

  {PROC_LISTENTRY, "ListEntry"},

  {0, NULL}

};

static const value_string listtypevalues[] = {

  { LISTTYPE_TIME, "smlTime" },

  { LISTTYPE_TIMESTAMPEDVALUE, "smlTimestampedValue" },

  { LISTTYPE_COSEMVALUE, "smlCosemValue" },

  { 0, NULL }

};

static const value_string cosemvaluevalues[] = {

  { COSEMVALUE_SCALER_UNIT, "scaler_unit" },

  { 0, NULL }

};

static const range_string attentionValues[]={

  {0xE000, 0xFCFF, "application specific"},

  {0xFD00, 0xFD00, "acknowledged"},

  {0xFD01, 0xFD01, "order will be executed later"},

  {0xFE00, 0xFE00, "error undefined"},

  {0xFE01, 0xFE01, "unknown SML designator"},

  {0xFE02, 0xFE02, "User/Password wrong"},

  {0xFE03, 0xFE03, "serverId not available"},

  {0xFE04, 0xFE04, "reqFileId not available"},

  {0xFE05, 0xFE05, "destination attributes cannot be written"},

  {0xFE06, 0xFE06, "destination attributes cannot be read"},

  {0xFE07, 0xFE07, "communication disturbed"},

  {0xFE08, 0xFE08, "rawdata cannot be interpreted"},

  {0xFE09, 0xFE09, "value out of range"},

  {0xFE0A, 0xFE0A, "order not executed"},

  {0xFE0B, 0xFE0B, "checksum failed"},

  {0xFE0C, 0xFE0C, "broadcast not supported"},

  {0xFE0D, 0xFE0D, "unexpected message"},

  {0xFE0E, 0xFE0E, "unknown object in the profile"},

  {0xFE0F, 0xFE0F, "datatype not supported"},

  {0xFE10, 0xFE10, "optional element not supported"},

  {0xFE11, 0xFE11, "no entry in requested profile"},

  {0xFE12, 0xFE12, "end limit before begin limit"},

  {0xFE13, 0xFE13, "no entry in requested area"},

  {0xFE14, 0xFE14, "SML file without close"},

  {0xFE15, 0xFE15, "busy, response cannot be sent"},

  {0,0, NULL}

};

static const range_string bools[]={

  {0x00, 0x00, "false"},

  {0x01, 0xFF, "true"},

  {0,0, NULL}

};

/* Initialize the subtree pointers */

static int ett_sml;

static int ett_sml_mainlist;

static int ett_sml_version;

static int ett_sml_sublist;

static int ett_sml_trans;

static int ett_sml_group;

static int ett_sml_abort;

static int ett_sml_body;

static int ett_sml_mblist;

static int ett_sml_mttree;

static int ett_sml_crc16;

static int ett_sml_clientId;

static int ett_sml_codepage;

static int ett_sml_reqFileId;

static int ett_sml_serverId;

static int ett_sml_username;

static int ett_sml_password;

static int ett_sml_smlVersion;

static int ett_sml_listName;

static int ett_sml_globalSignature;

static int ett_sml_refTime;

static int ett_sml_actSensorTime;

static int ett_sml_timetype;

static int ett_sml_time;

static int ett_sml_valList;

static int ett_sml_listEntry;

static int ett_sml_objName;

static int ett_sml_status;

static int ett_sml_valTime;

static int ett_sml_unit;

static int ett_sml_scaler;

static int ett_sml_value;

static int ett_sml_simplevalue;

static int ett_sml_valueSignature;

static int ett_sml_listSignature;

static int ett_sml_valtree;

static int ett_sml_actGatewayTime;

static int ett_sml_treepath;

static int ett_sml_parameterTreePath;

static int ett_sml_attribute;

static int ett_sml_parameterTree;

static int ett_sml_parameterName;

static int ett_sml_child;

static int ett_sml_periodEntry;

static int ett_sml_procParValue;

static int ett_sml_procParValueTime;

static int ett_sml_procParValuetype;

static int ett_sml_msgend;

static int ett_sml_tuple;

static int ett_sml_secIndex;

static int ett_sml_timestamp;

static int ett_sml_localTimestamp;

static int ett_sml_localOffset;

static int ett_sml_seasonTimeOffset;

static int ett_sml_signature;

static int ett_sml_attentionNo;

static int ett_sml_attentionMsg;

static int ett_sml_withRawdata;

static int ett_sml_beginTime;

static int ett_sml_endTime;

static int ett_sml_object_list;

static int ett_sml_object_list_Entry;

static int ett_sml_actTime;

static int ett_sml_regPeriod;

static int ett_sml_rawdata;

static int ett_sml_periodSignature;

static int ett_sml_period_List_Entry;

static int ett_sml_periodList;

static int ett_sml_headerList;

static int ett_sml_header_List_Entry;

static int ett_sml_profileSignature;

static int ett_sml_valuelist;

static int ett_sml_value_List_Entry;

static int ett_sml_signature_mA_R2_R3;

static int ett_sml_signature_pA_R1_R4;

static int ett_sml_unit_mA;

static int ett_sml_scaler_mA;

static int ett_sml_value_mA;

static int ett_sml_unit_pA;

static int ett_sml_scaler_pA;

static int ett_sml_value_pA;

static int ett_sml_unit_R1;

static int ett_sml_scaler_R1;

static int ett_sml_value_R1;

static int ett_sml_unit_R2;

static int ett_sml_scaler_R2;

static int ett_sml_value_R2;

static int ett_sml_unit_R3;

static int ett_sml_scaler_R3;

static int ett_sml_value_R3;

static int ett_sml_unit_R4;

static int ett_sml_scaler_R4;

static int ett_sml_value_R4;

static int ett_sml_tree_Entry;

static int ett_sml_dasDetails;

static int ett_sml_attentionDetails;

static int ett_sml_listtypetype;

static int ett_sml_listtype;

static int ett_sml_timestampedvaluetype;

static int ett_sml_timestampedvalue;

static int ett_sml_cosemvaluetype;

static int ett_sml_cosemvalue;

static int ett_sml_scaler_unit;

static expert_field ei_sml_messagetype_unknown;

static expert_field ei_sml_procParValue_errror;

static expert_field ei_sml_procParValue_invalid;

static expert_field ei_sml_segment_needed;

static expert_field ei_sml_endOfSmlMsg;

static expert_field ei_sml_crc_error;

static expert_field ei_sml_tuple_error;

static expert_field ei_sml_crc_error_length;

static expert_field ei_sml_invalid_count;

static expert_field ei_sml_MessageBody;

static expert_field ei_sml_esc_error;

static expert_field ei_sml_version2_not_supported;

static expert_field ei_sml_attentionNo;

static expert_field ei_sml_listtype_invalid;

static expert_field ei_sml_cosemvalue_invalid;

/*options*/

static bool sml_reassemble = true;

static bool sml_crc_enabled;

/*get number of length octets and calculate how many data octets, it's like BER but not the same! */

static void get_length(tvbuff_t *tvb, const unsigned *offset, unsigned *data, unsigned *length){

  unsigned check = 0;

  unsigned temp_offset = 0;

  temp_offset = *offset;

  *data = 0;

  *length = 0;

  check = tvb_get_uint8(tvb, temp_offset);

  if (check == OPTIONAL){

    *length = 1;

  }

  else if ((check & 0x80) == MSB){

    while ((check & 0x80) == MSB){

      check = check & 0x0F;

      *data = *data + check;

      *data <<= 4;

      *length+=1;

      temp_offset+=1;

      check = tvb_get_uint8(tvb, temp_offset);

    }

    check = check & 0x0F;

    *data = *data + check;

    *length+=1;

    *data = *data - *length;

  }

  else{

    check = check & 0x0F;

    *length+=1;

    *data = check - *length;

  }

}

/*often used fields*/

static void field_scaler(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length);

static void field_unit(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length);

static void field_status(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length);

static void sml_time_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *SML_time_tree, unsigned *offset);

static void sml_simplevalue(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *value = NULL;

  proto_tree *value_tree = NULL;

  get_length(tvb, offset, data, length);

  value = proto_tree_add_bytes_format(insert_tree, hf_sml_simplevalue, tvb, *offset, *length + *data, NULL, "value %s", (*data == 0) ? ": NOT SET" : "");

  if (tvb_get_uint8(tvb, *offset) != OPTIONAL){

    value_tree = proto_item_add_subtree(value, ett_sml_simplevalue);

    if ((tvb_get_uint8(tvb, *offset) & 0x80) == MSB || (tvb_get_uint8(tvb, *offset) & 0xF0) == 0){

      proto_tree_add_uint(value_tree, hf_sml_length, tvb, *offset, *length, *data);

      *offset += *length;

    }

    else {

      proto_tree_add_item(value_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

    }

    proto_tree_add_item(value_tree, hf_sml_simplevalue, tvb, *offset, *data, ENC_NA);

    *offset += *data;

  }

  else

    *offset += 1;

}

static void sml_timestampedvalue_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *timestampedvalue_tree, unsigned *offset){

  proto_tree *SML_timestampedvalue_type_tree;

  proto_tree *SML_time_tree;

  proto_item *SML_time;

  unsigned data = 0;

  unsigned length = 0;

  SML_timestampedvalue_type_tree = proto_tree_add_subtree(timestampedvalue_tree, tvb, *offset, -1, ett_sml_timestampedvaluetype, NULL, "SML_TimestampedValue Type");

  /*smlTime*/

  SML_time_tree = proto_tree_add_subtree(SML_timestampedvalue_type_tree, tvb, *offset, -1, ett_sml_time, &SML_time, "smlTime");

  *offset += 1;

  sml_time_type(tvb, pinfo, SML_time_tree, offset);

  proto_item_set_end(SML_time, tvb, *offset);

  /*status*/

  field_status(tvb, SML_timestampedvalue_type_tree, offset, &data, &length);

  /*simpleValue*/

  sml_simplevalue(tvb, SML_timestampedvalue_type_tree, offset, &data, &length);

}

static void sml_cosem_scaler_unit_type(tvbuff_t *tvb, proto_tree *cosem_scaler_unit_tree, unsigned *offset){

  unsigned data, length;

  /*scaler*/

  get_length(tvb, offset, &data, &length);

  field_scaler(tvb, cosem_scaler_unit_tree, offset, &data, &length);

  /*unit*/

  get_length(tvb, offset, &data, &length);

  field_unit(tvb, cosem_scaler_unit_tree, offset, &data, &length);

}

static void sml_cosemvalue_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *cosemvalue_tree, unsigned *offset){

  unsigned check = 0;

  proto_item *SML_cosem_scaler_unit;

  proto_tree *SML_cosemvalue_type_tree;

  proto_tree *SML_cosem_scaler_unit_tree;

  SML_cosemvalue_type_tree = proto_tree_add_subtree(cosemvalue_tree, tvb, *offset, -1, ett_sml_cosemvaluetype, NULL, "SML_CosemValue Type");

  proto_tree_add_item(SML_cosemvalue_type_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

  *offset += 1;

  proto_tree_add_item(SML_cosemvalue_type_tree, hf_sml_cosemvalue, tvb, *offset, 1, ENC_BIG_ENDIAN);

  check = tvb_get_uint8(tvb, *offset);

  *offset += 1;

  switch (check) {

    case COSEMVALUE_SCALER_UNIT:

      /*scaler_unit*/

      SML_cosem_scaler_unit_tree = proto_tree_add_subtree(SML_cosemvalue_type_tree, tvb, *offset, -1, ett_sml_scaler_unit, &SML_cosem_scaler_unit, "CosemScalerUnit");

      *offset += 1;

      sml_cosem_scaler_unit_type(tvb, SML_cosem_scaler_unit_tree, offset);

      break;

    default:

      expert_add_info(pinfo, SML_cosemvalue_type_tree, &ei_sml_cosemvalue_invalid);

      break;

  }

}

static void sml_listtype_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *listtype_tree, unsigned *offset){

  unsigned check = 0;

  proto_tree *SML_listtype_type_tree;

  proto_item *SML_time;

  proto_tree *SML_time_tree = NULL;

  proto_item *SML_timestampedvalue;

  proto_tree *SML_timestampedvalue_tree = NULL;

  proto_item *SML_cosemvalue;

  proto_tree *SML_cosemvalue_tree = NULL;

  SML_listtype_type_tree = proto_tree_add_subtree(listtype_tree, tvb, *offset, -1, ett_sml_listtypetype, NULL, "SML_ListType Type");

  proto_tree_add_item(SML_listtype_type_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

  *offset += 1;

  proto_tree_add_item(SML_listtype_type_tree, hf_sml_listtype, tvb, *offset, 1, ENC_BIG_ENDIAN);

  *offset += 1;

  check = tvb_get_uint8(tvb, *offset);

  *offset += 1;

  switch (check) {

    case LISTTYPE_TIME:

      /*smlTime*/

      SML_time_tree = proto_tree_add_subtree(SML_listtype_type_tree, tvb, *offset, -1, ett_sml_time, &SML_time, "Time");

      *offset += 1;

      sml_time_type(tvb, pinfo, SML_time_tree, offset);

      proto_item_set_end(SML_time, tvb, *offset);

      break;

    case LISTTYPE_TIMESTAMPEDVALUE:

      /*smlTimestampedValue*/

      SML_timestampedvalue_tree = proto_tree_add_subtree(SML_listtype_type_tree, tvb, *offset, -1, ett_sml_timestampedvalue, &SML_timestampedvalue, "TimestampedValue");

      *offset += 1;

      sml_timestampedvalue_type(tvb, pinfo, SML_timestampedvalue_tree, offset);

      proto_item_set_end(SML_timestampedvalue, tvb, *offset);

      break;

    case LISTTYPE_COSEMVALUE:

      /*smlCosemValue*/

      SML_cosemvalue_tree = proto_tree_add_subtree(SML_listtype_type_tree, tvb, *offset, -1, ett_sml_cosemvalue, &SML_cosemvalue, "CosemValue");

      *offset += 1;

      sml_cosemvalue_type(tvb, pinfo, SML_cosemvalue_tree, offset);

      break;

    default:

      expert_add_info(pinfo, SML_listtype_type_tree, &ei_sml_listtype_invalid);

      break;

  }

}

static void sml_value(tvbuff_t *tvb, packet_info *pinfo, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *value = NULL;

  proto_tree *value_tree = NULL;

  get_length(tvb, offset, data, length);

  value = proto_tree_add_bytes_format (insert_tree, hf_sml_value, tvb, *offset, *length + *data, NULL,"value %s", (*data == 0)? ": NOT SET" : "");

  if (tvb_get_uint8(tvb, *offset) != OPTIONAL){

    value_tree = proto_item_add_subtree (value, ett_sml_value);

    if (tvb_get_uint8(tvb, *offset) == 0x72) {

      sml_listtype_type(tvb, pinfo, value_tree, offset);

    }

    else

    {

      if ((tvb_get_uint8(tvb, *offset) & 0x80) == MSB || (tvb_get_uint8(tvb, *offset) & 0xF0) == 0){

        proto_tree_add_uint(value_tree, hf_sml_length, tvb, *offset, *length, *data);

        *offset+= *length;

      }

      else {

        proto_tree_add_item (value_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

        *offset+=1;

      }

      proto_tree_add_item (value_tree, hf_sml_value, tvb, *offset, *data, ENC_NA);

      *offset+= *data;

    }

  }

  else

    *offset+=1;

}

static void sml_time_type(tvbuff_t *tvb, packet_info *pinfo, proto_tree *SML_time_tree, unsigned *offset){

  unsigned check = 0;

  proto_tree *timetype_tree;

  proto_tree *timevalue_tree;

  proto_tree *localtimestamptype_tree;

  unsigned data = 0;

  unsigned length = 0;

  timetype_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, 2, ett_sml_timetype, NULL, "SML-Time Type");

  proto_tree_add_item (timetype_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

  *offset+=1;

  proto_tree_add_item (timetype_tree, hf_sml_timetype, tvb, *offset, 1, ENC_BIG_ENDIAN);

  //*offset+=1;

  check = tvb_get_uint8(tvb, *offset);

  *offset += 1;

  switch (check) {

    case TIME_SECINDEX:

      /*secIndex*/

      get_length(tvb, offset, &data, &length);

      timevalue_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_secIndex, NULL, "secIndex");

      proto_tree_add_item(timevalue_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

      proto_tree_add_item(timevalue_tree, hf_sml_secIndex, tvb, *offset, data, ENC_BIG_ENDIAN);

      *offset += data;

      break;

    case TIME_TIMESTAMP:

      /*timestamp*/

      get_length(tvb, offset, &data, &length);

      timevalue_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_timestamp, NULL, "timestamp");

      proto_tree_add_item(timevalue_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

      proto_tree_add_item(timevalue_tree, hf_sml_timestamp, tvb, *offset, data, ENC_BIG_ENDIAN);

      *offset += data;

      break;

    case TIME_LOCALTIMESTAMP:

      /*localTimestamp*/

      localtimestamptype_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_localTimestamp, NULL, "localTimestamp");

      *offset += 1;

      get_length(tvb, offset, &data, &length);

      timevalue_tree = proto_tree_add_subtree(localtimestamptype_tree, tvb, *offset, length + data, ett_sml_timestamp, NULL, "timestamp");

      proto_tree_add_item(timevalue_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

      proto_tree_add_item(timevalue_tree, hf_sml_timestamp, tvb, *offset, data, ENC_BIG_ENDIAN);

      *offset += data;

      get_length(tvb, offset, &data, &length);

      timevalue_tree = proto_tree_add_subtree(localtimestamptype_tree, tvb, *offset, length + data, ett_sml_localOffset, NULL, "localOffset");

      proto_tree_add_item(timevalue_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

      proto_tree_add_item(timevalue_tree, hf_sml_localOffset, tvb, *offset, data, ENC_BIG_ENDIAN);

      *offset += data;

      get_length(tvb, offset, &data, &length);

      timevalue_tree = proto_tree_add_subtree(localtimestamptype_tree, tvb, *offset, length + data, ett_sml_seasonTimeOffset, NULL, "seasonTimeOffset");

      proto_tree_add_item(timevalue_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

      *offset += 1;

      proto_tree_add_item(timevalue_tree, hf_sml_seasonTimeOffset, tvb, *offset, data, ENC_BIG_ENDIAN);

      *offset += data;

      break;

    default:

      expert_add_info(pinfo, timetype_tree, &ei_sml_listtype_invalid);

      break;

  }

}

static void field_codepage(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *codepage = NULL;

  proto_tree *codepage_tree = NULL;

  get_length(tvb, offset, data, length);

  codepage = proto_tree_add_bytes_format (insert_tree, hf_sml_codepage, tvb, *offset, *length + *data, NULL,"Codepage %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0) {

    codepage_tree = proto_item_add_subtree (codepage , ett_sml_codepage);

    proto_tree_add_uint(codepage_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+= *length;

    proto_tree_add_item (codepage_tree, hf_sml_codepage, tvb, *offset, *data, ENC_NA);

    *offset+= *data;

  }

  else

    *offset+=1;

}

static void field_clientId(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *clientId = NULL;

  proto_tree *clientId_tree = NULL;

  get_length(tvb, offset, data, length);

  clientId = proto_tree_add_bytes_format (insert_tree, hf_sml_clientId, tvb, *offset, *length + *data, NULL, "clientID %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0) {

    clientId_tree = proto_item_add_subtree (clientId, ett_sml_clientId);

    proto_tree_add_uint(clientId_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (clientId_tree, hf_sml_clientId, tvb, *offset, *data, ENC_NA);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_reqFileId(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_tree *reqFileId_tree;

  get_length(tvb, offset, data, length);

  reqFileId_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_reqFileId, NULL, "reqFileId");

  proto_tree_add_uint (reqFileId_tree, hf_sml_length, tvb, *offset, *length, *data);

  *offset+=*length;

  proto_tree_add_item (reqFileId_tree, hf_sml_reqFileId, tvb, *offset, *data, ENC_NA);

  *offset+=*data;

}

static void field_serverId(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *serverId = NULL;

  proto_tree *serverId_tree = NULL;

  /*Server ID OPTIONAL*/

  get_length(tvb, offset, data, length);

  serverId = proto_tree_add_bytes_format (insert_tree,hf_sml_serverId, tvb, *offset, *length + *data, NULL, "Server ID %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    serverId_tree = proto_item_add_subtree (serverId , ett_sml_serverId);

    proto_tree_add_uint (serverId_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (serverId_tree, hf_sml_serverId, tvb, *offset, *data, ENC_NA);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_username(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *username = NULL;

  proto_tree *username_tree = NULL;

  /*Username OPTIONAL*/

  get_length(tvb, offset, data, length);

  username = proto_tree_add_string_format (insert_tree,hf_sml_username, tvb, *offset, *length + *data, NULL, "Username %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    username_tree = proto_item_add_subtree (username , ett_sml_username);

    proto_tree_add_uint (username_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (username_tree, hf_sml_username, tvb, *offset, *data, ENC_ASCII | ENC_BIG_ENDIAN);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_password(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *password = NULL;

  proto_tree *password_tree = NULL;

  /*Password OPTIONAL*/

  get_length(tvb, offset, data, length);

  password = proto_tree_add_string_format (insert_tree,hf_sml_password, tvb, *offset, *length + *data, NULL, "Password %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0) {

    password_tree = proto_item_add_subtree (password, ett_sml_password);

    proto_tree_add_uint (password_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (password_tree, hf_sml_password, tvb, *offset, *data, ENC_ASCII | ENC_BIG_ENDIAN);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_smlVersion(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *smlVersion = NULL;

  proto_tree *smlVersion_tree = NULL;

  /*sml-Version OPTIONAL*/

  get_length(tvb, offset, data, length);

  smlVersion = proto_tree_add_uint_format (insert_tree, hf_sml_smlVersion, tvb, *offset, *length + *data, *length + *data, "SML-Version %s", (*data == 0)? ": Version 1" : "");

  if (*data > 0) {

    smlVersion_tree = proto_item_add_subtree (smlVersion, ett_sml_smlVersion);

    proto_tree_add_item (smlVersion_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

    proto_tree_add_item (smlVersion_tree, hf_sml_smlVersion, tvb, *offset, 1,ENC_BIG_ENDIAN);

    *offset+=1;

  }

  else

    *offset+=1;

}

static void field_globalSignature(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *globalSignature = NULL;

  proto_tree *globalSignature_tree = NULL;

  /*Global Signature OPTIONAL*/

  get_length(tvb, offset, data, length);

  globalSignature = proto_tree_add_bytes_format (insert_tree, hf_sml_globalSignature, tvb, *offset, *length + *data, NULL, "global Signature %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    globalSignature_tree = proto_item_add_subtree (globalSignature, ett_sml_globalSignature);

    proto_tree_add_uint (globalSignature_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (globalSignature_tree, hf_sml_globalSignature, tvb, *offset, *data, ENC_NA);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_listName(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *listName = NULL;

  proto_tree *listName_tree = NULL;

  /*List Name OPTIONAL*/

  get_length(tvb, offset, data, length);

  listName = proto_tree_add_bytes_format (insert_tree,hf_sml_listName, tvb, *offset, *length + *data, NULL, "List Name %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0) {

    listName_tree = proto_item_add_subtree (listName, ett_sml_listName);

    proto_tree_add_uint (listName_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (listName_tree, hf_sml_listName, tvb, *offset, *data, ENC_NA);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_objName(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_tree *objName_tree;

  /*Objectname*/

  get_length(tvb, offset, data, length);

  objName_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_objName, NULL, "Objectname");

  proto_tree_add_uint (objName_tree, hf_sml_length, tvb, *offset, *length, *data);

  *offset+=*length;

  proto_tree_add_item (objName_tree, hf_sml_objName, tvb, *offset, *data, ENC_NA);

  *offset+=*data;

}

static void field_status(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_tree *status_tree = NULL;

  get_length(tvb, offset, data, length);

  status_tree = proto_tree_add_subtree_format(insert_tree, tvb, *offset, *length + *data,

            ett_sml_status, NULL, "status %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    proto_tree_add_item (status_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

    proto_tree_add_item (status_tree, hf_sml_status, tvb, *offset, *data, ENC_BIG_ENDIAN);

    *offset+= *data;

  }

  else

    *offset+=1;

}

static void field_unit(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *unit = NULL;

  proto_tree *unit_tree = NULL;

  /*unit OPTIONAL*/

  get_length(tvb, offset, data, length);

  unit = proto_tree_add_uint_format (insert_tree, hf_sml_unit, tvb, *offset, *length + *data, *length + *data, "Unit %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0) {

    unit_tree = proto_item_add_subtree (unit, ett_sml_unit);

    proto_tree_add_item (unit_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

    proto_tree_add_item(unit_tree, hf_sml_unit, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

  }

  else

    *offset+=1;

}

static void field_scaler(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *scaler = NULL;

  proto_tree *scaler_tree = NULL;

  /*Scaler OPTIONAL*/

  get_length(tvb, offset, data, length);

  scaler = proto_tree_add_uint_format (insert_tree, hf_sml_scaler, tvb, *offset, *length + *data, *length + *data, "Scaler %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    scaler_tree = proto_item_add_subtree (scaler, ett_sml_scaler);

    proto_tree_add_item (scaler_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

    proto_tree_add_item(scaler_tree, hf_sml_scaler, tvb, *offset, 1, ENC_BIG_ENDIAN);

    *offset+=1;

  }

  else

    *offset+=1;

}

static void field_valueSignature(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *valueSignature = NULL;

  proto_tree *valueSignature_tree = NULL;

  /*value Signature*/

  get_length(tvb, offset, data, length);

  valueSignature = proto_tree_add_bytes_format (insert_tree, hf_sml_valueSignature, tvb, *offset, *length + *data, NULL, "ValueSignature %s", (*data == 0)? ": NOT SET" : "");

  if (*data > 0){

    valueSignature_tree = proto_item_add_subtree (valueSignature, ett_sml_valueSignature);

    proto_tree_add_uint (valueSignature_tree, hf_sml_length, tvb, *offset, *length, *data);

    *offset+=*length;

    proto_tree_add_item (valueSignature_tree, hf_sml_valueSignature, tvb, *offset, *data, ENC_NA);

    *offset+=*data;

  }

  else

    *offset+=1;

}

static void field_parameterTreePath(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_item *parameterTreePath = NULL;

  proto_tree *parameterTreePath_tree = NULL;

  /*parameterTreePath*/

  get_length(tvb, offset, data, length);

  parameterTreePath = proto_tree_add_bytes_format (insert_tree, hf_sml_parameterTreePath, tvb, *offset, *length + *data, NULL, "path_Entry %s", (*data == 0)? ": NOT SET" : "");

  parameterTreePath_tree = proto_item_add_subtree (parameterTreePath, ett_sml_parameterTreePath);

  proto_tree_add_uint (parameterTreePath_tree, hf_sml_length, tvb, *offset, *length, *data);

  *offset+=*length;

  proto_tree_add_item (parameterTreePath_tree, hf_sml_parameterTreePath, tvb, *offset, *data, ENC_NA);

  *offset+=*data;

}

static void field_ObjReqEntry(tvbuff_t *tvb, proto_tree *insert_tree, unsigned *offset, unsigned *data, unsigned *length){

  proto_tree *object_list_Entry_tree;

  /*parameterTreePath*/