/* packet-bpv6.c

 * References:

 *     RFC 5050: https://tools.ietf.org/html/rfc5050

 *

 * Copyright 2006-2007 The MITRE Corporation.

 * All Rights Reserved.

 * Approved for Public Release; Distribution Unlimited.

 * Tracking Number 07-0090.

 *

 * The US Government will not be charged any license fee and/or royalties

 * related to this software. Neither name of The MITRE Corporation; nor the

 * names of its contributors may be used to endorse or promote products

 * derived from this software without specific prior written permission.

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 *

 * Specification reference:

 * RFC 5050

 * https://tools.ietf.org/html/rfc5050

 */

/*

 *    Modifications were made to this file under designation MFS-33289-1 and

 *    are Copyright 2015 United States Government as represented by NASA

 *       Marshall Space Flight Center. All Rights Reserved.

 *

 *    Released under the GNU GPL with NASA legal approval granted 2016-06-10.

 *

 *    The subject software is provided "AS IS" WITHOUT ANY WARRANTY of any kind,

 *    either expressed, implied or statutory and this agreement does not,

 *    in any manner, constitute an endorsement by government agency of any

 *    results, designs or products resulting from use of the subject software.

 *    See the Agreement for the specific language governing permissions and

 *    limitations.

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <epan/wscbor.h>

#include "packet-bpv6.h"

#include "packet-cfdp.h"

void proto_register_bpv6(void);

void proto_reg_handoff_bpv6(void);

static int dissect_admin_record(proto_tree *primary_tree, tvbuff_t *tvb, packet_info *pinfo,

                                int offset, int payload_length, bool* success);

extern void

dissect_amp_as_subtree(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int evaluate_sdnv(tvbuff_t *tvb, int offset, int *bytecount);

/// Return an error_info index if not valid

static int evaluate_sdnv_ei(tvbuff_t *tvb, int offset, int *bytecount, expert_field **error);

static int add_sdnv_time_to_tree(proto_tree *tree, tvbuff_t *tvb, int offset, int hf_sdnv_time);

static int64_t

evaluate_sdnv_64(tvbuff_t *tvb, int offset, int *bytecount);

static int proto_bundle;

static dissector_handle_t bundle_handle;

static dissector_handle_t bpv6_handle;

static dissector_handle_t bpv7_handle;

static int hf_bundle_pdu_version;

/* Primary Header Processing Flag Variables */

static int hf_bundle_procflags;

static int hf_bundle_procflags_fragment;

static int hf_bundle_procflags_admin;

static int hf_bundle_procflags_dont_fragment;

static int hf_bundle_procflags_cust_xfer_req;

static int hf_bundle_procflags_dest_singleton;

static int hf_bundle_procflags_application_ack;

/* Additions for Version 5 */

static int hf_bundle_control_flags;

static int hf_bundle_procflags_general;

static int hf_bundle_procflags_cos;

static int hf_bundle_procflags_status;

/* Primary Header COS Flag Variables */

static int hf_bundle_cosflags;

static int hf_bundle_cosflags_priority;

/* Primary Header Status Report Request Flag Variables */

static int hf_bundle_srrflags;

static int hf_bundle_srrflags_report_receipt;

static int hf_bundle_srrflags_report_cust_accept;

static int hf_bundle_srrflags_report_forward;

static int hf_bundle_srrflags_report_delivery;

static int hf_bundle_srrflags_report_deletion;

static int hf_bundle_srrflags_report_ack;

/* Primary Header Fields*/

static int hf_bundle_primary_header_len;

static int hf_bundle_primary_dictionary_len;

static int hf_bundle_primary_timestamp;

static int hf_bundle_primary_fragment_offset;

static int hf_bundle_primary_total_adu_len;

static int hf_bundle_primary_timestamp_seq_num64;

static int hf_bundle_primary_timestamp_seq_num32;

static int hf_bundle_dest_scheme_offset_u16;

static int hf_bundle_dest_scheme_offset_i32;

static int hf_bundle_dest_ssp_offset_u16;

static int hf_bundle_dest_ssp_offset_i32;

static int hf_bundle_source_scheme_offset_u16;

static int hf_bundle_source_scheme_offset_i32;

static int hf_bundle_source_ssp_offset_u16;

static int hf_bundle_source_ssp_offset_i32;

static int hf_bundle_report_scheme_offset_u16;

static int hf_bundle_report_scheme_offset_i32;

static int hf_bundle_report_ssp_offset_u16;

static int hf_bundle_report_ssp_offset_i32;

static int hf_bundle_cust_scheme_offset_u16;

static int hf_bundle_cust_scheme_offset_i32;

static int hf_bundle_cust_ssp_offset_u16;

static int hf_bundle_cust_ssp_offset_i32;

/* Dictionary EIDs */

static int hf_bundle_dest_scheme;

static int hf_bundle_dest_ssp;

static int hf_bundle_source_scheme;

static int hf_bundle_source_ssp;

static int hf_bundle_report_scheme;

static int hf_bundle_report_ssp;

static int hf_bundle_custodian_scheme;

static int hf_bundle_custodian_ssp;

/* Remaining Primary Header Fields */

static int hf_bundle_creation_timestamp;

static int hf_bundle_lifetime;

static int hf_bundle_lifetime_sdnv;

/* Secondary Header Processing Flag Variables */

static int hf_bundle_payload_length;

static int hf_bundle_payload_header_type;

static int hf_bundle_payload_data;

static int hf_bundle_payload_flags;

static int hf_bundle_payload_flags_replicate_hdr;

static int hf_bundle_payload_flags_xmit_report;

static int hf_bundle_payload_flags_discard_on_fail;

static int hf_bundle_payload_flags_last_header;

/* Block Processing Control Flag Variables (Version 5) */

static int hf_block_control_flags;

static int hf_block_control_flags_sdnv;

static int hf_block_control_replicate;

static int hf_block_control_transmit_status;

static int hf_block_control_delete_bundle;

static int hf_block_control_last_block;

static int hf_block_control_discard_block;

static int hf_block_control_not_processed;

static int hf_block_control_eid_reference;

static int hf_block_control_block_length;

static int hf_block_control_block_cteb_custody_id;

static int hf_block_control_block_cteb_creator_custodian_eid;

/* Non-Primary Block Type Code Variable */

static int hf_bundle_block_type_code;

static int hf_bundle_unprocessed_block_data;

/* ECOS Flag Variables */

static int hf_ecos_flags;

static int hf_ecos_flags_critical;

static int hf_ecos_flags_streaming;

static int hf_ecos_flags_flowlabel;

static int hf_ecos_flags_reliable;

static int hf_ecos_flow_label;

static int hf_ecos_ordinal;

/* Administrative Record Variables */

static int hf_bundle_admin_record_type;

static int hf_bundle_admin_record_fragment;

static int hf_bundle_admin_statflags;

static int hf_bundle_admin_rcvd;

static int hf_bundle_admin_accepted;

static int hf_bundle_admin_forwarded;

static int hf_bundle_admin_delivered;

static int hf_bundle_admin_deleted;

static int hf_bundle_admin_acked;

static int hf_bundle_admin_fragment_offset;

static int hf_bundle_admin_fragment_length;

static int hf_bundle_admin_timestamp_seq_num64;

static int hf_bundle_admin_timestamp_seq_num32;

static int hf_bundle_admin_endpoint_length;

static int hf_bundle_admin_endpoint_id;

static int hf_bundle_admin_receipt_time;

static int hf_bundle_admin_accept_time;

static int hf_bundle_admin_forward_time;

static int hf_bundle_admin_delivery_time;

static int hf_bundle_admin_delete_time;

static int hf_bundle_admin_ack_time;

static int hf_bundle_admin_timestamp_copy;

static int hf_bundle_admin_signal_time;

static int hf_bundle_status_report_reason_code;

static int hf_bundle_custody_trf_succ_flg;

static int hf_bundle_custody_signal_reason;

static int hf_bundle_custody_id_range_start;

static int hf_bundle_custody_id_range_end;

static int hf_bundle_age_extension_block_code;

static int hf_bundle_block_previous_hop_scheme;

static int hf_bundle_block_previous_hop_eid;

/* Security Block Variables */

static int hf_bundle_target_block_type;

static int hf_bundle_target_block_occurrence;

static int hf_bundle_ciphersuite_type;

static int hf_bundle_ciphersuite_flags;

static int hf_block_ciphersuite_params;

static int hf_block_ciphersuite_params_length;

static int hf_block_ciphersuite_params_item_length;

static int hf_block_ciphersuite_param_type;

static int hf_block_ciphersuite_param_data;

static int hf_block_ciphersuite_result_length;

static int hf_block_ciphersuite_result_item_length;

static int hf_block_ciphersuite_result_type;

static int hf_block_ciphersuite_result_data;

static int hf_block_ciphersuite_range_offset;

static int hf_block_ciphersuite_range_length;

/* Tree Node Variables */

static int ett_bundle;

static int ett_bundle_hdr;

static int ett_primary_hdr;

static int ett_proc_flags;

static int ett_gen_flags;

static int ett_cos_flags;

static int ett_srr_flags;

static int ett_dictionary;

static int ett_payload_hdr;

static int ett_payload_flags;

static int ett_block_flags;

static int ett_admin_record;

static int ett_admin_rec_status;

static int ett_metadata_hdr;

static int ett_sec_block_param_data;

static expert_field ei_bundle_payload_length;

static expert_field ei_bundle_control_flags_length;

static expert_field ei_bundle_block_control_flags;

static expert_field ei_bundle_sdnv_length;

static expert_field ei_bundle_timestamp_seq_num;

static expert_field ei_bundle_offset_error;

static expert_field ei_block_control_block_cteb_invalid;

static expert_field ei_block_control_block_cteb_valid;

typedef struct dictionary_data {

    int bundle_header_dict_length;

    int dest_scheme_offset;

    int dst_scheme_pos;

    int dst_scheme_len;

    int source_scheme_offset;

    int src_scheme_pos;

    int src_scheme_len;

    int report_scheme_offset;

    int rpt_scheme_pos;

    int rpt_scheme_len;

    int cust_scheme_offset;

    int cust_scheme_pos;

    int cust_scheme_len;

    int dest_ssp_offset;

    int dst_ssp_len;

    int source_ssp_offset;

    int src_ssp_len;

    int report_ssp_offset;

    int rpt_ssp_len;

    int cust_ssp_offset;

    int cust_ssp_len;

} dictionary_data_t;

static const value_string admin_record_type_vals[] = {

    {ADMIN_REC_TYPE_STATUS_REPORT, "Bundle Status Report"},

    {ADMIN_REC_TYPE_CUSTODY_SIGNAL, "Custody Signal"},

    {ADMIN_REC_TYPE_AGGREGATE_CUSTODY_SIGNAL, "Aggregate Custody Signal"},

    {ADMIN_REC_TYPE_ANNOUNCE_BUNDLE, "Announce Record (Contact)"},

    {0, NULL}

};

static const value_string custody_signal_reason_codes[] = {

    {0x0, "No Additional Information"},

    {0x3, "Redundant Reception"},

    {0x4, "Depleted Storage"},

    {0x5, "Destination Endpoint ID Unintelligible"},

    {0x6, "No Known Route to Destination"},

    {0x7, "No Timely Contact with Next Node on Route"},

    {0x8, "Header Unintelligible"},

    {0, NULL}

};

static const value_string status_report_reason_codes[] = {

    {0x0, "No Additional Information"},

    {0x1, "Lifetime Expired"},

    {0x2, "Forwarded over Unidirectional Link"},

    {0x3, "Transmission Cancelled"},

    {0x4, "Depleted Storage"},

    {0x5, "Destination Endpoint ID Unintelligible"},

    {0x6, "No Known Route to Destination"},

    {0x7, "No Timely Contact with Next Node on Route"},

    {0x8, "Header Unintelligible"},

    {0, NULL}

};

static const value_string bundle_block_type_codes[] = {

    {0x01, "Bundle Payload Block"},

    {0x02, "Bundle Authentication Block"},

    {0x03, "Block Integrity Block"},

    {0x04, "Block Confidentiality Block"},

    {0x05, "Previous-Hop Insertion Block"},

    {0x08, "Metadata Extension Block"},

    {0x09, "Extension Security Block"},

    {0x0a, "Custody Transfer Enhancement Block"},

    {0x13, "Extended Class of Service Block"},

    {0x14, "Bundle Age Extension Block"},

    {0, NULL}

};

static const value_string cosflags_priority_vals[] = {

    {0x00, "Bulk"},

    {0x01, "Normal"},

    {0x02, "Expedited"},

    {0x03, "Invalid (Reserved)"},

    {0, NULL}

};

static const value_string ciphersuite_types[] = {

    {0x01, "HMAC_SHA1"},

    {0x05, "HMAC_SHA256"},

    {0x06, "ARC4_AES128"},

    {0xD1, "HMAC_SHA384"},

    {0xD2, "ECDSA_SHA256"},

    {0xD3, "ECDSA_SHA384"},

    {0xD4, "SHA256_AES128"},

    {0xD5, "SHA384_AES256"},

    {0, NULL}

};

static const value_string res_params_types[] = {

    {0x01, "Initialization Vector"},

    {0x03, "Key Information"},

    {0x04, "Content Range"},

    {0x05, "Integrity Signature"},

    {0x07, "Salt"},

    {0x08, "BCB Integrity Check Value"},

    {0, NULL}

};

/*

 * Adds the result of 2 SDNVs to tree: First SDNV is seconds, next is nanoseconds.

 * Returns bytes in both SDNVs or 0 if something goes wrong.

 */

static int

add_dtn_time_to_tree(proto_tree *tree, tvbuff_t *tvb, int offset, int hf_dtn_time)

{

    nstime_t dtn_time;

    int      sdnv_length, sdnv2_length;

    int      sdnv_value;

    int      orig_offset;

    orig_offset = offset;

    sdnv_value = evaluate_sdnv(tvb, offset, &sdnv_length);

    if (sdnv_value < 0) {

        return 0;

    }

    dtn_time.secs = (time_t)(sdnv_value + 946684800);

    offset += sdnv_length;

    dtn_time.nsecs = evaluate_sdnv(tvb, offset, &sdnv2_length);

    if (dtn_time.nsecs < 0) {

        return 0;

    }

    proto_tree_add_time(tree, hf_dtn_time, tvb, orig_offset, sdnv_length + sdnv2_length, &dtn_time);

    return (sdnv_length + sdnv2_length);

}

/*

 * Adds the result of SDNV which is a time since 2000 to tree.

 * Returns bytes in SDNV or 0 if something goes wrong.

 */

int

add_sdnv_time_to_tree(proto_tree *tree, tvbuff_t *tvb, int offset, int hf_sdnv_time)

{

    nstime_t dtn_time;

    int      sdnv_length;

    int      sdnv_value;

    sdnv_value = evaluate_sdnv(tvb, offset, &sdnv_length);

    if (sdnv_value < 0) {

        return 0;

    }

    dtn_time.secs = (time_t)(sdnv_value + 946684800);

    dtn_time.nsecs = 0;

    proto_tree_add_time(tree, hf_sdnv_time, tvb, offset, sdnv_length, &dtn_time);

    return sdnv_length;

}

static int

add_sdnv_to_tree(proto_tree *tree, tvbuff_t *tvb, packet_info* pinfo, int offset, int hf_sdnv)

{

    proto_item *ti;

    int         sdnv_length;

    int         sdnv_value;

    sdnv_value = evaluate_sdnv(tvb, offset, &sdnv_length);

    ti = proto_tree_add_int(tree, hf_sdnv, tvb, offset, sdnv_length, sdnv_value);

    if (sdnv_value < 0) {

        expert_add_info(pinfo, ti, &ei_bundle_sdnv_length);

        return 0;

    }

    return sdnv_length;

}

/*

 * Pull out stuff from the dictionary

 */

static int

dissect_dictionary(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset, dictionary_data_t* dict_data,

                    uint8_t pri_hdr_procflags, char **bundle_custodian, int creation_timestamp, int timestamp_sequence)

{

    proto_tree  *dict_tree;

    const char* col_text;

    col_text = col_get_text(pinfo->cinfo, COL_INFO);

    dict_tree = proto_tree_add_subtree(tree, tvb, offset, dict_data->bundle_header_dict_length, ett_dictionary, NULL, "Dictionary");

    /*

     * If the dictionary length is 0, then the CBHE block compression method is applied. (RFC6260)

     * So the scheme offset is the node number and the ssp offset is the service number.

     * If destination scheme offset is 2 and destination ssp offset is 1, then the EID is

     * ipn:2.1

     */

    if (dict_data->bundle_header_dict_length == 0)

    {

        const char *src_node, *dst_node;

        /*

         * Destination info

         */

        if (dict_data->dest_scheme_offset == 0 && dict_data->dest_ssp_offset == 0)

        {

            proto_tree_add_string(dict_tree, hf_bundle_dest_scheme, tvb, 0, 0, DTN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_dest_ssp, tvb, dict_data->dst_scheme_pos,

                            dict_data->dst_scheme_len + dict_data->dst_ssp_len, "none");

            dst_node = "dtn:none";

        }

        else

        {

            proto_tree_add_string(dict_tree, hf_bundle_dest_scheme, tvb, 0, 0, IPN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_dest_ssp, tvb, dict_data->dst_scheme_pos,

                            dict_data->dst_scheme_len + dict_data->dst_ssp_len,

                            wmem_strdup_printf(pinfo->pool, "%d.%d",dict_data->dest_scheme_offset,dict_data->dest_ssp_offset));

            dst_node = wmem_strdup_printf(pinfo->pool, "%s:%d.%d", IPN_SCHEME_STR,

                                          dict_data->dest_scheme_offset, dict_data->dest_ssp_offset);

        }

        /*

         * Source info

         */

        if (dict_data->source_scheme_offset == 0 && dict_data->source_ssp_offset == 0)

        {

            proto_tree_add_string(dict_tree, hf_bundle_source_scheme, tvb, 0, 0, DTN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_source_ssp, tvb, dict_data->src_scheme_pos,

                            dict_data->src_scheme_len + dict_data->src_ssp_len, "none");

            src_node = "dtn:none";

        }

        else

        {

            proto_tree_add_string(dict_tree, hf_bundle_source_scheme, tvb, 0, 0, IPN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_source_ssp, tvb, dict_data->src_scheme_pos,

                            dict_data->src_scheme_len + dict_data->src_ssp_len,

                            wmem_strdup_printf(pinfo->pool, "%d.%d", dict_data->source_scheme_offset, dict_data->source_ssp_offset));

            src_node = wmem_strdup_printf(pinfo->pool, "%s:%d.%d", IPN_SCHEME_STR,

                                          dict_data->source_scheme_offset, dict_data->source_ssp_offset);

        }

        /*

         * Report to info

         */

        if (dict_data->report_scheme_offset == 0 && dict_data->report_ssp_offset == 0)

        {

            proto_tree_add_string(dict_tree, hf_bundle_report_scheme, tvb, 0, 0, DTN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_report_ssp, tvb, dict_data->rpt_scheme_pos,

                            dict_data->rpt_scheme_len + dict_data->rpt_ssp_len, "none");

        }

        else

        {

            proto_tree_add_string(dict_tree, hf_bundle_report_scheme, tvb, 0, 0, IPN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_report_ssp, tvb, dict_data->rpt_scheme_pos,

                            dict_data->rpt_scheme_len + dict_data->rpt_ssp_len,

                            wmem_strdup_printf(pinfo->pool, "%d.%d", dict_data->report_scheme_offset, dict_data->report_ssp_offset));

        }

        /*

         * Custodian info

         */

        if (dict_data->cust_scheme_offset == 0 && dict_data->cust_ssp_offset == 0)

        {

            proto_tree_add_string(dict_tree, hf_bundle_custodian_scheme, tvb, 0, 0, DTN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_custodian_ssp, tvb, dict_data->cust_scheme_pos,

                            dict_data->cust_scheme_len + dict_data->cust_ssp_len, "none");

        }

        else

        {

            proto_tree_add_string(dict_tree, hf_bundle_custodian_scheme, tvb, 0, 0, IPN_SCHEME_STR);

            proto_tree_add_string(dict_tree, hf_bundle_custodian_ssp, tvb, dict_data->cust_scheme_pos,

                            dict_data->cust_scheme_len + dict_data->cust_ssp_len,

                            wmem_strdup_printf(pinfo->pool, "%d.%d", dict_data->cust_scheme_offset, dict_data->cust_ssp_offset));

        }

        /* remember custodian, for use in checking cteb validity */

        col_set_writable(pinfo->cinfo, COL_INFO, true);

        col_clear_fence(pinfo->cinfo, COL_INFO);

        if (col_text && strstr(col_text, " > ")) {

            if (! strstr(col_text, "[multiple]")) {

                col_append_str(pinfo->cinfo, COL_INFO, ", [multiple]");

            }

        } else {

            col_clear(pinfo->cinfo, COL_INFO);

            col_add_fstr(pinfo->cinfo, COL_INFO, "%s > %s %d.%d", src_node, dst_node, creation_timestamp, timestamp_sequence);

        }

        col_set_fence(pinfo->cinfo, COL_INFO);

        *bundle_custodian = wmem_strdup_printf(pinfo->pool, "%s:%d.%d", IPN_SCHEME_STR,

                                               dict_data->cust_scheme_offset, dict_data->cust_ssp_offset);

    }

    /*

     * This pointer can be made to address outside the packet boundaries so we

     * need to check for improperly formatted strings (no null termination).

     */

    else

    {

        /*

         * Destination info

         */

        proto_tree_add_item(dict_tree, hf_bundle_dest_scheme,

                            tvb, offset + dict_data->dest_scheme_offset, -1, ENC_ASCII);

        proto_tree_add_item(dict_tree, hf_bundle_dest_ssp,

                            tvb, offset + dict_data->dest_ssp_offset, -1, ENC_ASCII);

        /*

         * Source info

         */

        proto_tree_add_item(dict_tree, hf_bundle_source_scheme,

                            tvb, offset + dict_data->source_scheme_offset, -1, ENC_ASCII);

        proto_tree_add_item(dict_tree, hf_bundle_source_ssp,

                            tvb, offset + dict_data->source_ssp_offset, -1, ENC_ASCII);

        /*

         * Report to info

         */

        proto_tree_add_item(dict_tree, hf_bundle_report_scheme,

                            tvb, offset + dict_data->report_scheme_offset, -1, ENC_ASCII);

        proto_tree_add_item(dict_tree, hf_bundle_report_ssp,

                            tvb, offset + dict_data->report_ssp_offset, -1, ENC_ASCII);

        /*

         * Custodian info

         */

        proto_tree_add_item(dict_tree, hf_bundle_custodian_scheme, tvb, offset + dict_data->cust_scheme_offset, -1, ENC_ASCII);

        proto_tree_add_item(dict_tree, hf_bundle_custodian_ssp, tvb, offset + dict_data->cust_ssp_offset, -1, ENC_ASCII);

        /*

         * Add Source/Destination to INFO Field

         */

        col_set_writable(pinfo->cinfo, COL_INFO, true);

        col_clear_fence(pinfo->cinfo, COL_INFO);

        if (col_text && strstr(col_text, " > "))

            col_append_str(pinfo->cinfo, COL_INFO, ", [multiple]");

        else {

            col_clear(pinfo->cinfo, COL_INFO);

            col_add_fstr(pinfo->cinfo, COL_INFO, "%s:%s > %s:%s %d.%d",

                         tvb_get_stringz_enc(pinfo->pool, tvb, offset + dict_data->source_scheme_offset, NULL, ENC_ASCII),

                         tvb_get_stringz_enc(pinfo->pool, tvb, offset + dict_data->source_ssp_offset, NULL, ENC_ASCII),

                         tvb_get_stringz_enc(pinfo->pool, tvb, offset + dict_data->dest_scheme_offset, NULL, ENC_ASCII),

                         tvb_get_stringz_enc(pinfo->pool, tvb, offset + dict_data->dest_ssp_offset, NULL, ENC_ASCII),

                         creation_timestamp, timestamp_sequence);

        }

        col_set_fence(pinfo->cinfo, COL_INFO);

        /* remember custodian, for use in checking cteb validity */

        *bundle_custodian = wmem_strdup_printf(pinfo->pool,

                                               "%s:%s",

                                               tvb_get_stringz_enc(pinfo->pool,

                                                               tvb, offset + dict_data->cust_scheme_offset,

                                                               NULL, ENC_ASCII),

                                               tvb_get_stringz_enc(pinfo->pool,

                                                               tvb, offset + dict_data->cust_ssp_offset,

                                                               NULL, ENC_ASCII));

    }

    offset += dict_data->bundle_header_dict_length;        /*Skip over dictionary*/

    /*

     * Do this only if Fragment Flag is set

     */

    if (pri_hdr_procflags & BUNDLE_PROCFLAGS_FRAG_MASK) {

        int sdnv_length;

        sdnv_length = add_sdnv_to_tree(tree, tvb, pinfo, offset, hf_bundle_primary_fragment_offset);

        if (sdnv_length < 0) {

            return 0;

        }

        offset += sdnv_length;

        sdnv_length = add_sdnv_to_tree(tree, tvb, pinfo, offset, hf_bundle_primary_total_adu_len);

        if (sdnv_length < 0) {

            return 0;

        }

        offset += sdnv_length;

    }

    return offset;

}

/*

 * This routine returns 0 if header decoding fails, otherwise the length of the primary

 * header, starting right after version number.

 */

static int

dissect_version_4_primary_header(packet_info *pinfo, proto_tree *primary_tree, tvbuff_t *tvb,

                                 uint8_t* pri_hdr_procflags, char **bundle_custodian)

{

    int bundle_header_length;

    int offset = 1;             /* Version Number already displayed */

    int sdnv_length;

    dictionary_data_t dict_data;

    proto_item *ti;

    proto_tree *srr_flag_tree, *proc_flag_tree, *cos_flag_tree;

    /* Primary Header Processing Flags */

    *pri_hdr_procflags = tvb_get_uint8(tvb, offset);

    ti = proto_tree_add_item(primary_tree, hf_bundle_procflags, tvb,

                                                offset, 1, ENC_BIG_ENDIAN);

    proc_flag_tree = proto_item_add_subtree(ti, ett_proc_flags);

    proto_tree_add_item(proc_flag_tree, hf_bundle_procflags_fragment,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(proc_flag_tree, hf_bundle_procflags_admin,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(proc_flag_tree, hf_bundle_procflags_dont_fragment,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(proc_flag_tree, hf_bundle_procflags_cust_xfer_req,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(proc_flag_tree, hf_bundle_procflags_dest_singleton,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    /* Primary Header COS Flags */

    ++offset;

    ti = proto_tree_add_item(primary_tree, hf_bundle_cosflags, tvb,

                                                offset, 1, ENC_BIG_ENDIAN);

    cos_flag_tree = proto_item_add_subtree(ti, ett_cos_flags);

    proto_tree_add_item(cos_flag_tree, hf_bundle_cosflags_priority,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    /* Status Report Request Flags */

    ++offset;

    ti = proto_tree_add_item(primary_tree, hf_bundle_srrflags, tvb,

                                                offset, 1, ENC_BIG_ENDIAN);

    srr_flag_tree = proto_item_add_subtree(ti, ett_srr_flags);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_receipt,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_cust_accept,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_forward,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_delivery,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_deletion,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(srr_flag_tree, hf_bundle_srrflags_report_ack,

                                                tvb, offset, 1, ENC_BIG_ENDIAN);

    ++offset;

    bundle_header_length = evaluate_sdnv(tvb, offset, &sdnv_length);

    ti = proto_tree_add_int(primary_tree, hf_bundle_primary_header_len, tvb, offset, sdnv_length,

                            bundle_header_length);

    if (bundle_header_length < 0) {

        expert_add_info_format(pinfo, ti, &ei_bundle_sdnv_length, "Bundle Header Length Error");

        return tvb_reported_length_remaining(tvb, offset);

    }

    offset += sdnv_length;

    /* Ensure all fields have been initialized */

    memset(&dict_data, 0, sizeof(dict_data));

    /*

     * Pick up offsets into dictionary (8 of them)

     */

    dict_data.dest_scheme_offset = tvb_get_ntohs(tvb, offset);

    dict_data.dst_scheme_pos = offset;

    dict_data.dst_scheme_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_dest_scheme_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.dest_ssp_offset = tvb_get_ntohs(tvb, offset);

    dict_data.dst_ssp_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_dest_ssp_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.source_scheme_offset = tvb_get_ntohs(tvb, offset);

    dict_data.src_scheme_pos = offset;

    dict_data.src_scheme_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_source_scheme_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.source_ssp_offset = tvb_get_ntohs(tvb, offset);

    dict_data.src_ssp_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_source_ssp_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.report_scheme_offset = tvb_get_ntohs(tvb, offset);

    dict_data.rpt_scheme_pos = offset;

    dict_data.rpt_scheme_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_report_scheme_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.report_ssp_offset = tvb_get_ntohs(tvb, offset);

    dict_data.rpt_ssp_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_report_ssp_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.cust_scheme_offset = tvb_get_ntohs(tvb, offset);

    dict_data.cust_scheme_pos = offset;

    dict_data.cust_scheme_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_cust_scheme_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    dict_data.cust_ssp_offset = tvb_get_ntohs(tvb, offset);

    dict_data.cust_ssp_len = 2;

    proto_tree_add_item(primary_tree, hf_bundle_cust_ssp_offset_u16,

                                                        tvb, offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    proto_tree_add_item(primary_tree, hf_bundle_creation_timestamp,

                                                        tvb, offset, 8, ENC_BIG_ENDIAN);

    offset += 8;

    proto_tree_add_item(primary_tree, hf_bundle_lifetime, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    dict_data.bundle_header_dict_length = evaluate_sdnv(tvb, offset, &sdnv_length);

    ti = proto_tree_add_int(primary_tree, hf_bundle_primary_dictionary_len, tvb, offset, sdnv_length,

                            dict_data.bundle_header_dict_length);

    if (dict_data.bundle_header_dict_length < 0) {

        expert_add_info_format(pinfo, ti, &ei_bundle_sdnv_length, "Dictionary Header Length Error");

        return tvb_reported_length_remaining(tvb, offset);

    }

    offset += sdnv_length;

    offset = dissect_dictionary(pinfo, primary_tree, tvb, offset, &dict_data, *pri_hdr_procflags, bundle_custodian, 0, 0);

    return offset;

}

/*

 * This routine returns 0 if header decoding fails, otherwise the length of the primary

 * header, starting right after version number.

 */

static int src_ssp;

static int dst_ssp;

static int

dissect_version_5_and_6_primary_header(packet_info *pinfo,

                                       proto_tree *primary_tree, tvbuff_t *tvb,

                                       uint8_t* pri_hdr_procflags, char **bundle_custodian)

{

    uint64_t           bundle_processing_control_flags;

    uint8_t            cosflags;

    int                bundle_header_length;

    int                offset = 1; /* Version Number already displayed */

    int                sdnv_length;

    dictionary_data_t  dict_data;

    int                timestamp_sequence;

    int                creation_timestamp;

    uint8_t            srrflags;

    proto_item        *ti;

    proto_item        *ti_dst_scheme_offset, *ti_dst_ssp_offset;

    proto_item        *ti_src_scheme_offset, *ti_src_ssp_offset;

    proto_item        *ti_cust_scheme_offset, *ti_cust_ssp_offset;

    proto_item        *ti_rprt_scheme_offset, *ti_rprt_ssp_offset;

    proto_tree        *gen_flag_tree, *srr_flag_tree, *proc_flag_tree, *cos_flag_tree;

    static int * const pri_flags[] = {

        &hf_bundle_procflags_fragment,

        &hf_bundle_procflags_admin,

        &hf_bundle_procflags_dont_fragment,

        &hf_bundle_procflags_cust_xfer_req,

        &hf_bundle_procflags_dest_singleton,

        &hf_bundle_procflags_application_ack,

        NULL

    };

    static int * const srr_flags[] = {

        &hf_bundle_srrflags_report_receipt,

        &hf_bundle_srrflags_report_cust_accept,

        &hf_bundle_srrflags_report_forward,

        &hf_bundle_srrflags_report_delivery,

        &hf_bundle_srrflags_report_deletion,

        NULL

    };

    bundle_processing_control_flags = evaluate_sdnv_64(tvb, offset, &sdnv_length);

    /* Primary Header Processing Flags */

    *pri_hdr_procflags = (uint8_t) (bundle_processing_control_flags & 0x7f);

    if (sdnv_length < 1 || sdnv_length > 8) {

        expert_add_info_format(pinfo, primary_tree, &ei_bundle_control_flags_length,

                               "Wrong bundle control flag length: %d", sdnv_length);

        return 0;

    }

    ti = proto_tree_add_item(primary_tree, hf_bundle_control_flags, tvb,

                                                offset, sdnv_length, ENC_BIG_ENDIAN);

    proc_flag_tree = proto_item_add_subtree(ti, ett_proc_flags);

    ti = proto_tree_add_uint(proc_flag_tree, hf_bundle_procflags_general, tvb, offset,

                                        sdnv_length, *pri_hdr_procflags);

    gen_flag_tree = proto_item_add_subtree(ti, ett_gen_flags);

    /* With the variability of sdnv_length, proto_tree_add_bitmask_value

       can't be used */

    proto_tree_add_bitmask_list_value(gen_flag_tree, tvb, offset, sdnv_length, pri_flags, *pri_hdr_procflags);

    /* Primary Header COS Flags */

    cosflags = (uint8_t) ((bundle_processing_control_flags >> 7) & 0x7f);

    ti = proto_tree_add_uint(proc_flag_tree, hf_bundle_procflags_cos, tvb, offset,

                                        sdnv_length, cosflags);

    cos_flag_tree = proto_item_add_subtree(ti, ett_cos_flags);

    proto_tree_add_uint(cos_flag_tree, hf_bundle_cosflags_priority, tvb, offset,

                                    sdnv_length, cosflags);

    /* Status Report Request Flags */

    srrflags = (uint8_t) ((bundle_processing_control_flags >> 14) & 0x7f);

    ti = proto_tree_add_uint(proc_flag_tree, hf_bundle_procflags_status, tvb, offset,

                                        sdnv_length, srrflags);

    srr_flag_tree = proto_item_add_subtree(ti, ett_srr_flags);

    proto_tree_add_bitmask_list_value(srr_flag_tree, tvb, offset, sdnv_length, srr_flags, srrflags);

    offset += sdnv_length;

    /* -- hdr_length -- */

    bundle_header_length = evaluate_sdnv(tvb, offset, &sdnv_length);

    ti = proto_tree_add_int(primary_tree, hf_bundle_primary_header_len, tvb, offset, sdnv_length,

                            bundle_header_length);

    if (bundle_header_length < 0) {

        expert_add_info_format(pinfo, ti, &ei_bundle_sdnv_length, "Bundle Header Length Error");

        return tvb_reported_length_remaining(tvb, offset);

    }

    offset += sdnv_length;

    /*

     * Pick up offsets into dictionary (8 of them). Do rough sanity check that SDNV

     * hasn't told us to access way past the Primary Header.

     */

    /* Ensure all fields have been initialized */

    memset(&dict_data, 0, sizeof(dict_data));

    /* -- dest_scheme -- */

    dict_data.dest_scheme_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.dst_scheme_pos = offset;

    dict_data.dst_scheme_len = sdnv_length;

    ti_dst_scheme_offset = proto_tree_add_int(primary_tree, hf_bundle_dest_scheme_offset_i32, tvb, offset, sdnv_length,

                            dict_data.dest_scheme_offset);

    offset += sdnv_length;

    /* -- dest_ssp -- */

    dict_data.dest_ssp_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.dst_ssp_len = sdnv_length;

    dst_ssp = dict_data.dest_ssp_offset;

    ti_dst_ssp_offset = proto_tree_add_int(primary_tree, hf_bundle_dest_ssp_offset_i32, tvb, offset, sdnv_length,

                            dict_data.dest_ssp_offset);

    offset += sdnv_length;

    /* -- source_scheme -- */

    dict_data.source_scheme_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.src_scheme_pos = offset;

    dict_data.src_scheme_len = sdnv_length;

    ti_src_scheme_offset = proto_tree_add_int(primary_tree, hf_bundle_source_scheme_offset_i32, tvb, offset, sdnv_length,

                            dict_data.source_scheme_offset);

    offset += sdnv_length;

    /* -- source_ssp -- */

    dict_data.source_ssp_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.src_ssp_len = sdnv_length;

    src_ssp = dict_data.source_ssp_offset;

    ti_src_ssp_offset = proto_tree_add_int(primary_tree, hf_bundle_source_ssp_offset_i32, tvb, offset, sdnv_length,

                            dict_data.source_ssp_offset);

    offset += sdnv_length;

    /* -- report_scheme -- */

    dict_data.report_scheme_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.rpt_scheme_pos = offset;

    dict_data.rpt_scheme_len = sdnv_length;

    ti_rprt_scheme_offset = proto_tree_add_int(primary_tree, hf_bundle_report_scheme_offset_i32, tvb, offset,

                            sdnv_length, dict_data.report_scheme_offset);

    offset += sdnv_length;

    /* -- report_ssp -- */

    dict_data.report_ssp_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.rpt_ssp_len = sdnv_length;

    ti_rprt_ssp_offset = proto_tree_add_int(primary_tree, hf_bundle_report_ssp_offset_i32, tvb, offset, sdnv_length,

                            dict_data.report_ssp_offset);

    offset += sdnv_length;

    /* -- cust_scheme -- */

    dict_data.cust_scheme_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.cust_scheme_pos = offset;

    dict_data.cust_scheme_len = sdnv_length;

    ti_cust_scheme_offset = proto_tree_add_int(primary_tree, hf_bundle_cust_scheme_offset_i32, tvb, offset, sdnv_length,

                            dict_data.cust_scheme_offset);

    offset += sdnv_length;

    /* -- cust_ssp -- */

    dict_data.cust_ssp_offset = evaluate_sdnv(tvb, offset, &sdnv_length);

    dict_data.cust_ssp_len = sdnv_length;

    ti_cust_ssp_offset = proto_tree_add_int(primary_tree, hf_bundle_cust_ssp_offset_i32, tvb, offset, sdnv_length,

                            dict_data.cust_ssp_offset);

    offset += sdnv_length;

    creation_timestamp = evaluate_sdnv(tvb, offset, &sdnv_length);

    sdnv_length = add_sdnv_time_to_tree(primary_tree, tvb, offset, hf_bundle_primary_timestamp);

    if (sdnv_length == 0)

        return 0;

    offset += sdnv_length;

    /* -- timestamp_sequence -- */

    timestamp_sequence = evaluate_sdnv(tvb, offset, &sdnv_length);

    if (timestamp_sequence < 0) {

        int64_t ts_seq = evaluate_sdnv_64(tvb, offset, &sdnv_length);

        ti = proto_tree_add_int64(primary_tree, hf_bundle_primary_timestamp_seq_num64,

                                                        tvb, offset, sdnv_length, ts_seq);

        if (ts_seq < 0) {

            expert_add_info(pinfo, ti, &ei_bundle_timestamp_seq_num);

        }

    }

    else {

        proto_tree_add_int(primary_tree, hf_bundle_primary_timestamp_seq_num32,

                                                        tvb, offset, sdnv_length, timestamp_sequence);

    }

    offset += sdnv_length;

    /* -- lifetime -- */

    sdnv_length = add_sdnv_to_tree(primary_tree, tvb, pinfo, offset, hf_bundle_lifetime_sdnv);

    offset += sdnv_length;

    /* -- dict_length -- */

    dict_data.bundle_header_dict_length = evaluate_sdnv(tvb, offset, &sdnv_length);

    ti = proto_tree_add_int(primary_tree, hf_bundle_primary_dictionary_len, tvb, offset, sdnv_length,

                            dict_data.bundle_header_dict_length);

    if (dict_data.bundle_header_dict_length < 0) {

        expert_add_info_format(pinfo, ti, &ei_bundle_sdnv_length, "Dictionary Header Length Error");

        return tvb_reported_length_remaining(tvb, offset);

    }

    offset += sdnv_length;

    if ((dict_data.dest_scheme_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.dest_scheme_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_dst_scheme_offset, &ei_bundle_offset_error, "Destination Scheme Offset Error");

    }

    if ((dict_data.dest_ssp_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.dest_ssp_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_dst_ssp_offset, &ei_bundle_offset_error, "Destination SSP Offset Error");

    }

    if ((dict_data.source_scheme_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.source_scheme_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_src_scheme_offset, &ei_bundle_offset_error, "Source Scheme Offset Error");

    }

    if ((dict_data.source_ssp_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.source_ssp_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_src_ssp_offset, &ei_bundle_offset_error, "Source SSP Offset Error");

    }

    if ((dict_data.report_scheme_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.report_scheme_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_rprt_scheme_offset, &ei_bundle_offset_error, "Report Scheme Offset Error");

    }

    if ((dict_data.report_ssp_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.report_ssp_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_rprt_ssp_offset, &ei_bundle_offset_error, "Report SSP Offset Error");

    }

    if ((dict_data.cust_scheme_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.cust_scheme_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_cust_scheme_offset, &ei_bundle_offset_error, "Custodian Scheme Offset Error");

    }

    if ((dict_data.cust_ssp_offset < 0) ||

        (dict_data.bundle_header_dict_length > 0 && (dict_data.cust_ssp_offset > bundle_header_length))) {

        expert_add_info_format(pinfo, ti_cust_ssp_offset, &ei_bundle_offset_error, "Custodian SSP Offset Error");

    }

    offset = dissect_dictionary(pinfo, primary_tree, tvb, offset, &dict_data, *pri_hdr_procflags, bundle_custodian,

                                creation_timestamp, timestamp_sequence);

    return offset;

}

/*

 * offset is where the header starts.

 * Return new offset, and set lastheader if failure.

 */

static int

dissect_payload_header(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset, uint8_t version,

                       uint8_t pri_hdr_procflags, bool *lastheader)

{

    proto_item *payload_block, *payload_item, *ti;

    proto_tree *payload_block_tree, *payload_tree;

    int         sdnv_length, payload_length;

    payload_block_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_payload_hdr, &payload_block, "Payload Block");

    payload_tree = proto_tree_add_subtree(payload_block_tree, tvb, offset, -1, ett_payload_hdr, &payload_item, "Payload Header");