/* packet-jxta.c

 *

 * Routines for JXTA packet dissection

 * JXTA specification from https://jxta-spec.dev.java.net (now at https://github.com/chaupal/jxta-spec ?)

 *

 * Copyright 2004-08, Mike Duigou <bondolo@dev.java.net>

 *

 * Heavily based on packet-jabber.c, which in turn is heavily based on

 * on packet-acap.c, which in turn is heavily based on

 * packet-imap.c, Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>

 * Copied from packet-pop.c, packet-jabber.c, packet-udp.c, packet-http.c

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 2000 Gerald Combs

 *

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

 */

#include "config.h"

#define WS_LOG_DOMAIN "jxta"

#include <epan/packet.h>

#include <epan/conversation.h>

#include <epan/conversation_table.h>

#include <epan/prefs.h>

#include <epan/to_str.h>

#include <epan/address_types.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include <wsutil/str_util.h>

#include "packet-jxta.h"

#include "packet-media-type.h"

void proto_register_jxta(void);

void proto_reg_handoff_jxta(void);

static const char JXTA_UDP_SIG[] = { 'J', 'X', 'T', 'A' };

static const char JXTA_MSG_SIG[] = { 'j', 'x', 'm', 'g' };

static const char JXTA_MSGELEM_SIG[] = { 'j', 'x', 'e', 'l' };

static const char JXTA_WELCOME_MSG_SIG[] = { 'J', 'X', 'T', 'A', 'H', 'E', 'L', 'L', 'O', ' ' };

static const char* JXTA_WELCOME_MSG_VERSION_1_1 = "1.1";

static const char* JXTA_WELCOME_MSG_VERSION_3_0 = "3.0";

static const int JXTA_MSG_VERSION_1;

static const int JXTA_MSG_VERSION_2 = 1;

static const int JXTAMSG1_ELMFLAG_TYPE = 1 << 0;

static const int JXTAMSG1_ELMFLAG_ENCODING = 1 << 1;

static const int JXTAMSG1_ELMFLAG_SIGNATURE = 1 << 2;

static const int JXTAMSG2_ELMFLAG_UINT64_LENS = 1 << 0;

static const int JXTAMSG2_ELMFLAG_NAME_LITERAL = 1 << 1;

static const int JXTAMSG2_ELMFLAG_TYPE = 1 << 2;

static const int JXTAMSG2_ELMFLAG_SIGNATURE = 1 << 3;

static const int JXTAMSG2_ELMFLAG_ENCODINGS = 1 << 4;

static int proto_jxta;

static int proto_message_jxta;

static int jxta_tap;

static dissector_table_t media_type_dissector_table;

static dissector_handle_t media_handle;

static dissector_handle_t stream_jxta_handle;

static dissector_handle_t tls_handle;

static int hf_uri_addr;

static int hf_uri_src;

static int hf_uri_dst;

static int hf_jxta_udp;

static int hf_jxta_udpsig;

static int hf_jxta_welcome;

static int hf_jxta_welcome_initiator;

static int hf_jxta_welcome_sig;

static int hf_jxta_welcome_destAddr;

static int hf_jxta_welcome_pubAddr;

static int hf_jxta_welcome_peerid;

static int hf_jxta_welcome_noProp;

static int hf_jxta_welcome_msgVers;

static int hf_jxta_welcome_variable;

static int hf_jxta_welcome_version;

static int hf_jxta_framing;

static int hf_jxta_framing_header;

static int hf_jxta_framing_header_name;

static int hf_jxta_framing_header_value_length;

static int hf_jxta_framing_header_value;

static int hf_jxta_message_address;

static int hf_jxta_message_src;

static int hf_jxta_message_dst;

static int hf_jxta_message_sig;

static int hf_jxta_message_version;

static int hf_jxta_message_flags;

static int hf_jxta_message_flag_utf16be;

static int hf_jxta_message_flag_ucs32be;

static int hf_jxta_message_names_count;

static int hf_jxta_message_names_name;

static int hf_jxta_message_element_count;

static int hf_jxta_element;

static int hf_jxta_element_sig;

static int hf_jxta_element1_namespaceid;

static int hf_jxta_element2_namespaceid;

static int hf_jxta_element2_nameid;

static int hf_jxta_element2_mimeid;

static int hf_jxta_element2_encodingid;

static int hf_jxta_element_flags;

static int hf_jxta_element1_flag_hasType;

static int hf_jxta_element1_flag_hasEncoding;

static int hf_jxta_element1_flag_hasSignature;

static int hf_jxta_element2_flag_64bitlens;

static int hf_jxta_element2_flag_nameLiteral;

static int hf_jxta_element2_flag_hasType;

static int hf_jxta_element2_flag_hasSignature;

static int hf_jxta_element2_flag_hasEncoding;

static int hf_jxta_element2_flag_sigOfEncoded;

static int hf_jxta_element_name;

static int hf_jxta_element_type;

static int hf_jxta_element_encoding;

static int hf_jxta_element_content_len;

static int hf_jxta_element_content_len64;

/* static int hf_jxta_element_content; */

/**

*    JXTA Protocol subtree handles

**/

static int ett_jxta;

static int ett_jxta_welcome;

static int ett_jxta_udp;

static int ett_jxta_framing;

static int ett_jxta_framing_header;

static int ett_jxta_msg;

static int ett_jxta_msg_flags;

static int ett_jxta_elem;

static int ett_jxta_elem_1_flags;

static int ett_jxta_elem_2_flags;

static expert_field ei_media_too_short;

static int uri_address_type = -1;

/**

*   global preferences

**/

static bool gDESEGMENT = true;

static bool gMSG_MEDIA = true;

static dissector_handle_t jxta_udp_handle;

/**

*   Stream Conversation data

**/

struct jxta_stream_conversation_data {

    port_type tpt_ptype;

    address initiator_tpt_address;

    uint32_t initiator_tpt_port;

    uint32_t initiator_welcome_frame;

    address initiator_address;

    address receiver_tpt_address;

    uint32_t receiver_tpt_port;

    uint32_t receiver_welcome_frame;

    address receiver_address;

};

typedef struct jxta_stream_conversation_data jxta_stream_conversation_data;

static const char* jxta_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)

{

    if ((filter == CONV_FT_SRC_ADDRESS) && (conv->src_address.type == uri_address_type))

        return "jxta.message.src";

    if ((filter == CONV_FT_DST_ADDRESS) && (conv->dst_address.type == uri_address_type))

        return "jxta.message.dst";

    if ((filter == CONV_FT_ANY_ADDRESS) && (conv->src_address.type == uri_address_type))

        return "jxta.message.address";

    return CONV_FILTER_INVALID;

}

static ct_dissector_info_t jxta_ct_dissector_info = {&jxta_conv_get_filter_type};

static tap_packet_status

jxta_conversation_packet(void *pct, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)

{

    conv_hash_t *hash = (conv_hash_t*) pct;

    hash->flags = flags;

    const jxta_tap_header *jxtahdr = (const jxta_tap_header *) vip;

    add_conversation_table_data(hash, &jxtahdr->src_address, &jxtahdr->dest_address,

        0, 0, 1, jxtahdr->size, NULL, NULL, &jxta_ct_dissector_info, CONVERSATION_NONE);

    return TAP_PACKET_REDRAW;

}

static const char* jxta_endpoint_get_filter_type(endpoint_item_t* endpoint, conv_filter_type_e filter)

{

    if ((filter == CONV_FT_ANY_ADDRESS) && (endpoint->myaddress.type == uri_address_type))

        return "jxta.message.address";

    return CONV_FILTER_INVALID;

}

static et_dissector_info_t jxta_endpoint_dissector_info = {&jxta_endpoint_get_filter_type};

static tap_packet_status

jxta_endpoint_packet(void *pit, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)

{

    conv_hash_t *hash = (conv_hash_t*) pit;

    hash->flags = flags;

    const jxta_tap_header *jxtahdr = (const jxta_tap_header *)vip;

    /* Take two "add" passes per packet, adding for each direction, ensures that all

    packets are counted properly (even if address is sending to itself)

    XXX - this could probably be done more efficiently inside endpoint_table */

    add_endpoint_table_data(hash, &jxtahdr->src_address, 0, true, 1, jxtahdr->size, &jxta_endpoint_dissector_info, ENDPOINT_NONE);

    add_endpoint_table_data(hash, &jxtahdr->dest_address, 0, false, 1, jxtahdr->size, &jxta_endpoint_dissector_info, ENDPOINT_NONE);

    return TAP_PACKET_REDRAW;

}

static int uri_to_str(const address* addr, char *buf, int buf_len)

{

    int copy_len = addr->len < (buf_len - 1) ? addr->len : (buf_len - 1);

    memcpy(buf, addr->data, copy_len );

    buf[copy_len] = '\0';

    return copy_len+1;

}

static int uri_str_len(const address* addr)

{

    return addr->len+1;

}

static const char* uri_col_filter_str(const address* addr _U_, bool is_src)

{

    if (is_src)

        return "uri.src";

    return "uri.dst";

}

/**

*   Prototypes

**/

static int dissect_jxta_udp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data);

static int dissect_jxta_stream(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data);

static jxta_stream_conversation_data *get_tpt_conversation(packet_info * pinfo);

static conversation_t *get_peer_conversation(packet_info * pinfo, jxta_stream_conversation_data* tpt_conv_data, bool create);

static int dissect_jxta_welcome(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, address * found_addr, bool initiator);

static int dissect_jxta_message_framing(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, uint64_t * content_length,

                                        char ** content_type);

static int dissect_jxta_message(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data);

static int dissect_jxta_message_element_1(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, unsigned ns_count,

                                        const char ** namespaces);

static int dissect_jxta_message_element_2(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, unsigned ns_count,

                                        const char ** namespaces);

static int dissect_media( const char* fullmediatype, tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree);

/**

*   Heuristically dissect a tvbuff containing a JXTA UDP Message

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @return true if the tvb contained JXTA data which was dissected otherwise false

**/

static bool dissect_jxta_UDP_heur(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data _U_)

{

    /* This is a heuristic dissector, which means we get all the UDP

     * traffic not sent to a known dissector and not claimed by

     * a heuristic dissector called before us!

     */

    int save_desegment_offset;

    uint32_t save_desegment_len;

    int ret;

    if (tvb_strneql(tvb, 0, JXTA_UDP_SIG, sizeof (JXTA_UDP_SIG)) != 0) {

        /* Not a JXTA UDP packet (or not enough bytes to check for the sig) */

        return false;

    }

    save_desegment_offset = pinfo->desegment_offset;

    save_desegment_len = pinfo->desegment_len;

    ret = dissect_jxta_udp(tvb, pinfo, tree, NULL);

    /* ws_message( "%d Heuristic UDP Dissection : %d", pinfo->num, ret ); */

    if (ret < 0) {

        /*

         * UDP is not a packet stream protocol, so the UDP dissector

         * should not, and will not, do the sort of dissection help

         * that the TCP dissector will.  If JXTA messages don't

         * start and end on UDP packet boundaries, the JXTA dissector

         * will have to do its own byte stream reassembly.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else if (ret == 0) {

        /*

         * A clear rejection.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else {

        /*

         * A clear acceptance.

         */

        return true;

    }

}

/**

*   Heuristically dissect a tvbuff containing a JXTA TCP Stream

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @return true if the tvb contained JXTA data which was dissected otherwise false

**/

static bool dissect_jxta_TCP_heur(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data _U_)

{

    /* This is a heuristic dissector, which means we get all the TCP

     * traffic not sent to a known dissector and not claimed by

     * a heuristic dissector called before us!

     */

    int save_desegment_offset;

    uint32_t save_desegment_len;

    int ret;

    save_desegment_offset = pinfo->desegment_offset;

    save_desegment_len = pinfo->desegment_len;

    ret = dissect_jxta_stream(tvb, pinfo, tree, NULL);

    /* ws_message( "%d Heuristic TCP Dissection : %d", pinfo->num, ret ); */

    if (ret < 0) {

        /*

         * A heuristic dissector for a TCP-based protocol can reject

         * a packet, or it can request that more data be provided.

         * It must not attempt to do both, as the notion of doing both

         * is nonsensical - if the packet isn't considered a packet

         * for the dissector's protocol, that dissector won't be

         * dissecting it no matter *how* much more data is added.

         *

         * Therefore, we treat a negative return from

         * dissect_jxta_stream() as a rejection.

         *

         * If that's not desired - i.e., if we should keep trying to get

         * more data, in the hopes that we'll eventually be able to

         * determine whether the packet is a JXTA packet or not - we

         * should, in this case, leave pinfo->desegment_offset and

         * pinfo->desegment_len alone, and return true, *NOT* false.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else if (ret == 0) {

        /*

         * A clear rejection.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else {

        /*

         * A clear acceptance.

         */

        return true;

    }

}

/**

*   Heuristically dissect a tvbuff containing a JXTA SCTP Stream

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @return true if the tvb contained JXTA data which was dissected otherwise false

**/

static bool dissect_jxta_SCTP_heur(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void * data _U_)

{

    /* This is a heuristic dissector, which means we get all the SCTP

     * traffic not sent to a known dissector and not claimed by

     * a heuristic dissector called before us!

     */

    int save_desegment_offset;

    uint32_t save_desegment_len;

    int ret;

    save_desegment_offset = pinfo->desegment_offset;

    save_desegment_len = pinfo->desegment_len;

    ret = dissect_jxta_stream(tvb, pinfo, tree, NULL);

    /* ws_message( "%d Heuristic SCTP Dissection : %d", pinfo->num, ret ); */

    if (ret < 0) {

        /*

         * SCTP is not a byte stream protocol, so the SCTP dissector

         * should not, and will not, do the sort of dissection help

         * that the SCTP dissector will.  If JXTA messages don't

         * start and end on SCTP packet boundaries, the JXTA dissector

         * will have to do its own byte stream reassembly.

         *

         * The SCTP dissector currently won't do reassembly.  If that

         * causes a problem for the JXTA dissector, the correct fix

         * is to implement reassembly in the SCTP dissector, so *all*

         * dissectors for protocols running atop SCTP can benefit from

         * it.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else if (ret == 0) {

        /*

         * A clear rejection.

         */

        pinfo->desegment_offset = save_desegment_offset;

        pinfo->desegment_len = save_desegment_len;

        return false;

    } else {

        /*

         * A clear acceptance.

         */

        return true;

    }

}

/**

*   Dissect a tvbuff containing a JXTA UDP header, JXTA Message framing and a JXTA Message

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @return Number of bytes from the tvbuff_t which were processed, 0 (zero) if

*           the packet was not recognized as a JXTA packet and negative if the

*           dissector needs more bytes in order to process a PDU.

**/

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

{

    unsigned offset = 0;

    unsigned available;

    int needed = 0;

    conversation_t *conversation = find_or_create_conversation(pinfo);

    conversation_set_dissector(conversation, jxta_udp_handle);

    while (true) {

        tvbuff_t *jxta_message_framing_tvb;

        int processed = 0;

        uint64_t content_length = -1;

        char *content_type = NULL;

        available = tvb_reported_length_remaining(tvb, offset);

        if (available < sizeof(JXTA_UDP_SIG)) {

            needed = (int) (sizeof(JXTA_UDP_SIG) - available);

            break;

        }

        if (tvb_memeql(tvb, offset, (const uint8_t*)JXTA_UDP_SIG, sizeof(JXTA_UDP_SIG)) != 0) {

            /* not ours */

            return 0;

        }

        offset += (int)sizeof(JXTA_UDP_SIG);

        jxta_message_framing_tvb = tvb_new_subset_remaining(tvb, offset);

        processed = dissect_jxta_message_framing(jxta_message_framing_tvb, pinfo, NULL, &content_length, &content_type);

        if ((0 == processed) || (NULL == content_type) || (content_length <= 0) || (content_length > UINT_MAX)) {

            /** Buffer did not begin with valid framing headers */

            return 0;

        }

        if (processed < 0) {

            needed = -processed;

            break;

        }

        offset += processed;

        available = tvb_reported_length_remaining(tvb, offset);

        if (available < content_length) {

            needed = (int) (content_length - available);

            break;

        }

        offset += (unsigned) content_length;

        break;

    }

    if ((needed > 0) && gDESEGMENT && pinfo->can_desegment) {

        /* ws_message( "UDP requesting %d more bytes", needed ); */

        pinfo->desegment_offset = 0;

        pinfo->desegment_len = needed;

        return -needed;

    }

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

    unsigned tree_offset = 0;

    proto_item *jxta_tree_item =

        proto_tree_add_protocol_format(tree, proto_jxta, tvb, tree_offset, -1, "JXTA" );

    proto_tree *jxta_tree = proto_item_add_subtree(jxta_tree_item, ett_jxta);

    proto_item *jxta_udp_tree_item =

        proto_tree_add_none_format(jxta_tree, hf_jxta_udp, tvb, tree_offset, -1, "JXTA UDP Message");

    proto_tree *jxta_udp_tree = proto_item_add_subtree(jxta_udp_tree_item, ett_jxta_udp);

    tvbuff_t *jxta_message_framing_tvb;

    uint64_t content_length = -1;

    char *content_type = NULL;

    tvbuff_t *jxta_message_tvb;

    proto_tree_add_item(jxta_udp_tree, hf_jxta_udpsig, tvb, tree_offset, (int)sizeof(JXTA_UDP_SIG), ENC_ASCII);

    tree_offset += (int)sizeof(JXTA_UDP_SIG);

    jxta_message_framing_tvb = tvb_new_subset_remaining(tvb, tree_offset);

    tree_offset += dissect_jxta_message_framing(jxta_message_framing_tvb, pinfo, jxta_tree, &content_length, &content_type);

    jxta_message_tvb = tvb_new_subset_length(tvb, tree_offset, (int) content_length);

    tree_offset += dissect_media(content_type, jxta_message_tvb, pinfo, tree);

    proto_item_set_end(jxta_udp_tree_item, tvb, tree_offset);

    // offset is based on reported lengths. tree_offset is based on captured lengths via dissect_media.

    // Comment this out for now in favor of dissect_media's expert warning.

    // DISSECTOR_ASSERT(tree_offset == offset);

    return offset;

}

/**

*   Dissect a tvbuff containing JXTA stream PDUs. This commonly includes

*   connections over TCP sockets.

*

*   <p/>The stream (in both directions) will consist of a JXTA Welcome Message

*   followed by an indeterminate number of JXTA Message Framing Headers and

*   JXTA Messages.

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @return Number of bytes from the tvbuff_t which were processed, 0 (zero) if

*           the packet was not recognized as a JXTA packet and negative if the

*           dissector needs more bytes in order to process a PDU.

**/

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

{

    unsigned offset = 0;

    unsigned available = tvb_reported_length_remaining(tvb, offset);

    int processed = 0;

    int needed = 0;

    jxta_stream_conversation_data *tpt_conv_data = NULL;

    proto_item *jxta_tree_item = NULL;

    proto_tree *jxta_tree = NULL;

    /* ws_message("Dissecting%s : %d", (NULL != tree) ? " for display" : "", pinfo->num ); */

    if (available < sizeof(JXTA_WELCOME_MSG_SIG)) {

        needed = (int) (sizeof(JXTA_WELCOME_MSG_SIG) - available);

        goto Common_Exit;

    }

    if (0 == tvb_memeql(tvb, 0, (const uint8_t*)JXTA_WELCOME_MSG_SIG, sizeof(JXTA_WELCOME_MSG_SIG))) {

        /* The beginning of a JXTA stream connection */

        address *welcome_addr;

        bool initiator = false;

        tpt_conv_data = get_tpt_conversation(pinfo);

        if (0 == tpt_conv_data->initiator_welcome_frame) {

            /* The initiator welcome frame */

            tpt_conv_data->tpt_ptype = pinfo->ptype;

            tpt_conv_data->initiator_welcome_frame = pinfo->num;

            copy_address_wmem(wmem_file_scope(), &tpt_conv_data->initiator_tpt_address, &pinfo->src);

            tpt_conv_data->initiator_tpt_port = pinfo->srcport;

            welcome_addr = &tpt_conv_data->initiator_address;

            initiator = true;

        } else {

            if (tpt_conv_data->initiator_welcome_frame >= pinfo->num) {

                /* what we saw previously was the receiver welcome message */

                tpt_conv_data->receiver_welcome_frame = tpt_conv_data->initiator_welcome_frame;

                tpt_conv_data->receiver_tpt_address = tpt_conv_data->initiator_tpt_address;

                tpt_conv_data->receiver_tpt_port = tpt_conv_data->initiator_tpt_port;

                tpt_conv_data->receiver_address = tpt_conv_data->initiator_address;

                tpt_conv_data->initiator_welcome_frame = pinfo->num;

                copy_address_wmem(wmem_file_scope(), &tpt_conv_data->initiator_tpt_address, &pinfo->src);

                tpt_conv_data->initiator_tpt_port = pinfo->srcport;

                welcome_addr = &tpt_conv_data->initiator_address;

                initiator = true;

            } else {

                /* The receiver welcome frame */

                tpt_conv_data->tpt_ptype = pinfo->ptype;

                tpt_conv_data->receiver_welcome_frame = pinfo->num;

                copy_address_wmem(wmem_file_scope(), &tpt_conv_data->receiver_tpt_address, &pinfo->src);

                tpt_conv_data->receiver_tpt_port = pinfo->srcport;

                welcome_addr = &tpt_conv_data->receiver_address;

                initiator = false;

            }

        }

        processed = dissect_jxta_welcome(tvb, pinfo, NULL, welcome_addr, initiator);

        if( processed < 0 ) {

            needed = -processed;

            goto Common_Exit;

        }

        /* redo, this time creating the display tree. */

        jxta_tree_item = proto_tree_add_protocol_format(tree, proto_jxta, tvb, offset, -1, "JXTA" );

        jxta_tree = proto_item_add_subtree(jxta_tree_item, ett_jxta);

        processed = dissect_jxta_welcome(tvb, pinfo, jxta_tree, welcome_addr, initiator);

    } else {

        /* Somewhere in the middle of a JXTA stream connection */

        uint64_t content_length = UINT64_MAX;

        char *content_type = NULL;

        int headers_len = dissect_jxta_message_framing(tvb, pinfo, NULL, &content_length, &content_type);

        if ((0 == headers_len) || (NULL == content_type) || (content_length <= 0) || (content_length > UINT_MAX)) {

            /** Buffer did not begin with valid framing headers */

            return 0;

        }

        /* ws_message("%d Tpt %s:%d -> %s:%d tvb len=%d\n\t%s %d", pinfo->num,

                  address_to_str(pinfo->pool, &pinfo->src), pinfo->srcport,

                  address_to_str(pinfo->pool, &pinfo->dst), pinfo->destport,

                  tvb_reported_length_remaining(tvb, 0),

                  content_type ? content_type : "[unknown content type]", (int) content_length); */

        if (headers_len < 0) {

            /* negative headers_len means we need more bytes */

            needed = -headers_len;

            goto Common_Exit;

        }

        available = tvb_reported_length_remaining(tvb, offset + headers_len);

        if (available >= content_length) {

            tvbuff_t *jxta_message_tvb = tvb_new_subset_length(tvb, offset + headers_len, (int) content_length);

            conversation_t *peer_conversation = NULL;

            jxta_tree_item = proto_tree_add_protocol_format(tree, proto_jxta, tvb, offset, -1, "JXTA" );

            jxta_tree = proto_item_add_subtree(jxta_tree_item, ett_jxta);

            /* Redo header processing, this time populating the tree. */

            headers_len = dissect_jxta_message_framing(tvb, pinfo, jxta_tree, &content_length, &content_type);

            tpt_conv_data = get_tpt_conversation(pinfo);

            peer_conversation = get_peer_conversation(pinfo, tpt_conv_data, true);

            /* Use our source and destination addresses if we have them */

            if (NULL != peer_conversation) {

                /* ws_message("%d Tpt %s:%d -> %s:%d", pinfo->num,

                          address_to_str(pinfo->pool, &tpt_conv_data->initiator_tpt_address), tpt_conv_data->initiator_tpt_port,

                          address_to_str(pinfo->pool, &tpt_conv_data->receiver_tpt_address), tpt_conv_data->receiver_tpt_port); */

                if (addresses_equal(&pinfo->src, &tpt_conv_data->initiator_tpt_address)

                    && tpt_conv_data->initiator_tpt_port == pinfo->srcport) {

                    /* ws_message("%d From initiator : %s -> %s ", pinfo->num,

                              address_to_str(pinfo->pool, &tpt_conv_data->initiator_address),

                              address_to_str(pinfo->pool, &tpt_conv_data->receiver_address)); */

                    copy_address_shallow(&pinfo->src, &tpt_conv_data->initiator_address);

                    pinfo->srcport = 0;

                    copy_address_shallow(&pinfo->dst, &tpt_conv_data->receiver_address);

                    pinfo->destport = 0;

                    pinfo->ptype = PT_NONE;

                } else if (addresses_equal(&pinfo->src, &tpt_conv_data->receiver_tpt_address) &&

                           tpt_conv_data->receiver_tpt_port == pinfo->srcport) {

                    /* ws_message("%d From receiver : %s -> %s ", pinfo->num,

                              address_to_str(pinfo->pool, &tpt_conv_data->receiver_address),

                              address_to_str(pinfo->pool, &tpt_conv_data->initiator_address)); */

                    copy_address_shallow(&pinfo->src, &tpt_conv_data->receiver_address);

                    pinfo->srcport = 0;

                    copy_address_shallow(&pinfo->dst, &tpt_conv_data->initiator_address);

                    pinfo->destport = 0;

                    pinfo->ptype = PT_NONE;

                } else {

                    /* ws_message("%d Nothing matches %s:%d -> %s:%d", pinfo->num,

                              address_to_str(pinfo->pool, &pinfo->src), pinfo->srcport,

                              address_to_str(pinfo->pool, &pinfo->dst), pinfo->destport); */

                }

            }

            processed = headers_len;

            processed += dissect_media(content_type, jxta_message_tvb, pinfo, tree);

        } else {

            /* we need more bytes before we can process message body. */

            needed = (int) ((unsigned) content_length - available);

            goto Common_Exit;

        }

    }

    offset += processed;

Common_Exit:

    if ((needed > 0) && gDESEGMENT && pinfo->can_desegment) {

        /* ws_message( "Stream requesting %d more bytes", needed ); */

        pinfo->desegment_offset = offset;

        pinfo->desegment_len = needed;

        return -needed;

    }

    return offset;

}

/**

*   Find or possibly create a transport conversation object for the connection

*   which is associated with the packet info.

*

*   @param pinfo  The packet info from the underlying transport.

**/

static jxta_stream_conversation_data *get_tpt_conversation(packet_info * pinfo)

{

    conversation_t *tpt_conversation = find_or_create_conversation(pinfo);

    jxta_stream_conversation_data *tpt_conv_data;

    conversation_set_dissector(tpt_conversation, stream_jxta_handle);

    tpt_conv_data = (jxta_stream_conversation_data *) conversation_get_proto_data(tpt_conversation, proto_jxta);

    if (NULL == tpt_conv_data) {

        tpt_conv_data = wmem_new(wmem_file_scope(), jxta_stream_conversation_data);

        tpt_conv_data->tpt_ptype = pinfo->ptype;

        copy_address_wmem(wmem_file_scope(), &tpt_conv_data->initiator_tpt_address, &pinfo->src);

        tpt_conv_data->initiator_tpt_port = pinfo->srcport;

        tpt_conv_data->initiator_welcome_frame = 0;

        clear_address(&tpt_conv_data->initiator_address);

        copy_address_wmem(wmem_file_scope(), &tpt_conv_data->receiver_tpt_address, &pinfo->dst);

        tpt_conv_data->receiver_tpt_port = pinfo->destport;

        tpt_conv_data->receiver_welcome_frame = 0;

        clear_address(&tpt_conv_data->receiver_address);

        conversation_add_proto_data(tpt_conversation, proto_jxta, tpt_conv_data);

    }

    return tpt_conv_data;

}

/**

*   Find or possibly create a peer conversation object for the connection

*   which is associated with the packet info.

*

*   @param tpt_conv_data  The transport conversation from which we will locate the peer conversation.

*   @param create If true then create a new conversation object if necessary.

**/

static conversation_t *get_peer_conversation(packet_info * pinfo, jxta_stream_conversation_data* tpt_conv_data, bool create)

{

    conversation_t * peer_conversation = NULL;

    if ((AT_NONE != tpt_conv_data->initiator_address.type) && (AT_NONE != tpt_conv_data->receiver_address.type)) {

        peer_conversation = find_conversation(pinfo->num, &tpt_conv_data->initiator_address, &tpt_conv_data->receiver_address,

                                               CONVERSATION_NONE, 0, 0, NO_PORT_B);

        if (create && (NULL == peer_conversation)) {

            peer_conversation = conversation_new(pinfo->num, &tpt_conv_data->initiator_address,

                                                  &tpt_conv_data->receiver_address, CONVERSATION_NONE, 0, 0, NO_PORT2);

            conversation_set_dissector(peer_conversation, stream_jxta_handle);

        }

    }

    return peer_conversation;

}

/**

*   Dissect a tvbuff containing a JXTA Welcome Message

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @param  found_addr The address found in the welcome message.

*   @param  initiator If true then we believe this welcome message to be the initiator's.

*   @return Number of bytes from the tvbuff_t which were processed, 0 (zero) if

*           the packet was not recognized as a JXTA packet and negative if the

*           dissector needs more bytes in order to process a PDU.

**/

static int dissect_jxta_welcome(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, address * found_addr, bool initiator)

{

    unsigned offset = 0;

    int afterwelcome;

    int first_linelen;

    unsigned available = tvb_reported_length_remaining(tvb, offset);

    char **tokens = NULL;

    if (available < sizeof(JXTA_WELCOME_MSG_SIG)) {

        return (int) (available - sizeof(JXTA_WELCOME_MSG_SIG));

    }

    if (0 != tvb_memeql(tvb, 0, (const uint8_t*)JXTA_WELCOME_MSG_SIG, sizeof(JXTA_WELCOME_MSG_SIG))) {

        /* not ours! */

        return 0;

    }

    first_linelen = tvb_find_line_end(tvb, offset, -1, &afterwelcome, gDESEGMENT && pinfo->can_desegment);

    if (-1 == first_linelen) {

        if (available > 4096) {

            /* it's too far too be reasonable */

            return 0;

        } else {

            /* ask for more bytes */

            return -DESEGMENT_ONE_MORE_SEGMENT;

        }

    }

    /* Dissect the Welcome Message */

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

    col_set_str(pinfo->cinfo, COL_INFO, "Welcome");

    {

        char *welcomeline = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, first_linelen, ENC_ASCII);

        char **current_token;

        unsigned token_offset = offset;

        proto_item *jxta_welcome_tree_item = NULL;

        proto_tree *jxta_welcome_tree = NULL;

        tokens = wmem_strsplit(pinfo->pool, welcomeline, " ", 255);

        current_token = tokens;

        if (tree) {

            jxta_welcome_tree_item =

                proto_tree_add_none_format(tree, hf_jxta_welcome, tvb, offset, afterwelcome,

                                           "JXTA Connection Welcome Message, %s", welcomeline);

            jxta_welcome_tree = proto_item_add_subtree(jxta_welcome_tree_item, ett_jxta_welcome);

        }

        if (jxta_welcome_tree) {

            proto_item *jxta_welcome_initiator_item =

                proto_tree_add_boolean(jxta_welcome_tree, hf_jxta_welcome_initiator, tvb, 0, 0, initiator);

            proto_item_set_generated(jxta_welcome_initiator_item);

        }

        if (NULL != *current_token) {

            proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_sig, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

            token_offset += (unsigned) strlen(*current_token) + 1;

            current_token++;

        } else {

            /* invalid welcome message */

            afterwelcome = 0;

            goto Common_Exit;

        }

        if (NULL != *current_token) {

            if (jxta_welcome_tree) {

                proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_destAddr, tvb, token_offset, (int) strlen(*current_token),

                                    ENC_ASCII);

            }

            token_offset += (unsigned) strlen(*current_token) + 1;

            current_token++;

        } else {

            /* invalid welcome message */

            afterwelcome = 0;

            goto Common_Exit;

        }

        if (NULL != *current_token) {

            if (jxta_welcome_tree) {

                proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_pubAddr, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

            }

            token_offset += (unsigned) strlen(*current_token) + 1;

            current_token++;

        } else {

            /* invalid welcome message */

            afterwelcome = 0;

            goto Common_Exit;

        }

        if (NULL != *current_token) {

            if (jxta_welcome_tree) {

                proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_peerid, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

            }

            col_append_str(pinfo->cinfo, COL_INFO, (initiator ? " -> " : " <- ") );

            col_append_str(pinfo->cinfo, COL_INFO, *current_token);

            if (NULL != found_addr) {

                set_address(found_addr, uri_address_type, (int)strlen(*current_token) + 1, wmem_strdup(wmem_file_scope(), *current_token));

            }

            token_offset += (unsigned) strlen(*current_token) + 1;

            current_token++;

        } else {

            /* invalid welcome message */

            afterwelcome = 0;

            goto Common_Exit;

        }

        if (NULL != *current_token) {

            int variable_tokens = 0;

            char **variable_token = current_token;

            while(NULL != *variable_token) {

                variable_tokens++;

                variable_token++;

            }

            if( variable_tokens < 1 ) {

              /* invalid welcome message */

              afterwelcome = 0;

              goto Common_Exit;

            }

            if( (2 == variable_tokens) && (0 == strcmp(JXTA_WELCOME_MSG_VERSION_1_1, current_token[variable_tokens -1])) ) {

                  if (jxta_welcome_tree) {

                      proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_noProp, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

                  }

                  token_offset += (unsigned) strlen(*current_token) + 1;

                  current_token++;

                  if (jxta_welcome_tree) {

                      proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_version, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

                  }

            } else if( (3 == variable_tokens) && (0 == strcmp(JXTA_WELCOME_MSG_VERSION_3_0, current_token[variable_tokens -1])) ) {

                  if (jxta_welcome_tree) {

                      proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_noProp, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

                  }

                  token_offset += (unsigned) strlen(*current_token) + 1;

                  current_token++;

                  if (jxta_welcome_tree) {

                      proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_msgVers, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

                  }

                  token_offset += (unsigned) strlen(*current_token) + 1;

                  current_token++;

                  if (jxta_welcome_tree) {

                      proto_tree_add_item(jxta_welcome_tree, hf_jxta_welcome_version, tvb, token_offset, (int) strlen(*current_token), ENC_ASCII);

                  }

            } else {

                /* Unrecognized Welcome Version */

                int each_variable_token;

                for( each_variable_token = 0; each_variable_token < variable_tokens; each_variable_token++ ) {

                  if (jxta_welcome_tree) {

                      jxta_welcome_tree_item = proto_tree_add_item(jxta_welcome_tree,

                        (each_variable_token < (variable_tokens -1) ? hf_jxta_welcome_variable : hf_jxta_welcome_version),

                        tvb, token_offset, (int) strlen(*current_token), ENC_ASCII|ENC_NA);

                        proto_item_append_text(jxta_welcome_tree_item, " (UNRECOGNIZED)");

                  }

                  token_offset += (unsigned) strlen(*current_token) + 1;

                  current_token++;

                }

            }

        } else {

            /* invalid welcome message */

            afterwelcome = 0;

            goto Common_Exit;

        }

    }

Common_Exit:

    col_set_writable(pinfo->cinfo, -1, false);

    return afterwelcome;

}

/**

*   Dissect a tvbuff containing JXTA Message framing.

*

*   @param  tvb The buffer to dissect.

*   @param  pinfo Packet Info.

*   @param  tree The protocol tree.

*   @param  content_length Pointer to a buffer for storing the value of the

*           "content-length" header or NULL.

*   @param  content_type Pointer-to-a-pointer for a new buffer for storing the

*           value of the "content_type-length" header or NULL.

*   @return Number of bytes from the tvbuff_t which were processed, 0 (zero) if

*           the packet was not recognized as a JXTA packet and negative if the

*           dissector needs more bytes in order to process a PDU.

**/

static int dissect_jxta_message_framing(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, uint64_t * content_length,

                                        char ** content_type)

{

    unsigned offset = 0;

    unsigned available;

    int needed = 0;

    /*

     *   First go around. Make sure all of the bytes are there.

     */

    do {

        uint8_t headername_len;

        uint8_t headername_offset;

        uint16_t headervalue_len;

        uint16_t headervalue_offset;

        available = tvb_reported_length_remaining(tvb, offset);