packet-ilnp.c

/* packet-ilnp.c
 * Routines for ILNP dissection
 * Copyright 2025, Shubh Sinhal <shubh.sinhal@gmail.com>
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

/*
 * ILNP is an extension on IPv6 which changes the addressing semantics to
 * treat the Identifier (Node Identifier - 64 bits) and the Locator (Network
 * address - 64 bits) to improve mobility and multi-homing support
 *
 * RFC 6740 - ILNP Architectural Description
 * RFC 6741 - ILNP Engineering Considerations
 *
 * More information about ILNP can be found at "https://ilnp.cs.st-andrews.ac.uk/"
 *
 * This dissector was developed using the IPv6 dissector as a reference base
 */

#include "config.h"
#include <epan/packet.h>
#include <epan/address_types.h>
#include <epan/to_str.h>
#include <epan/proto.h>
#include <epan/tap.h>
#include <epan/conversation_table.h>
#include <epan/conversation_filter.h>
#include <epan/stats_tree.h>

void proto_register_ilnp(void);

/* Conversation data */
struct ilnp_analysis {
    uint32_t initial_frame; // Initial frame starting this conversation
    uint32_t stream;        // Stream ID
};

typedef struct _ilnp_tap_info_t {
    address ilnp_src_l64;     /* source l64*/
    address ilnp_src_nid;     /* source nid */
    address ilnp_dst_l64;     /* destination l64*/
    address ilnp_dst_nid;     /* destination nid */
    address ilnp_src_ilv;     /* source ilv */
    address ilnp_dst_ilv;     /* destination ilv */
    uint32_t ilnp_stream;     /* track conversations */
} ilnp_tap_info_t;

static int proto_ilnp;

/* Header fields */
static int hf_ilnp_nonce;
static int hf_ilnp_src_l64;
static int hf_ilnp_dst_l64;
static int hf_ilnp_src_nid;
static int hf_ilnp_dst_nid;
static int hf_ilnp_src_ilv;
static int hf_ilnp_dst_ilv;
static int hf_ilnp_l64;
static int hf_ilnp_nid;
static int hf_ilnp_ilv;
static int hf_ilnp_stream;

static int ett_ilnp;

static dissector_handle_t ilnp_handle;

// Global ILNP Stream counter
static uint32_t ilnp_stream_count;

/* ILNP tap handle */
static int ilnp_tap;


/***********************************************************************************************************************************
 *
 * CONVERSATIONS
 *
 ***********************************************************************************************************************************/

static const char* ilnp_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)
{
    if ((filter == CONV_FT_SRC_ADDRESS) && (conv->src_address.type == AT_ILNP_NID))
        return "ilnp.src_nid";

    if ((filter == CONV_FT_DST_ADDRESS) && (conv->dst_address.type == AT_ILNP_NID))
        return "ilnp.dst_nid";

    if ((filter == CONV_FT_ANY_ADDRESS) && (conv->src_address.type == AT_ILNP_NID))
        return "ilnp.nid";

    return CONV_FILTER_INVALID;
}

static ct_dissector_info_t ilnp_ct_dissector_info = {&ilnp_conv_get_filter_type};

// Callback to add an ilnp conversation to the Statistics->Conversations->ILNP table
static tap_packet_status
ilnp_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
{
    conv_hash_t *hash = (conv_hash_t*) pct;
    hash->flags = flags;

    const ilnp_tap_info_t *ilnp_tap_info = (const ilnp_tap_info_t *)vip;

    add_conversation_table_data_with_conv_id(hash, &ilnp_tap_info->ilnp_src_nid, &ilnp_tap_info->ilnp_dst_nid, 0, 0,
            (conv_id_t)ilnp_tap_info->ilnp_stream, 1, pinfo->fd->pkt_len,
            &pinfo->rel_ts, &pinfo->abs_ts, &ilnp_ct_dissector_info, CONVERSATION_ILNP);

    return TAP_PACKET_REDRAW;
}

static const char* ilnp_endpoint_get_filter_type(endpoint_item_t* endpoint, conv_filter_type_e filter)
{
    if ((filter == CONV_FT_ANY_ADDRESS) && (endpoint->myaddress.type == AT_ILNP_NID))
        return "ilnp.nid";

    return CONV_FILTER_INVALID;
}

static et_dissector_info_t ilnp_endpoint_dissector_info = {&ilnp_endpoint_get_filter_type};

// Callback to add an ilnp nids to the Statistics->Endpoints->ILNP table
static tap_packet_status
ilnp_endpoint_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
{
    conv_hash_t *hash = (conv_hash_t*) pit;
    hash->flags = flags;

    const ilnp_tap_info_t *ilnp_tap_info = (const ilnp_tap_info_t *)vip;

    add_endpoint_table_data(hash, &ilnp_tap_info->ilnp_src_nid, 0, true, 1,
                pinfo->fd->pkt_len, &ilnp_endpoint_dissector_info, ENDPOINT_ILNP);
    add_endpoint_table_data(hash, &ilnp_tap_info->ilnp_dst_nid, 0, false, 1,
                pinfo->fd->pkt_len, &ilnp_endpoint_dissector_info, ENDPOINT_ILNP);

    return TAP_PACKET_REDRAW;
}

static bool
ilnp_filter_valid(packet_info *pinfo, void *user_data _U_)
{
    return proto_is_frame_protocol(pinfo->layers, "ilnp");
}

static char*
ilnp_build_filter(packet_info *pinfo, void *user_data _U_)
{
    address src_nid, dst_nid;

    alloc_address_wmem(pinfo->pool, &src_nid, AT_ILNP_NID, 8, pinfo->net_src.data);
    alloc_address_wmem(pinfo->pool, &dst_nid, AT_ILNP_NID, 8, pinfo->net_dst.data);

    return ws_strdup_printf("ilnp.nid eq %s and ilnp.nid eq %s",
                address_to_str(pinfo->pool, &src_nid),
                address_to_str(pinfo->pool, &dst_nid));
}


static struct ilnp_analysis*
init_ilnp_conversation_data(packet_info *pinfo) {
    struct ilnp_analysis *ilnpd;

    /* Initialize the ip protocol data structure to add to the ilnp conversation */
    ilnpd=wmem_new0(wmem_file_scope(), struct ilnp_analysis);

    ilnpd->initial_frame = pinfo->num;
    ilnpd->stream = ilnp_stream_count++;

    return ilnpd;
}

static struct ilnp_analysis*
get_ilnp_conversation_data(conversation_t *conv, packet_info *pinfo) {
    struct ilnp_analysis *ilnpd;

    /* Get the data for this conversation */
    ilnpd = (struct ilnp_analysis *) conversation_get_proto_data(conv, proto_ilnp);
    if (!ilnpd) { // if it doesn't exist, initialise new one
        ilnpd = init_ilnp_conversation_data(pinfo);
        conversation_add_proto_data(conv, proto_ilnp, ilnpd);
    }

    return ilnpd;
}



/***********************************************************************************************************************************
 *
 * STATISTICS
 *
 ***********************************************************************************************************************************/

static int st_node_ilnp_nids = -1;
static int st_node_ilnp_src_nid = -1;
static int st_node_ilnp_dst_nid = -1;
static const char* st_str_ilnp_nid = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "All Node Identifiers";
static const char* st_str_ilnp_srcdst_nid = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "Source and Destination Node Identifier Addresses";
static const char* st_str_ilnp_src_nid = "Source ILNP Node Identifiers";
static const char* st_str_ilnp_dst_nid = "Destination ILNP Node Identifiers";

static int st_node_ilnp_l64s = -1;
static int st_node_ilnp_src_l64 = -1;
static int st_node_ilnp_dst_l64 = -1;
static const char* st_str_ilnp_l64 = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "All Locators";
static const char* st_str_ilnp_srcdst_l64 = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "Source and Destination Locator Addresses";
static const char* st_str_ilnp_src_l64 = "Source ILNP Locators";
static const char* st_str_ilnp_dst_l64 = "Destination ILNP Locators";

static int st_node_ilnp_ilvs = -1;
static int st_node_ilnp_src_ilv = -1;
static int st_node_ilnp_dst_ilv = -1;
static const char* st_str_ilnp_ilv = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "All Identifier-Locator Vectors";
static const char* st_str_ilnp_srcdst_ilv = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "Source and Destination Identifier-Locator Vector Addresses";
static const char* st_str_ilnp_src_ilv = "Source ILNP Identifier-Locator Vectors";
static const char* st_str_ilnp_dst_ilv = "Destination ILNP Identifier-Locator Vectors";

static int st_node_ilnp_ptype = -1;
static const char* st_str_ilnp_ptype = "ILNP Statistics" STATS_TREE_MENU_SEPARATOR "IP Protocol Types";


static void ilnp_nids_stats_tree_init(stats_tree* st) {
    st_node_ilnp_nids = stats_tree_create_node(st, st_str_ilnp_nid, 0, STAT_DT_INT, true);
}

static void ilnp_l64s_stats_tree_init(stats_tree* st) {
    st_node_ilnp_l64s = stats_tree_create_node(st, st_str_ilnp_l64, 0, STAT_DT_INT, true);
}

static void ilnp_ilvs_stats_tree_init(stats_tree* st) {
    st_node_ilnp_ilvs = stats_tree_create_node(st, st_str_ilnp_ilv, 0, STAT_DT_INT, true);
}

static tap_packet_status ilnp_nids_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    tick_stat_node(st, st_str_ilnp_nid, 0, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_src_nid), st_node_ilnp_nids, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_dst_nid), st_node_ilnp_nids, false);
    return TAP_PACKET_REDRAW;
}

static tap_packet_status ilnp_l64s_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    tick_stat_node(st, st_str_ilnp_l64, 0, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_src_l64), st_node_ilnp_l64s, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_dst_l64), st_node_ilnp_l64s, false);
    return TAP_PACKET_REDRAW;
}

static tap_packet_status ilnp_ilvs_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    tick_stat_node(st, st_str_ilnp_ilv, 0, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_src_ilv), st_node_ilnp_ilvs, false);
    tick_stat_node(st, address_to_str(pinfo->pool, &ilnpt->ilnp_dst_ilv), st_node_ilnp_ilvs, false);
    return TAP_PACKET_REDRAW;
}

//Same as ip_srcdst_stats_tree_init
static void ilnp_srcdst_stats_tree_init(stats_tree* st,
    const char* st_str_src, int* st_node_src_ptr,
    const char* st_str_dst, int* st_node_dst_ptr)
{
    /* create one tree branch for source */
    *st_node_src_ptr = stats_tree_create_node(st, st_str_src, 0, STAT_DT_INT, true);
    /* set flag so this branch will always be sorted to top of tree */
    stat_node_set_flags(st, st_str_src, 0, false, ST_FLG_SORT_TOP);
    /* create another top level node for destination branch */
    *st_node_dst_ptr = stats_tree_create_node(st, st_str_dst, 0, STAT_DT_INT, true);
    /* set flag so this branch will not be expanded by default */
    stat_node_set_flags(st, st_str_dst, 0, false, ST_FLG_DEF_NOEXPAND);
}

static void
ilnp_srcdst_nid_stats_tree_init(stats_tree* st)
{
    ilnp_srcdst_stats_tree_init(st, st_str_ilnp_src_nid, &st_node_ilnp_src_nid, st_str_ilnp_dst_nid, &st_node_ilnp_dst_nid);
}
static void ilnp_srcdst_l64_stats_tree_init(stats_tree* st)
{
    ilnp_srcdst_stats_tree_init(st, st_str_ilnp_src_l64, &st_node_ilnp_src_l64, st_str_ilnp_dst_l64, &st_node_ilnp_dst_l64);
}

static void ilnp_srcdst_ilv_stats_tree_init(stats_tree* st)
{
    ilnp_srcdst_stats_tree_init(st, st_str_ilnp_src_ilv, &st_node_ilnp_src_ilv, st_str_ilnp_dst_ilv, &st_node_ilnp_dst_ilv);
}

static tap_packet_status ilnp_srcdst_stats_tree_packet(stats_tree* st,
    packet_info* pinfo,
    const address* src_addr,
    const address* dst_addr,
    int st_node_src,
    const char* st_str_src,
    int st_node_dst,
    const char* st_str_dst)
{
    /* update source branch */
    tick_stat_node(st, st_str_src, 0, false);
    tick_stat_node(st, address_to_str(pinfo->pool, src_addr), st_node_src, false);
    /* update destination branch */
    tick_stat_node(st, st_str_dst, 0, false);
    tick_stat_node(st, address_to_str(pinfo->pool, dst_addr), st_node_dst, false);
    return TAP_PACKET_REDRAW;
}

static tap_packet_status ilnp_srcdst_nid_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    return ilnp_srcdst_stats_tree_packet(st, pinfo, &ilnpt->ilnp_src_nid, &ilnpt->ilnp_dst_nid, st_node_ilnp_src_nid, st_str_ilnp_src_nid, st_node_ilnp_dst_nid, st_str_ilnp_dst_nid);
}

static tap_packet_status ilnp_srcdst_l64_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    return ilnp_srcdst_stats_tree_packet(st, pinfo, &ilnpt->ilnp_src_l64, &ilnpt->ilnp_dst_l64, st_node_ilnp_src_l64, st_str_ilnp_src_l64, st_node_ilnp_dst_l64, st_str_ilnp_dst_l64);
}

static tap_packet_status ilnp_srcdst_ilv_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    const ilnp_tap_info_t* ilnpt = (const ilnp_tap_info_t*)p;
    return ilnp_srcdst_stats_tree_packet(st, pinfo, &ilnpt->ilnp_src_ilv, &ilnpt->ilnp_dst_ilv, st_node_ilnp_src_ilv, st_str_ilnp_src_ilv, st_node_ilnp_dst_ilv, st_str_ilnp_dst_ilv);
}

static void ilnp_ptype_stats_tree_init(stats_tree* st)
{
    st_node_ilnp_ptype = stats_tree_create_pivot(st, st_str_ilnp_ptype, 0);
}

static tap_packet_status ilnp_ptype_stats_tree_packet(stats_tree* st, packet_info* pinfo, epan_dissect_t* edt _U_, const void* p _U_, tap_flags_t flags _U_)
{
    stats_tree_tick_pivot(st, st_node_ilnp_ptype, port_type_to_str(pinfo->ptype));
    return TAP_PACKET_REDRAW;
}

/***********************************************************************************************************************************
 *
 * DISSECTION
 *
 ***********************************************************************************************************************************/

static int
dissect_ilnp(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_)
{
    proto_tree *ilnp_tree;
    proto_item *ilnp_item, *ti;
    const char *str_ilnp_src_nid, *str_ilnp_src_l64,
               *str_ilnp_dst_nid, *str_ilnp_dst_l64,
               *str_ilnp_src_ilv, *str_ilnp_dst_ilv;
    conversation_t* conv;
    struct ilnp_analysis* ilnpd;
    ilnp_tap_info_t* ilnph;

    //ILNP works on top of IPv6 only (as it "repurposes" the address data)
    if ((pinfo->net_src.type != AT_IPv6) || (pinfo->net_dst.type != AT_IPv6))
        return 0;

    ilnph = wmem_new0(pinfo->pool, ilnp_tap_info_t);

    // Define ilnp tree and add it as a subtree to the main proto tree
    ilnp_item = proto_tree_add_item(tree, proto_ilnp, tvb, 0, -1, ENC_NA);
    ilnp_tree = proto_item_add_subtree(ilnp_item, ett_ilnp);

    // Add ILNP Nonce to subtree
    proto_tree_add_item(ilnp_tree, hf_ilnp_nonce, tvb, 0, -1, ENC_NA);

    //Set the NID as source and destination addresses of the packet
    alloc_address_wmem(pinfo->pool, &pinfo->src, AT_ILNP_NID, 8, ((uint8_t*)pinfo->net_src.data)+8);
    alloc_address_wmem(pinfo->pool, &pinfo->dst, AT_ILNP_NID, 8, ((uint8_t*)pinfo->net_dst.data)+8);

    //Get address data from the current network layer and put into tap data
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_src_l64, AT_ILNP_L64, 8, pinfo->net_src.data);
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_src_nid, AT_ILNP_NID, 8, ((uint8_t*)pinfo->net_src.data)+8);
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_dst_l64, AT_ILNP_L64, 8, pinfo->net_dst.data);
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_dst_nid, AT_ILNP_NID, 8, ((uint8_t*)pinfo->net_dst.data)+8);
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_src_ilv, AT_ILNP_ILV, 16, pinfo->net_src.data);
    alloc_address_wmem(pinfo->pool, &ilnph->ilnp_dst_ilv, AT_ILNP_ILV, 16, pinfo->net_dst.data);

    //Add tap data to the dissection tree

    // convert all addresses to strings for display
    str_ilnp_src_nid = address_to_str(pinfo->pool, &ilnph->ilnp_src_nid);
    str_ilnp_src_l64 = address_to_str(pinfo->pool, &ilnph->ilnp_src_l64);
    str_ilnp_dst_nid = address_to_str(pinfo->pool, &ilnph->ilnp_dst_nid);
    str_ilnp_dst_l64 = address_to_str(pinfo->pool, &ilnph->ilnp_dst_l64);
    str_ilnp_src_ilv = address_to_str(pinfo->pool, &ilnph->ilnp_src_ilv);
    str_ilnp_dst_ilv = address_to_str(pinfo->pool, &ilnph->ilnp_dst_ilv);

    // Add address fields to ILNP subtree.  Some fields without specifying src or dst for added filter options
    proto_tree_add_string(ilnp_tree, hf_ilnp_src_l64, tvb, 0, 0, str_ilnp_src_l64);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_l64, tvb, 0, 0, str_ilnp_src_l64);
    proto_item_set_hidden(ti);
    proto_tree_add_string(ilnp_tree, hf_ilnp_src_nid, tvb, 0, 0, str_ilnp_src_nid);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_nid, tvb, 0, 0, str_ilnp_src_nid);
    proto_item_set_hidden(ti);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_src_ilv, tvb, 0, 0, str_ilnp_src_ilv);
    proto_item_set_hidden(ti);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_ilv, tvb, 0, 0, str_ilnp_src_ilv);
    proto_item_set_hidden(ti);
    proto_tree_add_string(ilnp_tree, hf_ilnp_dst_l64, tvb, 0, 0, str_ilnp_dst_l64);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_l64, tvb, 0, 0, str_ilnp_dst_l64);
    proto_item_set_hidden(ti);
    proto_tree_add_string(ilnp_tree, hf_ilnp_dst_nid, tvb, 0, 0, str_ilnp_dst_nid);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_nid, tvb, 0, 0, str_ilnp_dst_nid);
    proto_item_set_hidden(ti);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_dst_ilv, tvb, 0, 0, str_ilnp_dst_ilv);
    proto_item_set_hidden(ti);
    ti = proto_tree_add_string(ilnp_tree, hf_ilnp_ilv, tvb, 0, 0, str_ilnp_dst_ilv);
    proto_item_set_hidden(ti);

    // Add test to the main ILNP dropdown in the packet details pane.
    proto_item_append_text(ilnp_item, ", Src: %s, Dst: %s", str_ilnp_src_ilv, str_ilnp_dst_ilv);

    // does not use nonce or l64
    conv = find_conversation_strat(pinfo, CONVERSATION_ILNP, NO_PORT_X, false);
    if (!conv) { // if no conversation exists
        conv = conversation_new_strat(pinfo, CONVERSATION_ILNP, NO_PORTS);
    }
    else {    // otherwise add to existing conversation
        if (!(pinfo->fd->visited)) {
            if (pinfo->num > conv->last_frame) {
                conv->last_frame = pinfo->num;
            }
        }
    }

    // Get stream id for display
    ilnpd = get_ilnp_conversation_data(conv, pinfo);
    if (ilnpd) {
        // set stream id in tap info struct
        ilnph->ilnp_stream = ilnpd->stream;
        // add to protocol tree
        ti = proto_tree_add_uint(ilnp_tree, hf_ilnp_stream, tvb, 0, 0, ilnpd->stream);
        proto_item_set_generated(ti);
    }

    // queue packet to trigger linked tap listeners
    tap_queue_packet(ilnp_tap, pinfo, ilnph);

    return tvb_captured_length(tvb);
}

// Initialise the ILNP dissector with a stream count starting at 0
static void ilnp_init(void) {
    ilnp_stream_count = 0;
}

void proto_register_ilnp(void) {

    static hf_register_info hf[] = {
        { &hf_ilnp_nonce,
            { "ILNP Nonce Value", "ilnp.nonce", FT_BYTES, BASE_NONE, NULL, 0x0,
                NULL, HFILL }
        },
        { &hf_ilnp_src_l64,
            { "Source L64", "ilnp.src_l64", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source Locator", HFILL}
        },
        { &hf_ilnp_src_nid,
            { "Source NID", "ilnp.src_nid", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source Node Identifier", HFILL}
        },
        { &hf_ilnp_dst_l64,
            { "Destination L64", "ilnp.dst_l64", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Destination Locator", HFILL}
        },
        { &hf_ilnp_dst_nid,
            { "Destination NID", "ilnp.dst_nid", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Destination Node Identifier", HFILL}
        },
        { &hf_ilnp_src_ilv,
            { "Source ILV", "ilnp.src_ilv", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source Identifier-Locator Vector", HFILL}
        },
        { &hf_ilnp_dst_ilv,
            { "Destination ILV", "ilnp.dst_ilv", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Destination Identifier-Locator Vector", HFILL}
        },
        { &hf_ilnp_ilv,
            { "Source or Destination ILV", "ilnp.ilv", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source or Destination Identifier-Locator Vector", HFILL}
        },
        { &hf_ilnp_nid,
            { "Source or Destination NID", "ilnp.nid", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source or Destination Node Identifier", HFILL}
        },
        { &hf_ilnp_l64,
            { "Source or Destination L64", "ilnp.l64", FT_STRING, BASE_NONE, NULL, 0x0,
                "ILNP Source or Destination Locator", HFILL}
        },
        { &hf_ilnp_stream,
            { "Stream index", "ilnp.stream",
                FT_UINT32, BASE_DEC, NULL, 0x0,
                NULL, HFILL }
        },
    };

    static int* ett[] = {
        &ett_ilnp,
    };

    proto_ilnp = proto_register_protocol("Identifier-Locator Network Protocol", "ILNP", "ilnp");
    proto_register_field_array(proto_ilnp, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));

    register_init_routine(ilnp_init);

    ilnp_handle = register_dissector("ilnp", dissect_ilnp, proto_ilnp);

    ilnp_tap = register_tap("ilnp");

    register_conversation_table(proto_ilnp, true, ilnp_conversation_packet, ilnp_endpoint_packet);
    register_conversation_filter("ilnp", "ILNP", ilnp_filter_valid, ilnp_build_filter, NULL);

    /* XXX - This isn't really a plugin, but the non-plugin version requires GUI changes */
    stats_tree_register_plugin("ilnp", "ilnp_nids", st_str_ilnp_nid, 0, ilnp_nids_stats_tree_packet, ilnp_nids_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_l64s", st_str_ilnp_l64, 0, ilnp_l64s_stats_tree_packet, ilnp_l64s_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_ilvs", st_str_ilnp_ilv, 0, ilnp_ilvs_stats_tree_packet, ilnp_ilvs_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_ptype", st_str_ilnp_ptype, 0, ilnp_ptype_stats_tree_packet, ilnp_ptype_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_srcdst_nid", st_str_ilnp_srcdst_nid, 0, ilnp_srcdst_nid_stats_tree_packet, ilnp_srcdst_nid_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_srcdst_l64", st_str_ilnp_srcdst_l64, 0, ilnp_srcdst_l64_stats_tree_packet, ilnp_srcdst_l64_stats_tree_init, NULL);
    stats_tree_register_plugin("ilnp", "ilnp_srcdst_ilv", st_str_ilnp_srcdst_ilv, 0, ilnp_srcdst_ilv_stats_tree_packet, ilnp_srcdst_ilv_stats_tree_init, NULL);
}