/* packet-ositp.c

 * Routines for ISO/OSI transport protocol (connection-oriented

 * and connectionless) packet disassembly

 *

 * Laurent Deniel <laurent.deniel@free.fr>

 * Ralf Schneider <Ralf.Schneider@t-online.de>

 *

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

#include <epan/conversation.h>

#include <epan/expert.h>

#include <epan/proto_data.h>

#include <epan/tfs.h>

#include <epan/iana-info.h>

#include <wsutil/array.h>

#include <wsutil/str_util.h>

#include "packet-frame.h"

#include "packet-osi.h"

void proto_register_cotp(void);

void proto_register_cltp(void);

void proto_reg_handoff_cotp(void);

/* protocols and fields */

static int  proto_clnp;

static int  proto_cotp;

static int ett_cotp;

static int ett_cotp_segments;

static int ett_cotp_segment;

static int hf_cotp_li;

static int hf_cotp_type;

static int hf_cotp_srcref;

static int hf_cotp_destref;

static int hf_cotp_class;

static int hf_cotp_opts_extended_formats;

static int hf_cotp_opts_no_explicit_flow_control;

static int hf_cotp_tpdu_number;

static int hf_cotp_tpdu_number_extended;

static int hf_cotp_next_tpdu_number;

static int hf_cotp_next_tpdu_number_extended;

static int hf_cotp_eot;

static int hf_cotp_eot_extended;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_cotp_parameter_code;

static int hf_cotp_parameter_length;

static int hf_cotp_parameter_value;

static int hf_cotp_atn_extended_checksum16;

static int hf_cotp_atn_extended_checksum32;

static int hf_cotp_atn_extended_checksum_status;

static int hf_cotp_ack_time;

static int hf_cotp_res_error_rate_target_value;

static int hf_cotp_res_error_rate_min_accept;

static int hf_cotp_res_error_rate_tdsu;

static int hf_cotp_vp_priority;

static int hf_cotp_transit_delay_targ_calling_called;

static int hf_cotp_transit_delay_max_accept_calling_called;

static int hf_cotp_transit_delay_targ_called_calling;

static int hf_cotp_transit_delay_max_accept_called_calling;

static int hf_cotp_max_throughput_targ_calling_called;

static int hf_cotp_max_throughput_min_accept_calling_called;

static int hf_cotp_max_throughput_targ_called_calling;

static int hf_cotp_max_throughput_min_accept_called_calling;

static int hf_cotp_avg_throughput_targ_calling_called;

static int hf_cotp_avg_throughput_min_accept_calling_called;

static int hf_cotp_avg_throughput_targ_called_calling;

static int hf_cotp_avg_throughput_min_accept_called_calling;

static int hf_cotp_sequence_number;

static int hf_cotp_reassignment_time;

static int hf_cotp_lower_window_edge;

static int hf_cotp_credit;

static int hf_cotp_tpdu_size;

static int hf_cotp_checksum;

static int hf_cotp_checksum_status;

static int hf_cotp_vp_version_nr;

static int hf_cotp_network_expedited_data;

static int hf_cotp_vp_opt_sel_class1_use;

static int hf_cotp_use_16_bit_checksum;

static int hf_cotp_transport_expedited_data_transfer;

static int hf_cotp_preferred_maximum_tpdu_size;

static int hf_cotp_inactivity_timer;

static int hf_cotp_cause;

static int hf_cotp_segment_data;

static int hf_cotp_credit_cdt;

static int hf_cotp_reject_cause;

static int hf_cotp_segments;

static int hf_cotp_segment;

static int hf_cotp_segment_overlap;

static int hf_cotp_segment_overlap_conflict;

static int hf_cotp_segment_multiple_tails;

static int hf_cotp_segment_too_long_segment;

static int hf_cotp_segment_error;

static int hf_cotp_segment_count;

static int hf_cotp_reassembled_in;

static int hf_cotp_reassembled_length;

static expert_field ei_cotp_disconnect_confirm;

static expert_field ei_cotp_multiple_tpdus;

static expert_field ei_cotp_reject;

static expert_field ei_cotp_connection;

static expert_field ei_cotp_disconnect_request;

static expert_field ei_cotp_preferred_maximum_tpdu_size;

static expert_field ei_cotp_atn_extended_checksum;

static expert_field ei_cotp_checksum;

static int  proto_cltp;

static int ett_cltp;

static int hf_cltp_li;

static int hf_cltp_type;

static const fragment_items cotp_frag_items = {

  &ett_cotp_segment,

  &ett_cotp_segments,

  &hf_cotp_segments,

  &hf_cotp_segment,

  &hf_cotp_segment_overlap,

  &hf_cotp_segment_overlap_conflict,

  &hf_cotp_segment_multiple_tails,

  &hf_cotp_segment_too_long_segment,

  &hf_cotp_segment_error,

  &hf_cotp_segment_count,

  &hf_cotp_reassembled_in,

  &hf_cotp_reassembled_length,

  /* Reassembled data field */

  NULL,

  "segments"

};

static dissector_handle_t rdp_cr_handle;

static dissector_handle_t rdp_cc_handle;

static dissector_handle_t ositp_handle;

/*

 * ISO8073 OSI COTP definition

 * See http://standards.iso.org/ittf/PubliclyAvailableStandards/index.html

 * (or RFC905 for historic, and now-outdated information)

 */

/* don't use specific TPDU types to avoid alignment problems & copy overhead */

/* TPDU definition */

#define ED_TPDU             0x1 /* COTP */

#define EA_TPDU             0x2 /* COTP */

#define UD_TPDU             0x4 /* CLTP */

#define RJ_TPDU             0x5 /* COTP */

#define AK_TPDU             0x6 /* COTP */

#define ER_TPDU             0x7 /* COTP */

#define DR_TPDU             0x8 /* COTP */

#define DC_TPDU             0xC /* COTP */

#define CC_TPDU             0xD /* COTP */

#define CR_TPDU             0xE /* COTP */

#define DT_TPDU             0xF /* COTP */

static const value_string cotp_tpdu_type_abbrev_vals[] = {

  { ED_TPDU, "ED Expedited Data" },

  { EA_TPDU, "EA Expedited Data Acknowledgement" },

  { RJ_TPDU, "RJ Reject" },

  { AK_TPDU, "AK Data Acknowledgement" },

  { ER_TPDU, "ER TPDU Error" },

  { DR_TPDU, "DR Disconnect Request" },

  { DC_TPDU, "DC Disconnect Confirm" },

  { CC_TPDU, "CC Connect Confirm" },

  { CR_TPDU, "CR Connect Request" },

  { DT_TPDU, "DT Data" },

  { 0,       NULL }

};

static const value_string cltp_tpdu_type_abbrev_vals[] = {

  { UD_TPDU, "UD" },

  { 0,       NULL }

};

#if 0

static const value_string class_option_vals[] = {

  {0, "Class 0"},

  {1, "Class 1"},

  {2, "Class 2"},

  {3, "Class 3"},

  {4, "Class 4"},

  {0, NULL}

};

#endif

/* field position */

#define P_LI                0

#define P_TPDU              1

#define P_CDT               1

#define P_DST_REF           2

#define P_SRC_REF           4

#define P_TPDU_NR_0_1       2

#define P_TPDU_NR_234       4

#define P_VAR_PART_NDT      5

#define P_VAR_PART_EDT      8

#define P_VAR_PART_DC       6

#define P_CDT_IN_AK         8

#define P_CDT_IN_RJ         8

#define P_REJECT_ER         4

#define P_REASON_IN_DR      6

#define P_CLASS_OPTION      6

/*

 * TPDU length indicator values.

 * Checksum parameter is 4 octets - 1 octet of parameter code, 1 octet

 * of parameter length, 2 octets of checksum.

 */

#define LI_NORMAL_DT_CLASS_01           2

#define LI_NORMAL_DT_WITHOUT_CHECKSUM   4

#define LI_NORMAL_DT_WITH_CHECKSUM      (LI_NORMAL_DT_WITHOUT_CHECKSUM+4)

#define LI_EXTENDED_DT_WITHOUT_CHECKSUM 7

#define LI_EXTENDED_DT_WITH_CHECKSUM    (LI_EXTENDED_DT_WITHOUT_CHECKSUM+4)

#define LI_NORMAL_EA_WITHOUT_CHECKSUM   4

#define LI_NORMAL_EA_WITH_CHECKSUM      (LI_NORMAL_EA_WITHOUT_CHECKSUM+4)

#define LI_EXTENDED_EA_WITHOUT_CHECKSUM 7

#define LI_EXTENDED_EA_WITH_CHECKSUM    (LI_EXTENDED_EA_WITHOUT_CHECKSUM+4)

#define LI_NORMAL_RJ                    4

#define LI_EXTENDED_RJ                  9

#define LI_MIN_DR                       6

#define LI_MAX_DC                       9

#define LI_MAX_AK                       27

#define LI_MAX_EA                       11

#define LI_MAX_ER                       8

/* XXX - can we always decide this based on whether the length

   indicator is odd or not?  What if the variable part has an odd

   number of octets? */

#define is_LI_NORMAL_AK(p)               ((p & 0x01) == 0)

/*

 * Modified TPDU length indicator values due to ATN 4-octet extended

 * checksum.

 * Checksum parameter is 6 octets - 1 octet of parameter code, 1 octet

 * of parameter length, 4 octets of checksum.  That adds 2 octets to

 * the lengths with a 2-octet checksum.

 */

#define LI_ATN_NORMAL_DT_WITH_CHECKSUM       (LI_NORMAL_DT_WITH_CHECKSUM+2)

#define LI_ATN_EXTENDED_DT_WITH_CHECKSUM     (LI_EXTENDED_DT_WITH_CHECKSUM+2)

#define LI_ATN_NORMAL_EA_WITH_CHECKSUM       (LI_NORMAL_EA_WITH_CHECKSUM+2)

#define LI_ATN_EXTENDED_EA_WITH_CHECKSUM     (LI_EXTENDED_EA_WITH_CHECKSUM+2)

#define LI_ATN_NORMAL_RJ                     (LI_NORMAL_RJ+2)

#define LI_ATN_EXTENDED_RJ                   (LI_EXTENDED_RJ+2)

#define LI_ATN_MAX_DC                        (LI_MAX_DC+2)

#define LI_ATN_MAX_AK                        (LI_MAX_AK+2+1) /* +1 for padding? */

#define LI_ATN_MAX_EA                        (LI_MAX_EA+2)

#define LI_ATN_MAX_ER                        (LI_MAX_ER+2)

/* variant part */

#define VP_ACK_TIME             0x85

#define VP_RES_ERROR            0x86

#define VP_PRIORITY             0x87

#define VP_TRANSIT_DEL          0x88

#define VP_THROUGHPUT           0x89

#define VP_SEQ_NR               0x8A        /* in AK */

#define VP_REASSIGNMENT         0x8B

#define VP_FLOW_CNTL            0x8C        /* in AK */

#define VP_TPDU_SIZE            0xC0

#define VP_SRC_TSAP             0xC1        /* in CR/CC */

#define VP_DST_TSAP             0xC2

#define VP_CHECKSUM             0xC3

#define VP_VERSION_NR           0xC4

#define VP_PROTECTION           0xC5

#define VP_OPT_SEL              0xC6

#define VP_PROTO_CLASS          0xC7

#define VP_CLEARING_INFO        0xE0        /* in DR */

#define VP_PREF_MAX_TPDU_SIZE   0xF0

#define VP_INACTIVITY_TIMER     0xF2

/* ATN */

/* Parameter codes with bits 7 and 8 are explicitly not */

/* assigned by ISO/IEC 8073, nor is their use precluded. */

/* Parameter codes for ATN defined in ICAO doc 9507 Ed3 SV 5 section 5.5.2.4.3.1 */

#define VP_ATN_EC_32            0x08        /* 4 octet ATN Extended Transport Checksum parameter */

#define VP_ATN_EC_16            0x09        /* 2 octet ATN Extended Transport Checksum parameter */

/* ATN end */

static const value_string tp_vpart_type_vals[] = {

  { VP_ATN_EC_16,           "ATN extended checksum - 16 bit" },

  { VP_ATN_EC_32,           "ATN extended checksum - 32 bit" },

  { VP_ACK_TIME,            "ack time" },

  { VP_RES_ERROR,           "res error" },

  { VP_PRIORITY,            "priority" },

  { VP_TRANSIT_DEL,         "transit delay" },

  { VP_THROUGHPUT,          "throughput" },

  { VP_SEQ_NR,              "seq number" },

  { VP_REASSIGNMENT,        "reassignment" },

  { VP_FLOW_CNTL,           "flow control" },

  { VP_TPDU_SIZE,           "tpdu-size" },

  { VP_SRC_TSAP,            "src-tsap" },

  { VP_DST_TSAP,            "dst-tsap" },

  { VP_CHECKSUM,            "checksum" },

  { VP_VERSION_NR,          "version" },

  { VP_PROTECTION,          "protection" },

  { VP_OPT_SEL,             "options" },

  { VP_PROTO_CLASS,         "proto class" },

  { VP_CLEARING_INFO,       "additional connection clearing info" },

  { VP_PREF_MAX_TPDU_SIZE,  "preferred max TPDU size" },

  { VP_INACTIVITY_TIMER,    "inactivity timer" },

  { 0,                      NULL }

};

static int hf_cotp_vp_src_tsap;

static int hf_cotp_vp_dst_tsap;

static int hf_cotp_vp_src_tsap_bytes;

static int hf_cotp_vp_dst_tsap_bytes;

/* global variables */

/* List of dissectors to call for the variable part of CR PDUs. */

static heur_dissector_list_t cotp_cr_heur_subdissector_list;

/* List of dissectors to call for the variable part of CC PDUs. */

static heur_dissector_list_t cotp_cc_heur_subdissector_list;

/* List of dissectors to call for COTP packets put atop the Inactive

   Subset of CLNP. */

static heur_dissector_list_t cotp_is_heur_subdissector_list;

/* List of dissectors to call for COTP packets put atop CLNP */

static heur_dissector_list_t cotp_heur_subdissector_list;

/* List of dissectors to call for CLTP packets put atop CLNP */

static heur_dissector_list_t cltp_heur_subdissector_list;

/*

 * Reassembly of COTP.

 */

static reassembly_table cotp_reassembly_table;

#define TSAP_DISPLAY_AUTO   0

#define TSAP_DISPLAY_STRING 1

#define TSAP_DISPLAY_BYTES  2

/* options */

static bool cotp_reassemble = true;

static int32_t  tsap_display = TSAP_DISPLAY_AUTO;

static bool cotp_decode_atn;

static const enum_val_t tsap_display_options[] = {

  {"auto", "As strings if printable", TSAP_DISPLAY_AUTO},

  {"string", "As strings", TSAP_DISPLAY_STRING},

  {"bytes", "As bytes", TSAP_DISPLAY_BYTES},

  {NULL, NULL, -1}

};

/* function definitions */

#define MAX_TSAP_LEN    32

typedef struct _cotp_flow_info_t {

  uint16_t ref; // The dst-ref of this flow

  uint16_t frag_id;

  bool ref_set; // False if didn't get the CC/CR TPDU

  bool last_fragment;

} cotp_flow_info_t;

typedef struct _cotp_conv_info_t {

  cotp_flow_info_t flow[2];

  cotp_flow_info_t *fwd;

  cotp_flow_info_t *rev;

} cotp_conv_info_t;

static cotp_conv_info_t *get_cotp_conv_info(packet_info *pinfo)

{

  conversation_t *conv;

  cotp_conv_info_t *conv_info;

  int direction;

  conv = find_or_create_conversation(pinfo);

  conv_info = conversation_get_proto_data(conv, proto_cotp);

  if (!conv_info) {

    conv_info = wmem_new0(wmem_file_scope(), cotp_conv_info_t);

    conversation_add_proto_data(conv, proto_cotp, conv_info);

  }

  /* check direction; first compare addreses, then ports. */

  direction = cmp_address(&pinfo->src, &pinfo->dst);

  if (direction==0) {

    direction = (pinfo->srcport > pinfo->destport) ? 1 : -1;

  }

  if (direction >= 0) {

    conv_info->fwd = &(conv_info->flow[0]);

    conv_info->rev = &(conv_info->flow[1]);

  } else {

    conv_info->fwd = &(conv_info->flow[1]);

    conv_info->rev = &(conv_info->flow[0]);

  }

  return conv_info;

}

static uint16_t get_cotp_frag_id(packet_info *pinfo, cotp_flow_info_t *flow_info, bool fragment)

{

  /* When using fragment_add_seq_next and there is a possibility of multiple

   * TSDUs being completed in the same frame, each TSDU needs a unique ID/

   * sequence number in order to properly retrieve the reassembly on the

   * later passes. As COTP Class 0 doesn't provide that, we want to assign

   * our own. If a TSDU doesn't complete in a frame, we need to keep using

   * that ID in subsequent frames with TPDUs from the same conversation until

   * it does. We also need to keep track of that ID in file scoped data so

   * that we have it on the later, not necessarily sequential, passes.

   *

   * Cf. with epan/frame.h and with the streaming_data functions in

   * epan/reassemble.h for other approaches with this same issue. */

  uint16_t           frag_id;

  unsigned           flow_index = 0;

  bool               flow_first_seen = true;

  wmem_list_t       *used_flow_list;

  uint32_t          *prev_dst_ref;

  /* Have we seen this COTP flow before on this frame?

   * Using a list here is a bit of extra work that guards against

   * unusual captures with multiple TCP/TPKT streams on the same

   * frame (e.g., DVB-S2 GSE). */

  used_flow_list = (wmem_list_t *)p_get_proto_data(pinfo->pool, pinfo, proto_cotp, 0);

  if (!used_flow_list) {

    used_flow_list = wmem_list_new(pinfo->pool);

    p_add_proto_data(pinfo->pool, pinfo, proto_cotp, 0, used_flow_list);

  } else {

    if (wmem_list_find(used_flow_list, flow_info)) {

      flow_first_seen = false;

    } else {

      flow_index = wmem_list_count(used_flow_list);

    }

  }

  wmem_list_append(used_flow_list, flow_info);

  if (flow_first_seen) {

    /* If this is the first time this COTP conversation has been

     * seen in this frame on this pass, and last TPDU completed a

     * TSDU, then we can reset the fragment number back to zero.

     * (We don't really have to do this.) */

    if (!flow_info->last_fragment) {

      flow_info->frag_id = 0;

    }

    /* If this is the first sequential pass through the frame, then

     * we save the fragment number for this converation. If not, we

     * restore the conversation fragment number to what it was at

     * this point in the first pass. */

    prev_dst_ref = (uint32_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_cotp, flow_index);

    if (!prev_dst_ref) {

      DISSECTOR_ASSERT(!PINFO_FD_VISITED(pinfo));

      prev_dst_ref = wmem_new(wmem_file_scope(), uint32_t);

      *prev_dst_ref = flow_info->frag_id;

      p_add_proto_data(wmem_file_scope(), pinfo, proto_cotp, flow_index, prev_dst_ref);

    } else {

      flow_info->frag_id = *prev_dst_ref;

    }

  }

  frag_id = flow_info->frag_id;

  /* We update the conversation info frag id even on later passes, so

   * that we only have to store as proto data the first fragment ID

   * for the conversation. */

  flow_info->last_fragment = fragment;

  if (!fragment) {

    flow_info->frag_id++;

  }

  return frag_id;

}

static char *print_tsap(wmem_allocator_t *scope, tvbuff_t *tvb, int offset, int length)

{

  const unsigned char *tsap = tvb_get_ptr(tvb, offset, length);

  char     *cur;

  bool      allprintable;

  int       idx = 0, returned_length;

  cur=(char *)wmem_alloc(scope, MAX_TSAP_LEN * 2 + 3);

  cur[0] = '\0';

  if (length <= 0 || length > MAX_TSAP_LEN)

    snprintf(cur, MAX_TSAP_LEN * 2 + 3, "<unsupported TSAP length>");

  else {

    allprintable = tvb_ascii_isprint(tvb, offset, length);

    if (!allprintable) {

      returned_length = snprintf(cur, MAX_TSAP_LEN * 2 + 3, "0x");

      idx += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - 1);

    }

    while (length != 0) {

      if (allprintable) {

        returned_length = snprintf(&cur[idx], MAX_TSAP_LEN * 2 + 3 - idx,

                                     "%c", *tsap ++);

        idx += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - idx - 1);

      } else {

        returned_length = snprintf(&cur[idx], MAX_TSAP_LEN * 2 + 3 - idx,

                                     "%02x", *tsap ++);

        idx += MIN(returned_length, MAX_TSAP_LEN * 2 + 3 - idx - 1);

      }

      length --;

    }

  }

  return cur;

} /* print_tsap */

static const true_false_string tfs_vp_opt_sel_class1_use = { "Receipt confirmation", "Explicit AK variant" };

static bool ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,

                                      int class_option, int tpdu_len,

                                      packet_info *pinfo, proto_tree *tree)

{

  uint8_t         code, length;

  uint8_t         c1;

  uint16_t        s;

  uint32_t        offset_iso8073_checksum = 0;

  int32_t         i                       = 0;

  uint8_t         tmp_code                = 0;

  unsigned        tmp_len                 = 0;

  uint32_t        pref_max_tpdu_size;

  proto_item     *hidden_item;

  while (vp_length != 0) {

    proto_tree_add_item_ret_uint8(tree, hf_cotp_parameter_code, tvb, offset, 1, ENC_NA, &code);

    offset += 1;

    vp_length -= 1;

    if (vp_length == 0)

      break;

    proto_tree_add_item_ret_uint8(tree, hf_cotp_parameter_length, tvb, offset, 1, ENC_NA, &length);

    offset += 1;

    vp_length -= 1;

    switch (code) {

    case VP_ATN_EC_16 : /* ATN */

      if (cotp_decode_atn) {

        uint16_t sum;

        /* if an alternate OSI checksum is present in the currently unprocessed

         * VP section to the checksum algorithm has to know.

         * this may be the case for backward compatible CR TPDU */

        if (!offset_iso8073_checksum) {

          /* search following parameters in VP part for ISO checksum */

          for (i = offset + length; i < vp_length;) {

            tmp_code = tvb_get_uint8(tvb, i++);

            tmp_len = tvb_get_uint8(tvb, i++);

            if (tmp_code == VP_CHECKSUM) {

              offset_iso8073_checksum = i; /* save ISO 8073 checksum offset for ATN extended checksum calculation */

              break;

            }

            i += tmp_len;

          }

        }

        sum = check_atn_ec_16(tvb, tpdu_len , offset,

                                      offset_iso8073_checksum,

                                      pinfo->dst.len, (const uint8_t *)pinfo->dst.data,

                                      pinfo->src.len, (const uint8_t *)pinfo->src.data);

        proto_tree_add_checksum(tree, tvb, offset, hf_cotp_atn_extended_checksum16, hf_cotp_atn_extended_checksum_status, &ei_cotp_atn_extended_checksum,

                                pinfo, sum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);

      } else {

        proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>");

      }

      offset += length;

      vp_length -= length;

      break;

    case VP_ATN_EC_32 : /* ATN */

      if (cotp_decode_atn) {

        uint32_t sum;

        /* if an alternate OSI checksum is present in the currently unprocessed

         * VP section the checksum algorithm has to know.

         * this may be the case for backward compatible CR TPDU */

        if (!offset_iso8073_checksum) {

          /* search following parameters in VP part for ISO checksum */

          for (i = offset + length; i < vp_length;) {

            tmp_code = tvb_get_uint8(tvb, i++);

            tmp_len = tvb_get_uint8(tvb, i++);

            if (tmp_code == VP_CHECKSUM) {

              offset_iso8073_checksum = i; /* save ISO 8073 checksum offset for ATN extended checksum calculation */

              break;

            }

            i += tmp_len;

          }

        }

        sum = check_atn_ec_32(tvb, tpdu_len , offset,

                                      offset_iso8073_checksum,

                                      pinfo->dst.len, (const uint8_t *)pinfo->dst.data,

                                      pinfo->src.len, (const uint8_t *)pinfo->src.data);

        proto_tree_add_checksum(tree, tvb, offset, hf_cotp_atn_extended_checksum32, hf_cotp_atn_extended_checksum_status, &ei_cotp_atn_extended_checksum,

                                pinfo, sum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);

      } else {

        proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>");

      }

      offset += length;

      vp_length -= length;

      break;

    case VP_ACK_TIME:

      proto_tree_add_item(tree, hf_cotp_ack_time, tvb, offset, length, ENC_BIG_ENDIAN);

      offset += length;

      vp_length -= length;

      break;

    case VP_RES_ERROR:

      s = tvb_get_uint8(tvb, offset);

      proto_tree_add_uint_format_value(tree, hf_cotp_res_error_rate_target_value, tvb, offset, 1, s, "10^%u", s);

      offset += 1;

      vp_length -= 1;

      s = tvb_get_uint8(tvb, offset);

      proto_tree_add_uint_format_value(tree, hf_cotp_res_error_rate_min_accept, tvb, offset, 1, s, "10^%u", s);

      offset += 1;

      vp_length -= 1;

      s = tvb_get_uint8(tvb, offset);

      proto_tree_add_uint_format_value(tree, hf_cotp_res_error_rate_tdsu, tvb, offset, 1, s, "2^%u", s);

      offset += 1;

      vp_length -= 1;

      break;

    case VP_PRIORITY:

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

      offset += length;

      vp_length -= length;

      break;

    case VP_TRANSIT_DEL:

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

      offset += 2;

      vp_length -= 2;

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

      offset += 2;

      vp_length -= 2;

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

      offset += 2;

      vp_length -= 2;

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

      offset += 2;

      vp_length -= 2;

      break;

    case VP_THROUGHPUT:

      proto_tree_add_item(tree, hf_cotp_max_throughput_targ_calling_called, tvb, offset, 3, ENC_BIG_ENDIAN);

      offset += 3;

      length -= 3;

      vp_length -= 3;

      proto_tree_add_item(tree, hf_cotp_max_throughput_min_accept_calling_called, tvb, offset, 3, ENC_BIG_ENDIAN);

      offset += 3;

      length -= 3;

      vp_length -= 3;

      proto_tree_add_item(tree, hf_cotp_max_throughput_targ_called_calling, tvb, offset, 3, ENC_BIG_ENDIAN);

      offset += 3;

      length -= 3;

      vp_length -= 3;

      proto_tree_add_item(tree, hf_cotp_max_throughput_min_accept_called_calling, tvb, offset, 3, ENC_BIG_ENDIAN);

      offset += 3;

      length -= 3;

      vp_length -= 3;

      if (length != 0) {    /* XXX - should be 0 or 12 */

        proto_tree_add_item(tree, hf_cotp_avg_throughput_targ_calling_called, tvb, offset, 3, ENC_BIG_ENDIAN);

        offset += 3;

        vp_length -= 3;

        proto_tree_add_item(tree, hf_cotp_avg_throughput_min_accept_calling_called, tvb, offset, 3, ENC_BIG_ENDIAN);

        offset += 3;

        vp_length -= 3;

        proto_tree_add_item(tree, hf_cotp_avg_throughput_targ_called_calling, tvb, offset, 3, ENC_BIG_ENDIAN);

        offset += 3;

        vp_length -= 3;

        proto_tree_add_item(tree, hf_cotp_avg_throughput_min_accept_called_calling, tvb, offset, 3, ENC_BIG_ENDIAN);

        offset += 3;

        vp_length -= 3;

      }

      break;

    case VP_SEQ_NR:

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

      offset += length;

      vp_length -= length;

      break;

    case VP_REASSIGNMENT:

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

      offset += length;

      vp_length -= length;

      break;

    case VP_FLOW_CNTL:

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

      offset += 4;

      vp_length -= 4;

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

      offset += 2;

      vp_length -= 2;

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

      offset += 2;

      vp_length -= 2;

      break;

    case VP_TPDU_SIZE:

      c1 = tvb_get_uint8(tvb, offset) & 0x0F;

      proto_tree_add_uint(tree, hf_cotp_tpdu_size, tvb, offset, 1, 1 << c1);

      offset += length;

      vp_length -= length;

      break;

    case VP_SRC_TSAP:

      /* if our preference is set to STRING or the TSAP is not printable,

       * add as bytes and hidden as string; otherwise vice-versa */

      if (tsap_display==TSAP_DISPLAY_STRING ||

          (tsap_display==TSAP_DISPLAY_AUTO &&

            tvb_ascii_isprint(tvb, offset, length))) {

        proto_tree_add_string(tree, hf_cotp_vp_src_tsap, tvb, offset, length,

                              print_tsap(pinfo->pool, tvb, offset, length));

        hidden_item = proto_tree_add_item(tree, hf_cotp_vp_src_tsap_bytes, tvb,

                                          offset, length, ENC_NA);

        proto_item_set_hidden(hidden_item);

      } else {

        hidden_item = proto_tree_add_string(tree, hf_cotp_vp_src_tsap, tvb,

                                            offset, length,

                                            print_tsap(pinfo->pool, tvb, offset, length));

        proto_item_set_hidden(hidden_item);

        proto_tree_add_item(tree, hf_cotp_vp_src_tsap_bytes, tvb, offset,

                            length, ENC_NA);

      }

      offset += length;

      vp_length -= length;

      break;

    case VP_DST_TSAP:

      /* if our preference is set to STRING or the TSAP is not printable,

       * add as bytes and hidden as string; otherwise vice-versa */

      if (tsap_display==TSAP_DISPLAY_STRING ||

          (tsap_display==TSAP_DISPLAY_AUTO &&

            tvb_ascii_isprint(tvb, offset, length))) {

        proto_tree_add_string(tree, hf_cotp_vp_dst_tsap, tvb, offset, length,

                              print_tsap(pinfo->pool, tvb, offset, length));

        hidden_item = proto_tree_add_item(tree, hf_cotp_vp_dst_tsap_bytes, tvb,

                                          offset, length, ENC_NA);

        proto_item_set_hidden(hidden_item);

      } else {

        hidden_item = proto_tree_add_string(tree, hf_cotp_vp_dst_tsap, tvb,

                                            offset, length,

                                            print_tsap(pinfo->pool, tvb, offset, length));

        proto_item_set_hidden(hidden_item);

        proto_tree_add_item(tree, hf_cotp_vp_dst_tsap_bytes, tvb, offset,

                            length, ENC_NA);

      }

      offset += length;

      vp_length -= length;

      break;

    case VP_CHECKSUM:

      offset_iso8073_checksum = offset; /* save ISO 8073 checksum offset for ATN extended checksum calculation */

      if (tvb_get_ntohs(tvb, offset) == 0) {

        /* No checksum present */

        proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, hf_cotp_checksum_status, &ei_cotp_checksum, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);

      } else {

        uint32_t calc_c0 = 0, calc_c1 = 0;

        if (osi_calc_checksum(tvb, 0, tpdu_len, &calc_c0, &calc_c1)) {

            /* Successfully processed checksum, verify it */

            proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, hf_cotp_checksum_status, &ei_cotp_checksum, pinfo, calc_c0 | calc_c1, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);

        } else {

            proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, hf_cotp_checksum_status, &ei_cotp_checksum, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);

        }

      }

      offset += length;

      vp_length -= length;

      break;

    case VP_VERSION_NR:

      proto_tree_add_item(tree, hf_cotp_vp_version_nr, tvb, offset, 1, ENC_NA);

      offset += length;

      vp_length -= length;

      break;

    case VP_OPT_SEL:

      switch (class_option) {

      case 1:

        proto_tree_add_item(tree, hf_cotp_network_expedited_data, tvb, offset, 1, ENC_NA);

        proto_tree_add_item(tree, hf_cotp_vp_opt_sel_class1_use, tvb, offset, 1, ENC_NA);

        break;

      case 4:

        proto_tree_add_item(tree, hf_cotp_use_16_bit_checksum, tvb, offset, 1, ENC_NA);

        break;

      }

      proto_tree_add_item(tree, hf_cotp_transport_expedited_data_transfer, tvb, offset, 1, ENC_NA);

      offset += length;

      vp_length -= length;

      break;

    case VP_PREF_MAX_TPDU_SIZE:

      switch (length) {

      case 1:

        pref_max_tpdu_size = tvb_get_uint8(tvb, offset);

        break;

      case 2:

        pref_max_tpdu_size = tvb_get_ntohs(tvb, offset);

        break;

      case 3:

        pref_max_tpdu_size = tvb_get_ntoh24(tvb, offset);

        break;

      case 4:

        pref_max_tpdu_size = tvb_get_ntohl(tvb, offset);

        break;

      default:

        proto_tree_add_expert_format(tree, pinfo, &ei_cotp_preferred_maximum_tpdu_size, tvb, offset, length,

                            "Preferred maximum TPDU size: bogus length %u (not 1, 2, 3, or 4)", length);

        return false;

      }

      proto_tree_add_uint(tree, hf_cotp_preferred_maximum_tpdu_size, tvb, offset, length, pref_max_tpdu_size*128);

      offset += length;

      vp_length -= length;

      break;

    case VP_INACTIVITY_TIMER:

      proto_tree_add_item(tree, hf_cotp_inactivity_timer, tvb, offset, length, ENC_BIG_ENDIAN);

      offset += length;

      vp_length -= length;

      break;

    case VP_PROTECTION:             /* user-defined */

    case VP_PROTO_CLASS:            /* todo */

    case VP_CLEARING_INFO:          /* user-defined */

    default:                        /* unknown, no decoding */

      proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>");

      offset += length;

      vp_length -= length;

      break;

    }

  } /* while */

  return true;

}

static const value_string cotp_cause_vals[] = {

  { 0, "Reason not specified" },

  { 1, "Congestion at TSAP" },

  { 2, "Session entity not attached to TSAP" },

  { 3, "Address unknown" },

  { 128+0, "Normal Disconnect" },

  { 128+1, "Remote transport entity congestion" },

  { 128+2, "Connection negotiation failed" },

  { 128+3, "Duplicate source reference" },

  { 128+4, "Mismatched references" },

  { 128+5, "Protocol error" },

  { 128+7, "Reference overflow" },

  { 128+8, "Connection request refused" },

  { 128+10, "Header or parameter length invalid" },

  { 0,       NULL }

};

static int ositp_decode_DR(tvbuff_t *tvb, int offset, uint8_t li, uint8_t tpdu,

                           packet_info *pinfo, proto_tree *tree)

{

  proto_tree *cotp_tree = NULL;

  proto_item *ti        = NULL;

  uint16_t    dst_ref, src_ref;

  unsigned char      reason;

  unsigned    tpdu_len;

  /* ATN TPDU's tend to be larger than normal OSI,

   * so nothing to do with respect to LI checks */

  if (li < LI_MIN_DR)

    return -1;

  /* DR TPDUs can have user data, so they run to the end of the containing PDU */

  tpdu_len = tvb_reported_length_remaining(tvb, offset);

  dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);

  src_ref = tvb_get_ntohs(tvb, offset + P_SRC_REF);

  reason  = tvb_get_uint8(tvb, offset + P_REASON_IN_DR);

  pinfo->clnp_dstref = dst_ref;

  pinfo->clnp_srcref = src_ref;

  /* the settings of the TCP srcport and destport are currently disabled,

   * for the following reasons:

   * a) only used for ISO conversation handling (which currently doesn't work)

   * b) will prevent "ISO on TCP" (RFC1006) packets from using

   *    "follow TCP stream" correctly

   *

   * A future conversation handling might be able to handle different kinds of

   * conversations (TCP, ISO, TCP on TCP, ...), but in that case this has to be

   * fixed in any case.

   */

  /*pinfo->srcport = src_ref;*/

  /*pinfo->destport = dst_ref;*/

  if (try_val_to_str(reason, cotp_cause_vals) == NULL)

      return -1;

  col_append_fstr(pinfo->cinfo, COL_INFO,

                  "DR TPDU src-ref: 0x%04x dst-ref: 0x%04x", src_ref, dst_ref);

  if (tree) {

    ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);

    cotp_tree = proto_item_add_subtree(ti, ett_cotp);

    proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);

    proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset +  1, 1, tpdu);

    proto_tree_add_uint(cotp_tree, hf_cotp_destref, tvb, offset +  2, 2,

                        dst_ref);

    proto_tree_add_uint(cotp_tree, hf_cotp_srcref, tvb, offset +  4, 2,

                        src_ref);

    proto_tree_add_item(cotp_tree, hf_cotp_cause, tvb, offset + 6, 1, ENC_NA);

  }

  offset += 7;

  li -= 6;

  if (tree)

    ositp_decode_var_part(tvb, offset, li, 4, tpdu_len, pinfo, cotp_tree);

  offset += li;

  expert_add_info_format(pinfo, ti, &ei_cotp_disconnect_request, "Disconnect Request(DR): 0x%x -> 0x%x", src_ref, dst_ref);

  /* User data */

  call_data_dissector(tvb_new_subset_remaining(tvb, offset), pinfo, tree);

  offset += tvb_captured_length_remaining(tvb, offset);

     /* we dissected all of the containing PDU */

  return offset;

} /* ositp_decode_DR */

static int ositp_decode_DT(tvbuff_t *tvb, int offset, uint8_t li, uint8_t tpdu,

                           packet_info *pinfo, proto_tree *tree,

                           bool uses_inactive_subset,

                           bool *subdissector_found)

{

  proto_tree        *cotp_tree       = NULL;

  proto_item        *ti;

  bool               is_extended;

  bool               is_class_234;

  cotp_conv_info_t  *conv_info;

  uint32_t           dst_ref;

  unsigned           tpdu_nr;

  bool               fragment        = false;

  uint32_t           fragment_length = 0;

  tvbuff_t          *next_tvb;

  fragment_head     *fd_head;

  unsigned           tpdu_len;

  heur_dtbl_entry_t *hdtbl_entry;

  /* DT TPDUs have user data, so they run to the end of the containing PDU */

  tpdu_len = tvb_reported_length_remaining(tvb, offset);

  /* The fixed part is 2 octets long, not including the length indicator,

     for classes 0 and 1; it is at least 4 octets long, not including

     the length indicator, for classes 2, 3, and 4. */

  is_class_234 = true;

  /* note: in the ATN the user is up to chose between 3 different checksums:

   *       standard OSI, 2 or 4 octet extended checksum.

   * The differences for DT are that the TPDU headers may be enlarged by 2

   * octets and that checksum related option codes and option lengths are

   * different.  To not mess up the original OSI dissector LI checking was

   * implemented separately. */

  if (!cotp_decode_atn) { /* non ATN, plain OSI*/

    /* VP_CHECKSUM is the only parameter allowed in the variable part.

     * (This means we may misdissect this if the packet is bad and

     * contains other parameters.).

     * XXX - not true; ISO/IEC 8073:1997 (E) says that "if the use of

     * non-blocking expedited data transfer service is negotiated (class

     * 4 only), the variable part shall contain the ED-TPDU-NR for the

     * first DT-TPDU created from a T-DATA request subsequent to the

     * T-EXPEDITED DATA request". */

    switch (li) {

      case LI_NORMAL_DT_WITH_CHECKSUM      :

        if (tvb_get_uint8(tvb, offset + P_VAR_PART_NDT) != VP_CHECKSUM)

          return -1;

        /* FALLTHROUGH */

      case LI_NORMAL_DT_WITHOUT_CHECKSUM   :

        tpdu_nr = tvb_get_uint8(tvb, offset + P_TPDU_NR_234);

        if (tpdu_nr & 0x80)

          tpdu_nr = tpdu_nr & 0x7F;

        else

          fragment = true;

        is_extended = false;

        dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);

        break;

      case LI_EXTENDED_DT_WITH_CHECKSUM    :

        if (tvb_get_uint8(tvb, offset + P_VAR_PART_EDT) != VP_CHECKSUM)

          return -1;

        /* FALLTHROUGH */

      case LI_EXTENDED_DT_WITHOUT_CHECKSUM :

        tpdu_nr = tvb_get_ntohl(tvb, offset + P_TPDU_NR_234);

        if (tpdu_nr & 0x80000000)

          tpdu_nr = tpdu_nr & 0x7FFFFFFF;

        else

          fragment = true;

        is_extended = true;

        dst_ref = tvb_get_ntohs(tvb, offset + P_DST_REF);

        break;

      case LI_NORMAL_DT_CLASS_01           :

        is_class_234 = false;

        tpdu_nr = tvb_get_uint8(tvb, offset + P_TPDU_NR_0_1);

        if (tpdu_nr & 0x80)

          tpdu_nr = tpdu_nr & 0x7F;

        else

          fragment = true;

        is_extended = false;

        /* For these classes the DST_REF is not included, we have to get

         * it from the underlying transport and generate a frag id. */

        conv_info = get_cotp_conv_info(pinfo);

        dst_ref = conv_info->fwd->ref; // Note this may default to zero if not set

        break;

      default : /* bad TPDU */

        return -1;