/* packet-geonw.c

 * Routines for GeoNetworking and BTP-A/B dissection

 * Coyright 2018, C. Guerber <cguerber@yahoo.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/*

 * The GeoNetworking protocol is a network layer protocol that provides packet

 * routing in an ad hoc network. It makes use of geographical positions for

 * packet transport. GeoNetworking supports the communication among individual

 * ITS stations as well as the distribution of packets in geographical areas.

 * (Extracted from ETSI EN 302 636-4-1)

 *

 * The Basic Transport Protocol (BTP) provides an end-to-end, connection-less

 * transport service in the ITS ad hoc network. Its main purpose is the

 * multiplexing of messages from different processes at the ITS facilities

 * layer, e.g. CAM and DENM from the cooperative awareness basic service and

 * the distributed environmental notification basic service, for the

 * transmission of packets via the GeoNetworking protocol as well as the

 * de-multiplexing at the destination.

 * (Extracted from ETSI EN 302 636-5-1)

 *

 * Reference standards:

 * ETSI EN 302 636-4-1 v1.2.0 (2013-10)

 * Intelligent Transport Systems (ITS); Vehicular Communications; GeoNetworking;

 * Part 4:     Geographical addressing and forwarding for point-to-point and

 *             point-to-multipoint communications;

 * Sub-part 1: Media-Independent Functionality

 *

 * ETSI EN 302 636-5-1 v1.2.1 (2014-08)

 * Intelligent Transport Systems (ITS); Vehicular Communications; GeoNetworking;

 * Part 5:     Transport Protocols;

 * Sub-part 1: Basic Transport Protocol

 *

 * ETSI EN 302 636-6-1 v1.2.1 (2014-05)

 * Intelligent Transport Systems (ITS); Vehicular Communications; GeoNetworking;

 * Part 6:     Internet Integration;

 * Sub-part 1: Transmission of IPv6 Packets over GeoNetworking Protocols

 *

 * ETSI TS 103 248 v1.2.1 (2018-08)

 * Intelligent Transport Systems (ITS); GeoNetworking;

 * Port Numbers for the Basic Transport Protocol (BTP)

 *

 * ETSI TS 103 097 v1.1.1, v1.2.1 and v1.3.1

 * Intelligent Transport Systems (ITS); Security;

 * Security header and certificate formats

 *

 */

#include <config.h>

#include <stdlib.h>

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/decode_as.h>

#include <epan/proto_data.h>

#include <epan/address_types.h>

#include <epan/addr_resolv.h>

#include <epan/to_str.h>

#include <epan/conversation.h>

#include <epan/tap.h>

#include <epan/etypes.h>

#include <epan/unit_strings.h>

#include <epan/exceptions.h>

#include <wsutil/utf8_entities.h>

#include "packet-e164.h"

#include "packet-ieee1609dot2.h"

#include "packet-geonw.h"

/*

 * Prototypes

 */

void proto_reg_handoff_btpb(void);

void proto_register_btpb(void);

void proto_reg_handoff_btpa(void);

void proto_register_btpa(void);

void proto_reg_handoff_geonw(void);

void proto_register_geonw(void);

/*

 * Constants

 */

#define HT_MASK           0xf0

#define HST_MASK          0x0f

// Definition of header types See section 8.7.4 table 9

#define HT_BEACON         0x10

#define HT_GEOUNICAST     0x20

#define HT_GEOANYCAST     0x30

#define HT_GEOBROADCAST   0x40

#define HT_TSB            0x50

#define HT_LS             0x60

// Area subtypes

#define HST_CIRCULAR      0x00

#define HST_RECTANGULAR   0x01

#define HST_ELLIPSOIDAL   0x02

// TSB subtype

#define HST_SINGLE_HOP    0x00

#define HST_MULTI_HOP     0x01

// LS subtypes

#define HST_REQUEST       0x00

#define HST_REPLY         0x01

// Types and subtype combined

#define HTST_BEACON       (HT_BEACON)

#define HTST_GEOUNICAST   (HT_GEOUNICAST)

#define HTST_GAC_CIRCLE   (HT_GEOANYCAST|HST_CIRCULAR)

#define HTST_GAC_RECT     (HT_GEOANYCAST|HST_RECTANGULAR)

#define HTST_GAC_ELLIPSE  (HT_GEOANYCAST|HST_ELLIPSOIDAL)

#define HTST_GBC_CIRCLE   (HT_GEOBROADCAST|HST_CIRCULAR)

#define HTST_GBC_RECT     (HT_GEOBROADCAST|HST_RECTANGULAR)

#define HTST_GBC_ELLIPSE  (HT_GEOBROADCAST|HST_ELLIPSOIDAL)

#define HTST_TSB_SINGLE   (HT_TSB|HST_SINGLE_HOP)

#define HTST_TSB_MULT     (HT_TSB|HST_MULTI_HOP)

#define HTST_LS_REQUEST   (HT_LS|HST_REQUEST)

#define HTST_LS_REPLY     (HT_LS|HST_REPLY)

#define HT_GET(ht)        ((ht)&HT_MASK)

#define HST_GET(ht)       ((ht)&HST_MASK)

#define IS_HT_KNOWN(ht)   ((ht) <= 0x61) && (ht >= 0x10) && (HST_GET(ht) < 3) && ((HST_GET(ht) == 0) || ((HT_GET(ht) > 0x30) && ((HST_GET(ht) == 1) || ((HST_GET(ht) == 2) && (HT_GET(ht) < 0x43)))))

#define BH_LEN            4

#define BH_NH_COMMON_HDR  1

#define BH_NH_SECURED_PKT 2

#define CH_LEN            8

#define CH_NH_BTP_A       1

#define CH_NH_BTP_B       2

#define CH_NH_IPV6        3

#define GUC_LEN           48

#define TSB_LEN           28

#define GAC_LEN           44

#define GBC_LEN           44

#define BEACON_LEN        24

#define LS_REQUEST_LEN    36

#define LS_REPLY_LEN      48

#define TST_MAX 0xffffffff

#define SEC_TVB_KEY 0

/*

 * Variables

 */

static wmem_map_t *geonw_hashtable;

static int proto_geonw;

static int proto_btpa;

static int proto_btpb;

static int geonw_tap;

static int btpa_tap;

static int btpa_follow_tap;

static int btpb_tap;

static int btpb_follow_tap;

static int hf_geonw_bh;

static int hf_geonw_bh_version;

static int hf_geonw_bh_next_header;

static int hf_geonw_bh_reserved;

static int hf_geonw_bh_life_time;

static int hf_geonw_bh_lt_mult;

static int hf_geonw_bh_lt_base;

static int hf_geonw_bh_remain_hop_limit;

static int hf_geonw_ch;

static int hf_geonw_ch_next_header;

static int hf_geonw_ch_reserved1;

static int hf_geonw_ch_header_type;

//static int hf_geonw_ch_header_subtype;

static int hf_geonw_ch_traffic_class;

static int hf_geonw_ch_tc_scf;

static int hf_geonw_ch_tc_offload;

static int hf_geonw_ch_tc_id;

static int hf_geonw_ch_flags;

static int hf_geonw_ch_flags_mob;

static int hf_geonw_ch_flags_reserved;

static int hf_geonw_ch_payload_length;

static int hf_geonw_ch_max_hop_limit;

static int hf_geonw_ch_reserved2;

static int hf_geonw_seq_num;

static int hf_geonw_reserved;

static int hf_geonw_so_pv;

static int hf_geonw_so_pv_addr;

static int hf_geonw_so_pv_addr_manual;

static int hf_geonw_so_pv_addr_type;

static int hf_geonw_so_pv_addr_country;

static int hf_geonw_so_pv_addr_mid;

static int hf_geonw_so_pv_time;

static int hf_geonw_so_pv_lat;

static int hf_geonw_so_pv_lon;

static int hf_geonw_so_pv_pai;

static int hf_geonw_so_pv_speed;

static int hf_geonw_so_pv_heading;

static int hf_geonw_de_pv;

static int hf_geonw_de_pv_addr;

static int hf_geonw_de_pv_addr_manual;

static int hf_geonw_de_pv_addr_type;

static int hf_geonw_de_pv_addr_country;

static int hf_geonw_de_pv_addr_mid;

static int hf_geonw_de_pv_time;

static int hf_geonw_de_pv_lat;

static int hf_geonw_de_pv_lon;

static int hf_geonw_gxc_latitude;

static int hf_geonw_gxc_longitude;

static int hf_geonw_gxc_radius;

static int hf_geonw_gxc_distancea;

static int hf_geonw_gxc_distanceb;

static int hf_geonw_gxc_angle;

static int hf_geonw_gxc_reserved;

static int hf_geonw_shb_reserved;

static int hf_geonw_lsrq_addr;

static int hf_geonw_lsrq_addr_manual;

static int hf_geonw_lsrq_addr_type;

static int hf_geonw_lsrq_addr_country;

static int hf_geonw_lsrq_addr_mid;

static int hf_geonw_beacon;

static int hf_geonw_guc;

static int hf_geonw_gac;

static int hf_geonw_gbc;

static int hf_geonw_tsb;

static int hf_geonw_ls;

static int hf_geonw_analysis_flags;

static int hf_btpa_dstport;

static int hf_btpa_srcport;

static int hf_btpa_port;

static int hf_btpb_dstport;

static int hf_btpb_dstport_info;

static int hf_geonw_resp_in;

static int hf_geonw_resp_to;

static int hf_geonw_no_resp;

static int hf_geonw_resptime;

static int hf_geonw_dccmco;

static int hf_geonw_dccmco_cbr_l_0_hop;

static int hf_geonw_dccmco_cbr_l_1_hop;

static int hf_geonw_dccmco_output_power;

static int hf_geonw_dccmco_reserved;

static int ett_geonw;

static int ett_geonw_bh;

static int ett_geonw_bh_lt;

static int ett_geonw_ch;

static int ett_geonw_ch_tc;

static int ett_geonw_sh;

static int ett_geonw_so;

static int ett_geonw_so_add;

static int ett_geonw_de;

static int ett_geonw_de_add;

static int ett_geonw_lsrq_add;

static int ett_geonw_analysis;

static int ett_geonw_dccmco;

static int ett_btpa;

static int ett_btpb;

static int geonw_address_type = -1;

static expert_field ei_geonw_nz_reserved;

static expert_field ei_geonw_version_err;

static expert_field ei_geonw_rhl_lncb;

static expert_field ei_geonw_rhl_too_low;

static expert_field ei_geonw_mhl_lt_rhl;

static expert_field ei_geonw_scc_too_big;

static expert_field ei_geonw_analysis_duplicate;

static expert_field ei_geonw_resp_not_found;

static expert_field ei_geonw_out_of_range;

static expert_field ei_geonw_payload_len;

static expert_field ei_geonw_intx_too_big;

static dissector_table_t geonw_subdissector_table;

static dissector_table_t ssp_subdissector_table;

static dissector_table_t btpa_subdissector_table;

static dissector_table_t btpb_subdissector_table;

static const value_string ch_header_type_names[] = {

    { HTST_BEACON, "Beacon" },

    { HTST_GEOUNICAST, "Geo Unicast" },

    { HTST_GAC_CIRCLE, "Geo-scoped Anycast Circular area" },

    { HTST_GAC_RECT, "Geo-scoped Anycast Rectangular area" },

    { HTST_GAC_ELLIPSE, "Geo-scoped Anycast Ellipsoidal area" },

    { HTST_GBC_CIRCLE, "Geo-scoped Broadcast Circular area" },

    { HTST_GBC_RECT, "Geo-scoped Broadcast Rectangular area" },

    { HTST_GBC_ELLIPSE, "Geo-scoped Broadcast Ellipsoidal area" },

    { HTST_TSB_SINGLE, "Topologically-scoped broadcast Single-hop broadcast (SHB)" },

    { HTST_TSB_MULT, "Topologically-scoped broadcast Multi-hop broadcast (TSB)" },

    { HTST_LS_REQUEST, "Location Service Request" },

    { HTST_LS_REPLY, "Location Service Reply" },

    { 0x00, NULL}

};

static dissector_handle_t ieee1609dot2_handle;

static dissector_handle_t geonw_handle;

static dissector_handle_t btpa_handle;

static dissector_handle_t btpb_handle;

static dissector_handle_t ipv6_handle;

static heur_dissector_list_t btpa_heur_subdissector_list;

static heur_dissector_list_t btpb_heur_subdissector_list;

/*

 * Basic Transport Protocol A dissector

 */

static int

dissect_btpa(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

    heur_dtbl_entry_t *hdtbl_entry;

    uint32_t low_port, high_port;

    uint32_t dst_port, src_port;

    proto_item *hidden_item;

    struct btpaheader *btpah;

    btpah = wmem_new0(pinfo->pool, struct btpaheader);

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

    /* Clear out stuff in the info column */

    col_clear(pinfo->cinfo,COL_INFO);

    proto_item *ti = proto_tree_add_item(tree, proto_btpa, tvb, 0, 4, ENC_NA);

    proto_tree *btpa_tree = proto_item_add_subtree(ti, ett_btpa);

    proto_tree_add_item_ret_uint(btpa_tree, hf_btpa_dstport, tvb, 0, 2, ENC_BIG_ENDIAN, &dst_port);

    proto_tree_add_item_ret_uint(btpa_tree, hf_btpa_srcport, tvb, 2, 2, ENC_BIG_ENDIAN, &src_port);

    pinfo->srcport = src_port;

    pinfo->destport = dst_port;

    col_append_ports(pinfo->cinfo, COL_INFO, PT_NONE, pinfo->srcport, pinfo->destport);

    // Add hidden port field

    hidden_item = proto_tree_add_item(btpa_tree, hf_btpa_port, tvb, 0, 2, ENC_BIG_ENDIAN);

    proto_item_set_hidden(hidden_item);

    hidden_item = proto_tree_add_item(btpa_tree, hf_btpa_port, tvb, 2, 2, ENC_BIG_ENDIAN);

    proto_item_set_hidden(hidden_item);

    btpah->btp_psrc = src_port;

    btpah->btp_pdst = dst_port;

    copy_address_shallow(&btpah->gnw_src, &pinfo->src);

    copy_address_shallow(&btpah->gnw_dst, &pinfo->dst);

    tap_queue_packet(btpa_tap, pinfo, btpah);

    tvbuff_t *next_tvb = tvb_new_subset_remaining(tvb, 4);

    if (have_tap_listener(btpa_follow_tap))

        tap_queue_packet(btpa_follow_tap, pinfo, next_tvb);

    if (src_port > dst_port) {

        low_port = dst_port;

        high_port = src_port;

    } else {

        low_port = src_port;

        high_port = dst_port;

    }

    if (dissector_try_uint_with_data(btpa_subdissector_table, low_port, next_tvb, pinfo, tree, true, NULL))

        return tvb_captured_length(tvb);

    if (dissector_try_uint_with_data(btpa_subdissector_table, high_port, next_tvb, pinfo, tree, true, NULL))

        return tvb_captured_length(tvb);

    if (dissector_try_heuristic(btpa_heur_subdissector_list, next_tvb, pinfo, tree, &hdtbl_entry, NULL))

        return tvb_captured_length(tvb);

    call_data_dissector(next_tvb, pinfo, tree);

    return tvb_captured_length(tvb);

}

/*

 * Basic Transport Protocol B dissector

 */

static int

dissect_btpb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

    heur_dtbl_entry_t *hdtbl_entry;

    uint32_t dst_port;

    uint32_t dst_info;

    struct btpbheader *btpbh;

    btpbh = wmem_new0(pinfo->pool, struct btpbheader);

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

    /* Clear out stuff in the info column */

    col_clear(pinfo->cinfo,COL_INFO);

    proto_item *ti = proto_tree_add_item(tree, proto_btpb, tvb, 0, 4, ENC_NA);

    proto_tree *btpb_tree = proto_item_add_subtree(ti, ett_btpb);

    proto_tree_add_item_ret_uint(btpb_tree, hf_btpb_dstport, tvb, 0, 2, ENC_BIG_ENDIAN, &dst_port);

    proto_tree_add_item_ret_uint(btpb_tree, hf_btpb_dstport_info, tvb, 2, 2, ENC_BIG_ENDIAN, &dst_info);

    pinfo->destport = dst_port;

    col_append_fstr(pinfo->cinfo, COL_INFO, " " UTF8_RIGHTWARDS_ARROW " %u", dst_port);

    btpbh->btp_pdst = dst_port;

    btpbh->btp_idst = dst_info;

    copy_address_shallow(&btpbh->gnw_src, &pinfo->src);

    copy_address_shallow(&btpbh->gnw_dst, &pinfo->dst);

    tap_queue_packet(btpb_tap, pinfo, btpbh);

    tvbuff_t *next_tvb = tvb_new_subset_remaining(tvb, 4);

    if (have_tap_listener(btpb_follow_tap))

        tap_queue_packet(btpb_follow_tap, pinfo, next_tvb);

    if (dissector_try_uint_with_data(btpb_subdissector_table, dst_port, next_tvb, pinfo, tree, true, NULL)) {

        return tvb_captured_length(tvb);

    }

    if (dissector_try_heuristic(btpb_heur_subdissector_list, next_tvb, pinfo, tree, &hdtbl_entry, NULL)) {

        return tvb_captured_length(tvb);

    }

    call_data_dissector(next_tvb, pinfo, tree);

    return tvb_captured_length(tvb);

}

/*

 * ===========================================================================

 * GeoNetworking dissector

 * ===========================================================================

 */

typedef struct _geonw_transaction_t {

    uint32_t rqst_frame;

    uint32_t resp_frame;

    nstime_t rqst_time;

    nstime_t resp_time;

} geonw_transaction_t;

typedef struct _geonw_conv_info_t {

    wmem_stack_t *unmatched_pdus;

    wmem_tree_t  *matched_pdus;

} geonw_conv_info_t;

static const char * get_geonw_name(const uint8_t *addr);

static const char* geonw_name_resolution_str(const address* addr);

static int geonw_name_resolution_len(void);

static geonw_transaction_t *transaction_start(packet_info * pinfo, proto_tree * tree);

static geonw_transaction_t *transaction_end(packet_info * pinfo, proto_tree * tree);

static bool geonw_analyze_seq           = true;

/*

 * GeoNetworking Address Type

 */

/* Adapter from ethernet and ipv4 Address Type code */

struct hashgeonw;

typedef struct hashgeonw hashgeonw_t;

struct hashgeonw {

    unsigned          status;

    uint8_t           addr[8];

    char              hexaddr[28];

    char              resolved_name[MAXNAMELEN];

    // Node follow up used for duplication detection

    uint32_t          timestamp;

    uint32_t          sequence_number;

};

static int

geonw_str_len(const address* addr _U_)

{

    // (0/1)'.'(0..31)'.'(0..1023)'.'{eth}

    return 28;

}

static int

_geonw_to_str(const uint8_t* addrdata, char *buf, int buf_len _U_)

{

    address eth_addr;

    // Initial or Manual

    if (addrdata[0] & 0x80)

        *buf++ = '1';

    else

        *buf++ = '0';

    *buf++ = '.';

    // Station Type

    uint32_to_str_buf((addrdata[0] & 0x7C) >> 2, buf, 26);

    buf += (unsigned) strlen(buf);

    *buf++ = '.';

    // Country Code

    uint32_to_str_buf(((uint32_t)(addrdata[0] & 0x03) << 8) + addrdata[1], buf, 23); // > 23

    buf += (unsigned) strlen(buf);

    *buf++ = '.';

    // LL_ADDR

    set_address(&eth_addr, AT_ETHER, 6, &(addrdata[2]));

    ether_to_str(&eth_addr, buf, 18);

    return 28;

}

static int

geonw_to_str(const address* addr, char *buf, int buf_len _U_)

{

    return _geonw_to_str((const uint8_t *)addr->data, buf, buf_len);

}

static const char*

geonw_col_filter_str(const address* addr _U_, bool is_src)

{

    if (is_src)

        return "geonw.src_pos.addr";

    return "geonw.dst_pos.addr";

}

static int

geonw_len(void)

{

    return 8;

}

static unsigned

geonw_addr_hash(const void *key)

{

    return wmem_strong_hash((const uint8_t *)key, 8);

}

static gboolean

geonw_addr_cmp(const void *a, const void *b)

{

    return (memcmp(a, b, 8) == 0);

}

/*

 * These two value_string are used for address resolv:

 */

static const value_string itss_type_small_names[] = {

    { 0,  "unk" },

    { 1,  "ped" },

    { 2,  "cyc" },

    { 3,  "mop" },

    { 4,  "mot" },

    { 5,  "pas" },

    { 6,  "bus" },

    { 7,  "ltr" },

    { 8,  "htr" },

    { 9,  "trl" },

    { 10, "spe" },

    { 11, "trm" },

    { 15, "rsu" },

    { 0, NULL}

};

/* Resolve geonetworking address */

static hashgeonw_t *

geonw_addr_resolve(hashgeonw_t *tp) {

    const uint8_t *addr = tp->addr;

    uint16_t val;

    char *rname = tp->resolved_name;

    address eth_addr;

    uint8_t l1, l2;

    // Initial or Manual

    if (addr[0] & 0x80)

        *rname++ = 'm';

    else

        *rname++ = 'i';

    *rname++ = '.';

    // Station Type

    val = (addr[0] & 0x7C) >> 2;

    const char *string = try_val_to_str(val, itss_type_small_names);

    if (string == NULL) {

        uint32_to_str_buf(val, rname, MAXNAMELEN-2);

        l1 = (uint8_t) strlen(rname);

    }

    else {

        l1 = (uint8_t) g_strlcpy(rname, string, MAXNAMELEN-2);

    }

    rname += l1;

    *rname++ = '.';

    // Country Code

    val = ((uint32_t)(addr[0] & 0x03) << 8) + addr[1];

    string = try_val_to_str(val, E164_ISO3166_country_code_short_value);

    if (string == NULL) {

        uint32_to_str_buf(val, rname, MAXNAMELEN-12);

        l2 = (uint8_t) strlen(rname);

    }

    else {

        l2 = (uint8_t) g_strlcpy(rname, string, MAXNAMELEN-l1-3);

    }

    rname += l2;

    //l1 += l2;

    *rname++ = '.';

    // LL_ADDR

    set_address(&eth_addr, AT_ETHER, 6, &(addr[2]));

    ether_to_str(&eth_addr, rname, 18);

    // We could use ether_name_resolution_str:

    //     (void) g_strlcpy(rname, ether_name_resolution_str(&eth_addr), MAXNAMELEN-l1-4);

    tp->status = 1;

    return tp;

}

static hashgeonw_t *

geonw_hash_new_entry(const uint8_t *addr, bool resolve)

{

    hashgeonw_t *tp;

    tp = wmem_new(wmem_file_scope(), hashgeonw_t);

    memcpy(tp->addr, addr, sizeof(tp->addr));

    /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */

    _geonw_to_str(addr, tp->hexaddr, 28);

    tp->resolved_name[0] = '\0';

    tp->status = 0;

    tp->timestamp = 0;

    tp->sequence_number = SN_MAX + 1;

    if (resolve)

        geonw_addr_resolve(tp);

    wmem_map_insert(geonw_hashtable, tp->addr, tp);

    return tp;

} /* geonw_hash_new_entry */

static hashgeonw_t *

geonw_name_lookup(const uint8_t *addr, bool resolve)

{

    hashgeonw_t  *tp;

    tp = (hashgeonw_t *)wmem_map_lookup(geonw_hashtable, addr);

    if (tp == NULL) {

        tp = geonw_hash_new_entry(addr, resolve);

    } else {

        if (resolve && !tp->status) {

            geonw_addr_resolve(tp); /* Found but needs to be resolved */

        }

    }

    return tp;

} /* geonw_name_lookup */

const char *

get_geonw_name(const uint8_t *addr)

{

    hashgeonw_t *tp;

    bool resolve = gbl_resolv_flags.network_name;

    tp = geonw_name_lookup(addr, resolve);

    return resolve ? tp->resolved_name : tp->hexaddr;

} /* get_geonw_name */

const char* geonw_name_resolution_str(const address* addr)

{

    return get_geonw_name((const uint8_t *)addr->data);

}

int geonw_name_resolution_len(void)

{

    return MAX_ADDR_STR_LEN; /* XXX - This can be lower */

}

/*

 * Conversations for GeoNetworking

 */

/* Adapted from ICMP echo request/reply code */

/* GeoNw LS request/reply transaction statistics ... */

static geonw_transaction_t *transaction_start(packet_info * pinfo, proto_tree * tree)

{

    conversation_t *conversation;

    geonw_conv_info_t *geonw_info;

    geonw_transaction_t *geonw_trans;

    wmem_tree_key_t geonw_key[3];

    proto_item *it;

    /* Handle the conversation tracking */

    conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst, conversation_pt_to_conversation_type(pinfo->ptype), HT_LS, HT_LS, 0);

    if (conversation == NULL) {

        /* No, this is a new conversation. */

        conversation = conversation_new(pinfo->num, &pinfo->src, &pinfo->dst, conversation_pt_to_conversation_type(pinfo->ptype), HT_LS, HT_LS, 0);

    }

    geonw_info = (geonw_conv_info_t *)conversation_get_proto_data(conversation, proto_geonw);

    if (geonw_info == NULL) {

        geonw_info = wmem_new(wmem_file_scope(), geonw_conv_info_t);

        geonw_info->unmatched_pdus = wmem_stack_new(wmem_file_scope());

        geonw_info->matched_pdus   = wmem_tree_new(wmem_file_scope());

        conversation_add_proto_data(conversation, proto_geonw, geonw_info);

    }

    if (!PINFO_FD_VISITED(pinfo)) {

        /* this is a new request, create a new transaction structure and map it to the

           unmatched table

         */

        geonw_trans = wmem_new(wmem_file_scope(), geonw_transaction_t);

        geonw_trans->rqst_frame = pinfo->num;

        geonw_trans->resp_frame = 0;

        geonw_trans->rqst_time = pinfo->abs_ts;

        nstime_set_zero(&geonw_trans->resp_time);

        wmem_stack_push(geonw_info->unmatched_pdus, (void *) geonw_trans);

    } else {

        /* Already visited this frame */

        uint32_t frame_num = pinfo->num;

        geonw_key[0].length = 1;

        geonw_key[0].key = &frame_num;

        geonw_key[1].length = 0;

        geonw_key[1].key = NULL;

        geonw_trans = (geonw_transaction_t *)wmem_tree_lookup32_array(geonw_info->matched_pdus, geonw_key);

    }

    if (geonw_trans == NULL) {

        if (PINFO_FD_VISITED(pinfo)) {

            /* No response found - add field and expert info */

            it = proto_tree_add_item(tree, hf_geonw_no_resp, NULL, 0, 0, ENC_NA);

            proto_item_set_generated(it);

            col_append_str(pinfo->cinfo, COL_INFO, " (no response found!)");

            /* Expert info. */

            expert_add_info_format(pinfo, it, &ei_geonw_resp_not_found, "No response seen to LS Request");

        }

        return NULL;

    }

    /* Print state tracking in the tree */

    if (geonw_trans->resp_frame) {

        it = proto_tree_add_uint(tree, hf_geonw_resp_in, NULL, 0, 0, geonw_trans->resp_frame);

        proto_item_set_generated(it);

        col_append_frame_number(pinfo, COL_INFO, " (reply in %u)", geonw_trans->resp_frame);

    }

    return geonw_trans;

} /* transaction_start() */

static geonw_transaction_t *transaction_end(packet_info * pinfo, proto_tree * tree)

{

    conversation_t *conversation;

    geonw_conv_info_t *geonw_info;

    geonw_transaction_t *geonw_trans;

    wmem_tree_key_t geonw_key[3];

    proto_item *it;

    nstime_t ns;

    double resp_time;

    conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst, conversation_pt_to_conversation_type(pinfo->ptype), HT_LS, HT_LS, 0);

    if (conversation == NULL) {

        return NULL;

    }

    geonw_info = (geonw_conv_info_t *)conversation_get_proto_data(conversation, proto_geonw);

    if (geonw_info == NULL) {

        return NULL;

    }

    if (!PINFO_FD_VISITED(pinfo)) {

        uint32_t frame_num;

        geonw_trans = (geonw_transaction_t *)wmem_stack_peek(geonw_info->unmatched_pdus);

        if (geonw_trans == NULL) {

            return NULL;

        }

        /* we have already seen this response, or an identical one */

        if (geonw_trans->resp_frame != 0) {

            return NULL;

        }

        geonw_trans->resp_frame = pinfo->num;

        /* we found a match. Add entries to the matched table for both request and reply frames

         */

        geonw_key[0].length = 1;

        geonw_key[0].key = &frame_num;

        geonw_key[1].length = 0;

        geonw_key[1].key = NULL;

        frame_num = geonw_trans->rqst_frame;

        wmem_tree_insert32_array(geonw_info->matched_pdus, geonw_key, (void *) geonw_trans);

        frame_num = geonw_trans->resp_frame;

        wmem_tree_insert32_array(geonw_info->matched_pdus, geonw_key, (void *) geonw_trans);

    } else {

        /* Already visited this frame */

        uint32_t frame_num = pinfo->num;

        geonw_key[0].length = 1;

        geonw_key[0].key = &frame_num;

        geonw_key[1].length = 0;

        geonw_key[1].key = NULL;

        geonw_trans = (geonw_transaction_t *)wmem_tree_lookup32_array(geonw_info->matched_pdus, geonw_key);

        if (geonw_trans == NULL) {

            return NULL;

        }

    }

    it = proto_tree_add_uint(tree, hf_geonw_resp_to, NULL, 0, 0, geonw_trans->rqst_frame);

    proto_item_set_generated(it);

    nstime_delta(&ns, &pinfo->abs_ts, &geonw_trans->rqst_time);

    geonw_trans->resp_time = ns;

    resp_time = nstime_to_msec(&ns);

    it = proto_tree_add_double_format_value(tree, hf_geonw_resptime, NULL, 0, 0, resp_time, "%.3f ms", resp_time);

    proto_item_set_generated(it);

    col_append_frame_number(pinfo, COL_INFO, " (request in %d)", geonw_trans->rqst_frame);

    return geonw_trans;

} /* transaction_end() */

// Adapted from TCP sequence number analysis

// Conversation data

struct geonw_analysis {

    // Node follow up used for duplication detection

    uint32_t          timestamp;

    uint16_t          sequence_number;

};

/*

 * Secured geonetworking

 */

static int hf_geonw_sec;

static int hf_sgeonw_version;

static int hf_sgeonw_profile;

static int hf_sgeonw_hdr;

static int hf_sgeonw_pl;

static int hf_sgeonw_trl;

static int hf_sgeonw_var_len;

static int hf_sgeonw_var_len_det;

static int hf_sgeonw_var_len_val;

static int hf_sgeonw_header_field;

static int hf_sgeonw_header_field_type_v1;

static int hf_sgeonw_header_field_type_v2;

static int hf_sgeonw_opaque;

static int hf_sgeonw_payload_field;

static int hf_sgeonw_payload_field_type;

static int hf_sgeonw_trailer_field;

static int hf_sgeonw_trailer_field_type;

static int hf_sgeonw_certificate;

static int hf_sgeonw_encryption_parameter;

static int hf_sgeonw_signature;

static int hf_sgeonw_subject_info;

static int hf_sgeonw_subject_attribute;

static int hf_sgeonw_intx;

static int hf_sgeonw_time64;

static int hf_sgeonw_conf;

static int hf_sgeonw_time32;

static int hf_sgeonw_lat;

static int hf_sgeonw_lon;

static int hf_sgeonw_elev;

static int hf_sgeonw_hashedid3;

static int hf_sgeonw_hashedid8;

static int hf_sgeonw_duration;

static int hf_sgeonw_duration_unit;

static int hf_sgeonw_duration_value;

static int hf_sgeonw_encryption_parameter_nonce;

static int hf_sgeonw_msg_id;

static int hf_sgeonw_app_id;

static int ett_geonw_sec;

static int ett_sgeonw_hdr;

static int ett_sgeonw_field;

static int ett_sgeonw_var_len;

static int ett_sgeonw_intx;

static int ett_sgeonw_duration;

static int ett_sgeonw_encryption_parameter;

static int ett_sgeonw_signature;

static int ett_sgeonw_subject_info;

static int ett_sgeonw_subject_attribute;

static int ett_sgeonw_ssp;

static expert_field ei_sgeonw_len_unsupported;

static expert_field ei_sgeonw_len_too_long;

static expert_field ei_sgeonw_subj_info_too_long;

static expert_field ei_sgeonw_ssp_too_long;

static expert_field ei_sgeonw_bogus;

typedef enum {

    generation_time = 0,

    generation_time_confidence = 1,

    expiration = 2,

    generation_location = 3,

    request_unrecognized_certificate = 4,

    message_type = 5,

    signer_info = 128,

    recipient_info = 129,

    encryption_parameters = 130,

    last_hdr_type = (2<<8)-1

} HeaderFieldType;

static const value_string header_field_type_v1_names[] = {

    { generation_time,                  "Generation time" },

    { generation_time_confidence,       "Generation time confidence" },

    { expiration,                       "Expiration" },

    { generation_location,              "Generation location" },

    { request_unrecognized_certificate, "Request unrecognized certificate" },

    { message_type,                     "Message type" },

    { signer_info,                      "Signer info" },

    { recipient_info,                   "Recipient info" },

    { encryption_parameters,            "Encryption parameters" },

    { 0x00, NULL}

};

static const value_string header_field_type_v2_names[] = {

    { generation_time,                  "Generation time" },

    { generation_time_confidence,       "Generation time standard deviation" },

    { expiration,                       "Expiration" },

    { generation_location,              "Generation location" },

    { request_unrecognized_certificate, "Request unrecognized certificate" },

    { message_type,                     "ITS Application ID" }, // Change in definition

    { signer_info,                      "Signer info" },

    { recipient_info,                   "Encryption parameters" }, // Change in definition

    { encryption_parameters,            "Recipient info" }, // Change in definition

    { 0x00, NULL}

};

typedef enum  {

    unsecured = 0,

    signed_pl = 1,

    encrypted = 2,

    signed_external = 3,

    signed_and_encrypted = 4,

    last_pl_type = (2<<8)-1

} PayloadType;

static const value_string payload_field_type_names[] = {

    { unsecured,            "Unsecured" },

    { signed_pl,            "Signed" },

    { encrypted,            "Encrypted" },

    { signed_external,      "Signed external" },

    { signed_and_encrypted, "Signed and encrypted" },

    { 0, NULL },

};

typedef enum {

    signature = 1,

    last_trl_type = (2<<8)-1

} TrailerFieldType;

static const value_string trailer_field_type_names[] = {

    { signature, "signature" },

    { 0, NULL },

};

static int hf_sgeonw_signer_info;

static int hf_sgeonw_signer_info_type;

typedef enum {

    self = 0,

    certificate_digest_with_ecdsap256 = 1,

    certificate = 2,

    certificate_chain = 3,

    certificate_digest_with_other_algorithm = 4,

    //reserved(240..255),

    last_sif_type = (2<<8)-1

} SignerInfoType;

static const value_string signer_info_type_names[] = {

    { self,                                    "Self signed" },

    { certificate_digest_with_ecdsap256,       "Certificate digest with ecdsap256" },

    { certificate,                             "Certificate" },

    { certificate_chain,                       "Certificate chain" },

    { certificate_digest_with_other_algorithm, "Certificate digest with other algorithm" },

    { 0, NULL },

};

static int hf_sgeonw_public_key;

static int ett_sgeonw_public_key;

static int hf_sgeonw_public_key_algorithm;

static int hf_sgeonw_ecdsasignature_s;

typedef enum {

    ecdsa_nistp256_with_sha256 = 0,

    ecies_nistp256 = 1,

    // reserved(240..255),

    last_pubkey_algo = (2<<8)-1

} PublicKeyAlgorithm;

static const value_string public_key_algorithm_names[] = {

    { ecdsa_nistp256_with_sha256, "ECDSA nistp256 with SHA256" },

    { ecies_nistp256,             "ECIES nistp256" },

    { 0, NULL },

};

static const int etsits103097_table_2[] = {

    32, // ecdsa_nistp256_with_sha256(0)

    32 // ecies_nistp256(1)

};

static int hf_sgeonw_symmetric_algorithm;

typedef enum {

    aes_128_ccm = 0,

    // reserved(240..255),

    last_sym_algo = (2<<8)-1

} SymmetricAlgorithm;

static const value_string symmetric_algorithm_names[] = {

    { aes_128_ccm, "aes_128_ccm" },

    { 0, NULL },

};

static const int etsits103097_table_4[] = {

    16 // aes_128_ccm(0)

};

static int hf_sgeonw_region_type;

static int hf_sgeonw_radius;

typedef enum {

    none = 0,

    circle = 1,

    rectangle = 2,