/* packet-fortinet-fgcp.c
 * Routines for FortiGate Cluster Protocol dissection
 * Copyright 2023, Alexis La Goutte <alexis.lagoutte at gmail dot com>
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * No spec/doc is available based on reverse/analysis of protocol...
 *
 */

#include "config.h"

#include <wireshark.h>

#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/prefs.h>
#include <epan/etypes.h>
#include <epan/tfs.h>

void proto_reg_handoff_fortinet_fgcp(void);
void proto_register_fortinet_fgcp(void);

static int proto_fortinet_fgcp_hb;
static int hf_fortinet_fgcp_hb_magic;
static int hf_fortinet_fgcp_hb_flag;
static int hf_fortinet_fgcp_hb_flag_b74;
static int hf_fortinet_fgcp_hb_flag_b3;
static int hf_fortinet_fgcp_hb_flag_b2;
static int hf_fortinet_fgcp_hb_flag_authentication;
static int hf_fortinet_fgcp_hb_flag_encryption;
static int hf_fortinet_fgcp_hb_mode;
static int hf_fortinet_fgcp_hb_gn;
static int hf_fortinet_fgcp_hb_group_id;
static int hf_fortinet_fgcp_hb_port;
static int hf_fortinet_fgcp_hb_revision;
static int hf_fortinet_fgcp_hb_sn;
static int hf_fortinet_fgcp_hb_payload_encrypted;
static int hf_fortinet_fgcp_hb_authentication;

static int hf_fortinet_fgcp_hb_tlv;
static int hf_fortinet_fgcp_hb_tlv_type;
static int hf_fortinet_fgcp_hb_tlv_length;
static int hf_fortinet_fgcp_hb_tlv_value;
static int hf_fortinet_fgcp_hb_tlv_vcluster_id;
static int hf_fortinet_fgcp_hb_tlv_priority;
static int hf_fortinet_fgcp_hb_tlv_override;
static int hf_fortinet_fgcp_hb_tlv_ha_checksum_global;
static int hf_fortinet_fgcp_hb_tlv_ha_checksum_vdom;
static int hf_fortinet_fgcp_hb_tlv_ha_checksum_root;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_interface;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_number;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_name;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_mac;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_admin_status;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_operation_status;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_link_monitored;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_ha_eligible;
static int hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_b74;

//static int hf_fortinet_fgcp_hb_unknown;
static int hf_fortinet_fgcp_hb_unknown_uint16;

static dissector_handle_t fortinet_fgcp_hb_handle;

static int ett_fortinet_fgcp_hb;
static int ett_fortinet_fgcp_hb_flag;
static int ett_fortinet_fgcp_hb_tlv;
static int ett_fortinet_fgcp_hb_tlv_interface;
static int ett_fortinet_fgcp_hb_tlv_interface_flag;

static int proto_fortinet_fgcp_session;
static int hf_fortinet_fgcp_session_magic;
static int hf_fortinet_fgcp_session_type;

static dissector_handle_t fortinet_fgcp_session_handle;
static dissector_handle_t ip_handle;

static int ett_fortinet_fgcp_session;

static const value_string fortinet_fgcp_hb_mode_vals[] = {
    { 0x1,            "A/A (Active/Active)"},
    { 0x2,            "A/P (Active/Passive)"},
    {0, NULL }
};

#define HB_TLV_END_OF_TLV       0x00
#define HB_TLV_VCLUSTER_ID      0x0B
#define HB_TLV_PRIORITY         0x0C
#define HB_TLV_OVERRIDE         0x0D
#define HB_TLV_INTERFACE_INVENTORY 0x2a
#define HB_TLV_HA_CHECKSUM      0x3C

static const value_string fortinet_fgcp_hb_tlv_vals[] = {
    { HB_TLV_END_OF_TLV, "End of TLV" },
    { HB_TLV_PRIORITY, "Port Priority" },
    { HB_TLV_OVERRIDE, "Override" },
    { HB_TLV_INTERFACE_INVENTORY, "Interface Inventory" },
    { HB_TLV_HA_CHECKSUM, "HA Checksum" },
    { 0, NULL }
};


static int
dissect_fortinet_fgcp_hb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        void *data _U_)
{
    proto_item *ti;
    proto_tree *fortinet_hb_tree;
    unsigned    offset = 0, length, auth_len=0;
    uint8_t     flags;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "FGCP-HB");

    col_add_fstr(pinfo->cinfo, COL_INFO, "Cluster: %s(%u) - monitor: %s - SN: %s",
                tvb_get_string_enc(pinfo->pool, tvb, offset+4, 32, ENC_ASCII), /* Group Name*/
                tvb_get_uint16(tvb, (offset+4+32+2), ENC_LITTLE_ENDIAN),  /* Group ID*/
                tvb_get_string_enc(pinfo->pool, tvb, offset+4+32+2+14, 16, ENC_ASCII), /* Port */
                tvb_get_string_enc(pinfo->pool, tvb, offset+4+32+2+14+16+2+2, 16, ENC_ASCII) /* Serial Number */);

    ti = proto_tree_add_item(tree, proto_fortinet_fgcp_hb, tvb, 0, -1, ENC_NA);

    fortinet_hb_tree = proto_item_add_subtree(ti, ett_fortinet_fgcp_hb);

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_magic, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_mode, tvb, offset, 1, ENC_NA);
    offset += 1;

    static int * const fortinet_fgcp_hb_flag[] = {
        &hf_fortinet_fgcp_hb_flag_b74,
        &hf_fortinet_fgcp_hb_flag_b3,
        &hf_fortinet_fgcp_hb_flag_b2,
        &hf_fortinet_fgcp_hb_flag_authentication,
        &hf_fortinet_fgcp_hb_flag_encryption,
        NULL
    };

    static int * const fortinet_fgcp_tlv_interface_flag[] = {
        &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_admin_status,
        &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_operation_status,
        &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_link_monitored,
        &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_ha_eligible,
        &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_b74,
        NULL
    };

    proto_tree_add_bitmask(fortinet_hb_tree, tvb, offset, hf_fortinet_fgcp_hb_flag, ett_fortinet_fgcp_hb_flag,
                           fortinet_fgcp_hb_flag, ENC_NA);
    flags =  tvb_get_uint8(tvb, offset);
    offset += 1;

    /* Group Name */
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_gn, tvb, offset, 32, ENC_ASCII);
    offset += 32;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    /* Group Id */
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_group_id, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    /* Heartbeat Port */
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_port, tvb, offset, 16, ENC_ASCII);
    offset += 16;

    /* Revision ? */
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_revision, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    /* Hash/crc ? change after each revision*/
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_unknown_uint16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    /* Serial Number */
    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_sn, tvb, offset, 16, ENC_ASCII);
    offset += 16;

    if (flags & 0x02) { /* Authentication ? */
        /* the payload finish with 32bits of authentication (hash ?) */
        auth_len = 32;
    }

    if (flags & 0x01) { /* Encrypted Payload ?*/
        length = tvb_reported_length_remaining(tvb, offset) - auth_len;
        proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_payload_encrypted, tvb, offset, length, ENC_NA);
        offset += length;
    } else {
        unsigned next_offset;

        length = tvb_reported_length_remaining(tvb, offset) - auth_len;
        next_offset = offset + length;

        while (offset < next_offset) {
                uint32_t type, len;
                proto_item *ti_tlv;
                proto_tree *tlv_tree;

                ti_tlv = proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_tlv, tvb, offset, 3, ENC_NA);
                tlv_tree = proto_item_add_subtree(ti_tlv, ett_fortinet_fgcp_hb_tlv);
                proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_type, tvb, offset, 2, ENC_LITTLE_ENDIAN, &type);
                offset += 2;
                proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_length, tvb, offset, 2, ENC_LITTLE_ENDIAN, &len);
                offset += 2;

                proto_item_append_text(ti_tlv, ": (t=%u,l=%d) %s", type, len, val_to_str_const(type, fortinet_fgcp_hb_tlv_vals ,"Unknown type") );
                proto_item_set_len(ti_tlv, 2 + 2 + len);

                proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_value, tvb, offset, len, ENC_NA);
                switch (type) {
                case HB_TLV_VCLUSTER_ID:{
                    uint32_t vcluster_id;
                    proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_vcluster_id, tvb, offset, 1, ENC_NA, &vcluster_id);
                    proto_item_append_text(ti_tlv, ": %u", vcluster_id);
                    offset += 1;
                    }
                break;
                case HB_TLV_PRIORITY:{
                    uint32_t priority;
                    proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_priority, tvb, offset, 1, ENC_NA, &priority);
                    proto_item_append_text(ti_tlv, ": %u", priority);
                    offset += 1;
                    }
                break;
                case HB_TLV_OVERRIDE:{
                    uint32_t override;
                    proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_override, tvb, offset, 1, ENC_NA, &override);
                    if (override){
                        proto_item_append_text(ti_tlv, ": True");
                    } else {
                        proto_item_append_text(ti_tlv, ": False");
                    }
                    offset += 1;
                    }
                break;
                case HB_TLV_HA_CHECKSUM:{
                    proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_ha_checksum_global, tvb, offset, 16, ENC_NA);
                    offset += 16;
                    proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_ha_checksum_vdom, tvb, offset, 16, ENC_NA);
                    offset += 16;
                    proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_ha_checksum_root, tvb, offset, 16, ENC_NA);
                    offset += 16;
                }
                break;
                case HB_TLV_INTERFACE_INVENTORY:{
                    tvbuff_t* compressed_tvb;
                    uint32_t number;
                    unsigned    coffset = 0;
                    proto_item *ti_interface;
                    proto_tree *interface_tree;
                    proto_tree_add_item_ret_uint(tlv_tree, hf_fortinet_fgcp_hb_tlv_interface_inventory_number, tvb, offset, 2, ENC_LITTLE_ENDIAN, &number);
                    offset += 2;
                    compressed_tvb = tvb_child_uncompress_zlib(tvb, tvb, offset, len-2);
                    if (compressed_tvb) {
                        add_new_data_source(pinfo, compressed_tvb, "Decompressed Data");
                        proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_interface_inventory, compressed_tvb, 0, -1, ENC_NA);
                        while (number) {
                            ti_interface = proto_tree_add_item(tlv_tree, hf_fortinet_fgcp_hb_tlv_interface_inventory_interface, compressed_tvb, coffset, 16+6+1, ENC_NA);
                            interface_tree = proto_item_add_subtree(ti_interface, ett_fortinet_fgcp_hb_tlv_interface);
                            proto_tree_add_item(interface_tree, hf_fortinet_fgcp_hb_tlv_interface_inventory_name, compressed_tvb, coffset, 16, ENC_ASCII);
                            proto_item_append_text(ti_interface, ": %s", tvb_get_stringz_enc(pinfo->pool, compressed_tvb, coffset, NULL, ENC_ASCII) );
                            coffset += 16;
                            proto_tree_add_item(interface_tree, hf_fortinet_fgcp_hb_tlv_interface_inventory_mac, compressed_tvb, coffset, 6, ENC_NA);
                            coffset += 6;
                            proto_tree_add_bitmask(interface_tree, compressed_tvb, coffset, hf_fortinet_fgcp_hb_tlv_interface_inventory_flag,
                                                   ett_fortinet_fgcp_hb_tlv_interface_flag, fortinet_fgcp_tlv_interface_flag, ENC_NA);
                            flags =  tvb_get_uint8(compressed_tvb, coffset);
                            if (flags & 0x01) {
                                proto_item_append_text(ti_interface, ", Admin Status: UP");
                            }
                            if (flags & 0x02) {
                                proto_item_append_text(ti_interface, ", Operation Status: UP");
                            }
                            if (flags & 0x04) {
                                proto_item_append_text(ti_interface, ", Link Monitored: Yes");
                            }
                            if (flags & 0x08) {
                                proto_item_append_text(ti_interface, ", HA Eligible: Yes");
                            }
                            coffset += 1;
                            number--;
                        }

                    }
                    offset += (len-2);
                }
                break;

                default:
                    offset += len;
                break;
                }
            }
    }

    if (auth_len) { /* Authentication ? */
        proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_hb_authentication, tvb, offset, 32, ENC_NA);
        offset += 32;
    }

    return offset;
}

static int
dissect_fortinet_fgcp_session(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        void *data _U_)
{
    proto_item *ti;
    proto_tree *fortinet_hb_tree;
    unsigned    offset = 0;
    tvbuff_t    *data_tvb;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "FGCP-SESSION");

    ti = proto_tree_add_item(tree, proto_fortinet_fgcp_session, tvb, 0, -1, ENC_NA);

    fortinet_hb_tree = proto_item_add_subtree(ti, ett_fortinet_fgcp_session);

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_session_magic, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    proto_tree_add_item(fortinet_hb_tree, hf_fortinet_fgcp_session_type, tvb, offset, 2, ENC_LITTLE_ENDIAN);
    offset += 2;

    data_tvb = tvb_new_subset_remaining(tvb, offset);
    call_dissector(ip_handle, data_tvb, pinfo, tree);

    return offset;
}

void
proto_register_fortinet_fgcp(void)
{

    static hf_register_info hf[] = {
        /* HeartBeat */
        { &hf_fortinet_fgcp_hb_magic,
            { "Magic Number", "fortinet_fgcp.hb.magic",
            FT_UINT16, BASE_HEX_DEC, NULL, 0x0,
            "Magic Number ?", HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag,
            { "Flag", "fortinet_fgcp.hb.flag",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag_b74,
            { "Bit 7 to 4", "fortinet_fgcp.hb.flag.b74",
            FT_UINT8, BASE_HEX, NULL, 0xF0,
            "Unknown", HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag_b3,
            { "Bit b3", "fortinet_fgcp.hb.flag.b3",
            FT_UINT8, BASE_HEX, NULL, 0x08,
            "Unknown", HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag_b2,
            { "Bit b2", "fortinet_fgcp.hb.flag.b2",
            FT_UINT8, BASE_HEX, NULL, 0x04,
            "Unknown", HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag_authentication,
            { "Authentication", "fortinet_fgcp.hb.flag.authentication",
            FT_BOOLEAN, 8, NULL, 0x02,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_flag_encryption,
            { "Encryption", "fortinet_fgcp.hb.flag.encryption",
            FT_BOOLEAN, 8, NULL, 0x01,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_mode,
            { "Mode", "fortinet_fgcp.hb.mode",
            FT_UINT8, BASE_DEC, VALS(fortinet_fgcp_hb_mode_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_gn,
            { "Group Name", "fortinet_fgcp.hb.gn",
            FT_STRING, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_group_id,
            { "Group Id", "fortinet_fgcp.hb.group_id",
            FT_UINT16, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_port,
            { "Port", "fortinet_fgcp.hb.port",
            FT_STRING, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_revision,
            { "Revision", "fortinet_fgcp.hb.revision",
            FT_UINT16, BASE_DEC, NULL, 0x0,
            "Number of revision config for HA", HFILL }
        },
        { &hf_fortinet_fgcp_hb_sn,
            { "Serial Number", "fortinet_fgcp.hb.sn",
            FT_STRING, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_payload_encrypted,
            { "Payload (encrypted)", "fortinet_fgcp.hb.payload_encrypted",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_authentication,
            { "Authentication", "fortinet_fgcp.hb.authentication",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },

        { &hf_fortinet_fgcp_hb_tlv,
          { "TLV", "fortinet_fgcp.hb.tlv",
            FT_NONE, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_type,
          { "Type", "fortinet_fgcp.hb.tlv.type",
            FT_UINT16, BASE_HEX, VALS(fortinet_fgcp_hb_tlv_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_length,
          { "Length", "fortinet_fgcp.hb.tlv.length",
            FT_UINT16, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_value,
          { "Value", "fortinet_fgcp.hb.tlv.value",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },

        { &hf_fortinet_fgcp_hb_tlv_vcluster_id,
            { "Vcluster ID", "fortinet_fgcp.hb.tlv.vcluster_id",
            FT_UINT8, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_priority,
            { "Port Priority", "fortinet_fgcp.hb.tlv.priority",
            FT_UINT8, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_override,
            { "Override", "fortinet_fgcp.hb.tlv.override",
            FT_UINT8, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_ha_checksum_global,
            { "HA Checksum Global", "fortinet_fgcp.hb.tlv.ha_checksum.global",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_ha_checksum_vdom,
            { "HA Checksum VDOM", "fortinet_fgcp.hb.tlv.ha_checksum.vdom",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_ha_checksum_root,
            { "HA Checksum Root", "fortinet_fgcp.hb.tlv.ha_checksum.root",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory,
            { "Interface Inventory", "fortinet_fgcp.hb.tlv.interface_inventory",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_interface,
            { "Interface", "fortinet_fgcp.hb.tlv.interface_inventory.interface",
            FT_NONE, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_number,
            { "Number of Interfaces", "fortinet_fgcp.hb.tlv.interface_inventory.number",
            FT_UINT16, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_name,
            { "Name", "fortinet_fgcp.hb.tlv.interface_inventory.name",
            FT_STRINGZ, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_mac,
            { "Mac", "fortinet_fgcp.hb.tlv.interface_inventory.mac",
            FT_ETHER, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag,
            { "Flag", "fortinet_fgcp.hb.tlv.interface_inventory.flag",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_admin_status,
            { "Admin Status", "fortinet_fgcp.hb.tlv.interface_inventory.flag.admin_status",
            FT_BOOLEAN, 8, TFS(&tfs_up_down), 0x01,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_operation_status,
            { "Operation Status", "fortinet_fgcp.hb.tlv.interface_inventory.flag.operation_status",
            FT_BOOLEAN, 8, TFS(&tfs_up_down), 0x02,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_link_monitored,
            { "Link Monitored", "fortinet_fgcp.hb.tlv.interface_inventory.flag.link_monitored",
            FT_BOOLEAN, 8, NULL, 0x04,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_ha_eligible,
            { "HA Eligible", "fortinet_fgcp.hb.tlv.interface_inventory.flag.ha_eligbile",
            FT_BOOLEAN, 8, NULL, 0x08,
            NULL, HFILL }
        },
        { &hf_fortinet_fgcp_hb_tlv_interface_inventory_flag_b74,
            { "Reserved", "fortinet_fgcp.hb.tlv.interface_inventory.flag.b74",
            FT_UINT8, BASE_HEX, NULL, 0xF0,
            "Bit 7 to 4", HFILL }
        },
        /*
        { &hf_fortinet_fgcp_hb_unknown,
            { "Unknown", "fortinet_fgcp.hb.unknown",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Always NULL ?", HFILL }
        },
        */
        { &hf_fortinet_fgcp_hb_unknown_uint16,
            { "Unknown", "fortinet_fgcp.hb.unknown.uint16",
            FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
            NULL, HFILL }
        },

        /* Session */
        { &hf_fortinet_fgcp_session_magic,
            { "Magic Number", "fortinet_fgcp.session.magic",
            FT_UINT16, BASE_HEX_DEC, NULL, 0x0,
            "Magic Number ?", HFILL }
        },
        { &hf_fortinet_fgcp_session_type,
            { "Type", "fortinet_fgcp.session.type",
            FT_UINT16, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
    };

    /* Setup protocol subtree array */
    static int *ett[] = {
        &ett_fortinet_fgcp_hb,
        &ett_fortinet_fgcp_hb_flag,
        &ett_fortinet_fgcp_hb_tlv,
        &ett_fortinet_fgcp_hb_tlv_interface,
        &ett_fortinet_fgcp_hb_tlv_interface_flag,
        &ett_fortinet_fgcp_session,
    };

    /* Register the protocol name and description */
    proto_fortinet_fgcp_hb = proto_register_protocol("FortiGate Cluster Protocol - HeartBeat",
            "fortinet_fgcp_hb", "fortinet_fgcp_hb");

    proto_fortinet_fgcp_session = proto_register_protocol("FortiGate Cluster Protocol - Session",
            "fortinet_fgcp_session", "fortinet_fgcp_session");

    /* Required function calls to register the header fields and subtrees */
    proto_register_field_array(proto_fortinet_fgcp_hb, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));

    fortinet_fgcp_hb_handle = register_dissector("fortinet_fgcp_hb", dissect_fortinet_fgcp_hb,
            proto_fortinet_fgcp_hb);

    fortinet_fgcp_session_handle = register_dissector("fortinet_fgcp_session", dissect_fortinet_fgcp_session,
            proto_fortinet_fgcp_session);

}


void
proto_reg_handoff_fortinet_fgcp(void)
{
      dissector_add_uint("ethertype", ETHERTYPE_FORTINET_FGCP_HB, fortinet_fgcp_hb_handle);
      dissector_add_uint("ethertype", ETHERTYPE_FORTINET_FGCP_SESSION, fortinet_fgcp_session_handle);

      ip_handle  = find_dissector_add_dependency("ip", proto_fortinet_fgcp_session);
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */
