Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1197 insertions, 0 deletions

diff --git a/epan/dissectors/packet-rtps-virtual-transport.c b/epan/dissectors/packet-rtps-virtual-transport.c
new file mode 100644
index 00000000..f30f951b
--- /dev/null
+++ b/epan/dissectors/packet-rtps-virtual-transport.c
@@ -0,0 +1,1197 @@
+/* packet-rtps-virtual-transport.c
+ * Dissector for the Real-Time Publish-Subscribe (RTPS) Virtual Transport
+ * Protocol.
+ *
+ * (c) 2020 Copyright, Real-Time Innovations, Inc.
+ * Real-Time Innovations, Inc.
+ * 232 East Java Drive
+ * Sunnyvale, CA 94089
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * -----------------------------------------------------------------------------
+ * RTI Connext DDS can capture RTPS-related traffic by using the Network Capture
+ * Utility. The generated .pcap capture files will follow the RTPS-VT protocol,
+ * which establishes a format for how information must be saved, and then
+ * parsed.
+ *
+ * The protocol is divided into two layers: transport
+ * (packet-rtps-virtual-transport.c) and advanced (packet-rtps-processed.c).
+ * This file is about the transport dissector. For more information about the
+ * advanced dissector, read the documentation at the beginning of
+ * packet-rtps-processed.c.
+ *
+ * Every packet saved in the capture file follows the PCAP file format.
+ * As a consequence, there are two headers: a global one (unique per file) and
+ * a per-packet header. These headers have the typical content described in the
+ * PCAP format: a magic number, version number, some timestamps, information
+ * describing the length of the packet and the data link layer (0x000000fc, i.e.
+ * custom protocol), etc. Then, we have a header that indicates Wireshark the
+ * name of the protocol: "rtpsvt". The transport dissector is called when
+ * Wireshark finds "rtpsvt" as the protocol name.
+ *
+ * After the RTPS-VT header, we have the frame type. The frame type determines
+ * what kind of information has the dumped packet. RTPS-VT data comes as a
+ * series of [parameter identifier, content length, content]. Depending on the
+ * type of frame (RTPS or lossInfo), the dissector will expect some parameters
+ * or others.
+ *
+ * If the frame type is RTPS, we will continue parsing transport-layer data.
+ * The transport layer contains all information about the source and destination
+ * of a packet. This corresponds to data typically found on Network or Transport
+ * protocols. However, because RTI Connext DDS generates the capture file
+ * directly at application-level, this information is added at the moment of
+ * writing the capture file.
+ * After the transport-layer information, we will call the advanced dissector.
+ *
+ * If the frame type is lossInfo, the dissector will generate a packet
+ * indicating that there were missing frames (and the range of sequence
+ * numbers).
+ */
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/expert.h>
+#include <epan/prefs.h>
+#include <epan/addr_resolv.h>
+#include <epan/wmem_scopes.h>
+#include <epan/conversation.h>
+#include "packet-tcp.h"
+#include "packet-rtps.h"
+
+
+#define CONTENT_KIND_RTPS                        0x01
+#define CONTENT_KIND_LOSS_INFO                   0x02
+
+#define PARAM_ID_TRANSPORT_CLASS                 0x0001
+#define PARAM_ID_MONITORING_GUID                 0x0002
+#define PARAM_ID_MONITORING_SN                   0x0003
+#define PARAM_ID_SOURCE_IP_ADDRESS               0x0004
+#define PARAM_ID_SOURCE_PORT                     0x0005
+#define PARAM_ID_DESTINATION_IP_ADDRESS          0x0006
+#define PARAM_ID_DESTINATION_RTPS_PORT           0x0007
+#define PARAM_ID_DESTINATION_PORT                0x0008
+#define PARAM_ID_DIRECTION                       0x0009
+#define FIRST_PARAM_ID_RTPS  PARAM_ID_TRANSPORT_CLASS
+#define LAST_PARAM_ID_RTPS   PARAM_ID_DIRECTION
+
+/* First parameter Identifier that the "rtpsproc" protocol accepts */
+#define PARAM_ID_MAIN_FRAME                      0x00C0
+
+#define PARAM_ID_LOST_MESSAGES                   0x0001
+
+void proto_register_rtps_virtual_transport(void);
+static gint dissect_rtps_virtual_transport(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree,
+        void *data _U_);
+static gint dissect_rtps_virtual_transport_rtps_type(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree,
+        proto_tree *tree_transport,
+        gint offset,
+        struct rtpsvt_data *transport_data);
+static gint dissect_parameter_transport_rtps_type(
+        tvbuff_t *tvb,
+        proto_tree *rtpsvt_tree_general,
+        proto_tree *rtpsvt_tree_identifier,
+        proto_tree *rtpsvt_tree_information,
+        gint offset,
+        packet_info *pinfo,
+        struct rtpsvt_data *transport_data);
+static gint dissect_rtps_virtual_transport_loss_info_type(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree_transport,
+        gint offset);
+
+/* Subtree pointers */
+static gint proto_rtpsvt = -1;
+static gint rtpsvt_ett = -1;
+static gint rtpsvt_ett_version = -1;
+static gint rtpsvt_ett_identifier = -1;
+static gint rtpsvt_ett_information = -1;
+static gint rtpsvt_ett_information_class = -1;
+static gint rtpsvt_ett_information_src_port = -1;
+static gint rtpsvt_ett_information_dst_port = -1;
+static gint rtpsvt_ett_information_src_addr = -1;
+static gint rtpsvt_ett_information_dst_addr = -1;
+static gint rtpsvt_ett_information_direction = -1;
+static gint rtpsvt_ett_monitoring_sn = -1;
+static gint rtpsvt_ett_frame = -1;
+
+/* Initialize the protocol and registered fields */
+static header_field_info *rtpsvt_hf = NULL;
+static gint rtpsvt_hf_version = -1;
+static gint rtpsvt_hf_version_major = -1;
+static gint rtpsvt_hf_version_minor = -1;
+static gint rtpsvt_hf_content_kind = -1;
+static gint rtpsvt_hf_param_id = -1;
+static gint rtpsvt_hf_param_length = -1;
+static gint rtpsvt_hf_packet_identifier = -1;
+static gint rtpsvt_hf_monitoring_guid = -1;
+static gint rtpsvt_hf_monitoring_seqNr = -1;
+static gint rtpsvt_hf_information = -1;
+static gint rtpsvt_hf_class = -1;
+static gint rtpsvt_hf_source_port = -1;
+static gint rtpsvt_hf_source_address = -1;
+static gint rtpsvt_hf_source_pid = -1;
+static gint rtpsvt_hf_destination_port = -1;
+static gint rtpsvt_hf_destination_rtps_port = -1;
+static gint rtpsvt_hf_destination_address = -1;
+static gint rtpsvt_hf_direction = -1;
+static gint rtpsvt_hf_destination_pid = -1;
+static gint rtpsvt_hf_missing_messages = -1;
+
+/* expert info fields */
+static expert_field ei_missing_msg = EI_INIT;
+
+/* Vendor specific: RTI */
+static const value_string ndds_transport_class_id_vals[] = {
+    { NDDS_TRANSPORT_CLASSID_ANY,           "ANY" },
+    { NDDS_TRANSPORT_CLASSID_UDPv4,         "UDPv4" },
+    { NDDS_TRANSPORT_CLASSID_UDPv4_WAN,     "UDPv4_WAN"},
+    { NDDS_TRANSPORT_CLASSID_SHMEM,         "SHMEM" },
+    { NDDS_TRANSPORT_CLASSID_INTRA,         "INTRA" },
+    { NDDS_TRANSPORT_CLASSID_UDPv6,         "UDPv6" },
+    { NDDS_TRANSPORT_CLASSID_DTLS,          "DTLS" },
+    { NDDS_TRANSPORT_CLASSID_WAN,           "WAN" },
+    { NDDS_TRANSPORT_CLASSID_TCPV4_LAN,     "TCPv4_LAN" },
+    { NDDS_TRANSPORT_CLASSID_TCPV4_WAN,     "TCPv4_WAN" },
+    { NDDS_TRANSPORT_CLASSID_TLSV4_LAN,     "TLSv4_LAN" },
+    { NDDS_TRANSPORT_CLASSID_TLSV4_WAN,     "TLSv4_WAN" },
+    { NDDS_TRANSPORT_CLASSID_PCIE,          "PCIE" },
+    { NDDS_TRANSPORT_CLASSID_ITP,           "ITP" },
+    { 0, NULL }
+};
+
+static gint dissect_rtps_virtual_transport(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree,
+        void *data _U_)
+{
+    proto_tree *rtpsvt_tree_transport;
+    proto_item *rtpsvt_ti_transport;
+    proto_item *rtpsvt_ti_version;
+    proto_tree *rtpsvt_tree_version;
+    proto_item *rtpsvt_ti_content_kind;
+    struct rtpsvt_data transport_data;
+    guint16 version;
+    guint8 content_type;
+    const gchar *content_type_label;
+    gint offset = 0;
+    gint output = 0;
+
+    /* Add transport tree, used for the fields of our proto_rtpsvt */
+    rtpsvt_ti_transport = proto_tree_add_item(
+            tree,
+            proto_rtpsvt,
+            tvb,
+            offset,
+            -1,
+            ENC_BIG_ENDIAN);
+    rtpsvt_tree_transport = proto_item_add_subtree(rtpsvt_ti_transport, rtpsvt_ett);
+
+    /* Add the version to the transport protocol */
+    version = tvb_get_ntohs(tvb, offset);
+    transport_data.version_major = version >> 8;
+    transport_data.version_minor = version & 0xff;
+    rtpsvt_ti_version = proto_tree_add_uint_format(
+            rtpsvt_tree_transport,
+            rtpsvt_hf_version,
+            tvb,
+            offset,
+            2, /* 2B: sizeof(guint16) */
+            version,
+            "Version: %d.%d",
+            transport_data.version_major,
+            transport_data.version_minor);
+    rtpsvt_tree_version = proto_item_add_subtree(
+            rtpsvt_ti_version,
+            rtpsvt_ett_version);
+
+    proto_tree_add_item(
+            rtpsvt_tree_version,
+            rtpsvt_hf_version_major,
+            tvb,
+            offset,
+            1, /* length: sizeof(guint8) */
+            ENC_NA);
+    proto_tree_add_item(
+            rtpsvt_tree_version,
+            rtpsvt_hf_version_minor,
+            tvb,
+            offset + 1,
+            1, /* length: sizeof(guint8) */
+            ENC_NA);
+    offset += 2;
+
+    /* Add the content kind. */
+    content_type = tvb_get_guint8(tvb, offset);
+    rtpsvt_ti_content_kind = proto_tree_add_item(
+            rtpsvt_ti_transport,
+            rtpsvt_hf_content_kind,
+            tvb,
+            offset,
+            1, /* length: sizeof(guint8) */
+            ENC_NA);
+    if (content_type == CONTENT_KIND_RTPS) {
+        content_type_label = "RTPS";
+    } else {
+        content_type_label = "LOST_INFO";
+    }
+    proto_item_append_text(rtpsvt_ti_content_kind, " (%s)", content_type_label);
+    offset += 1;
+
+    switch(content_type) {
+        case CONTENT_KIND_RTPS:
+            output = dissect_rtps_virtual_transport_rtps_type(
+                    tvb,
+                    pinfo,
+                    tree,
+                    rtpsvt_tree_transport,
+                    offset,
+                    &transport_data);
+            break;
+
+        case CONTENT_KIND_LOSS_INFO:
+            output = dissect_rtps_virtual_transport_loss_info_type(
+                    tvb,
+                    pinfo,
+                    rtpsvt_tree_transport,
+                    offset);
+            break;
+    }
+    return output;
+}
+
+static gint dissect_rtps_virtual_transport_rtps_type(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree,
+        proto_tree *tree_transport,
+        gint offset,
+        struct rtpsvt_data *transport_data)
+{
+    proto_item *rtpsvt_ti_identifier;
+    proto_tree *rtpsvt_tree_identifier;
+    proto_item *rtpsvt_ti_information;
+    proto_tree *rtpsvt_tree_information;
+    tvbuff_t *advanced_payload;
+    static dissector_handle_t advanced_handle = NULL;
+    unsigned int idx = FIRST_PARAM_ID_RTPS;
+    guint16 param_id;
+    guint16 param_length;
+
+    /*
+     * Add the tree for the packet identifier, which will be populated in
+     * dissect_parameter_transport_rtps_type.
+     */
+    rtpsvt_ti_identifier = proto_tree_add_item(
+            tree_transport,
+            rtpsvt_hf_packet_identifier,
+            tvb,
+            offset,
+            -1,
+            ENC_NA);
+    rtpsvt_tree_identifier = proto_item_add_subtree(
+            rtpsvt_ti_identifier,
+            rtpsvt_ett_identifier);
+
+    /*
+     * Add the tree for the transport information, which will be populated in
+     * dissect_parameter_transport_rtps_type.
+     */
+    rtpsvt_ti_information = proto_tree_add_item(
+            tree_transport,
+            rtpsvt_hf_information,
+            tvb,
+            offset,
+            -1,
+            ENC_NA);
+    rtpsvt_tree_information = proto_item_add_subtree(
+            rtpsvt_ti_information,
+            rtpsvt_ett_information);
+
+    /*
+     * Each parameter has an id, a length and a value.
+     */
+    for (idx = FIRST_PARAM_ID_RTPS; idx <= LAST_PARAM_ID_RTPS; idx++) {
+        offset = dissect_parameter_transport_rtps_type(
+                tvb,
+                tree_transport,
+                rtpsvt_tree_identifier,
+                rtpsvt_tree_information,
+                offset,
+                pinfo,
+                transport_data);
+    }
+
+    /*
+     * In the future we may have more transport parameters.
+     * These parameters will have an identifier less than PARAM_ID_MAIN_FRAME
+     * (which is parsed by the rtpsproc dissector).
+     * If we open a "future" capture file with this dissector, we will skip all
+     * of those parameters and parse only the ones we know about.
+     */
+    do {
+        param_id = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
+        offset += 2;
+        param_length = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
+        offset += 2;
+        if (param_id == PARAM_ID_MAIN_FRAME) {
+            proto_tree *rtpsvt_tree_frame;
+            transport_data->rtps_length = param_length;
+            rtpsvt_tree_frame = proto_tree_add_subtree_format(
+                    tree_transport,
+                    tvb,
+                    offset,
+                    0,
+                    rtpsvt_ett_frame,
+                    NULL,
+                    "Real-Time Publish-Subscribe Wire Protocol (content)");
+
+            proto_tree_add_uint(
+                    rtpsvt_tree_frame,
+                    rtpsvt_hf_param_id,
+                    tvb,
+                    offset,
+                    2, /* 2B: sizeof(guint16) */
+                    param_id);
+            proto_tree_add_uint(
+                    rtpsvt_tree_frame,
+                    rtpsvt_hf_param_length,
+                    tvb,
+                    offset + 2,
+                    2,
+                    param_length);
+            break;
+        }
+        offset += param_length;
+    } while (tvb_reported_length_remaining(tvb, offset) > 0);
+
+    if (param_id != PARAM_ID_MAIN_FRAME || param_length <= 0) {
+        /*
+         * Reject the packet if we don't have an RTPS frame.
+         * The rtpsproc dissector assumes that the contents start with the
+         * RTPS frame (parameter value; the length is obtained from
+         * transport_data).
+         */
+        return 0;
+    }
+
+    advanced_payload = tvb_new_subset_length(tvb, offset, -1);
+    advanced_handle = find_dissector("rtpsproc");
+    call_dissector_with_data(
+            advanced_handle,
+            advanced_payload,
+            pinfo,
+            tree,
+            (void *) transport_data);
+
+    return tvb_captured_length(tvb);
+}
+
+static gint dissect_parameter_transport_rtps_type(
+        tvbuff_t *tvb,
+        proto_tree *rtpsvt_tree_general,
+        proto_tree *rtpsvt_tree_identifier,
+        proto_tree *rtpsvt_tree_information,
+        gint offset,
+        packet_info *pinfo,
+        struct rtpsvt_data *transport_data)
+{
+    /*
+     * We will add the parameter id and length later, as part of a subtree
+     * dependent of the parameter.
+     * That is why value of the parameter is now at offset + 4
+     * (i.e. offset + sizeof(param_id) + sizeof(param_length))
+     */
+    guint16 param_id = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
+    guint16 param_length = tvb_get_guint16(tvb, offset + 2, ENC_BIG_ENDIAN);
+    const gint OFFSET_TO_VAL = offset + 4;
+    if (param_length <=0) {
+        /* Length not valid: skip parameter (id + length) */
+        return OFFSET_TO_VAL;
+    }
+
+    switch(param_id) {
+        case PARAM_ID_TRANSPORT_CLASS:
+            {
+                proto_tree *rtpsvt_tree_information_class;
+                gint32 classId = tvb_get_gint32(tvb, OFFSET_TO_VAL, ENC_BIG_ENDIAN);
+                const gchar *className = val_to_str(
+                        classId,
+                        ndds_transport_class_id_vals,
+                        "%d");
+
+                rtpsvt_tree_information_class = proto_tree_add_subtree_format(
+                        rtpsvt_tree_information,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_class,
+                        NULL,
+                        "Class: %s",
+                        className);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_class,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_class,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                /*
+                 * Add transport class as item to the tree.
+                 * This is useful to apply as column or filter.
+                 */
+                proto_tree_add_string(
+                        rtpsvt_tree_information_class,
+                        rtpsvt_hf_class,
+                        tvb,
+                        offset,
+                        param_length,
+                        className);
+                offset += param_length;
+
+                /* Add summary to protocol header */
+                proto_item_append_text(rtpsvt_tree_general, ", %s", className);
+
+                /* Add summary to the transport information header */
+                proto_item_append_text(
+                        rtpsvt_tree_information,
+                        ", %s",
+                        className);
+            }
+            break;
+
+        case PARAM_ID_MONITORING_GUID:
+            {
+                proto_tree *rtpsvt_tree_monitoring_guid;
+                const guint8 *guid_bytes = tvb_get_ptr(
+                        tvb,
+                        OFFSET_TO_VAL,
+                        param_length);
+                const gchar *guid_string = bytes_to_str_punct(
+                        pinfo->pool,
+                        guid_bytes,
+                        MIN(param_length, 12),
+                        0);
+
+                rtpsvt_tree_monitoring_guid = proto_tree_add_subtree_format(
+                        rtpsvt_tree_identifier,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_src_addr,
+                        NULL,
+                        "Monitoring GUID Prefix: %s",
+                        guid_string);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_monitoring_guid,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_monitoring_guid,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                proto_tree_add_item(
+                        rtpsvt_tree_monitoring_guid,
+                        rtpsvt_hf_monitoring_guid,
+                        tvb,
+                        offset,
+                        param_length,
+                        ENC_NA);
+                offset += param_length;
+
+                /* Add summary to packet identifier header */
+                proto_item_append_text(
+                        rtpsvt_tree_identifier,
+                       ", GUID: %s",
+                       guid_string);
+            }
+            break;
+        case PARAM_ID_MONITORING_SN:
+            {
+                proto_tree *rtpsvt_tree_seqNr;
+                guint64 seqNr = tvb_get_guint64(tvb, OFFSET_TO_VAL, ENC_BIG_ENDIAN);
+
+                rtpsvt_tree_seqNr = proto_tree_add_subtree_format(
+                        rtpsvt_tree_identifier,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_monitoring_sn,
+                        NULL,
+                        "Monitoring Sequence Number: %" PRIu64,
+                        seqNr);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_seqNr,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_seqNr,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                proto_tree_add_uint64(
+                        rtpsvt_tree_seqNr,
+                        rtpsvt_hf_monitoring_seqNr,
+                        tvb,
+                        offset,
+                        param_length,
+                        seqNr);
+                offset += param_length;
+
+                /* Add summary to packet identifier header */
+                proto_item_append_text(
+                        rtpsvt_tree_identifier,
+                        ", SeqNum: %" PRIu64,
+                        seqNr);
+            }
+            break;
+        case PARAM_ID_SOURCE_IP_ADDRESS:
+            {
+                proto_tree *rtpsvt_tree_information_address;
+                gint temporary_hf = rtpsvt_hf_source_address;
+                const gchar *prefix = "shmem_prefix";
+                const gchar *title_tree = "Source address";
+                gchar addr[COL_MAX_LEN];
+                ws_in6_addr addr_raw;
+                const guint8 bytes_zeroed[12] = {0};
+                tvb_get_ipv6(tvb, OFFSET_TO_VAL, &addr_raw);
+
+                /* shared memory pid or address? */
+                if (memcmp(&addr_raw.bytes, prefix, strlen(prefix)) == 0) {
+                    temporary_hf = rtpsvt_hf_source_pid;
+                    title_tree = "Source process ID";
+                    guint32 pid = tvb_get_guint32(
+                            tvb,
+                            OFFSET_TO_VAL + (gint) (strlen(prefix)),
+                            ENC_BIG_ENDIAN);
+                    snprintf(addr, sizeof(addr), "%u", pid);
+                } else if (memcmp(
+                        &addr_raw.bytes,
+                        bytes_zeroed,
+                        sizeof(bytes_zeroed)) == 0){
+                    snprintf(
+                            addr,
+                            sizeof(addr),
+                            "%s",
+                            tvb_ip_to_str(pinfo->pool, tvb, OFFSET_TO_VAL + sizeof(bytes_zeroed)));
+                } else {
+                    snprintf(
+                            addr,
+                            sizeof(addr),
+                            "%s",
+                            tvb_ip6_to_str(pinfo->pool, tvb, OFFSET_TO_VAL));
+                }
+
+                /* Add source to destination column field */
+                if (pinfo->cinfo) {
+                    col_append_str(pinfo->cinfo, COL_DEF_SRC, addr);
+                }
+
+                rtpsvt_tree_information_address = proto_tree_add_subtree_format(
+                        rtpsvt_tree_information,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_src_addr,
+                        NULL,
+                        "%s: %s",
+                        title_tree,
+                        addr);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_address,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_address,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                /* Add source to the transport information tree */
+                proto_tree_add_string(
+                        rtpsvt_tree_information_address,
+                        temporary_hf,
+                        tvb,
+                        offset,
+                        param_length,
+                        addr);
+                offset += param_length;
+
+                /* Add summary to protocol header */
+                proto_item_append_text(rtpsvt_tree_general, ", Src: (%s", addr);
+
+                /* Add summary to transport information header */
+                proto_item_append_text(
+                        rtpsvt_tree_information,
+                        ", Src: (%s",
+                        addr);
+            }
+            break;
+        case PARAM_ID_SOURCE_PORT:
+            {
+                proto_tree *rtpsvt_tree_information_port;
+                guint32 port = tvb_get_guint32(
+                        tvb,
+                        OFFSET_TO_VAL,
+                        ENC_BIG_ENDIAN);
+
+                rtpsvt_tree_information_port = proto_tree_add_subtree_format(
+                        rtpsvt_tree_information,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_src_port,
+                        NULL,
+                        "Source port: %d",
+                        port);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_source_port,
+                        tvb,
+                        offset,
+                        param_length,
+                        port);
+                offset += param_length;
+
+                /* Add summary to protocol header */
+                proto_item_append_text(rtpsvt_tree_general, ":%d)", port);
+
+                /* Add summary to transport information header */
+                proto_item_append_text(
+                        rtpsvt_tree_information,
+                        ":%d)",
+                        port);
+
+                /*
+                 * Add the source port to pinfo.
+                 * This is used by the RTPS dissector to get the domainId and
+                 * participantIdx information displayed in discovery packets.
+                 */
+                pinfo->srcport = port;
+            }
+            break;
+        case PARAM_ID_DESTINATION_IP_ADDRESS:
+            {
+                proto_tree *rtpsvt_tree_information_address;
+                gint temporary_hf= rtpsvt_hf_destination_address;
+                const gchar *prefix = "shmem_prefix";
+                const gchar *title_tree = "Destination address";
+                gchar addr[COL_MAX_LEN];
+                ws_in6_addr addr_raw;
+                const guint8 bytes_zeroed[12] = {0};
+                tvb_get_ipv6(tvb, OFFSET_TO_VAL, &addr_raw);
+
+                /* shared memory pid or address? */
+                if (memcmp(&addr_raw.bytes, prefix, strlen(prefix)) == 0) {
+                    temporary_hf = rtpsvt_hf_destination_pid;
+                    title_tree = "Destination process ID";
+                    guint32 pid = tvb_get_guint32(
+                            tvb,
+                            OFFSET_TO_VAL + (gint) (strlen(prefix)),
+                            ENC_BIG_ENDIAN);
+                    snprintf(addr, sizeof(addr), "%u", pid);
+                } else if (memcmp(
+                        &addr_raw.bytes,
+                        bytes_zeroed,
+                        sizeof(bytes_zeroed)) == 0){
+                    snprintf(
+                            addr,
+                            sizeof(addr),
+                            "%s",
+                            tvb_ip_to_str(pinfo->pool, tvb, OFFSET_TO_VAL + sizeof(bytes_zeroed)));
+                } else {
+                    snprintf(
+                            addr,
+                            sizeof(addr),
+                            "%s",
+                            tvb_ip6_to_str(pinfo->pool, tvb, OFFSET_TO_VAL));
+                }
+
+                /* Add address to destination column field */
+                if (pinfo->cinfo) {
+                    col_append_str(pinfo->cinfo, COL_DEF_DST, addr);
+                }
+
+                rtpsvt_tree_information_address = proto_tree_add_subtree_format(
+                        rtpsvt_tree_information,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_dst_addr,
+                        NULL,
+                        "%s: %s",
+                        title_tree,
+                        addr);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_address,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_address,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                /* Add destination to the transport information tree */
+                proto_tree_add_string(
+                        rtpsvt_tree_information_address,
+                        temporary_hf,
+                        tvb,
+                        offset,
+                        param_length,
+                        addr);
+                offset += param_length;
+
+                /* Add summary to protocol header */
+                proto_item_append_text(rtpsvt_tree_general, ", Dst: (%s", addr);
+
+                /* Add summary to transport information header */
+                proto_item_append_text(
+                        rtpsvt_tree_information,
+                        ", Dst: (%s",
+                        addr);
+            }
+            break;
+        case PARAM_ID_DESTINATION_RTPS_PORT:
+            {
+                guint32 port = tvb_get_guint32(tvb, OFFSET_TO_VAL, ENC_BIG_ENDIAN);
+
+                proto_tree_add_uint(
+                        rtpsvt_tree_information,
+                        rtpsvt_hf_destination_rtps_port,
+                        tvb,
+                        OFFSET_TO_VAL,
+                        param_length,
+                        port);
+
+                offset = OFFSET_TO_VAL + param_length;
+            }
+            break;
+        case PARAM_ID_DESTINATION_PORT:
+            {
+                proto_tree *rtpsvt_tree_information_port;
+                guint32 port = tvb_get_guint32(tvb, OFFSET_TO_VAL, ENC_BIG_ENDIAN);
+
+                rtpsvt_tree_information_port = proto_tree_add_subtree_format(
+                        rtpsvt_tree_information,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_dst_port,
+                        NULL,
+                        "Destination port: %d",
+                        port);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+                offset += 2;
+
+                proto_tree_add_uint(
+                        rtpsvt_tree_information_port,
+                        rtpsvt_hf_destination_port,
+                        tvb,
+                        offset,
+                        param_length,
+                        port);
+                offset += param_length;
+
+                /* Add summary to protocol header */
+                proto_item_append_text(rtpsvt_tree_general, ":%d)", port);
+
+                /* Add summary to transport information header */
+                proto_item_append_text(
+                        rtpsvt_tree_information,
+                        ":%d)",
+                        port);
+
+                /*
+                 * Add the destination port to pinfo.
+                 * This is used by the RTPS dissector to get the domainId and
+                 * participantIdx information displayed in discovery packets.
+                 */
+                pinfo->destport = port;
+            }
+            break;
+        case PARAM_ID_DIRECTION:
+            {
+                proto_tree *rtpsvt_tree_direction;
+                guint8 value = tvb_get_guint8(tvb, OFFSET_TO_VAL);
+                const gchar *direction = value ? "INBOUND" : "OUTBOUND";
+
+                rtpsvt_tree_direction = proto_tree_add_subtree_format(
+                        rtpsvt_tree_general,
+                        tvb,
+                        offset,
+                        0,
+                        rtpsvt_ett_information_src_addr,
+                        NULL,
+                        "Traffic Direction: %s",
+                        direction);
+
+                /* Add parameter identifier and length */
+                proto_tree_add_uint(
+                        rtpsvt_tree_direction,
+                        rtpsvt_hf_param_id,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_id);
+                offset += 2;
+                proto_tree_add_uint(
+                        rtpsvt_tree_direction,
+                        rtpsvt_hf_param_length,
+                        tvb,
+                        offset,
+                        2, /* length: sizeof(guint16) */
+                        param_length);
+
+                proto_tree_add_string(
+                        rtpsvt_tree_direction,
+                        rtpsvt_hf_direction,
+                        tvb,
+                        OFFSET_TO_VAL,
+                        param_length,
+                        direction);
+                offset = OFFSET_TO_VAL + param_length;
+
+                /* Save transport direction for the RTPS-PROC protocol */
+                transport_data->direction = value;
+            }
+            break;
+    }
+    return offset;
+}
+
+static gint dissect_rtps_virtual_transport_loss_info_type(
+        tvbuff_t *tvb,
+        packet_info *pinfo,
+        proto_tree *tree_transport,
+        gint offset)
+{
+
+    guint16 param_id;
+
+    param_id = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
+    offset += 2;
+    offset += 2; /* parameter length */
+    if (param_id == PARAM_ID_LOST_MESSAGES) {
+        guint64 first_lost = tvb_get_guint64(tvb, offset, ENC_BIG_ENDIAN);
+        guint64 last_lost = tvb_get_guint64(tvb, offset+8, ENC_BIG_ENDIAN);
+
+        if (pinfo->cinfo) {
+            char info[COL_MAX_INFO_LEN] = {'\0'};
+            snprintf(
+                    info,
+                    sizeof(info),
+                    "Missing RTPS messages [%" PRIu64 "-%" PRIu64 "]",
+                    first_lost,
+                    last_lost);
+            col_append_str(pinfo->cinfo, COL_INFO, info);
+        }
+        expert_add_info(NULL, tree_transport, &ei_missing_msg);
+    }
+
+    return tvb_captured_length(tvb);
+}
+
+/* Register the protocol with Wireshark */
+void
+proto_register_rtps_virtual_transport(void)
+{
+    expert_module_t* expert_info;
+
+    static hf_register_info hf[] = {
+        {
+            &rtpsvt_hf_version,
+            {
+                "Version", "rtpsvt.version",
+                FT_UINT16, BASE_HEX, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_version_major,
+            {
+                "Major", "rtpsvt.version.major",
+                FT_INT8, BASE_DEC, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_version_minor,
+            {
+                "Minor", "rtpsvt.version.minor",
+                FT_INT8, BASE_DEC, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_content_kind,
+            {
+                "Content kind", "rtpsvt.content.kind",
+                FT_INT8, BASE_DEC, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_param_id,
+            {
+                "Parameter Identifier", "rtpsvt.param.id",
+                FT_UINT16, BASE_DEC, NULL, 0, 0, HFILL
+            },
+        },
+        {
+            &rtpsvt_hf_param_length,
+            {
+                "Parameter Length", "rtpsvt.param.length",
+                FT_UINT16, BASE_DEC, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_direction,
+            {
+                "Traffic Direction", "rtpsvt.direction",
+                FT_STRING, BASE_NONE, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_packet_identifier,
+            {
+                "Packet identifier", "rtpsvt.identifier",
+                FT_NONE, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_monitoring_guid,
+            {
+                "GUID", "rtpsvt.monitoring_guid",
+                FT_BYTES, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_monitoring_seqNr,
+            {
+                "SeqNum", "rtpsvt.seqNr",
+                FT_UINT64, BASE_DEC, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_information,
+            {
+                "Transport Information", "rtpsvt.information",
+                FT_NONE, BASE_NONE, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_source_port,
+            {
+                "Source Port", "rtpsvt.source_port",
+                FT_UINT32, BASE_DEC, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_source_address,
+            {
+                "Source address", "rtpsvt.source_address",
+                FT_STRING, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_source_pid,
+            {
+                "Source process ID", "rtpsvt.source_pid",
+                FT_STRING, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_destination_port,
+            {
+                "Destination Port", "rtpsvt.port",
+                FT_UINT32, BASE_DEC, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_destination_rtps_port,
+            {
+                "Destination RTPS Port", "rtpsvt.rtps_port",
+                FT_UINT32, BASE_DEC, NULL, 0x0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_destination_address,
+            {
+                "Destination address", "rtpsvt.destination_address",
+                FT_STRING, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_destination_pid,
+            {
+                "Destination process ID", "rtpsvt.destination_pid",
+                FT_STRING, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            &rtpsvt_hf_class,
+            {
+                "Transport class", "rtpsvt.class",
+                FT_STRING, BASE_NONE, NULL, 0, 0, HFILL
+            }
+        },
+        {
+            /* Information related to the 'lost' content type */
+            &rtpsvt_hf_missing_messages,
+            {
+                "Packets lost", "rtpsvt.missing_messages",
+                FT_UINT64, BASE_DEC, NULL, 0x0, 0, HFILL
+            }
+        }
+    };
+
+    static gint *ett[] = {
+        &rtpsvt_ett,
+        &rtpsvt_ett_version,
+        &rtpsvt_ett_identifier,
+        &rtpsvt_ett_information,
+        &rtpsvt_ett_information_class,
+        &rtpsvt_ett_information_src_port,
+        &rtpsvt_ett_information_dst_port,
+        &rtpsvt_ett_information_src_addr,
+        &rtpsvt_ett_information_dst_addr,
+        &rtpsvt_ett_information_direction,
+        &rtpsvt_ett_monitoring_sn,
+        &rtpsvt_ett_frame
+    };
+
+    static ei_register_info ei[] = {
+        {
+        &ei_missing_msg,
+        {
+            "rtpsvt.expert.missing_messages",
+            PI_PROTOCOL,
+            PI_NOTE,
+            "Missing RTPS Messages because of full buffer pool",
+            EXPFILL
+        }
+    },
+    };
+
+    /* Register the protocol name and description */
+    proto_rtpsvt = proto_register_protocol("Real-Time Publish-Subscribe Virtual Transport", "RTPS-VT", "rtpsvt");
+
+    /* Required function calls to register the header fields and subtrees */
+    rtpsvt_hf = proto_registrar_get_nth(proto_rtpsvt);
+    proto_register_field_array(proto_rtpsvt, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+
+    /* Register expert information */
+    expert_info = expert_register_protocol(proto_rtpsvt);
+    expert_register_field_array(expert_info, ei, array_length(ei));
+
+    register_dissector("rtpsvt", dissect_rtps_virtual_transport, proto_rtpsvt);
+}
+
+/*
+ * 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:
+ */