/* packet-p_mul.c

 *

 * Routines for P_Mul (ACP142) packet disassembly.

 * A protocol for reliable multicast messaging in bandwidth constrained

 * and delayed acknowledgement (EMCON) environments.

 *

 * Copyright 2005, Stig Bjorlykke <stig@bjorlykke.org>, Thales Norway AS

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 *

 * Ref:  http://jcs.dtic.mil/j6/cceb/acps/acp142/

 */

/*

 * TODO:

 * - Obtain dedicated UDP port numbers

 * - SEQ/ACK analysis for Announce/Request/Reject/Release PDU

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/reassemble.h>

#include <epan/expert.h>

#include <epan/in_cksum.h>

#include <epan/proto_data.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include <wsutil/str_util.h>

#include "packet-cdt.h"

#include "packet-ber.h"

#include "packet-s5066sis.h"

void proto_register_p_mul(void);

void proto_reg_handoff_p_mul(void);

#define PNAME  "P_Mul (ACP142)"

#define PSNAME "P_MUL"

#define PFNAME "p_mul"

/* Recommended UDP Port Numbers */

#define DEFAULT_P_MUL_PORT_RANGE ""

/* PDU Types */

#define Data_PDU               0x00

#define Ack_PDU                0x01

#define Address_PDU            0x02

#define Discard_Message_PDU    0x03

#define Announce_PDU           0x04

#define Request_PDU            0x05

#define Reject_PDU             0x06

#define Release_PDU            0x07

#define FEC_Address_PDU        0x08

#define Extra_Address_PDU      0x12

#define Extra_FEC_Address_PDU  0x18

#define Ack_Ack_PDU            0xFF    /* Fake type to indicate Ack-Ack */

/* Type of content to decode from Data_PDU */

#define DECODE_NONE      0

#define DECODE_BER       1

#define DECODE_CDT       2

static int proto_p_mul;

static int hf_length;

static int hf_priority;

static int hf_map_first;

static int hf_map_last;

static int hf_map_unused;

static int hf_pdu_type;

static int hf_pdu_type_value;

static int hf_no_pdus;

static int hf_seq_no;

static int hf_unused8;

static int hf_unused16;

static int hf_checksum;

static int hf_checksum_good;

static int hf_checksum_bad;

static int hf_source_id_ack;

static int hf_source_id;

static int hf_message_id;

static int hf_expiry_time;

static int hf_mc_group;

static int hf_ann_mc_group;

static int hf_fec_len;

static int hf_fec_id;

static int hf_fec_parameters;

static int hf_count_of_dest;

static int hf_length_of_res;

static int hf_ack_count;

static int hf_ack_entry;

static int hf_ack_length;

static int hf_miss_seq_no;

static int hf_miss_seq_range;

static int hf_miss_seq_range_from;

static int hf_miss_seq_range_delimiter;

static int hf_miss_seq_range_to;

static int hf_tot_miss_seq_no;

static int hf_timestamp_option;

static int hf_dest_entry;

static int hf_dest_id;

static int hf_msg_seq_no;

static int hf_sym_key;

static int hf_data_fragment;

static int hf_msg_fragments;

static int hf_msg_fragment;

static int hf_msg_fragment_overlap;

static int hf_msg_fragment_overlap_conflicts;

static int hf_msg_fragment_multiple_tails;

static int hf_msg_fragment_too_long_fragment;

static int hf_msg_fragment_error;

static int hf_msg_fragment_count;

static int hf_msg_reassembled_in;

static int hf_msg_reassembled_length;

static int hf_analysis_ack_time;

static int hf_analysis_trans_time;

static int hf_analysis_retrans_time;

static int hf_analysis_total_retrans_time;

static int hf_analysis_last_pdu_num;

static int hf_analysis_addr_pdu_num;

static int hf_analysis_acks_addr_pdu_num;

static int hf_analysis_acks_acked_addr_pdu_num;

static int hf_analysis_addr_pdu_time;

static int hf_analysis_prev_pdu_num;

static int hf_analysis_prev_pdu_time;

static int hf_analysis_retrans_no;

static int hf_analysis_ack_num;

static int hf_analysis_ack_missing;

static int hf_analysis_ack_dup_no;

static int hf_analysis_msg_resend_from;

static int hf_analysis_ack_resend_from;

static int hf_analysis_total_time;

static int ett_p_mul;

static int ett_pdu_type;

static int ett_dest_entry;

static int ett_ack_entry;

static int ett_range_entry;

static int ett_checksum;

static int ett_seq_analysis;

static int ett_ack_analysis;

static int ett_seq_ack_analysis;

static int ett_msg_fragment;

static int ett_msg_fragments;

static expert_field ei_more_data;

static expert_field ei_checksum_bad;

static expert_field ei_illegal_seq_no;

static expert_field ei_tot_miss_seq_no;

static expert_field ei_miss_seq_no;

static expert_field ei_analysis_ack_missing;

static expert_field ei_miss_seq_range;

static expert_field ei_address_pdu_missing;

static expert_field ei_analysis_ack_dup_no;

static expert_field ei_length;

static expert_field ei_analysis_prev_pdu_missing;

static expert_field ei_message_discarded;

static expert_field ei_ack_length;

static expert_field ei_analysis_retrans_no;

static dissector_handle_t p_mul_handle;

typedef struct _p_mul_id_key {

  uint32_t id;

  uint16_t seq;

  address addr;

} p_mul_id_key;

typedef struct _p_mul_seq_val {

  int         msg_type;         /* Message type                      */

  uint32_t    prev_msg_id;      /* Previous message package num      */

  nstime_t    prev_msg_time;    /* Previous message receive time     */

  uint32_t    addr_id;          /* PDU package num for Address_PDU   */

  nstime_t    addr_time;        /* PDU received time for Address_PDU */

  uint32_t    pdu_id;           /* PDU package num                   */

  nstime_t    pdu_time;         /* PDU receive time                  */

  uint32_t    prev_pdu_id;      /* Previous PDU package num          */

  nstime_t    prev_pdu_time;    /* Previous PDU receive time         */

  uint16_t    last_found_pdu;   /* Last PDU num                      */

  nstime_t    first_msg_time;   /* First message receive time        */

  uint32_t    msg_resend_count; /* Message resend counter            */

  wmem_map_t *ack_data;

} p_mul_seq_val;

typedef struct _p_mul_ack_data {

  uint32_t ack_id;                     /* Ack PDU package num               */

  uint32_t ack_resend_count;           /* Ack resend counter                */

} p_mul_ack_data;

/* Hash table with current data for seq/ack analysis */

static wmem_map_t *p_mul_id_hash_table;

/* User definable values to use for dissection */

static bool p_mul_reassemble = true;

static int decode_option = DECODE_NONE;

static bool use_relative_msgid = true;

static bool use_seq_ack_analysis = true;

static reassembly_table p_mul_reassembly_table;

static uint32_t message_id_offset;

static const fragment_items p_mul_frag_items = {

  /* Fragment subtrees */

  &ett_msg_fragment,

  &ett_msg_fragments,

  /* Fragment fields */

  &hf_msg_fragments,

  &hf_msg_fragment,

  &hf_msg_fragment_overlap,

  &hf_msg_fragment_overlap_conflicts,

  &hf_msg_fragment_multiple_tails,

  &hf_msg_fragment_too_long_fragment,

  &hf_msg_fragment_error,

  &hf_msg_fragment_count,

  /* Reassembled in field */

  &hf_msg_reassembled_in,

  /* Reassembled length field */

  &hf_msg_reassembled_length,

  /* Reassembled data field */

  NULL,

  /* Tag */

  "Message fragments"

};

static const value_string pdu_vals[] = {

  { Data_PDU,              "Data PDU"              },

  { Ack_PDU,               "Ack PDU"               },

  { Address_PDU,           "Address PDU"           },

  { Discard_Message_PDU,   "Discard Message PDU"   },

  { Announce_PDU,          "Announce PDU"          },

  { Request_PDU,           "Request PDU"           },

  { Reject_PDU,            "Reject PDU"            },

  { Release_PDU,           "Release PDU"           },

  { FEC_Address_PDU,       "FEC Address PDU"       },

  { Extra_Address_PDU,     "Extra Address PDU"     },

  { Extra_FEC_Address_PDU, "Extra FEC Address PDU" },

  { Ack_Ack_PDU,           "Ack-Ack PDU"           },

  { 0,                     NULL                    }

};

static const enum_val_t decode_options[] = {

  { "none", "No decoding",          DECODE_NONE },

  { "ber",  "BER encoded ASN.1",    DECODE_BER  },

  { "cdt",  "Compressed Data Type", DECODE_CDT  },

  { NULL,   NULL,                   0           }

};

static const char *get_type (uint8_t value)

{

  return val_to_str_const (value, pdu_vals, "Unknown");

}

/* Function checksum, found in ACP 142 annex B04 (Fletcher algorithm) */

static uint16_t checksum_acp142 (uint8_t *buffer, int len, int offset)

{

  uint16_t c0 = 0, c1 = 0, ret, ctmp;

  int16_t  cs;

  uint8_t *hpp, *pls;

  if (len < offset+2) {

    /* Buffer too small */

    return 0;

  }

  ctmp = len - offset - 1;

  pls = buffer + len;

  hpp = buffer;

  while (hpp < pls) {

    if ((c0 += *hpp++) > 254) { c0 -= 255; }

    if ((c1 += c0) > 254) { c1 -= 255; }

  }

  if ((cs = ((ctmp * c0) - c1) % 255) < 0) { cs += 255; }

  ret = cs << 8;

  if ((cs = (c1 - ((ctmp + 1L) * c0)) % 255) < 0) { cs += 255; }

  ret |= cs;

  return ret;

}

static unsigned p_mul_id_hash (const void *k)

{

  const p_mul_id_key *p_mul = (const p_mul_id_key *)k;

  return p_mul->id;

}

static int p_mul_id_hash_equal (const void *k1, const void *k2)

{

  const p_mul_id_key *p_mul1 = (const p_mul_id_key *)k1;

  const p_mul_id_key *p_mul2 = (const p_mul_id_key *)k2;

  if (p_mul1->id != p_mul2->id)

    return 0;

  if (p_mul1->seq != p_mul2->seq)

    return 0;

  return (addresses_equal (&p_mul1->addr, &p_mul2->addr));

}

static p_mul_seq_val *lookup_seq_val (uint32_t message_id, uint16_t seq_no,

                                      address *addr)

{

  p_mul_seq_val *pkg_data;

  p_mul_id_key  *p_mul_key = wmem_new(wmem_file_scope(), p_mul_id_key);

  p_mul_key->id = message_id;

  p_mul_key->seq = seq_no;

  copy_address_wmem(wmem_file_scope(), &p_mul_key->addr, addr);

  pkg_data = (p_mul_seq_val *) wmem_map_lookup (p_mul_id_hash_table, p_mul_key);

  return pkg_data;

}

static void copy_hashtable_data (void *key, void *value, void *user_data)

{

  p_mul_ack_data *ack_data1 = (p_mul_ack_data*)value;

  p_mul_ack_data *ack_data2;

  wmem_map_t *table = (wmem_map_t*)user_data;

  ack_data2 = wmem_new(wmem_file_scope(), p_mul_ack_data);

  ack_data2->ack_id = ack_data1->ack_id;

  ack_data2->ack_resend_count = ack_data1->ack_resend_count;

  wmem_map_insert (table, key, ack_data2);

}

static p_mul_seq_val *register_p_mul_id (packet_info *pinfo, address *addr, uint32_t dstIP,

                                         uint8_t pdu_type, uint32_t message_id,

                                         uint16_t seq_no, int no_missing)

{

  p_mul_seq_val  *p_mul_data = NULL, *pkg_data = NULL;

  p_mul_id_key   *p_mul_key;

  p_mul_ack_data *ack_data = NULL;

  nstime_t        addr_time, prev_time;

  unsigned        addr_id = 0, prev_id = 0;

  uint16_t        last_found_pdu = 0;

  bool            missing_pdu = false, need_set_address = false;

  wmem_map_t     *pkg_list;

  if (pinfo->flags.in_error_pkt) {

    /* No analysis of error packets */

    return NULL;

  }

  if (pdu_type == Data_PDU && seq_no == 0) {

    /* Illegal sequence number for Data PDU */

    return NULL;

  }

  nstime_set_zero(&addr_time);

  nstime_set_zero(&prev_time);

  p_mul_key = wmem_new(wmem_file_scope(), p_mul_id_key);

  if (!pinfo->fd->visited &&

      (pdu_type == Address_PDU || pdu_type == Data_PDU || pdu_type == Discard_Message_PDU))

  {

    /* Try to match corresponding address PDU */

    p_mul_key->id = message_id;

    p_mul_key->seq = 0;

    copy_address_wmem(wmem_file_scope(), &p_mul_key->addr, addr);

    need_set_address = true;

    p_mul_data = (p_mul_seq_val *) wmem_map_lookup (p_mul_id_hash_table, p_mul_key);

    if (p_mul_data) {

      /* Found address PDU */

      last_found_pdu = p_mul_data->last_found_pdu;

      p_mul_data->last_found_pdu = seq_no;

      addr_id = p_mul_data->pdu_id;

      addr_time = p_mul_data->pdu_time;

      /* Save data for last found PDU */

      p_mul_data->prev_pdu_id = pinfo->num;

      p_mul_data->prev_pdu_time = pinfo->abs_ts;

      if (pdu_type == Data_PDU && p_mul_data->msg_resend_count == 0 && last_found_pdu != seq_no - 1) {

        /* Data_PDU and missing previous PDU */

        missing_pdu = true;

      }

      if (last_found_pdu) {

        /* Try to match previous data PDU */

        p_mul_key->seq = last_found_pdu;

        p_mul_data = (p_mul_seq_val *) wmem_map_lookup (p_mul_id_hash_table, p_mul_key);

      }

      if (p_mul_data) {

        /* Found a previous PDU (Address or Data) */

        if (p_mul_data->prev_msg_id > 0) {

          prev_id = p_mul_data->prev_msg_id;

        } else {

          prev_id = p_mul_data->pdu_id;

        }

        prev_time = p_mul_data->pdu_time;

      }

    } else if (pdu_type == Address_PDU) {

      addr_id = pinfo->num;

      addr_time = pinfo->abs_ts;

    }

  }

  pkg_list = (wmem_map_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_p_mul, 0);

  if (!pkg_list) {

    /* Never saved list for this packet, create a new */

    pkg_list = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);

    p_add_proto_data(wmem_file_scope(), pinfo, proto_p_mul, 0, pkg_list);

  }

  if (!pinfo->fd->visited) {

    p_mul_key->id = message_id;

    p_mul_key->seq = seq_no;

    if (!need_set_address) {

      copy_address_wmem(wmem_file_scope(), &p_mul_key->addr, addr);

    }

    p_mul_data = (p_mul_seq_val *) wmem_map_lookup (p_mul_id_hash_table, p_mul_key);

    if (p_mul_data) {

      if (pdu_type == Ack_PDU) {

        /* Only save this data if positive ack */

        if (no_missing == 0) {

          ack_data = (p_mul_ack_data *)wmem_map_lookup (p_mul_data->ack_data, GUINT_TO_POINTER(dstIP));

          if (!ack_data) {

            /* Only save reference to first ACK */

            ack_data = wmem_new0(wmem_file_scope(), p_mul_ack_data);

            ack_data->ack_id = pinfo->num;

            wmem_map_insert (p_mul_data->ack_data, GUINT_TO_POINTER(dstIP), ack_data);

          } else {

            /* Only count when resending */

            ack_data->ack_resend_count++;

          }

        }

      } else {

        /* Message resent */

        p_mul_data->msg_resend_count++;

        p_mul_data->prev_msg_id = pinfo->num;

        p_mul_data->prev_msg_time = p_mul_data->pdu_time;

        p_mul_data->pdu_time = pinfo->abs_ts;

        if (pdu_type == Data_PDU) {

          p_mul_data->prev_pdu_id = prev_id;

          p_mul_data->prev_pdu_time = prev_time;

        }

      }

    } else {

      /* New message */

      if (pdu_type == Ack_PDU) {

        /* Data is just copied to the structure and never stored,

             so keep a "more temporary" structure */

        p_mul_data = wmem_new0(pinfo->pool, p_mul_seq_val);

      } else {

        p_mul_data = wmem_new0(wmem_file_scope(), p_mul_seq_val);

      }

      p_mul_data->msg_type = pdu_type;

      if (pdu_type == Address_PDU || pdu_type == Ack_PDU) {

        p_mul_data->ack_data = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);

      }

      if (pdu_type == Ack_PDU) {

        /* No matching message for this ack */

        ack_data = wmem_new0(wmem_file_scope(), p_mul_ack_data);

        ack_data->ack_id = pinfo->num;

        wmem_map_insert (p_mul_data->ack_data, GUINT_TO_POINTER(dstIP), ack_data);

      } else {

        p_mul_data->pdu_id = pinfo->num;

        p_mul_data->pdu_time = pinfo->abs_ts;

        p_mul_data->addr_id = addr_id;

        p_mul_data->addr_time = addr_time;

        p_mul_data->first_msg_time = pinfo->abs_ts;

        if (pdu_type == Data_PDU && !missing_pdu) {

          p_mul_data->prev_pdu_id = prev_id;

          p_mul_data->prev_pdu_time = prev_time;

        }

        wmem_map_insert (p_mul_id_hash_table, p_mul_key, p_mul_data);

      }

    }

    /* Copy the current package data to the frame */

    pkg_data = wmem_new(wmem_file_scope(), p_mul_seq_val);

    *pkg_data = *p_mul_data;

    if (p_mul_data->ack_data) {

      /* Copy the hash table for ack data */

      pkg_data->ack_data = wmem_map_new(wmem_file_scope(), g_direct_hash, g_direct_equal);

      wmem_map_foreach (p_mul_data->ack_data, copy_hashtable_data, pkg_data->ack_data);

    }

    wmem_map_insert(pkg_list, GUINT_TO_POINTER(message_id), pkg_data);

  } else {

    /* Fetch last values from data saved in packet */

    pkg_data = (p_mul_seq_val *)wmem_map_lookup (pkg_list, GUINT_TO_POINTER(message_id));

  }

  DISSECTOR_ASSERT (pkg_data);

  return pkg_data;

}

static void add_ack_analysis (tvbuff_t *tvb, packet_info *pinfo, proto_tree *p_mul_tree,

                              int offset, uint8_t pdu_type, address *src, address *dst,

                              uint32_t message_id, int no_missing)

{

  proto_tree     *analysis_tree = NULL;

  proto_item     *sa            = NULL;

  proto_item     *en            = NULL;

  p_mul_seq_val  *pkg_data      = NULL;

  p_mul_ack_data *ack_data      = NULL;

  bool            item_added    = false;

  uint32_t        dstIp;

  nstime_t        ns;

  if (pinfo->flags.in_error_pkt) {

    /* No analysis of error packets */

    return;

  }

  if (pdu_type == Address_PDU) {

    analysis_tree = proto_tree_add_subtree(p_mul_tree, tvb, 0, 0, ett_ack_analysis, &sa, "ACK analysis");

    proto_item_set_generated (sa);

    /* Fetch package data */

    if ((pkg_data = lookup_seq_val (message_id, 0, src)) == NULL) {

      /* No need for seq/ack analysis yet */

      return;

    }

    if (dst == NULL) {

      /* Ack-Ack */

      if (pkg_data->addr_id) {

        en = proto_tree_add_uint (analysis_tree, hf_analysis_acks_acked_addr_pdu_num, tvb,

                                  0, 0, pkg_data->addr_id);

        proto_item_set_generated (en);

        nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->addr_time);

        en = proto_tree_add_time (analysis_tree, hf_analysis_total_time,

                                  tvb, 0, 0, &ns);

        proto_item_set_generated (en);

      } else {

        proto_tree_add_expert(analysis_tree, pinfo, &ei_address_pdu_missing, tvb, offset, 0);

      }

      item_added = true;

    } else {

      memcpy((uint8_t *)&dstIp, dst->data, 4);

      if (pkg_data->ack_data) {

        ack_data = (p_mul_ack_data *)wmem_map_lookup (pkg_data->ack_data, GUINT_TO_POINTER(dstIp));

      }

      /* Add reference to Ack_PDU */

      if (ack_data && ack_data->ack_id) {

        en = proto_tree_add_uint (analysis_tree, hf_analysis_ack_num, tvb,

                                  0, 0, ack_data->ack_id);

        proto_item_set_generated (en);

        item_added = true;

      } else if (!pkg_data->msg_resend_count) {

        en = proto_tree_add_item (analysis_tree,

                                  hf_analysis_ack_missing,

                                  tvb, offset, 0, ENC_NA);

        if (pinfo->fd->visited) {

          /* We do not know this on first visit and we do not want to

             add a entry in the "Expert Severity Info" for this note */

          expert_add_info(pinfo, en, &ei_analysis_ack_missing);

          proto_item_set_generated (en);

        }

        item_added = true;

      }

    }

    if (!item_added) {

      proto_item_set_hidden (sa);

    }

  } else if (pdu_type == Ack_PDU) {

    analysis_tree = proto_tree_add_subtree(p_mul_tree, tvb, 0, 0, ett_seq_ack_analysis, &sa, "SEQ/ACK analysis");

    proto_item_set_generated (sa);

    /* Fetch package data */

    memcpy((uint8_t *)&dstIp, dst->data, 4);

    if ((pkg_data = register_p_mul_id (pinfo, src, dstIp, pdu_type, message_id, 0, no_missing)) == NULL) {

      /* No need for seq/ack analysis yet */

      return;

    }

    if (pkg_data->ack_data) {

      ack_data = (p_mul_ack_data *)wmem_map_lookup(pkg_data->ack_data, GUINT_TO_POINTER(dstIp));

    }

    /* Add reference to Address_PDU */

    if (pkg_data->msg_type != Ack_PDU) {

      en = proto_tree_add_uint (analysis_tree, hf_analysis_acks_addr_pdu_num, tvb,

                                0, 0, pkg_data->pdu_id);

      proto_item_set_generated (en);

      if (no_missing == 0) {

        nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->first_msg_time);

        en = proto_tree_add_time (analysis_tree, hf_analysis_trans_time,

                                  tvb, 0, 0, &ns);

        proto_item_set_generated (en);

      }

    } else {

      proto_tree_add_expert(analysis_tree, pinfo, &ei_address_pdu_missing, tvb, offset, 0);

    }

    if (pkg_data->msg_type != Ack_PDU && pkg_data->prev_pdu_id) {

      /* Add reference to previous PDU */

      en = proto_tree_add_uint (analysis_tree, hf_analysis_last_pdu_num,

                                tvb, 0, 0, pkg_data->prev_pdu_id);

      proto_item_set_generated (en);

      nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->prev_pdu_time);

      en = proto_tree_add_time (analysis_tree, hf_analysis_ack_time,

                                tvb, 0, 0, &ns);

      proto_item_set_generated (en);

    }

    if (ack_data && ack_data->ack_resend_count) {

      /* Add resend statistics */

      en = proto_tree_add_uint (analysis_tree, hf_analysis_ack_dup_no,

                                tvb, 0, 0, ack_data->ack_resend_count);

      proto_item_set_generated (en);

      expert_add_info_format(pinfo, en, &ei_analysis_ack_dup_no, "Dup ACK #%d", ack_data->ack_resend_count);

      en = proto_tree_add_uint (analysis_tree, hf_analysis_ack_resend_from,

                                tvb, 0, 0, ack_data->ack_id);

      proto_item_set_generated (en);

      col_append_fstr (pinfo->cinfo, COL_INFO, "[Dup ACK %d#%d] ",

                       ack_data->ack_id, ack_data->ack_resend_count);

    }

  }

}

static p_mul_seq_val *add_seq_analysis (tvbuff_t *tvb, packet_info *pinfo,

                                        proto_tree *p_mul_tree, address *src,

                                        int offset,

                                        uint8_t pdu_type, uint32_t message_id,

                                        uint16_t seq_no, int no_missing)

{

  p_mul_seq_val *pkg_data;

  proto_tree    *analysis_tree;

  proto_item    *sa, *en = NULL, *eh = NULL;

  bool           item_added = false;

  nstime_t       ns;

  pkg_data = register_p_mul_id (pinfo, src, 0, pdu_type, message_id, seq_no,

                                no_missing);

  if (!pkg_data) {

    /* No need for seq/ack analysis */

    return NULL;

  }

  analysis_tree = proto_tree_add_subtree(p_mul_tree, tvb, 0, 0, ett_seq_analysis, &sa, "SEQ analysis");

  proto_item_set_generated (sa);

  if (pdu_type == Data_PDU || pdu_type == Discard_Message_PDU) {

    /* Add reference to Address_PDU */

    if (pkg_data->addr_id) {

      en = proto_tree_add_uint (analysis_tree, hf_analysis_addr_pdu_num, tvb,

                                0, 0, pkg_data->addr_id);

      proto_item_set_generated (en);

      nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->addr_time);

      en = proto_tree_add_time (analysis_tree, hf_analysis_addr_pdu_time,

                                tvb, 0, 0, &ns);

      proto_item_set_generated (en);

      if (pkg_data->prev_pdu_id == pkg_data->addr_id) {

        /* Previous pdu time is the same as time since address pdu */

        en = proto_tree_add_time (analysis_tree, hf_analysis_prev_pdu_time,

                                  tvb, 0, 0, &ns);

        proto_item_set_generated (en);

      }

      item_added = true;

    } else if (!pkg_data->msg_resend_count) {

      proto_tree_add_expert(analysis_tree, pinfo, &ei_address_pdu_missing, tvb, offset, 0);

      item_added = true;

    }

  }

  if ((pdu_type == Data_PDU) && (pkg_data->prev_pdu_id != pkg_data->addr_id)) {

    /* Add reference to previous Data_PDU */

    if (pkg_data->prev_pdu_id) {

      en = proto_tree_add_uint (analysis_tree, hf_analysis_prev_pdu_num, tvb,

                                0, 0, pkg_data->prev_pdu_id);

      proto_item_set_generated (en);

      nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->prev_pdu_time);

      en = proto_tree_add_time (analysis_tree, hf_analysis_prev_pdu_time,

                                tvb, 0, 0, &ns);

      proto_item_set_generated (en);

      item_added = true;

    } else if (!pkg_data->msg_resend_count) {

      proto_tree_add_expert(analysis_tree, pinfo, &ei_analysis_prev_pdu_missing, tvb, offset, 0);

      item_added = true;

    }

  }

  if ((pdu_type == Address_PDU) || (pdu_type == Data_PDU) ||

      (pdu_type == Discard_Message_PDU)) {

    /* Add resend statistics */

    if (pkg_data->msg_resend_count) {

      en = proto_tree_add_uint (analysis_tree, hf_analysis_retrans_no,

                                tvb, 0, 0, pkg_data->msg_resend_count);

      proto_item_set_generated (en);

      en = proto_tree_add_uint (analysis_tree, hf_analysis_msg_resend_from,

                                tvb, 0, 0, pkg_data->pdu_id);

      proto_item_set_generated (en);

      expert_add_info_format(pinfo, en, &ei_analysis_retrans_no, "Retransmission #%d", pkg_data->msg_resend_count);

      nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->prev_msg_time);

      en = proto_tree_add_time (analysis_tree, hf_analysis_retrans_time,

                                tvb, 0, 0, &ns);

      proto_item_set_generated (en);

      nstime_delta (&ns, &pinfo->abs_ts, &pkg_data->first_msg_time);

      eh = proto_tree_add_time (analysis_tree, hf_analysis_total_retrans_time,

                                tvb, 0, 0, &ns);

      proto_item_set_generated (eh);

      if (pkg_data->first_msg_time.secs == pkg_data->prev_msg_time.secs &&

          pkg_data->first_msg_time.nsecs == pkg_data->prev_msg_time.nsecs) {

        /* Time values does not differ, hide the total time */

        proto_item_set_hidden (eh);

      }

      item_added = true;

      col_append_fstr (pinfo->cinfo, COL_INFO, "[Retrans %d#%d] ",

                       pkg_data->pdu_id, pkg_data->msg_resend_count);

    }

  }

  if (!item_added) {

    proto_item_set_hidden (sa);

  }

  return pkg_data;

}

static void dissect_reassembled_data (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)

{

  DISSECTOR_ASSERT(tvb != NULL);

  switch (decode_option) {

  case DECODE_BER:

    dissect_unknown_ber (pinfo, tvb, 0, tree);

    break;

  case DECODE_CDT:

    dissect_cdt (tvb, pinfo, tree);

    break;

  default:

    call_data_dissector(tvb, pinfo, tree);

    break;

  }

}

static int dissect_p_mul (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

  proto_tree    *p_mul_tree, *field_tree, *checksum_tree;

  proto_item    *ti, *en, *len_en;

  bool           save_fragmented;

  uint32_t       message_id = 0;

  uint16_t       no_dest = 0, count = 0, len, data_len = 0;

  uint16_t       checksum_calc, checksum_found;

  uint16_t       pdu_length, no_pdus = 0, seq_no = 0;

  uint8_t        pdu_type, *value, map = 0, fec_len;

  int            i, tot_no_missing = 0, no_missing = 0, offset = 0;

  address        src, dst;

  wmem_strbuf_t *message_id_list = NULL;

  bool           fletcher = false;

  col_set_str (pinfo->cinfo, COL_PROTOCOL, "P_MUL");

  col_clear (pinfo->cinfo, COL_INFO);

  /* First fetch PDU Type */

  pdu_type = tvb_get_uint8 (tvb, offset + 3) & 0x3F;

  ti = proto_tree_add_item (tree, proto_p_mul, tvb, offset, -1, ENC_NA);

  proto_item_append_text (ti, ", %s", get_type (pdu_type));

  p_mul_tree = proto_item_add_subtree (ti, ett_p_mul);

  /* Length of PDU */

  pdu_length = tvb_get_ntohs (tvb, offset);

  len_en = proto_tree_add_item (p_mul_tree, hf_length, tvb, offset, 2, ENC_BIG_ENDIAN);

  offset += 2;

  switch (pdu_type) {

  case Data_PDU:

  case Ack_PDU:

  case Address_PDU:

  case Discard_Message_PDU:

  case Extra_Address_PDU:

  case FEC_Address_PDU:

  case Extra_FEC_Address_PDU:

    /* Priority */

    proto_tree_add_item (p_mul_tree, hf_priority, tvb, offset, 1, ENC_BIG_ENDIAN);

    break;

  default:

    /* Unused */

    proto_tree_add_item (p_mul_tree, hf_unused8, tvb, offset, 1, ENC_BIG_ENDIAN);

  }

  offset += 1;

  /* MAP / PDU_Type */

  en = proto_tree_add_uint_format (p_mul_tree, hf_pdu_type, tvb, offset, 1,

                                   pdu_type, "PDU Type: %s (0x%02x)",

                                   get_type (pdu_type), pdu_type);

  field_tree = proto_item_add_subtree (en, ett_pdu_type);

  if (pdu_type == Discard_Message_PDU) {

    expert_add_info(pinfo, en, &ei_message_discarded);

  }

  switch (pdu_type) {

  case Address_PDU:

  case Announce_PDU:

  case Extra_Address_PDU:

  case FEC_Address_PDU:

  case Extra_FEC_Address_PDU:

    map = tvb_get_uint8 (tvb, offset);

    proto_tree_add_item (field_tree, hf_map_first, tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item (field_tree, hf_map_last, tvb, offset, 1, ENC_BIG_ENDIAN);

    if ((map & 0x80) || (map & 0x40)) {

      proto_item_append_text (en, ", %s / %s",

                              (map & 0x80) ? "Not first" : "First",

                              (map & 0x40) ? "Not last" : "Last");

    } else {

      proto_item_append_text (en, ", Only one PDU");

    }

    break;

  default:

    proto_tree_add_item (field_tree, hf_map_unused, tvb, offset, 1, ENC_BIG_ENDIAN);

    break;

  }

  proto_tree_add_item (field_tree, hf_pdu_type_value, tvb, offset, 1, ENC_BIG_ENDIAN);

  offset += 1;

  switch (pdu_type) {

  case Address_PDU:

  case Extra_Address_PDU:

  case FEC_Address_PDU:

  case Extra_FEC_Address_PDU:

    /* Total Number of PDUs */

    no_pdus = tvb_get_ntohs (tvb, offset);

    seq_no = 0;

    proto_tree_add_item (p_mul_tree, hf_no_pdus, tvb, offset, 2, ENC_BIG_ENDIAN);

    proto_item_append_text (ti, ", No PDUs: %u", no_pdus);

    break;

  case Data_PDU:

    /* Sequence Number of PDUs */

    seq_no = tvb_get_ntohs (tvb, offset);

    en = proto_tree_add_item (p_mul_tree, hf_seq_no, tvb, offset, 2, ENC_BIG_ENDIAN);

    if (seq_no == 0) {

      expert_add_info(pinfo, en, &ei_illegal_seq_no);

    }

    proto_item_append_text (ti, ", Seq no: %u", seq_no);

    break;

  case Announce_PDU:

    /* Count of Destination Entries */

    count = tvb_get_ntohs (tvb, offset);

    proto_tree_add_item (p_mul_tree, hf_count_of_dest, tvb, offset, 2, ENC_BIG_ENDIAN);

    break;

  default:

    /* Unused */

    proto_tree_add_item (p_mul_tree, hf_unused16, tvb, offset, 2, ENC_BIG_ENDIAN);

    break;

  }

  offset += 2;

  /* Checksum */

  en = proto_tree_add_item (p_mul_tree, hf_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);

  checksum_tree = proto_item_add_subtree (en, ett_checksum);

  len = tvb_captured_length (tvb);

  value = (uint8_t *)tvb_memdup (pinfo->pool, tvb, 0, len);

  if (len >= offset+2) {

    value[offset] = 0;

    value[offset+1] = 0;

  }

  checksum_found = tvb_get_ntohs (tvb, offset);

  /* This computed IP checksum is network-byte-order, so convert to host-byte-order */

  checksum_calc = g_ntohs (ip_checksum (value, len));

  if (checksum_calc != checksum_found) {

    uint16_t checksum1 = checksum_acp142 (value, len, offset);

    if (checksum1 == checksum_found) {

      checksum_calc = checksum1;

      fletcher = true;

    }

  }

  if (checksum_calc == checksum_found) {

    if (fletcher) {

      proto_item_append_text (en, " [Fletcher algorithm]");

    }

    proto_item_append_text (en, " (correct)");

    en = proto_tree_add_boolean (checksum_tree, hf_checksum_good, tvb,

                                 offset, 2, true);