/* packet-vpp.c

 *

 * Routines for the disassembly of fd.io vpp project

 * dispatch captures

 *

 * Copyright 2019, Dave Barach <wireshark@barachs.net>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/to_str.h>

#include <epan/etypes.h>

#include <epan/ws_printf.h>

#include <wiretap/wtap.h>

#include "packet-osi.h"

void proto_register_vpp(void);

void proto_reg_handoff_vpp(void);

static int proto_vpp;

static int proto_vpp_metadata;

static int proto_vpp_opaque;

static int proto_vpp_opaque2;

static int proto_vpp_trace;

static int hf_vpp_nodename;

static int hf_vpp_metadata;

static int hf_vpp_buffer_index;

static int hf_vpp_buffer_opaque;

static int hf_vpp_buffer_opaque2;

static int hf_vpp_buffer_trace;

static int hf_vpp_major_version;

static int hf_vpp_minor_version;

static int hf_vpp_protocol_hint;

static expert_module_t* expert_vpp;

static expert_field ei_vpp_major_version_error;

static expert_field ei_vpp_minor_version_error;

static expert_field ei_vpp_protocol_hint_error;

static int ett_vpp;

static int ett_vpp_opaque;

static int ett_vpp_opaque2;

static int ett_vpp_metadata;

static int ett_vpp_trace;

static dissector_handle_t vpp_dissector_handle;

static dissector_handle_t vpp_opaque_dissector_handle;

static dissector_handle_t vpp_opaque2_dissector_handle;

static dissector_handle_t vpp_metadata_dissector_handle;

static dissector_handle_t vpp_trace_dissector_handle;

#define VPP_MAJOR_VERSION       1

#define VPP_MINOR_VERSION       0

#define IP4_TYPICAL_VERSION_LENGTH      0x45

#define IP6_TYPICAL_VERSION_AND_TRAFFIC_CLASS   0x60

typedef enum

  {

    VLIB_NODE_PROTO_HINT_NONE = 0,

    VLIB_NODE_PROTO_HINT_ETHERNET,

    VLIB_NODE_PROTO_HINT_IP4,

    VLIB_NODE_PROTO_HINT_IP6,

    VLIB_NODE_PROTO_HINT_TCP,

    VLIB_NODE_PROTO_HINT_UDP,

    VLIB_NODE_N_PROTO_HINTS,

  } vlib_node_proto_hint_t;

static dissector_handle_t next_dissectors[VLIB_NODE_N_PROTO_HINTS];

/* List of next dissectors hints that we know about */

#define foreach_next_dissector                          \

_(VLIB_NODE_PROTO_HINT_ETHERNET, eth_withoutfcs)        \

_(VLIB_NODE_PROTO_HINT_IP4, ip)                         \

_(VLIB_NODE_PROTO_HINT_IP6, ipv6)                       \

_(VLIB_NODE_PROTO_HINT_TCP, tcp)                        \

_(VLIB_NODE_PROTO_HINT_UDP, udp)

static void

add_multi_line_string_to_tree(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo,

                              int start,

                              int len, int hf)

{

    int next;

    int line_len;

    int data_len;

    while(len > 0) {

        line_len = tvb_find_line_end(tvb, start, len, &next, false);

        data_len = next - start;

        proto_tree_add_string(tree, hf, tvb, start, data_len,

                              tvb_format_stringzpad(pinfo->pool, tvb, start, line_len));

        start += data_len;

        len -= data_len;

    }

}

static int

dissect_vpp_metadata(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                     void* data _U_)

{

    int offset = 0;

    proto_item *ti;

    proto_tree *metadata_tree;

    int metadata_string_length;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "VPP-Metadata");

    col_clear(pinfo->cinfo, COL_INFO);

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

    metadata_tree = proto_item_add_subtree(ti, ett_vpp_metadata);

    /* How long is the metadata string? */

    metadata_string_length = tvb_strsize(tvb, offset);

    add_multi_line_string_to_tree(metadata_tree, tvb, pinfo, 0,

                                  metadata_string_length,

                                  hf_vpp_metadata);

    return tvb_captured_length(tvb);

}

static int

dissect_vpp_trace(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                  void* data _U_)

{

    int offset = 0;

    proto_item *ti;

    proto_tree *trace_tree;

    int trace_string_length;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "VPP-Trace");

    col_clear(pinfo->cinfo, COL_INFO);

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

    trace_tree = proto_item_add_subtree(ti, ett_vpp_trace);

    /* How long is the trace string? */

    trace_string_length = tvb_strsize(tvb, offset);

    add_multi_line_string_to_tree(trace_tree, tvb, pinfo, 0,

                                  trace_string_length,

                                  hf_vpp_buffer_trace);

    return tvb_captured_length(tvb);

}

static int

dissect_vpp_opaque(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                   void* data _U_)

{

    int offset = 0;

    proto_item *ti;

    proto_tree *opaque_tree;

    int opaque_string_length;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "VPP-Opaque");

    col_clear(pinfo->cinfo, COL_INFO);

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

    opaque_tree = proto_item_add_subtree(ti, ett_vpp_opaque);

    opaque_string_length = tvb_strsize(tvb, offset);

    add_multi_line_string_to_tree(opaque_tree, tvb, pinfo, 0, opaque_string_length,

                                  hf_vpp_buffer_opaque);

    return tvb_captured_length(tvb);

}

static int

dissect_vpp_opaque2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                    void* data _U_)

{

    int offset = 0;

    proto_item *ti;

    proto_tree *opaque2_tree;

    int opaque2_string_length;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "VPP-Opaque2");

    col_clear(pinfo->cinfo, COL_INFO);

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

    opaque2_tree = proto_item_add_subtree(ti, ett_vpp_opaque2);

    opaque2_string_length = tvb_strsize(tvb, offset);

    add_multi_line_string_to_tree(opaque2_tree, tvb, pinfo, 0, opaque2_string_length,

                                  hf_vpp_buffer_opaque2);

    return tvb_captured_length(tvb);

}

static int

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

{

    proto_item *ti;

    proto_tree *vpp_tree;

    tvbuff_t *metadata_tvb, *opaque_tvb, *opaque2_tvb, *eth_tvb, *trace_tvb;

    int offset = 0;

    uint8_t major_version, minor_version, string_count, protocol_hint;

    char *name;

    unsigned len;

    uint8_t maybe_protocol_id;

    dissector_handle_t use_this_dissector;

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

    col_clear(pinfo->cinfo, COL_INFO);

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

    vpp_tree = proto_item_add_subtree(ti, ett_vpp);

    major_version = tvb_get_uint8(tvb, offset);

    /* If the major version doesn't match, quit on the spot */

    if(major_version != VPP_MAJOR_VERSION) {

        proto_item *major_version_item;

        major_version_item =

            proto_tree_add_item(tree, hf_vpp_major_version,

                                tvb, offset, 1, ENC_NA);

        expert_add_info_format(pinfo, major_version_item,

                               &ei_vpp_major_version_error,

                               "Major Version Mismatch read %d not %d",

                               (int)major_version, VPP_MAJOR_VERSION);

        return tvb_captured_length(tvb);

    }

    offset++;

    minor_version = tvb_get_uint8(tvb, offset);

    /* If the minor version doesn't match, make a note and try to continue */

    if(minor_version != VPP_MINOR_VERSION) {

        proto_item *minor_version_item;

        minor_version_item =

            proto_tree_add_item(tree, hf_vpp_minor_version,

                                tvb, offset, 1, ENC_NA);

        expert_add_info_format(pinfo, minor_version_item,

                               &ei_vpp_minor_version_error,

                               "Minor Version Mismatch read %d not %d",

                               (int)minor_version, VPP_MINOR_VERSION);

    }

    offset++;

    /* Number of counted strings in this trace record */

    string_count = tvb_get_uint8(tvb, offset);

    offset++;

    /*

     * Hint: protocol which should be at b->data[b->current_data]

     * It will be a while before vpp sends useful hints for every

     * possible node, see heuristic below.

     */

    protocol_hint = tvb_get_uint8(tvb, offset);

    if(protocol_hint >= array_length(next_dissectors)) {

        proto_item *protocol_hint_item;

        protocol_hint_item =

            proto_tree_add_item(tree, hf_vpp_protocol_hint,

                                tvb, offset, 1, ENC_NA);

        expert_add_info_format(pinfo, protocol_hint_item,

                               &ei_vpp_protocol_hint_error,

                               "Protocol hint %d out of range, max %d",

                               (int)protocol_hint,

                               (int)array_length(next_dissectors));

        protocol_hint = 0;

    }

    offset++;

    /* Buffer Index */

    proto_tree_add_item(vpp_tree, hf_vpp_buffer_index, tvb,

                        offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* Nodename */

    len = tvb_strsize(tvb, offset);

    name = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, len,

                              ENC_ASCII);

    proto_tree_add_string(tree, hf_vpp_nodename, tvb, offset, len, name);

    offset += len;

    /* Metadata */

    len = tvb_strsize(tvb, offset);

    metadata_tvb = tvb_new_subset_remaining(tvb, offset);

    call_dissector(vpp_metadata_dissector_handle, metadata_tvb, pinfo, tree);

    offset += len;

    /* Opaque */

    len = tvb_strsize(tvb, offset);

    opaque_tvb = tvb_new_subset_remaining(tvb, offset);

    call_dissector(vpp_opaque_dissector_handle, opaque_tvb, pinfo, tree);

    offset += len;

    /* Opaque2 */

    len = tvb_strsize(tvb, offset);

    opaque2_tvb = tvb_new_subset_remaining(tvb, offset);

    call_dissector(vpp_opaque2_dissector_handle, opaque2_tvb, pinfo, tree);

    offset += len;

    /* Trace, if present */

    if(string_count > 4) {

        len = tvb_strsize(tvb, offset);

        trace_tvb = tvb_new_subset_remaining(tvb, offset);

        call_dissector(vpp_trace_dissector_handle, trace_tvb, pinfo, tree);

        offset += len;

    }

    eth_tvb = tvb_new_subset_remaining(tvb, offset);

    /*

     * Delegate the rest of the packet dissection to the per-node

     * next dissector in the foreach_node_to_dissector_pair list

     *

     * Failing that, pretend its an ethernet packet

     */

    /* See setup for hint == 0 below */

    use_this_dissector = next_dissectors [protocol_hint];

    if(protocol_hint == 0) {

        maybe_protocol_id = tvb_get_uint8(tvb, offset);

        switch(maybe_protocol_id) {

        case IP4_TYPICAL_VERSION_LENGTH:

            use_this_dissector = next_dissectors[VLIB_NODE_PROTO_HINT_IP4];

            break;

        case IP6_TYPICAL_VERSION_AND_TRAFFIC_CLASS:

            use_this_dissector = next_dissectors[VLIB_NODE_PROTO_HINT_IP6];

            break;

        default:

            break;

        }

    }

    call_dissector(use_this_dissector, eth_tvb, pinfo, tree);

    return tvb_captured_length(tvb);

}

void

proto_register_vpp(void)

{

    static hf_register_info vpp_hf[] = {

        { &hf_vpp_buffer_index,

          { "BufferIndex", "vpp.BufferIndex",  FT_UINT32, BASE_HEX, NULL, 0x0,

            NULL, HFILL },

        },

        { &hf_vpp_nodename,

          { "NodeName", "vpp.NodeName",  FT_STRINGZ, BASE_NONE, NULL, 0x0,

            NULL, HFILL },

        },

        { &hf_vpp_major_version,

          { "MajorVersion", "vpp.MajorVersion",  FT_UINT8, BASE_DEC, NULL, 0x0,

            NULL, HFILL },

        },

        { &hf_vpp_minor_version,

          { "MinorVersion", "vpp.MinorVersion",  FT_UINT8, BASE_DEC, NULL, 0x0,

            NULL, HFILL },

        },

        { &hf_vpp_protocol_hint,

          { "ProtocolHint", "vpp.ProtocolHint",  FT_UINT8, BASE_DEC, NULL, 0x0,

            NULL, HFILL },

        },

    };

    static ei_register_info vpp_ei[] = {

        { &ei_vpp_major_version_error,

          { "vpp.bad_major_version", PI_MALFORMED, PI_ERROR,

            "Bad Major Version", EXPFILL }},

        { &ei_vpp_minor_version_error,

          { "vpp.bad_minor_version", PI_UNDECODED, PI_WARN,

            "Bad Minor Version", EXPFILL }},

        { &ei_vpp_protocol_hint_error,

          { "vpp.bad_protocol_hint", PI_PROTOCOL, PI_WARN,

            "Bad Protocol Hint", EXPFILL }},

    };

    static hf_register_info metadata_hf[] = {

        { &hf_vpp_metadata,

          { "Metadata", "vpp.metadata",

            FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL },

        },

    };

    static hf_register_info opaque_hf[] = {

        { &hf_vpp_buffer_opaque,

          { "Opaque", "vpp.opaque",

            FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL },

        },

    };

    static hf_register_info opaque2_hf[] = {

        { &hf_vpp_buffer_opaque2,

          { "Opaque2", "vpp.opaque2",

            FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL },

        },

    };

    static hf_register_info trace_hf[] = {

        { &hf_vpp_buffer_trace,

          { "Trace", "vpp.trace",  FT_STRINGZ, BASE_NONE, NULL, 0x0,

            NULL, HFILL },

        },

    };

    static int *vpp_ett[] = {

        &ett_vpp,

    };

    static int *ett_metadata[] = {

        &ett_vpp_metadata,

    };

    static int *ett_opaque[] = {

        &ett_vpp_opaque,

    };

    static int *ett_opaque2[] = {

        &ett_vpp_opaque2,

    };

    static int *ett_trace[] = {

        &ett_vpp_trace,

    };

    proto_vpp = proto_register_protocol("VPP Dispatch Trace", "VPP", "vpp");

    proto_register_field_array(proto_vpp, vpp_hf, array_length(vpp_hf));

    proto_register_subtree_array(vpp_ett, array_length(vpp_ett));

    register_dissector("vpp", dissect_vpp, proto_vpp);

    expert_vpp = expert_register_protocol(proto_vpp);

    expert_register_field_array(expert_vpp, vpp_ei, array_length(vpp_ei));

    proto_vpp_metadata = proto_register_protocol("VPP Buffer Metadata",

                                                 "VPP-Metadata",

                                                 "vpp-metadata");

    proto_register_field_array(proto_vpp_metadata, metadata_hf,

                               array_length(metadata_hf));

    proto_register_subtree_array(ett_metadata, array_length(ett_metadata));

    register_dissector("vppMetadata", dissect_vpp_metadata, proto_vpp_metadata);

    proto_vpp_opaque = proto_register_protocol("VPP Buffer Opaque", "VPP-Opaque",

                                               "vpp-opaque");

    proto_register_field_array(proto_vpp_opaque, opaque_hf,

                               array_length(opaque_hf));

    proto_register_subtree_array(ett_opaque, array_length(ett_opaque));

    register_dissector("vppOpaque", dissect_vpp_opaque, proto_vpp_opaque);

    proto_vpp_opaque2 = proto_register_protocol("VPP Buffer Opaque2",

                                                "VPP-Opaque2", "vpp-opaque2");

    proto_register_field_array(proto_vpp_opaque2, opaque2_hf,

                               array_length(opaque2_hf));

    proto_register_subtree_array(ett_opaque2, array_length(ett_opaque2));

    register_dissector("vppOpaque2", dissect_vpp_opaque2, proto_vpp_opaque2);

    proto_vpp_trace = proto_register_protocol("VPP Buffer Trace", "VPP-Trace",

                                              "vpp-trace");

    proto_register_field_array(proto_vpp_trace, trace_hf,

                               array_length(trace_hf));

    proto_register_subtree_array(ett_trace, array_length(ett_trace));

    register_dissector("vppTrace", dissect_vpp_trace, proto_vpp_trace);

#define _(idx,dname) next_dissectors[idx] = find_dissector(#dname);

    foreach_next_dissector;

#undef _

    /* if all else fails, dissect data as if ethernet MAC */

    next_dissectors[VLIB_NODE_PROTO_HINT_NONE] =

        next_dissectors [VLIB_NODE_PROTO_HINT_ETHERNET];

}

void

proto_reg_handoff_vpp(void)

{

    vpp_dissector_handle = find_dissector("vpp");

    vpp_metadata_dissector_handle = find_dissector("vppMetadata");

    vpp_opaque_dissector_handle = find_dissector("vppOpaque");

    vpp_opaque2_dissector_handle = find_dissector("vppOpaque2");

    vpp_trace_dissector_handle = find_dissector("vppTrace");

    dissector_add_uint("wtap_encap", WTAP_ENCAP_VPP, vpp_dissector_handle);

}

/*

 * 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:

 */