/* packet-alljoyn.c

 * Routines for AllJoyn (AllJoyn.org) packet dissection

 * Copyright (c) 2013-2014, The Linux Foundation.

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/* AI generated comment:

 * AllJoyn was an open-source discovery and communication framework for the Internet of Things (IoT)

 * that enabled devices to find and interact with each other. It allowed for remote method calls and

 * one-way signals between applications on a distributed bus, making it possible for devices from

 * different brands and types to work together. Although it was sponsored by the AllSeen Alliance,

 * the framework is now deprecated and the "Windows.Devices.AllJoyn" namespace is considered legacy.

 * Current status

 *          Deprecated: AllJoyn is no longer actively maintained as a primary IoT protocol.

 *                      The namespace in Windows is deprecated.

 * Successor protocols:

 *                      Alternatives like Project CHIP (now Matter) and IoTivity have emerged

 *                      to take its place in the IoT ecosystem.

 * Wikipedia:

 * "In 2018, development ended after the source and documentation were copied to GitHub."

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <wsutil/ws_roundup.h>

#include <wsutil/array.h>

#include <wsutil/str_util.h>

void proto_register_AllJoyn(void);

void proto_reg_handoff_AllJoyn(void);

static dissector_handle_t alljoyn_handle_ns;

static dissector_handle_t alljoyn_handle_ardp;

#define ALLJOYN_NAME_SERVER_PORT      9956 /* IANA lists only UDP as being registered (dissector also uses TCP port) */

#define ALLJOYN_MESSAGE_PORT      9955

/* DBus limits array length to 2^26. AllJoyn limits it to 2^17 */

#define MAX_ARRAY_LEN 131072

/* DBus limits packet length to 2^27. AllJoyn limits it further to 2^17 + 4096 to allow for 2^17 payload */

#define MAX_PACKET_LEN (MAX_ARRAY_LEN + 4096)

/* The following are protocols within a frame.

   The actual value of the handle is set when the various fields are

   registered in proto_register_AllJoyn() with a call to

   proto_register_protocol().

*/

static int proto_AllJoyn_mess; /* The top level. Entire AllJoyn message protocol. */

/* These are Wireshark header fields. You can search/filter on these values. */

/* The initial byte sent when first connecting. */

static int hf_alljoyn_connect_byte_value;

/* SASL fields. */

static int hf_alljoyn_sasl_command;

static int hf_alljoyn_sasl_parameter;

/* Message header fields.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messages

for details. */

static int hf_alljoyn_mess_header;              /* The complete header. */

static int hf_alljoyn_mess_header_endian;       /* 1st byte. */

static int hf_alljoyn_mess_header_type;         /* 2nd byte. */

static int hf_alljoyn_mess_header_flags;        /* 3rd byte. */

static int hf_alljoyn_mess_header_majorversion; /* 4th byte. */

static int hf_alljoyn_mess_header_body_length;  /* 1st uint32. */

static int hf_alljoyn_mess_header_serial;       /* 2nd uint32. */

static int hf_alljoyn_mess_header_header_length;/* 3rd uint32. AllJoyn extension. */

static int hf_alljoyn_mess_header_flags_no_reply;          /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_no_auto_start;     /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_allow_remote_msg;  /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_sessionless;       /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_global_broadcast;  /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_compressed;        /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_flags_encrypted;         /* Part of 3rd byte. */

static int hf_alljoyn_mess_header_field;

static int hf_alljoyn_mess_header_fields;

static int hf_alljoyn_mess_body_header_fieldcode;

static int hf_alljoyn_mess_body_header_typeid;

static int hf_alljoyn_mess_body_array;

static int hf_alljoyn_mess_body_structure;

static int hf_alljoyn_mess_body_dictionary_entry;

static int hf_alljoyn_mess_body_parameters;

static int hf_alljoyn_mess_body_variant;

static int hf_alljoyn_mess_body_signature;

static int hf_alljoyn_mess_body_signature_length;

static int hf_alljoyn_boolean;

static int hf_alljoyn_uint8;

static int hf_alljoyn_int16;

static int hf_alljoyn_uint16;

static int hf_alljoyn_int32;

static int hf_alljoyn_handle;

static int hf_alljoyn_uint32;

static int hf_alljoyn_int64;

static int hf_alljoyn_uint64;

static int hf_alljoyn_double;

static int hf_padding;         /* Some fields are padded to an even number of 2, 4, or 8 bytes. */

#define MESSAGE_HEADER_FLAG_NO_REPLY_EXPECTED 0x01

#define MESSAGE_HEADER_FLAG_NO_AUTO_START     0x02

#define MESSAGE_HEADER_FLAG_ALLOW_REMOTE_MSG  0x04

#define MESSAGE_HEADER_FLAG_SESSIONLESS       0x10

#define MESSAGE_HEADER_FLAG_GLOBAL_BROADCAST  0x20

#define MESSAGE_HEADER_FLAG_COMPRESSED        0x40

#define MESSAGE_HEADER_FLAG_ENCRYPTED         0x80

/* Protocol identifiers. */

static int proto_AllJoyn_ns;  /* The top level. Entire AllJoyn Name Service protocol. */

static int hf_alljoyn_answer;

static int hf_alljoyn_isat_entry;

static int hf_alljoyn_isat_guid_string;

static int hf_alljoyn_ns_header;

static int hf_alljoyn_ns_sender_version;

static int hf_alljoyn_ns_message_version;

static int hf_alljoyn_ns_questions;

static int hf_alljoyn_ns_answers;

static int hf_alljoyn_ns_timer;

/* These are bit masks for version 0 "who has" records. */

/* These bits are deprecated and do not exist for version 1. */

#define WHOHAS_T 0x08

#define WHOHAS_U 0x04

#define WHOHAS_S 0x02

#define WHOHAS_F 0x01

static int hf_alljoyn_ns_whohas;

static int hf_alljoyn_ns_whohas_t_flag;   /* 0x8 -- TCP  */

static int hf_alljoyn_ns_whohas_u_flag;   /* 0x4 -- UDP  */

static int hf_alljoyn_ns_whohas_s_flag;   /* 0x2 -- IPV6 */

static int hf_alljoyn_ns_whohas_f_flag;   /* 0x1 -- IPV4 */

/* End of version 0 bit masks. */

static int hf_alljoyn_ns_whohas_count;    /* octet count of bus names */

/* Bitmasks common to v0 and v1 IS-AT messages. */

#define ISAT_C 0x10

#define ISAT_G 0x20

/* Bitmasks for v0 IS-AT messages. */

#define ISAT_F 0x01

#define ISAT_S 0x02

#define ISAT_U 0x04

#define ISAT_T 0x08

/* Bitmasks for v1 IS-AT messages. */

#define ISAT_U6 0x01

#define ISAT_R6 0x02

#define ISAT_U4 0x04

#define ISAT_R4 0x08

/* Bitmasks for v1 transports. */

#define TRANSPORT_LOCAL     0x0001  /* Local (same device) transport. */

#define TRANSPORT_BLUETOOTH 0x0002  /* Bluetooth transport. */

#define TRANSPORT_TCP       0x0004  /* Transport using TCP (same as TRANSPORT_WLAN). */

#define TRANSPORT_WWAN      0x0008  /* Wireless wide-area network transport. */

#define TRANSPORT_LAN       0x0010  /* Wired local-area network transport. */

#define TRANSPORT_ICE       0x0020  /* Transport using ICE protocol. */

#define TRANSPORT_WFD       0x0080  /* Transport using Wi-Fi Direct transport. */

/* Tree indexes common to v0 and v1 IS-AT messages. */

static int hf_alljoyn_ns_isat_g_flag;     /* 0x20 -- GUID present */

static int hf_alljoyn_ns_isat_c_flag;     /* 0x10 -- Complete */

/* Tree indexes for v0 IS-AT messages. */

static int hf_alljoyn_ns_isat_t_flag;     /* 0x8 -- TCP */

static int hf_alljoyn_ns_isat_u_flag;     /* 0x4 -- UDP */

static int hf_alljoyn_ns_isat_s_flag;     /* 0x2 -- IPV6 */

static int hf_alljoyn_ns_isat_f_flag;     /* 0x1 -- IPV4 */

static int hf_alljoyn_ns_isat_count;      /* octet count of bus names */

static int hf_alljoyn_ns_isat_port;       /* two octets of port number */

static int hf_alljoyn_ns_isat_ipv4;       /* four octets of IPv4 address */

static int hf_alljoyn_ns_isat_ipv6;       /* sixteen octets of IPv6 address */

/* Tree indexes for v1 IS-AT messages. */

static int hf_alljoyn_ns_isat_u6_flag;    /* 0x8 -- UDP IPV6 */

static int hf_alljoyn_ns_isat_r6_flag;    /* 0x4 -- TCP IPV6 */

static int hf_alljoyn_ns_isat_u4_flag;    /* 0x2 -- UDP IPV4 */

static int hf_alljoyn_ns_isat_r4_flag;    /* 0x1 -- TCP IPV4 */

static int hf_alljoyn_ns_isat_transport_mask; /* All bits of the transport mask. */

/* Individual bits of the mask. */

static int hf_alljoyn_ns_isat_transport_mask_local;    /* Local (same device) transport */

static int hf_alljoyn_ns_isat_transport_mask_bluetooth;/* Bluetooth transport */

static int hf_alljoyn_ns_isat_transport_mask_tcp;      /* Transport using TCP (same as TRANSPORT_WLAN) */

static int hf_alljoyn_ns_isat_transport_mask_wwan;     /* Wireless wide-area network transport */

static int hf_alljoyn_ns_isat_transport_mask_lan;      /* Wired local-area network transport */

static int hf_alljoyn_ns_isat_transport_mask_ice;      /* Transport using ICE protocol */

static int hf_alljoyn_ns_isat_transport_mask_wfd;      /* Transport using Wi-Fi Direct transport */

static int hf_alljoyn_string;

static int hf_alljoyn_string_size_8bit;    /* 8-bit size of string */

static int hf_alljoyn_string_size_32bit;   /* 32-bit size of string */

static int hf_alljoyn_string_data;         /* string characters */

/* Protocol identifiers. */

static int proto_AllJoyn_ardp;  /* The top level. Entire AllJoyn Reliable Datagram Protocol. */

#define ARDP_SYN_FIXED_HDR_LEN  28 /* Size of the fixed part for the ARDP connection packet header. */

#define ARDP_FIXED_HDR_LEN      34 /* Size of the fixed part for the ARDP header. */

#define ARDP_DATA_LENGTH_OFFSET  6 /* Offset into the ARDP header for the data length. */

#define ARDP_HEADER_LEN_OFFSET   1 /* Offset into the ARDP header for the actual length of the header. */

/* These are bit masks for ARDP flags. */

/* These bits are deprecated and do not exist for version 1. */

#define ARDP_SYN 0x01

#define ARDP_ACK 0x02

#define ARDP_EAK 0x04

#define ARDP_RST 0x08

#define ARDP_NUL 0x10

#define ARDP_UNUSED 0x20

#define ARDP_VER0 0x40

#define ARDP_VER1 0x80

#define ARDP_VER (ARDP_VER0 | ARDP_VER1)

static int hf_ardp_syn_flag;       /* 0x01 -- SYN */

static int hf_ardp_ack_flag;       /* 0x02 -- ACK */

static int hf_ardp_eak_flag;       /* 0x04 -- EAK */

static int hf_ardp_rst_flag;       /* 0x08 -- RST */

static int hf_ardp_nul_flag;       /* 0x10 -- NUL */

static int hf_ardp_unused_flag;    /* 0x20 -- UNUSED */

static int hf_ardp_version_field;  /* 0xc0 */

static int hf_ardp_hlen;   /* header length */

static int hf_ardp_src;    /* source port */

static int hf_ardp_dst;    /* destination port */

static int hf_ardp_dlen;   /* data length */

static int hf_ardp_seq;    /* sequence number */

static int hf_ardp_ack;    /* acknowledge number */

static int hf_ardp_ttl;    /* time to live (ms) */

static int hf_ardp_lcs;    /* last consumed sequence number */

static int hf_ardp_nsa;    /* next sequence to ack */

static int hf_ardp_fss;    /* fragment starting sequence number */

static int hf_ardp_fcnt;   /* fragment count */

static int hf_ardp_bmp;    /* EACK bitmap */

static int hf_ardp_segmax; /* The maximum number of outstanding segments the other side can send without acknowledgment. */

static int hf_ardp_segbmax;/* The maximum segment size we are willing to receive. */

static int hf_ardp_dackt;  /* Receiver's delayed ACK timeout. Used in TTL estimate prior to sending a message. */

static int hf_ardp_options;/* Options for the connection. Always Sequenced Delivery Mode (SDM). */

static expert_field ei_alljoyn_empty_arg;

/* These are the ids of the subtrees we will be creating */

static int ett_alljoyn_ns;    /* This is the top NS tree. */

static int ett_alljoyn_ns_header;

static int ett_alljoyn_ns_answers;

static int ett_alljoyn_ns_guid_string;

static int ett_alljoyn_ns_isat_entry;

static int ett_alljoyn_ns_string;

static int ett_alljoyn_whohas;

static int ett_alljoyn_string;

static int ett_alljoyn_isat_entry;

static int ett_alljoyn_mess;  /* This is the top message tree. */

static int ett_alljoyn_header;

static int ett_alljoyn_header_flags;

static int ett_alljoyn_mess_header_field;

static int ett_alljoyn_mess_header;

static int ett_alljoyn_mess_body_parameters;

static int ett_alljoyn_ardp;  /* This is the top ARDP tree. */

#define ROUND_TO_2BYTE(len) WS_ROUNDUP_2(len)

#define ROUND_TO_4BYTE(len) WS_ROUNDUP_4(len)

#define ROUND_TO_8BYTE(len) WS_ROUNDUP_8(len)

static const value_string endian_encoding_vals[] = {

    { 'B', "Big endian" },

    { 'l', "Little endian" },

    { 0, NULL },

};

#define MESSAGE_TYPE_INVALID        0

#define MESSAGE_TYPE_METHOD_CALL    1

#define MESSAGE_TYPE_METHOD_REPLY   2

#define MESSAGE_TYPE_ERROR_REPLY    3

#define MESSAGE_TYPE_SIGNAL         4

static const value_string message_header_encoding_vals[] = {

    { MESSAGE_TYPE_INVALID,      "Invalid type" },

    { MESSAGE_TYPE_METHOD_CALL,  "Method call" },

    { MESSAGE_TYPE_METHOD_REPLY, "Method reply with returned data" },

    { MESSAGE_TYPE_ERROR_REPLY,  "Error reply" },

    { MESSAGE_TYPE_SIGNAL,       "Signal emission" },

    { 0, NULL }

};

/*

 * The array at the end of the header contains header fields,

 * where each field is a 1-byte field code followed by a field value.

 * See also: http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messages

 *

 * In the D-Bus world these are the "field codes".

 * In the AllJoyn world these are called "field types".

 */

#define HDR_INVALID               0x00

#define HDR_OBJ_PATH              0x01

#define HDR_INTERFACE             0x02

#define HDR_MEMBER                0x03

#define HDR_ERROR_NAME            0x04

#define HDR_REPLY_SERIAL          0x05

#define HDR_DESTINATION           0x06

#define HDR_SENDER                0x07

#define HDR_SIGNATURE             0x08

#define HDR_HANDLES               0x09

#define HDR_TIMESTAMP             0x10 /* AllJoyn specific headers start at 0x10 */

#define HDR_TIME_TO_LIVE          0x11

#define HDR_COMPRESSION_TOKEN     0x12

#define HDR_SESSION_ID            0x13

static const value_string mess_header_field_encoding_vals[] = {

    { HDR_INVALID,           "Invalid" },           /* Not a valid field name (error if it appears in a message). */

    { HDR_OBJ_PATH,          "Object Path" },       /* The object to send a call to, or the object a signal

                                                       is emitted from. */

    { HDR_INTERFACE,         "Interface" },         /* The interface to invoke a method call on, or that a

                                                       signal is emitted from. Optional for method calls,

                                                       required for signals. */

    { HDR_MEMBER,            "Member" },            /* The member, either the method name or signal name. */

    { HDR_ERROR_NAME,        "Error Name" },        /* The name of the error that occurred, for errors. */

    { HDR_REPLY_SERIAL,      "Reply Serial" },      /* The serial number of the message this message is a reply to. */

    { HDR_DESTINATION,       "Destination" },       /* The name of the connection this message is intended for. */

    { HDR_SENDER,            "Sender" },            /* Unique name of the sending connection. */

    { HDR_SIGNATURE,         "Signature" },         /* The signature of the message body. */

    { HDR_HANDLES,           "Handles" },           /* The number of handles (Unix file descriptors) that

                                                       accompany the message.  */

    { HDR_TIMESTAMP,         "Time stamp" },

    { HDR_TIME_TO_LIVE,      "Time to live" },

    { HDR_COMPRESSION_TOKEN, "Compression token" },

    { HDR_SESSION_ID,        "Session ID" },

    { 0, NULL }

};

/* This is used to round up offsets into a packet to an even two byte

 * boundary from starting_offset.

 * @param current_offset is the current offset into the packet.

 * @param starting_offset is offset into the packet from the beginning of

 *        the message.

 * @returns the offset rounded up to the next even two byte boundary from

            start of the message.

 */

static int round_to_2byte(int current_offset,

                           int starting_offset)

{

    int length = current_offset - starting_offset;

    return starting_offset + ROUND_TO_2BYTE(length);

}

/* This is used to round up offsets into a packet to an even four byte

 * boundary from starting_offset.

 * @param current_offset is the current offset into the packet.

 * @param starting_offset is offset into the packet from the beginning of

 *        the message.

 * @returns the offset rounded up to the next even four byte boundary from

            start of the message.

 */

static int round_to_4byte(int current_offset,

                           int starting_offset)

{

    int length = current_offset - starting_offset;

    return starting_offset + ROUND_TO_4BYTE(length);

}

/* This is used to round up offsets into a packet to an even eight byte

 * boundary from starting_offset.

 * @param current_offset is the current offset into the packet.

 * @param starting_offset is offset into the packet from the beginning of

 *        the message.

 * @returns the offset rounded up to the next even eight byte boundary from

            start of the message.

 */

static unsigned round_to_8byte(unsigned current_offset,

                           unsigned starting_offset)

{

    unsigned length = current_offset - starting_offset;

    return starting_offset + ROUND_TO_8BYTE(length);

}

/* This is the maximum number of rounding bytes that is ever used.

 * This define is used for error checking. */

#define MAX_ROUND_TO_BYTES 7

/* This is called by dissect_AllJoyn_message() to handle the initial byte for

 * a connect message.

 * If it was the initial byte for a connect message and was handled then return

 * the number of bytes consumed out of the packet. If not an connect initial

 * byte message or unhandled return 0.

 * @param tvb is the incoming network data buffer.

 * @param pinfo contains information about the incoming packet which

 *         we update as we dissect the packet.

 * @param offset is the offset into the packet to check for the connect message.

 * @param message_tree is the subtree that any connect data items should be added to.

 * @returns the offset into the packet that has successfully been handled or

 * the input offset value if it was not the connect initial byte of 0.

 */

static int

handle_message_connect(tvbuff_t    *tvb,

                       packet_info *pinfo,

                       int          offset,

                       proto_tree  *message_tree)

{

    uint8_t the_one_byte;

    the_one_byte = tvb_get_uint8(tvb, offset);

    if(0 == the_one_byte) {

        col_set_str(pinfo->cinfo, COL_INFO, "CONNECT-initial byte");

        /* Now add the value as a subtree to the initial byte. */

        proto_tree_add_item(message_tree, hf_alljoyn_connect_byte_value, tvb, offset, 1, ENC_NA);

        offset += 1;

    }

    return offset;

}

typedef struct _sasl_cmd

{

    const char *text;

    unsigned     length;

} sasl_cmd;

static const char CMD_AUTH[]     = "AUTH";

static const char CMD_CANCEL[]   = "CANCEL";

static const char CMD_BEGIN[]    = "BEGIN";

static const char CMD_DATA[]     = "DATA";

static const char CMD_ERROR[]    = "ERROR";

static const char CMD_REJECTED[] = "REJECTED";

static const char CMD_OK[]       = "OK";

#define MAX_SASL_COMMAND_LENGTH sizeof(CMD_REJECTED)

/* The 256 is just something I pulled out of the air. */

#define MAX_SASL_PACKET_LENGTH (MAX_SASL_COMMAND_LENGTH + 256)

static const sasl_cmd sasl_commands[] = {

    {CMD_AUTH,      G_N_ELEMENTS(CMD_AUTH) - 1},

    {CMD_CANCEL,    G_N_ELEMENTS(CMD_CANCEL) - 1},

    {CMD_BEGIN,     G_N_ELEMENTS(CMD_BEGIN) - 1},

    {CMD_DATA,      G_N_ELEMENTS(CMD_DATA) - 1},

    {CMD_ERROR,     G_N_ELEMENTS(CMD_ERROR) - 1},

    {CMD_REJECTED,  G_N_ELEMENTS(CMD_REJECTED) - 1},

    {CMD_OK,        G_N_ELEMENTS(CMD_OK) - 1},

};

static const int sasl_commands_count = G_N_ELEMENTS(sasl_commands);

static const sasl_cmd *

find_sasl_command(tvbuff_t *tvb,

                  int       offset)

{

    int command_index;

    for(command_index = 0; command_index < sasl_commands_count; command_index++) {

        const sasl_cmd *cmd;

        cmd = &sasl_commands[command_index];

        if(0 == tvb_strneql(tvb, offset, cmd->text, cmd->length)) {

            return cmd;

        }

    }

    return NULL;

}

/* Call this to test whether desegmentation is possible and if so correctly

 * set the pinfo structure with the applicable data.

 * @param pinfo contains information about the incoming packet.

 * @param next_offset is the offset into the tvbuff where it is desired to start processing next time.

 * @param addition_bytes_needed is the additional bytes required beyond what is already available.

 * @returns true if desegmentation is possible. false if not.

 */

static bool set_pinfo_desegment(packet_info *pinfo, int next_offset, int addition_bytes_needed)

{

    if(pinfo->can_desegment) {

        pinfo->desegment_offset = next_offset;

        pinfo->desegment_len = addition_bytes_needed;

        return true;

    }

    return false;

}

/* This is called by dissect_AllJoyn_message() to handle SASL messages.

 * If it was a SASL message and was handled then return the number of bytes

 * used (should be the entire packet). If not a SASL message or unhandled return 0.

 * If more bytes are needed then return the negative of the bytes expected.

 * @param tvb is the incoming network data buffer.

 * @param pinfo contains information about the incoming packet which

 *         we update as we dissect the packet.

 * @param offset is the offset into the packet to start processing.

 * @param message_tree is the subtree that any connect data items should be added to.

 * @returns the offset into the packet that has successfully been handled or

 *         the input offset value if it was not a sasl message.

 */

static int

handle_message_sasl(tvbuff_t    *tvb,

                    packet_info *pinfo,

                    int          offset,

                    proto_tree  *message_tree)

{

    int             return_value = offset;

    const sasl_cmd *command;

    command = find_sasl_command(tvb, offset);

    if(command) {

        unsigned param_len, next_offset;

        /* The terminating character of the command is an '\n'. */

        /* If not found see if we should request another segment. */

        if(!tvb_find_line_end_remaining(tvb, offset + command->length, &param_len, &next_offset)) {

            if(tvb_captured_length_remaining(tvb, offset) < MAX_SASL_PACKET_LENGTH &&

                set_pinfo_desegment(pinfo, offset, DESEGMENT_ONE_MORE_SEGMENT)) {

                /* Return the length of the buffer we successfully parsed. */

                return_value = offset + command->length;

            } else {

                /* If we can't desegment then return 0 meaning we didn't do anything. */

                return_value = 0;

            }

        } else {

            col_add_fstr(pinfo->cinfo, COL_INFO, "SASL-%s", command->text);

            /* Add a subtree/row for the command. */

            proto_tree_add_item(message_tree, hf_alljoyn_sasl_command, tvb, offset, command->length, ENC_ASCII);

            offset += command->length;

            /* Add a subtree for the parameter. */

            proto_tree_add_item(message_tree, hf_alljoyn_sasl_parameter, tvb, offset, param_len, ENC_ASCII);

            return_value = next_offset;

        }

    }

    return return_value;

}

#define ENC_ALLJOYN_BAD_ENCODING 0xBADF00D

#define ENDIANNESS_OFFSET 0 /* The offset for endianness is always 0. */

/* This is called by handle_message_header_body() to get the endianness from

 * message headers.

 * @param tvb is the incoming network data buffer.

 * @param offset is the current offset into network data buffer.

 * @return The type of encoding, ENC_LITTLE_ENDIAN or ENC_BIG_ENDIAN, for

 * the message.

 */

static uint32_t

get_message_header_endianness(tvbuff_t *tvb,

                              int       offset)

{

    uint8_t endianness;

    unsigned  encoding;

    /* The endianness field. */

    endianness = tvb_get_uint8(tvb, offset + ENDIANNESS_OFFSET);

    switch(endianness)

    {

    case 'l':

        encoding = ENC_LITTLE_ENDIAN;

        break;

    case 'B':

        encoding = ENC_BIG_ENDIAN;

        break;

    default:

        encoding = ENC_ALLJOYN_BAD_ENCODING;

        break;

    }

    return encoding;

}

/* This is called by handle_message_field() to handle bytes of particular values

 * in messages.

 * @param tvb is the incoming network data buffer.

 * @param offset is the offset into the packet to start processing.

 * @param field_tree is the subtree that we connect data items to.

 * @param expected_value is the value the byte is expected to have.

 */

static void

handle_message_header_expected_byte(tvbuff_t   *tvb,

                                    int         offset,

                                    proto_tree *field_tree,

                                    uint8_t     expected_value)

{

    proto_item *item;

    uint8_t     byte_value;

    item = proto_tree_add_item(field_tree, hf_alljoyn_uint8, tvb, offset, 1, ENC_NA);

    byte_value = tvb_get_uint8(tvb, offset);

    if(expected_value == byte_value) {

        proto_item_set_text(item, "0x%02x byte", expected_value);

    } else {

        proto_item_set_text(item, "Expected '0x%02x byte' but found '0x%02x'", expected_value, byte_value);

    }

}

/*

 * Message argument types

 */

#define ARG_INVALID           '\0'

#define ARG_ARRAY             'a'    /* AllJoyn array container type */

#define ARG_BOOLEAN           'b'    /* AllJoyn boolean basic type */

#define ARG_DOUBLE            'd'    /* AllJoyn IEEE 754 double basic type */

#define ARG_SIGNATURE         'g'    /* AllJoyn signature basic type */

#define ARG_HANDLE            'h'    /* AllJoyn socket handle basic type */

#define ARG_INT32             'i'    /* AllJoyn 32-bit signed integer basic type */

#define ARG_INT16             'n'    /* AllJoyn 16-bit signed integer basic type */

#define ARG_OBJ_PATH          'o'    /* AllJoyn Name of an AllJoyn object instance basic type */

#define ARG_UINT16            'q'    /* AllJoyn 16-bit unsigned integer basic type */

#define ARG_STRING            's'    /* AllJoyn UTF-8 NULL terminated string basic type */

#define ARG_UINT64            't'    /* AllJoyn 64-bit unsigned integer basic type */

#define ARG_UINT32            'u'    /* AllJoyn 32-bit unsigned integer basic type */

#define ARG_VARIANT           'v'    /* AllJoyn variant container type */

#define ARG_INT64             'x'    /* AllJoyn 64-bit signed integer basic type */

#define ARG_BYTE              'y'    /* AllJoyn 8-bit unsigned integer basic type */

#define ARG_STRUCT            '('    /* AllJoyn struct container type */

#define ARG_DICT_ENTRY        '{'    /* AllJoyn dictionary or map container type - an array of key-value pairs */

static const value_string header_type_vals[] = {

    { ARG_INVALID,    "invalid" },

    { ARG_ARRAY,      "array" },

    { ARG_BOOLEAN,    "boolean" },

    { ARG_DOUBLE,     "IEEE 754 double" },

    { ARG_SIGNATURE,  "signature" },

    { ARG_HANDLE,     "socket handle" },

    { ARG_INT32,      "int32" },

    { ARG_INT16,      "int16" },

    { ARG_OBJ_PATH,   "object path" },

    { ARG_UINT16,     "uint16" },

    { ARG_STRING,     "string" },

    { ARG_UINT64,     "uint64" },

    { ARG_UINT32,     "uint32" },

    { ARG_VARIANT,    "variant" },

    { ARG_INT64,      "int64" },

    { ARG_BYTE,       "byte" },

    { ARG_STRUCT,     "structure" },

    { ARG_DICT_ENTRY, "dictionary" },

    { 0, NULL }

};

static int

pad_according_to_type(int offset, int field_starting_offset, int max_offset, uint8_t type)

{

    switch(type)

    {

    case ARG_BYTE:

        break;

    case ARG_DOUBLE:

    case ARG_UINT64:

    case ARG_INT64:

    case ARG_STRUCT:

    case ARG_DICT_ENTRY:

        offset = round_to_8byte(offset, field_starting_offset);

        break;

    case ARG_SIGNATURE:

        break;

    case ARG_HANDLE:

        break;

    case ARG_INT32:

    case ARG_UINT32:

    case ARG_BOOLEAN:

        offset = round_to_4byte(offset, field_starting_offset);

        break;

    case ARG_INT16:

    case ARG_UINT16:

        offset = round_to_2byte(offset, field_starting_offset);

        break;

    case ARG_STRING:

        break;

    case ARG_VARIANT:

        break;

    case ARG_OBJ_PATH:

        break;

    default:

        break;

    }

    if(offset > max_offset) {

        offset = max_offset;

    }

    return offset;

}

/* This is called by parse_arg to append the signature of structure or dictionary

 * to an item. This is complicated a bit by the fact that structures can be nested.

 * @param item is the item to append the signature data to.

 * @param signature points to the signature to be appended.

 * @param signature_max_length is the specified maximum length of this signature.

 * @param type_stop is the character when indicates the end of the signature.

 */

static void

append_struct_signature(proto_item   *item,

                        const uint8_t *signature,

                        int           signature_max_length,

                        const uint8_t type_stop)

{

    int    depth            = 0;

    uint8_t type_start;

    int    signature_length = 0;

    char c;

    proto_item_append_text(item, "%c", ' ');

    type_start = *signature;

    do {

        if(type_start == *signature) {

            depth++;

        }

        if(type_stop == *signature) {

            depth--;

        }

        c = *signature++;

        proto_item_append_text(item, "%c", g_ascii_isprint(c) ? c : '?');

    } while(depth > 0 && ++signature_length < signature_max_length);

    if(signature_length >= signature_max_length) {

        proto_item_append_text(item, "... Invalid signature!");

    }

}

/* This is called to advance the signature pointer to the end of the signature

 * it is currently pointing at. signature_length is decreased by the appropriate

 * amount before returning.

 * @param signature is a pointer to the signature. It could be simple data type

 * such as 'i', 'b', etc. In these cases *signature is advanced by 1 and

 * *signature_length is decreased by 1. Or it could be an array, structure, dictionary,

 * array of arrays or even more complex things. In these cases the advancement could

 * be much larger. For example with the signature "a(bdas)i" *signature will be advanced

 * to the 'i' and *signature_length will be set to '1'.

 * @param signature_length is a pointer to the length of the signature.

 */

static void

// NOLINTNEXTLINE(misc-no-recursion)

advance_to_end_of_signature(packet_info *pinfo, const uint8_t **signature, uint8_t *signature_length)

{

    bool done = false;

    int8_t current_type;

    int8_t end_type = ARG_INVALID;

    increment_dissection_depth(pinfo);

    while (*signature_length > 0 && **signature && !done) {

        current_type = *(++(*signature));

        --*signature_length;

        /* Were we looking for the end of a structure or dictionary? If so, did we find it? */

        if(end_type != ARG_INVALID) {

            if(end_type == current_type) {

                done = true; /* Found the end of the structure or dictionary. All done. */

            }

            continue;

        }

        switch(current_type)

        {

        case ARG_ARRAY:

            advance_to_end_of_signature(pinfo, signature, signature_length);

            break;

        case ARG_STRUCT:

            end_type = ')';

            advance_to_end_of_signature(pinfo, signature, signature_length);

            break;

        case ARG_DICT_ENTRY:

            end_type = '}';

            advance_to_end_of_signature(pinfo, signature, signature_length);

            break;

        case ARG_BYTE:

        case ARG_DOUBLE:

        case ARG_UINT64:

        case ARG_INT64:

        case ARG_SIGNATURE:

        case ARG_HANDLE:

        case ARG_INT32:

        case ARG_UINT32:

        case ARG_BOOLEAN:

        case ARG_INT16:

        case ARG_UINT16:

        case ARG_STRING:

        case ARG_VARIANT:

        case ARG_OBJ_PATH:

            done = true;

            break;

        default:    /* Unrecognized signature. Bail out. */

            done = true;

            break;

        }

    }

    decrement_dissection_depth(pinfo);

}

/* This is called to add a padding item. There is not padding done for each call made.

 * There is testing for the padding length which must be greater than zero. It's also possible,

 * in the case of bad packets, that the end of the padding is wrong so range checking is

 * also done. In the case of something being obviously wrong this function returns

 * without adding the padding item.

 * @param padding_start is the offset into tvb at which the (possible) padding starts.

 * @param padding_end is the offset into tvb at which the (possible) padding ends.

 * @param tvb is the incoming network data buffer.

 * @param tree is the tree to which the new item should be attached.

 */

static void add_padding_item(unsigned padding_start, unsigned padding_end, tvbuff_t *tvb, proto_tree *tree)

{

    if(padding_end > padding_start && padding_end < tvb_reported_length(tvb)) {

        int padding_length = padding_end - padding_start;

        if (padding_length <= MAX_ROUND_TO_BYTES) {

            proto_tree_add_item(tree, hf_padding, tvb, padding_start, padding_length, ENC_NA);

        }

    }

}

/* This is called to handle a single typed argument. Recursion is used

 * to handle arrays and structures.

 * @param tvb is the incoming network data buffer.

 * @param pinfo contains information about the incoming packet which

 *         we update as we dissect the packet.

 * @param header_item if not NULL, is appended with the text name of the data type.

 * @param encoding indicates big (ENC_BIG_ENDIAN) or little (ENC_LITTLE_ENDIAN)

 * @param offset is the offset into tvb to get the field from.

 * @param field_tree is the tree to which this argument should be attached.

 * @param is_reply_to if true, means this uint32 value should be used to update

 *         header_item and pinfo->cinfo with a special message.

 * @param type_id is the type of this argument.

 * @param field_code is the type of header, or HDR_INVALID if not used, which this

 *         arg is a part of. If field_code is HDR_MEMBER or HDR_SIGNATURE then

 *         pinfo->cinfo is updated with information.

 * @param signature is a pointer to the signature of the parameters. If type_id is

 *         ARG_SIGNATURE this is a return value for the caller to pass to the function

 *         that parses the parameters. If type_id is something like ARG_STRUCT then it points

 *         to the actual signature of the type.

 * @param signature_length is a pointer to the length of the signature and if type_id is

 *         ARG_SIGNATURE this is a return value for the caller to pass to the function

 *         that parses the parameters.

 * @param field_starting_offset is the offset at the beginning of the field that contains

 *         this arg. When rounding this starting_offset is used rather than the absolute offset.

 * @return The new offset into the buffer after removing the field code and value.

 *         the message or the packet length to stop further processing if "really bad"

 *         parameters come in.

 */

static unsigned

// NOLINTNEXTLINE(misc-no-recursion)

parse_arg(tvbuff_t      *tvb,

          packet_info   *pinfo,

          proto_item    *header_item,

          unsigned       encoding,

          unsigned        offset,

          proto_tree    *field_tree,

          bool           is_reply_to,

          uint8_t        type_id,

          uint8_t        field_code,

          const uint8_t **signature,

          uint8_t       *signature_length,

          int            field_starting_offset)

{

    unsigned length;

    int padding_start;

    unsigned saved_offset = offset;

    switch(type_id)

    {

    case ARG_INVALID:

        offset = round_to_8byte(offset + 1, field_starting_offset);

        break;

    case ARG_ARRAY:      /* AllJoyn array container type */

        {

            proto_item   *item;

            proto_tree   *tree;

            const uint8_t *sig_saved;

            int           starting_offset;

            int           number_of_items      = 0;

            unsigned      packet_length        = tvb_reported_length(tvb);

            if(*signature == NULL || *signature_length < 1) {

                col_set_str(pinfo->cinfo, COL_INFO, "BAD DATA: An array argument needs a signature.");

                return tvb_reported_length(tvb);

            }

            /* *sig_saved will now be the element type after the 'a'. */

            sig_saved = (*signature) + 1;

            padding_start = offset;

            offset = round_to_4byte(offset, field_starting_offset);

            add_padding_item(padding_start, offset, tvb, field_tree);

            /* This is the length of the entire array in bytes but does not include the length field. */

            length = tvb_get_uint32(tvb, offset, encoding);

            padding_start = offset + 4;

            starting_offset = pad_according_to_type(padding_start, field_starting_offset, packet_length, *sig_saved); /* Advance to the data elements. */

            if(length > MAX_ARRAY_LEN || starting_offset + length > packet_length) {

                col_add_fstr(pinfo->cinfo, COL_INFO, "BAD DATA: Array length (in bytes) is %d. Remaining packet length is %d.",

                    length, tvb_reported_length_remaining(tvb, starting_offset));

                return tvb_reported_length(tvb);

            }

            /* This item is the entire array including the length specifier plus any pad bytes. */

            item = proto_tree_add_item(field_tree, hf_alljoyn_mess_body_array, tvb, offset, (starting_offset-offset) + length, encoding);

            tree = proto_item_add_subtree(item, ett_alljoyn_mess_body_parameters);

            offset = starting_offset;

            add_padding_item(padding_start, offset, tvb, tree);

            if(0 == length) {

                advance_to_end_of_signature(pinfo, signature, signature_length);

            } else {

                uint8_t sig_length_saved = *signature_length - 1;

                increment_dissection_depth(pinfo);

                while((unsigned)(offset - starting_offset) < length) {

                    const uint8_t *sig_pointer;

                    uint8_t       remaining_sig_length;

                    number_of_items++;

                    sig_pointer = sig_saved;

                    remaining_sig_length = sig_length_saved;

                    offset = parse_arg(tvb,

                                       pinfo,

                                       header_item,

                                       encoding,

                                       offset,

                                       tree,

                                       is_reply_to,

                                       *sig_pointer,

                                       field_code,

                                       &sig_pointer,

                                       &remaining_sig_length,

                                       field_starting_offset);

                    /* Set the signature pointer to be just past the type just handled. */

                    *signature = sig_pointer;

                    *signature_length = remaining_sig_length;

                }

                decrement_dissection_depth(pinfo);

            }

            if(item) {

                proto_item_append_text(item, " of %d '%s' elements", number_of_items, format_char(pinfo->pool, *sig_saved));

            }

        }

        break;

    case ARG_BOOLEAN:    /* AllJoyn boolean basic type */

        padding_start = offset;

        offset = round_to_4byte(offset, field_starting_offset);

        add_padding_item(padding_start, offset, tvb, field_tree);

        proto_tree_add_item(field_tree, hf_alljoyn_boolean, tvb, offset, 4, encoding);

        offset += 4;

        break;

    case ARG_DOUBLE:     /* AllJoyn IEEE 754 double basic type */

        padding_start = offset;

        offset = round_to_8byte(offset, field_starting_offset);

        add_padding_item(padding_start, offset, tvb, field_tree);

        proto_tree_add_item(field_tree, hf_alljoyn_double, tvb, offset, 8, encoding);

        offset += 8;

        break;

    case ARG_SIGNATURE:  /* AllJoyn signature basic type */

        length = tvb_get_uint8(tvb, offset);

        if (length + 2 > tvb_reported_length_remaining(tvb, offset)) {

            int bytes_left = tvb_reported_length_remaining(tvb, offset);

            col_add_fstr(pinfo->cinfo, COL_INFO, "BAD DATA: Signature length is %d. Only %d bytes left in packet.",

                         length, bytes_left);

            return tvb_reported_length(tvb);

        }

        /* Include the terminating '/0'. */

        length++;

        proto_tree_add_item(field_tree, hf_alljoyn_mess_body_signature_length, tvb, offset, 1, encoding);

        offset += 1;

        /* Extract signature from tvb and return to caller. */

        /* XXX should this extract "length - 1" since we always expect /0? */

        proto_tree_add_item_ret_string(field_tree, hf_alljoyn_mess_body_signature, tvb, offset, length, ENC_ASCII|ENC_NA, pinfo->pool, signature);

        *signature_length = length;

        if(HDR_SIGNATURE == field_code) {

            col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", *signature);

        }

        offset += length;

        break;

    case ARG_HANDLE:     /* AllJoyn socket handle basic type. */

        padding_start = offset;

        offset = round_to_4byte(offset, field_starting_offset);

        add_padding_item(padding_start, offset, tvb, field_tree);

        proto_tree_add_item(field_tree, hf_alljoyn_handle, tvb, offset, 4, encoding);

        offset += 4;

        break;

    case ARG_INT32:      /* AllJoyn 32-bit signed integer basic type. */

        padding_start = offset;

        offset = round_to_4byte(offset, field_starting_offset);

        add_padding_item(padding_start, offset, tvb, field_tree);

        proto_tree_add_item(field_tree, hf_alljoyn_int32, tvb, offset, 4, encoding);

        offset += 4;

        break;