/* packet-pnrp.c

 * Routines for Peer Name Resolution Protocol (PNRP) dissection

 *

 *  Copyright 2010, Jan Gerbecks <jan.gerbecks@stud.uni-due.de>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/* The official Documentation for the Peer Name Resolution Protocol

 * ([MS-PNRP]) can be found at

 *

 *    https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pnrp

 *

 * This dissector is based on Revision 6.1.2

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/reassemble.h>

#define PROTONAME "Peer Name Resolution Protocol"

#define PROTOSHORTNAME "PNRP"

#define PROTOABBREV "pnrp"

#define PNRP_PORT 3540

#define FIELDID_LENGTH = 2

#define LENGTH_FIELD = 2

/* Define all FieldIDs here, so we can use them later on in switch statement etc */

#define PNRP_HEADER         0x0010

#define PNRP_HEADER_ACKED   0x0018

#define PNRP_ID             0x0030

#define TARGET_PNRP_ID      0x0038

#define VALIDATE_PNRP_ID    0x0039

#define FLAGS_FIELD         0x0040

#define FLOOD_CONTROLS      0x0043

#define SOLICIT_CONTROLS    0x0044

#define LOOKUP_CONTROLS     0x0045

#define EXTENDED_PAYLOAD    0x005A

#define PNRP_ID_ARRAY       0x0060

#define CERT_CHAIN          0x0080

#define WCHAR               0x0084

#define CLASSIFIER          0x0085

#define HASHED_NONCE        0x0092

#define NONCE               0x0093

#define SPLIT_CONTROLS      0x0098

#define ROUTING_ENTRY       0x009A

#define VALIDATE_CPA        0x009B

#define REVOKE_CPA          0x009C

#define IPV6_ENDPOINT       0x009D

#define IPV6_ENDPOINT_ARRAY 0x009E

/* Define all message types */

#define SOLICIT             0x01

#define ADVERTISE           0x02

#define REQUEST             0x03

#define FLOOD               0x04

#define INQUIRE             0x07

#define AUTHORITY           0x08

#define ACK                 0x09

#define LOOKUP              0x0B

/* Define flags mask fields */

#define FLAGS_INQUIRE_RESERVED1       0xFFE0

#define FLAGS_INQUIRE_A               0x0010

#define FLAGS_INQUIRE_X               0x0008

#define FLAGS_INQUIRE_C               0x0004

#define FLAGS_INQUIRE_RESERVED2       0x0003

#define FLAGS_AUTHORITY_RESERVED1     0xFC00

#define FLAGS_AUTHORITY_L             0x0200

#define FLAGS_AUTHORITY_RESERVED2     0x01F0

#define FLAGS_AUTHORITY_B             0x0008

#define FLAGS_AUTHORITY_RESERVED3     0x0006

#define FLAGS_AUTHORITY_N             0x0001

#define FLAGS_LOOKUPCONTROLS_RESERVED 0xFFFC

#define FLAGS_LOOKUPCONTROLS_A        0x0002

#define FLAGS_LOOKUPCONTROLS_0        0x0001

#define FLAGS_ENCODED_CPA_RESERVED    0xC0

#define FLAGS_ENCODED_CPA_X           0x20

#define FLAGS_ENCODED_CPA_U           0x02

#define FLAGS_ENCODED_CPA_R           0x01

#define FLAGS_ENCODED_CPA_A           0x04

#define FLAGS_ENCODED_CPA_C           0x08

#define FLAGS_ENCODED_CPA_F           0x10

void proto_register_pnrp(void);

void proto_reg_handoff_pnrp(void);

static dissector_handle_t pnrp_handle;

/* Define all helper methods  */

static void dissect_pnrp_ids(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_ipv6_address(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_route_entry(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_ipv6_endpoint_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_encodedCPA_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_payload_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_publicKey_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

static void dissect_signature_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree);

/* Define global variables

 ----------------------------*/

static int proto_pnrp;

/* Define FieldIDs */

static const value_string fieldID[] = {

    { PNRP_HEADER,         "PNRP_HEADER" },

    { PNRP_HEADER_ACKED,   "PNRP_HEADER_ACKED" },

    { PNRP_ID,             "PNRP_ID" },

    { TARGET_PNRP_ID,      "TARGET_PNRP_ID" },

    { VALIDATE_PNRP_ID,    "VALIDATE_PNRP_ID" },

    { FLAGS_FIELD,         "FLAGS_FIELD" },

    { FLOOD_CONTROLS,      "FLOOD_CONTROLS" },

    { SOLICIT_CONTROLS,    "SOLICIT_CONTROLS" },

    { LOOKUP_CONTROLS,     "LOOKUP_CONTROLS" },

    { EXTENDED_PAYLOAD,    "EXTENDED_PAYLOAD" },

    { PNRP_ID_ARRAY,       "PNRP_ID_ARRAY" },

    { CERT_CHAIN,          "CERT_CHAIN" },

    { WCHAR,               "WCHAR" },

    { CLASSIFIER,          "CLASSIFIER" },

    { HASHED_NONCE,        "HASHED_NONCE" },

    { NONCE,               "NONCE" },

    { SPLIT_CONTROLS,      "SPLIT_CONTROLS" },

    { ROUTING_ENTRY,       "ROUTING_ENTRY" },

    { VALIDATE_CPA,        "VALIDATE_CPA" },

    { REVOKE_CPA,          "REVOKE_CPA" },

    { IPV6_ENDPOINT,       "IPV6_ENDPOINT" },

    { IPV6_ENDPOINT_ARRAY, "IPV6_ENDPOINT_ARRAY" },

    {0,                     NULL}

};

/* Define Packetnames */

static const value_string messageType[] = {

    { SOLICIT,             "SOLICIT" },

    { ADVERTISE,           "ADVERTISE" },

    { REQUEST,             "REQUEST" },

    { FLOOD,               "FLOOD" },

    { INQUIRE,             "INQUIRE" },

    { AUTHORITY,           "AUTHORITY" },

    { ACK,                 "ACK" },

    { LOOKUP,              "LOOKUP" },

    {0,                     NULL}

};

/* Define Solicit Type */

static const value_string solicitType[] = {

    { 0x00,                "SOLICIT_TYPE_ANY" },

    { 0x01,                "SOLICIT_TYPE_LOCAL" },

    {0,                     NULL}

};

/* Define Resolve Criteria for Lookup Controls */

static const value_string resolveCriteria[] = {

    { 0x00,                "SEARCH_OPCODE_NONE" },

    { 0x01,                "SEARCH_OPCODE_ANY_PEERNAME" },

    { 0x02,                "SEARCH_OPCODE_NEAREST_PEERNAME" },

    { 0x04,                "SEARCH_OPCODE_NEAREST64_PEERNAME" },

    { 0x08,                "SEARCH_OPCODE_UPPER_BITS" },

    {0,                     NULL}

};

/* Define Reason Code for Lookup Controls */

static const value_string reasonCode[] = {

    { 0x00,                "REASON_APP_REQUEST" },

    { 0x01,                "REASON_REGISTRATION" },

    { 0x02,                "REASON_CACHE_MAINTENANCE" },

    { 0x03,                "REASON_SPLIT_DETECTION" },

    {0,                     NULL}

};

/* Define IDs for subcomponents */

/* Message Header */

static int hf_pnrp_header;

static int hf_pnrp_header_fieldID;

static int hf_pnrp_header_length;

static int hf_pnrp_header_ident;

static int hf_pnrp_header_versionMajor;

static int hf_pnrp_header_versionMinor;

static int hf_pnrp_header_messageType;

static int hf_pnrp_header_messageID;

/* Message Body */

static int hf_pnrp_message_type;

static int hf_pnrp_message_length;

static int hf_pnrp_message_headerack;

static int hf_pnrp_message_pnrpID;    /* Generic variable to display pnrp ID in various situations */

/* Inquire Message Flags */

static int hf_pnrp_message_inquire_flags;

static int hf_pnrp_message_inquire_flags_reserved1;

static int hf_pnrp_message_inquire_flags_Abit;

static int hf_pnrp_message_inquire_flags_Xbit;

static int hf_pnrp_message_inquire_flags_Cbit;

static int hf_pnrp_message_inquire_flags_reserved2;

static int hf_pnrp_padding;

static int * const inquire_flags[] = {

    &hf_pnrp_message_inquire_flags_reserved1,

    &hf_pnrp_message_inquire_flags_Abit,

    &hf_pnrp_message_inquire_flags_Xbit,

    &hf_pnrp_message_inquire_flags_Cbit,

    &hf_pnrp_message_inquire_flags_reserved2,

    NULL

};

/* Classifier */

static int hf_pnrp_message_classifier_unicodeCount;

static int hf_pnrp_message_classifier_arrayLength;

static int hf_pnrp_message_classifier_entryLength;

static int hf_pnrp_message_classifier_string;

/* ACK Message Flags */

static int hf_pnrp_message_ack_flags_reserved;

static int hf_pnrp_message_ack_flags_Nbit;

/* SplitControls */

static int hf_pnrp_message_splitControls_authorityBuffer;

/* IPv6 Endpoint Array */

static int hf_pnrp_message_ipv6EndpointArray_NumberOfEntries;

static int hf_pnrp_message_ipv6EndpointArray_ArrayLength;

static int hf_pnrp_message_ipv6EndpointArray_EntryLength;

/* AUTHORITY Message Flags */

static int hf_pnrp_message_authority_flags;

static int hf_pnrp_message_authority_flags_reserved1;

static int hf_pnrp_message_authority_flags_Lbit;

static int hf_pnrp_message_authority_flags_reserved2;

static int hf_pnrp_message_authority_flags_Bbit;

static int hf_pnrp_message_authority_flags_reserved3;

static int hf_pnrp_message_authority_flags_Nbit;

static int * const authority_flags[] = {

    &hf_pnrp_message_authority_flags_reserved1,

    &hf_pnrp_message_authority_flags_Lbit,

    &hf_pnrp_message_authority_flags_reserved2,

    &hf_pnrp_message_authority_flags_Bbit,

    &hf_pnrp_message_authority_flags_reserved3,

    &hf_pnrp_message_authority_flags_Nbit,

    NULL

};

/* Flood Control Flags */

static int hf_pnrp_message_flood_flags_reserved1;

static int hf_pnrp_message_flood_flags_Dbit;

/* PNRP ID Array */

static int hf_pnrp_message_idArray_NumEntries;

static int hf_pnrp_message_idArray_Length;

static int hf_pnrp_message_ElementFieldType;

static int hf_pnrp_message_idarray_Entrylength;

static int hf_pnrp_message_solicitType;

static int hf_pnrp_message_certChain;

static int hf_pnrp_message_nonce;

static int hf_pnrp_message_hashednonce;

static int hf_pnrp_message_ipv6;

/* Encoded CPA */

static int hf_pnrp_encodedCPA;

static int hf_pnrp_encodedCPA_length;

static int hf_pnrp_encodedCPA_minorVersion;

static int hf_pnrp_encodedCPA_majorVersion;

static int hf_pnrp_encodedCPA_flags;

static int hf_pnrp_encodedCPA_flags_reserved;

static int hf_pnrp_encodedCPA_flags_Xbit;

static int hf_pnrp_encodedCPA_flags_Fbit;

static int hf_pnrp_encodedCPA_flags_Cbit;

static int hf_pnrp_encodedCPA_flags_Abit;

static int hf_pnrp_encodedCPA_flags_Ubit;

static int hf_pnrp_encodedCPA_flags_Rbit;

static int * const encodedCPA_flags[] = {

    &hf_pnrp_encodedCPA_flags_reserved,

    &hf_pnrp_encodedCPA_flags_Xbit,

    &hf_pnrp_encodedCPA_flags_Fbit,

    &hf_pnrp_encodedCPA_flags_Cbit,

    &hf_pnrp_encodedCPA_flags_Abit,

    &hf_pnrp_encodedCPA_flags_Ubit,

    &hf_pnrp_encodedCPA_flags_Rbit,

    NULL

};

static int hf_pnrp_encodedCPA_notAfter;

static int hf_pnrp_encodedCPA_serviceLocation;

static int hf_pnrp_encodedCPA_binaryAuthority;

static int hf_pnrp_encodedCPA_classifierHash;

static int hf_pnrp_encodedCPA_friendlyName;

/* Lookup Controls */

static int hf_pnrp_message_lookupControls_flags;

static int hf_pnrp_message_lookupControls_flags_reserved;

static int hf_pnrp_message_lookupControls_flags_Abit;

static int hf_pnrp_message_lookupControls_flags_0bit;

static int * const lookupControls_flags[] = {

    &hf_pnrp_message_lookupControls_flags_reserved,

    &hf_pnrp_message_lookupControls_flags_Abit,

    &hf_pnrp_message_lookupControls_flags_0bit,

    NULL

};

static int hf_pnrp_message_lookupControls_precision;

static int hf_pnrp_message_lookupControls_resolveCriteria;

static int hf_pnrp_message_lookupControls_reasonCode;

/* Dissect Route Entry */

static int hf_pnrp_message_routeEntry_portNumber;

static int hf_pnrp_message_routeEntry_flags;

static int hf_pnrp_message_routeEntry_addressCount;

/* Public Key Structure */

static int hf_pnrp_publicKey_objID;

static int hf_pnrp_publicKey_publicKeyData;

/* Signature Structure */

static int hf_pnrp_signature_signatureData;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_pnrp_payload_port;

static int hf_pnrp_signature_length;

static int hf_pnrp_signature_structure_length;

static int hf_pnrp_encodedCPA_total_bytes_of_payload;

static int hf_pnrp_signature_hash_id;

static int hf_pnrp_message_flags;

static int hf_pnrp_encodedCPA_number_of_service_addresses;

static int hf_pnrp_payload_iana_proto;

static int hf_pnrp_reserved8;

static int hf_pnrp_reserved16;

static int hf_pnrp_encodedCPA_service_address_length;

static int hf_pnrp_message_data;

static int hf_pnrp_publicKey_length_of_structure;

static int hf_pnrp_publicKey_size_of_cbdata;

static int hf_pnrp_payload_type;

static int hf_pnrp_publicKey_size_of_algorithm_oid;

static int hf_pnrp_message_port_number;

static int hf_pnrp_publicKey_reserved;

static int hf_pnrp_encodedCPA_friendlyName_length;

static int hf_pnrp_message_offset;

static int hf_pnrp_publicKey_unused_bits;

static int hf_pnrp_length_of_data;

static int hf_pnrp_encodedCPA_number_of_payload_structures;

/* Reassembly */

static int hf_pnrp_fragments;

static int hf_pnrp_fragment;

static int hf_pnrp_fragment_overlap;

static int hf_pnrp_fragment_overlap_conflict;

static int hf_pnrp_fragment_multiple_tails;

static int hf_pnrp_fragment_too_long_fragment;

static int hf_pnrp_fragment_error;

static int hf_pnrp_fragment_count;

static int hf_pnrp_reassembled_in;

static int hf_pnrp_reassembled_length;

static int hf_pnrp_reassembled_data;

static int hf_pnrp_fragmented_payload;

/* Define variables to reference subtrees */

static int ett_pnrp;

static int ett_pnrp_header;

static int ett_pnrp_message;

static int ett_pnrp_message_inquire_flags;

static int ett_pnrp_message_authority_flags;

static int ett_pnrp_message_encodedCPA;

static int ett_pnrp_message_encodedCPA_flags;

static int ett_pnrp_message_lookupControls_flags;

static int ett_pnrp_message_payloadStructure;

static int ett_pnrp_message_publicKeyStructure;

static int ett_pnrp_message_signatureStructure;

static int ett_pnrp_fragment;

static int ett_pnrp_fragments;

static reassembly_table pnrp_reassembly_table;

static const fragment_items pnrp_frag_items = {

    &ett_pnrp_fragment,

    &ett_pnrp_fragments,

    &hf_pnrp_fragments,

    &hf_pnrp_fragment,

    &hf_pnrp_fragment_overlap,

    &hf_pnrp_fragment_overlap_conflict,

    &hf_pnrp_fragment_multiple_tails,

    &hf_pnrp_fragment_too_long_fragment,

    &hf_pnrp_fragment_error,

    &hf_pnrp_fragment_count,

    &hf_pnrp_reassembled_in,

    &hf_pnrp_reassembled_length,

    &hf_pnrp_reassembled_data,

    "PNRP fragments"

};

/* Do actual dissection work */

static int dissect_pnrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

    /* Variable declaration */

    int offset, start_offset;

    int padding_bytes;

    uint8_t message_type;

    char* str_message_type;

    uint16_t field_type;

    unsigned data_length;

    proto_item *ti;

    proto_tree *pnrp_tree;

    proto_item *pnrp_header_item;

    proto_tree *pnrp_header_tree;

    proto_item *pnrp_message_tree = NULL;

    uint32_t msg_id;

    /*----------------------------------------

     * Validate if it is really a PNRP Packet

     *----------------------------------------*/

    /* Check that there's enough data */

    data_length = tvb_captured_length(tvb);

    /* Shortest Message is ACK -> 12 Bytes for Header plus 8 Bytes for Data */

    if (data_length <  12+8 )

    {

        return 0;

    }

    /* Check some values from the packet header */

    /* First 2 bytes must be 0x0010 */

    if (tvb_get_ntohs(tvb,0) != PNRP_HEADER )

    {

        return 0;

    }

    /* Length of Header must be 0x000C = 12 */

    if (tvb_get_ntohs(tvb,2) != 0x000C) {

        return 0;

    }

    /* Identifier must 0x51 */

    if (tvb_get_uint8(tvb,4) != 0x51) {

        return 0;

    }

    /* Assign Values to Variables */

    /* Use to track data */

    offset= 0;

    /* Get the message Information beforehand */

    message_type = tvb_get_uint8(tvb,7);

    str_message_type = val_to_str(pinfo->pool, message_type, messageType, "Unknown (0x%02x)");

    /* Simply Display the Protocol Name in the INFO column */

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

    /* Clear out stuff in the info column */

    col_add_fstr(pinfo->cinfo, COL_INFO, "PNRP %s Message ", str_message_type);

    /* Lets add a subtree to our dissection to display the info */

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

    proto_item_append_text(ti, ", Message Type %s", str_message_type);

    /* Get a main tree for the whole protocol */

    pnrp_tree = proto_item_add_subtree(ti, ett_pnrp);

    /*-------------------------------

     *--Add all Header Fields

     *------------------------------*/

    /* Get a subtree for the Header */

    pnrp_header_item = proto_tree_add_item(pnrp_tree, hf_pnrp_header, tvb, offset,12,ENC_NA);

    pnrp_header_tree = proto_item_add_subtree(pnrp_header_item, ett_pnrp_header);

    /* Add Field ID should be 0c0010 */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_fieldID,tvb,offset,2,ENC_BIG_ENDIAN);

    offset += 2;

    /* Add Length should be 0x000C */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_length,tvb,offset,2,ENC_BIG_ENDIAN);

    offset += 2;

    /* Add Ident should be 0x51 */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_ident,tvb,offset,1,ENC_BIG_ENDIAN);

    offset += 1;

    /* Add Major Version */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_versionMajor,tvb,offset,1,ENC_BIG_ENDIAN);

    offset += 1;

    /* Add Minor Version */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_versionMinor,tvb,offset,1,ENC_BIG_ENDIAN);

    offset += 1;

    /* Add Message Type */

    proto_tree_add_item(pnrp_header_tree,hf_pnrp_header_messageType,tvb,offset,1,ENC_BIG_ENDIAN);

    offset += 1;

    /* Add Message ID */

    proto_tree_add_item_ret_uint(pnrp_header_tree,hf_pnrp_header_messageID,tvb,offset,4,ENC_BIG_ENDIAN,&msg_id);

    offset += 4;

    /*-------------------------------

     *--Add all Message Fields

     *------------------------------*/

    /* The following part has dynamic length depending on message type */

    start_offset = offset;

    while (tvb_reported_length_remaining(tvb, offset) > 0) {

        /* Determine the Field Type */

        field_type = tvb_get_ntohs(tvb,offset );

        /* Determine length of this message */

        data_length = tvb_get_ntohs(tvb,offset + 2);

        /* Length must be at least 4, because field_type and data_length are part of data_length information */

        if (data_length < 4) {

            pnrp_message_tree = proto_tree_add_subtree_format(pnrp_tree, tvb, offset, 4, ett_pnrp_message, NULL,

                                "Message with invalid length %u (< 4)", data_length);

            proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset, 2, ENC_BIG_ENDIAN);

            proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

            offset += 4;

            /* Don't continue parsing this message segment */

            break;

        }

        /* Actual Parsing of the message Type */

        switch (field_type) {

            /* First Field in ACK Message */

            case PNRP_HEADER_ACKED:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                data_length, ett_pnrp_message, NULL, "Message ACK ID: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_headerack, tvb, offset + 4, data_length -4, ENC_BIG_ENDIAN);

                offset += data_length;

                break;

                /* A validate pnrp id follows as found in FLOOD */

            case VALIDATE_PNRP_ID:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Validate PNRP ID: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* We can have a large number of pnrp IDs here */

                dissect_pnrp_ids(tvb,offset+4,data_length-4,pnrp_message_tree);

                offset += data_length;

                break;

                /* The Flags have different meaning, depending on the message */

            case FLAGS_FIELD:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Flags Field: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                switch (message_type) {

                    case INQUIRE:

                        proto_tree_add_bitmask(pnrp_message_tree, tvb, offset+4, hf_pnrp_message_inquire_flags, ett_pnrp_message_inquire_flags, inquire_flags, ENC_BIG_ENDIAN);

                        proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + 6, 2, ENC_NA);

                        offset += data_length+2;

                        break;

                    case ACK:

                        /* Reserved 0 - 14 bits */

                        proto_tree_add_bits_item(pnrp_message_tree, hf_pnrp_message_ack_flags_reserved, tvb, (offset + 4)*8, 15, ENC_BIG_ENDIAN);

                        /* N - Bit */

                        proto_tree_add_bits_item(pnrp_message_tree, hf_pnrp_message_ack_flags_Nbit, tvb,((offset + 4)*8)+15, 1, ENC_BIG_ENDIAN);

                        offset += data_length;

                        break;

                    case AUTHORITY:

                        proto_tree_add_bitmask(pnrp_message_tree, tvb, offset+4, hf_pnrp_message_authority_flags, ett_pnrp_message_authority_flags, authority_flags, ENC_BIG_ENDIAN);

                        /* Check if the Flags Field is the last message part. If so, no padding of 2 bytes is added */

                        if(tvb_reported_length_remaining(tvb, offset+data_length)==0)

                        {

                            offset += data_length;

                        }

                        else {

                            padding_bytes = 2;

                            proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + 6, padding_bytes, ENC_NA);

                            offset += data_length+2;

                        }

                        break;

                    default:

                        proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_flags, tvb, offset + 4, data_length -4, ENC_BIG_ENDIAN);

                        offset += data_length;

                        break;

                }

                break;

                /* Flood controls found in FLOOD Message */

            case FLOOD_CONTROLS:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Flood Control: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* Reserved 1 - 15 bits */

                proto_tree_add_bits_item(pnrp_message_tree, hf_pnrp_message_flood_flags_reserved1, tvb, (offset + 4)*8, 15, ENC_BIG_ENDIAN);

                /* D - Bit */

                proto_tree_add_bits_item(pnrp_message_tree, hf_pnrp_message_flood_flags_Dbit, tvb,((offset + 4)*8)+15, 1, ENC_BIG_ENDIAN);

                /* Reserved 2 */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_reserved8, tvb, offset + 6, 1, ENC_NA);

                /* Padding 1 */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + 7, 1, ENC_NA);

                offset += data_length+1;

                break;

                /* Solicit Controls found in SOLICIT Message */

            case SOLICIT_CONTROLS:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Solicit Controls: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_reserved8, tvb, offset + 4, 1, ENC_NA);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_solicitType, tvb, offset + 5, 1, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_reserved16, tvb, offset + 6, 2, ENC_LITTLE_ENDIAN);

                offset += data_length +2;   /* Padding involved */

                break;

                /* Lookup controls found in LOOKUP Message */

            case LOOKUP_CONTROLS:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Lookup Control: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* 2 Bytes of Flags */

                proto_tree_add_bitmask(pnrp_message_tree, tvb, offset+4, hf_pnrp_message_lookupControls_flags, ett_pnrp_message_lookupControls_flags, lookupControls_flags, ENC_BIG_ENDIAN);

                /* Precision Bytes */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_lookupControls_precision, tvb, offset + 6, 2, ENC_BIG_ENDIAN);

                /* Resolve Criteria */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_lookupControls_resolveCriteria, tvb, offset + 8, 1, ENC_BIG_ENDIAN);

                /* Reason Code */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_lookupControls_reasonCode, tvb, offset + 9, 1, ENC_BIG_ENDIAN);

                /* Reserved */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_reserved16, tvb, offset + 10, 2, ENC_LITTLE_ENDIAN);

                offset += data_length;

                break;

                /* Target PNRP ID found in Lookup Message */

            case TARGET_PNRP_ID:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Target PNRP ID: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                dissect_pnrp_ids(tvb, offset+4, data_length-4, pnrp_message_tree);

                offset += data_length;

                break;

                /* Extended Payload found in AUTHORITY Message */

            case EXTENDED_PAYLOAD:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Extended Payload: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* TODO: Do actual parsing */

                offset += data_length;

                break;

                /* Pnrp id Array as found in REQUEST & ADVERTISE Message */

            case PNRP_ID_ARRAY:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "PNRP ID Array: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_idArray_NumEntries, tvb, offset + 4, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_idArray_Length, tvb, offset + 6, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_ElementFieldType, tvb, offset + 8, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_idarray_Entrylength, tvb, offset + 10, 2, ENC_BIG_ENDIAN);

                dissect_pnrp_ids(tvb,offset+12,data_length-12,pnrp_message_tree);

                offset += data_length;

                break;

                /* Cert Chain follows as found in AUTHORITY */

            case CERT_CHAIN:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "CERT Chain: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_certChain, tvb, offset + 4, data_length-4, ENC_NA);

                /* There might be padding, so fill up to the next byte */

                padding_bytes = 0;

                while (data_length%4 != 0 &&tvb_reported_length_remaining(tvb, offset+data_length)>0) {

                    data_length++;

                    padding_bytes++;

                }

                /* Check if we actually had some padding bytes */

                if (0<padding_bytes) {

                    proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + data_length-padding_bytes, padding_bytes, ENC_NA);

                }

                offset += data_length;

                break;

                /* classifier: A classifier string follows as found in AUTHORITY */

            case CLASSIFIER:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Classifier: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* NumEntries */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_classifier_unicodeCount, tvb, offset + 4, 2, ENC_BIG_ENDIAN);

                /* Array Length: 8+(NumEntries*EntryLength */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_classifier_arrayLength, tvb, offset + 6, 2, ENC_BIG_ENDIAN);

                /* Element Field Type: WCHAR */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset+8 , 2, ENC_BIG_ENDIAN);

                /* Entry Length: Must be 0x0002 */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_classifier_entryLength, tvb, offset + 10, 2, ENC_BIG_ENDIAN);

                /* The actual classifier String */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_classifier_string, tvb, offset + 12, tvb_get_ntohs(tvb,offset+6)-8, ENC_UTF_16|ENC_BIG_ENDIAN);

                /* There might be padding, so fill up to the next byte */

                padding_bytes = 0;

                while (data_length%4 != 0 &&tvb_reported_length_remaining(tvb, offset+data_length)>0) {

                    data_length++;

                    padding_bytes++;

                }

                /* Check if we actually had some padding bytes */

                if (0<padding_bytes) {

                    proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + data_length-padding_bytes, padding_bytes, ENC_NA);

                }

                offset += data_length;

                break;

                /* A hashed nonce follows as found in ADVERTISE & SOLICIT */

            case HASHED_NONCE:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Hashed Nonce: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_hashednonce, tvb, offset + 4, data_length-4, ENC_NA);

                offset += data_length;

                break;

                /* A nonce follows as found in REQUEST & INQUIRE */

            case NONCE:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Nonce: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_nonce, tvb, offset + 4, data_length-4, ENC_NA);

                offset += data_length;

                break;

                /* split controls as found in AUTHORITY */

            case SPLIT_CONTROLS:

            {

                fragment_head *frag_data;

                tvbuff_t *frag_tvb;

                uint32_t buffer_len, frag_offset, remaining_len;

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Split controls: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* Size of Authority Buffer */

                proto_tree_add_item_ret_uint(pnrp_message_tree, hf_pnrp_message_splitControls_authorityBuffer,

                                             tvb, offset + 4, 2, ENC_BIG_ENDIAN, &buffer_len);

                /* Byte offset */

                proto_tree_add_item_ret_uint(pnrp_message_tree, hf_pnrp_message_offset,

                                             tvb, offset + 6, 2, ENC_BIG_ENDIAN, &frag_offset);

                offset += data_length;

                remaining_len = tvb_reported_length_remaining(tvb, offset);

                frag_data = fragment_add_check(&pnrp_reassembly_table, tvb, offset, pinfo,

                                               msg_id, NULL, frag_offset, remaining_len,

                                               (buffer_len != (frag_offset + remaining_len)));

                frag_tvb = process_reassembled_data(tvb, offset, pinfo, "Reassembled PNRP message",

                                                    frag_data, &pnrp_frag_items, NULL, pnrp_message_tree);

                if (frag_tvb) {

                    tvb = frag_tvb;

                    offset = 0;

                } else {

                    proto_tree_add_item(pnrp_message_tree, hf_pnrp_fragmented_payload, tvb, offset, -1, ENC_NA);

                    col_append_str(pinfo->cinfo, COL_INFO, " [Fragmented message]");

                    return tvb_captured_length(tvb);

                }

                break;

            }

                /* routing entry: A route entry follows as found in ADVERTISE, INQUIRE, LOOKUP & AUTHORITY */

            case ROUTING_ENTRY:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Routing Entry: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                dissect_route_entry(tvb,offset+4, tvb_get_ntohs(tvb,offset+2)-4, pnrp_message_tree);

                /* There might be padding, so fill up to the next byte */

                padding_bytes = 0;

                while (data_length%4 != 0 &&tvb_reported_length_remaining(tvb, offset+data_length)>0) {

                    data_length++;

                    padding_bytes++;

                }

                /* Check if we actually had some padding bytes */

                if (0<padding_bytes) {

                    proto_tree_add_item(pnrp_message_tree, hf_pnrp_padding, tvb, offset + data_length-padding_bytes, padding_bytes, ENC_NA);

                }

                offset += data_length;

                break;

                /* validate cpa: an encoded CPA structure follows as found in AUTHORITY */

            case VALIDATE_CPA:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Validate CPA: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* Do the actual parsing in own method */

                dissect_encodedCPA_structure(tvb, offset+4, data_length-4, pnrp_message_tree);

                offset += data_length;

                break;

                /* IPV6 Endpoint: an ipv6 endpoint array structure follows as found in LOOKUP */

            case IPV6_ENDPOINT_ARRAY:

                pnrp_message_tree = proto_tree_add_subtree(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "IPv6 Endpoint Array: ");

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                /* Number of route entries */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_ipv6EndpointArray_NumberOfEntries, tvb, offset + 4, 2, ENC_BIG_ENDIAN);

                /* Array length */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_ipv6EndpointArray_ArrayLength, tvb, offset + 6, 2, ENC_BIG_ENDIAN);

                /* Element Field Type */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset+8 , 2, ENC_BIG_ENDIAN);

                /* Entry Length: must be 0x0012 (18 bytes) */

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_ipv6EndpointArray_EntryLength, tvb, offset + 10, 2, ENC_BIG_ENDIAN);

                /* Flagged Path */

                dissect_ipv6_endpoint_structure(tvb, offset+12, tvb_get_ntohs(tvb,offset+6)-8,pnrp_message_tree);

                offset += data_length;

                break;

            default:

                pnrp_message_tree = proto_tree_add_subtree_format(pnrp_tree, tvb, offset,

                                                        data_length, ett_pnrp_message, NULL, "Type: %s, length: %u",

                                                        val_to_str(pinfo->pool, field_type, fieldID, "Unknown (0x%04x)"), data_length);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_type, tvb, offset , 2, ENC_BIG_ENDIAN);

                proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);

                if(data_length > 4)

                {

                    proto_tree_add_item(pnrp_message_tree, hf_pnrp_message_data, tvb, offset + 4, data_length -4, ENC_NA);

                }

                else {

                    return 0;

                }

                offset += data_length;

                break;

        }

        // SPLIT_CONTROLS might reset our offset.

        if (start_offset <= offset) {

            THROW(ReportedBoundsError);

        }

    }

    return offset;

}

/*--------------------------------------------------------------*

 * Dissecting helper methods                                    *

 *--------------------------------------------------------------*/

static void dissect_pnrp_ids(tvbuff_t *tvb, int offset, int length, proto_tree *tree)

{

    while (32 <=length) {

        proto_tree_add_item(tree, hf_pnrp_message_pnrpID, tvb, offset, 32, ENC_NA);

        length -= 32;

        offset += 32;

    }

}

static void dissect_route_entry(tvbuff_t *tvb, int offset, int length, proto_tree *tree)

{

    int tmp_offset;

    tmp_offset = 0;

    /* First, we have a 32 Bit long PNRP ID */

    proto_tree_add_item(tree, hf_pnrp_message_pnrpID, tvb, offset+tmp_offset, 32, ENC_NA);

    tmp_offset +=32;

    /* Add PNRP Major Version */

    proto_tree_add_item(tree,hf_pnrp_header_versionMajor,tvb,offset+tmp_offset,1,ENC_BIG_ENDIAN);

    tmp_offset += 1;

    /* Add Minor Version */

    proto_tree_add_item(tree,hf_pnrp_header_versionMinor,tvb,offset+tmp_offset,1,ENC_BIG_ENDIAN);

    tmp_offset +=1;

    /* Port Number */

    proto_tree_add_item(tree,hf_pnrp_message_routeEntry_portNumber,tvb,offset+tmp_offset,2,ENC_BIG_ENDIAN);

    tmp_offset +=2;

    /* Flags */

    proto_tree_add_item(tree,hf_pnrp_message_routeEntry_flags,tvb,offset+tmp_offset,1,ENC_BIG_ENDIAN);

    tmp_offset +=1;

    /* Address count */

    proto_tree_add_item(tree,hf_pnrp_message_routeEntry_addressCount,tvb,offset+tmp_offset,1,ENC_BIG_ENDIAN);

    tmp_offset +=1;

    /* IPv6 Addresses */

    dissect_ipv6_address(tvb, offset+tmp_offset, length -tmp_offset, tree);

}

static void dissect_ipv6_endpoint_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree)

{

    /* Check if we don't run out of data */

    while (18 <= length) {

        /* Port Number */

        proto_tree_add_item(tree, hf_pnrp_message_port_number, tvb, offset, 2, ENC_BIG_ENDIAN);

        /* IPv6 Addresses */

        dissect_ipv6_address(tvb, offset+2,16,tree);

        offset += 18;

        length -= 18;

    }

}

static void dissect_ipv6_address(tvbuff_t *tvb, int offset, int length, proto_tree *tree)

{

    while (16 <= length) {

        proto_tree_add_item(tree, hf_pnrp_message_ipv6, tvb, offset, 16, ENC_NA);

        offset += 16;

        length -= 16;

    }

}

static void dissect_encodedCPA_structure(tvbuff_t *tvb, int offset, int length, proto_tree *tree)

{

    uint8_t flagsField;

    /* Add a new subtree */

    proto_item *pnrp_encodedCPA_tree = NULL;

    proto_item *pnrp_encodedCPA_item = NULL;

    pnrp_encodedCPA_item = proto_tree_add_item(tree, hf_pnrp_encodedCPA, tvb, offset,length,ENC_NA);

    pnrp_encodedCPA_tree = proto_item_add_subtree(pnrp_encodedCPA_item, ett_pnrp_message_encodedCPA);

    /* Length information */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_length, tvb, offset, 2, ENC_BIG_ENDIAN);

    /* CPA Minor Version */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_minorVersion, tvb, offset+2, 1, ENC_BIG_ENDIAN);

    /* CPA Major Version */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_majorVersion, tvb, offset+3, 1, ENC_BIG_ENDIAN);

    /* PNRP Minor Version */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_header_versionMinor, tvb, offset+4, 1, ENC_BIG_ENDIAN);

    /* PNRP Major Version */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_header_versionMajor, tvb, offset+5, 1, ENC_BIG_ENDIAN);

    /* Flags Field */

    proto_tree_add_bitmask(pnrp_encodedCPA_tree, tvb, offset+6, hf_pnrp_encodedCPA_flags, ett_pnrp_message_encodedCPA_flags, encodedCPA_flags, ENC_BIG_ENDIAN);

    flagsField = tvb_get_uint8(tvb,offset+6);

    /* Reserved */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_reserved8, tvb, offset + 7, 1, ENC_NA);

    /* Not After */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_notAfter, tvb, offset+8, 8, ENC_BIG_ENDIAN);

    /* Service Location */

    proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_serviceLocation, tvb, offset+16, 16, ENC_NA);

    /* now, the structure is variable, so add bytes to offset */

    offset +=32;

    /* Check if R Flag is set */

    if ((flagsField & FLAGS_ENCODED_CPA_R)==0x00) {

        /* Nonce follows */

        proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_message_nonce, tvb, offset, 16, ENC_NA);

        offset +=16;

    }

    /* Check if A Flag is set */

    if (flagsField & FLAGS_ENCODED_CPA_A) {

        /* Binary authority */

        proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_binaryAuthority, tvb, offset, 20, ENC_NA);

        offset +=20;

    }

    /* Check if C Flag is set */

    if (flagsField & FLAGS_ENCODED_CPA_C) {

        /* Classifier Hash */

        proto_tree_add_item(pnrp_encodedCPA_tree, hf_pnrp_encodedCPA_classifierHash, tvb, offset, 20, ENC_NA);

        offset +=20;

    }

    /* Check if F Flag is set */

    if (flagsField & FLAGS_ENCODED_CPA_F) {