2005-01-07 12:58:43 +00:00
|
|
|
/* packet-jxta.c
|
|
|
|
* Routines for JXTA packet dissection
|
|
|
|
* Copyright 2004, Mike Duigou <bondolo@jxta.org>
|
|
|
|
* 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>
|
|
|
|
*
|
|
|
|
* $Id$
|
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* Copied from packet-pop.c, packet-jabber.c, packet-udp.c
|
|
|
|
*
|
|
|
|
* JXTA specification from http://spec.jxta.org
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <glib.h>
|
|
|
|
#include <epan/packet.h>
|
|
|
|
#include <epan/strutil.h>
|
|
|
|
#include <epan/prefs.h>
|
|
|
|
#include "packet-tcp.h"
|
|
|
|
|
|
|
|
static int proto_jxta = -1;
|
|
|
|
|
|
|
|
static int hf_jxta_udp = -1;
|
|
|
|
static int hf_jxta_udpsig = -1;
|
|
|
|
static int hf_jxta_welcome = -1;
|
|
|
|
static int hf_jxta_framing = -1;
|
|
|
|
static int hf_jxta_framing_header_name_length = -1;
|
|
|
|
static int hf_jxta_framing_header_name = -1;
|
|
|
|
static int hf_jxta_framing_header_value_length = -1;
|
|
|
|
static int hf_jxta_framing_header_value = -1;
|
|
|
|
static int hf_jxta_message = -1;
|
|
|
|
static int hf_jxta_message_sig = -1;
|
|
|
|
static int hf_jxta_message_version = -1;
|
|
|
|
static int hf_jxta_message_namespaces_count = -1;
|
|
|
|
static int hf_jxta_message_namespace_len = -1;
|
|
|
|
static int hf_jxta_message_namespace_name = -1;
|
|
|
|
static int hf_jxta_message_element_count = -1;
|
|
|
|
static int hf_jxta_element = -1;
|
|
|
|
static int hf_jxta_element_sig = -1;
|
|
|
|
static int hf_jxta_element_namespaceid = -1;
|
|
|
|
static int hf_jxta_element_flags = -1;
|
|
|
|
static int hf_jxta_element_name_len = -1;
|
|
|
|
static int hf_jxta_element_name = -1;
|
|
|
|
static int hf_jxta_element_type_len = -1;
|
|
|
|
static int hf_jxta_element_type = -1;
|
|
|
|
static int hf_jxta_element_encoding_len = -1;
|
|
|
|
static int hf_jxta_element_encoding = -1;
|
|
|
|
static int hf_jxta_element_data_length = -1;
|
|
|
|
static int hf_jxta_element_content_len = -1;
|
|
|
|
static int hf_jxta_element_content = -1;
|
|
|
|
|
|
|
|
static gint ett_jxta_welcome = -1;
|
|
|
|
static gint ett_jxta_udp = -1;
|
|
|
|
static gint ett_jxta_framing = -1;
|
|
|
|
static gint ett_jxta_msg = -1;
|
|
|
|
static gint ett_jxta_elem = -1;
|
|
|
|
|
|
|
|
static dissector_handle_t udpm_jxta_handle;
|
|
|
|
static dissector_handle_t tcp_jxta_handle;
|
|
|
|
static dissector_handle_t http_jxta_handle;
|
|
|
|
|
|
|
|
/** our header fields */
|
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_jxta_udp,
|
|
|
|
{ "JXTA UDP Message", "jxta.udp", FT_NONE, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA UDP Message", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_udpsig,
|
|
|
|
{ "Signature", "jxta.udpsig", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA UDP Signature", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_welcome,
|
|
|
|
{ "Welcome Message", "jxta.welcome", FT_NONE, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Connection Welcome Message", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_framing,
|
|
|
|
{ "JXTA Message Framing", "jxta.framing", FT_NONE, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Framing Header", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_framing_header_name_length,
|
|
|
|
{ "Name Length", "jxta.framing.header.namelen", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Framing Header Name Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_framing_header_name,
|
2005-01-07 19:34:36 +00:00
|
|
|
{ "Name", "jxta.framing.header.name", FT_STRING, BASE_NONE, NULL, 0x0,
|
2005-01-07 12:58:43 +00:00
|
|
|
"JXTA Message Framing Header Name", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_framing_header_value_length,
|
|
|
|
{ "Value Length", "jxta.framing.header.valuelen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Framing Header Value Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_framing_header_value,
|
|
|
|
{ "Value", "jxta.framing.header.value", FT_BYTES, BASE_HEX, NULL, 0x0,
|
|
|
|
"JXTA Message Framing Header Value", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message,
|
|
|
|
{ "JXTA Message", "jxta.message", FT_NONE, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_sig,
|
|
|
|
{ "Signature", "jxta.message.signature", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Signature", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_version,
|
|
|
|
{ "Version", "jxta.message.version", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Version", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_namespaces_count,
|
|
|
|
{ "Namespace Count", "jxta.message.namespaces", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Namespaces", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_namespace_len,
|
|
|
|
{ "Namespace Name Length", "jxta.message.namespace.len", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Namespace Name Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_namespace_name,
|
|
|
|
{ "Namespace Name", "jxta.message.namespace.name", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Namespace Name", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_message_element_count,
|
|
|
|
{ "Element Count", "jxta.message.elements", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Count", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element,
|
|
|
|
{ "JXTA Message Element", "jxta.message.element", FT_NONE, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Element", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_sig,
|
|
|
|
{ "Signature", "jxta.message.element.signature", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Element Signature", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_namespaceid,
|
|
|
|
{ "Namespace ID", "jxta.message.element.namespaceid", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Namespace ID", HFILL }
|
|
|
|
},
|
|
|
|
|
|
|
|
/* TODO 20050104 bondolo This should be a bitfield */
|
|
|
|
|
|
|
|
{ &hf_jxta_element_flags,
|
|
|
|
{ "Flags", "jxta.message.element.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
|
|
|
|
"JXTA Message Element Flags", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_name_len,
|
|
|
|
{ "Element Name Length", "jxta.message.element.name.length", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Name Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_name,
|
|
|
|
{ "Element Name", "jxta.message.element.name", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Element Name", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_type_len,
|
|
|
|
{ "Element Type Length", "jxta.message.element.type.length", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Name Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_type,
|
|
|
|
{ "Element Type", "jxta.message.element.type", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Element Name", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_encoding_len,
|
|
|
|
{ "Element Type Length", "jxta.message.element.encoding.length", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Encoding Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_encoding,
|
|
|
|
{ "Element Type", "jxta.message.element.encoding", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"JXTA Message Element Encoding", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_content_len,
|
|
|
|
{ "Element Content Length", "jxta.message.element.content.length", FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"JXTA Message Element Content Length", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_jxta_element_content,
|
|
|
|
{ "Element Content", "jxta.message.element.content", FT_BYTES, BASE_HEX, NULL, 0x0,
|
|
|
|
"JXTA Message Element Content", HFILL }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
/** setup protocol subtree array */
|
|
|
|
static gint * const ett[] = {
|
|
|
|
&ett_jxta_welcome,
|
|
|
|
&ett_jxta_udp,
|
|
|
|
&ett_jxta_framing,
|
|
|
|
&ett_jxta_msg,
|
|
|
|
&ett_jxta_elem
|
|
|
|
};
|
|
|
|
|
|
|
|
static int gUDP_MULTICAST_PORT_JXTA = 1234;
|
|
|
|
static int gHTTP_PORT_JXTA = 9700;
|
|
|
|
static int gTCP_PORT_JXTA = 9701;
|
|
|
|
|
|
|
|
static int regUDP_MULTICAST_PORT_JXTA = -1;
|
|
|
|
static int regHTTP_PORT_JXTA = -1;
|
|
|
|
static int regTCP_PORT_JXTA = -1;
|
|
|
|
|
|
|
|
|
|
|
|
static void dissect_jxta_framing(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
|
|
|
|
|
|
|
|
static void dissect_jxta_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
|
|
|
|
|
|
|
|
void proto_reg_handoff_jxta(void);
|
|
|
|
|
|
|
|
/**
|
|
|
|
Dissect a tvbuff containing a JXTA UDP header, JXTA Message framing and a JXTA Message
|
|
|
|
**/
|
|
|
|
static void dissect_jxta_udp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
proto_tree *jxta_tree = NULL;
|
|
|
|
proto_item *ti;
|
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "JXTA");
|
2005-01-07 19:29:54 +00:00
|
|
|
}
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
/*
|
|
|
|
* bondolo For now just say its a message. eventually put in dest addr.
|
2005-01-07 19:29:54 +00:00
|
|
|
* XXX - if "dest addr" means the IP destination address, that's
|
|
|
|
* already going to be in the "destination address" column if you're
|
|
|
|
* displaying that.
|
2005-01-07 12:58:43 +00:00
|
|
|
*/
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", "UDP Message");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, hf_jxta_udp, tvb, 0, -1, FALSE);
|
|
|
|
jxta_tree = proto_item_add_subtree(ti, ett_jxta_udp);
|
|
|
|
|
|
|
|
ti = proto_tree_add_item( jxta_tree, hf_jxta_udpsig, tvb, 0, 4, FALSE );
|
|
|
|
}
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
if( tvb_memeql(tvb, 0, "JXTA", 4) == 0 ) {
|
|
|
|
tvbuff_t* jxta_framed_message_tvb = tvb_new_subset( tvb, 4, -1, -1 );
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
dissect_jxta_framing( jxta_framed_message_tvb, pinfo, tree );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_jxta_tcp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
dissect_jxta_message( tvb, pinfo, tree );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_jxta_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
tcp_dissect_pdus(tvb, pinfo, tree, TRUE, 0, NULL, dissect_jxta_tcp_pdu);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Dissect a tvbuff containing a JXTA Message framing and a JXTA Message
|
|
|
|
**/
|
|
|
|
static void dissect_jxta_framing(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
proto_tree *jxta_tree = NULL;
|
|
|
|
proto_item *ti;
|
|
|
|
guint offset = 0;
|
2005-01-07 19:29:54 +00:00
|
|
|
tvbuff_t* jxta_message_tvb;
|
|
|
|
|
2005-01-07 12:58:43 +00:00
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, hf_jxta_framing, tvb, 0, -1, FALSE);
|
|
|
|
jxta_tree = proto_item_add_subtree(ti, ett_jxta_framing);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* parse framing headers */
|
|
|
|
do {
|
|
|
|
guint8 headernamelen = tvb_get_guint8( tvb, offset );
|
|
|
|
|
|
|
|
if(tree) {
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item( jxta_tree, hf_jxta_framing_header_name_length, tvb, offset, 1, headernamelen );
|
2005-01-07 12:58:43 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
if( tree && (headernamelen != 0) ) {
|
2005-01-07 12:58:43 +00:00
|
|
|
/*
|
|
|
|
* Put header name into protocol tree.
|
|
|
|
*/
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_tree, hf_jxta_framing_header_name, tvb, offset+1, headernamelen, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
offset += 1 + headernamelen;
|
|
|
|
|
|
|
|
if( headernamelen > 0 ) {
|
|
|
|
guint16 headervaluelen = tvb_get_ntohs( tvb, offset );
|
|
|
|
|
|
|
|
if( tree ) {
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint(jxta_tree, hf_jxta_framing_header_value_length, tvb, offset, 2, headervaluelen );
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
/** TODO bondolo Add specific handling for known header types */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Put header value into protocol tree.
|
|
|
|
*/
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_tree, hf_jxta_framing_header_value, tvb, offset+2, headervaluelen, FALSE );
|
2005-01-07 12:58:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
offset += 2 + headervaluelen;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( 0 == headernamelen ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while( TRUE );
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
jxta_message_tvb = tvb_new_subset( tvb, offset, -1, -1 );
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
/* Call it a new layer and pass the tree as we got it */
|
|
|
|
dissect_jxta_message( jxta_message_tvb, pinfo, tree );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Dissect a tvbuff containing a JXTA Message
|
|
|
|
**/
|
|
|
|
static void dissect_jxta_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
proto_tree *jxta_tree = NULL;
|
|
|
|
proto_item *ti;
|
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "JXTA");
|
2005-01-07 19:29:54 +00:00
|
|
|
}
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
/*
|
|
|
|
* TODO bondolo For now just say its a message. eventually put in dest addr.
|
2005-01-07 19:29:54 +00:00
|
|
|
* XXX - if "dest addr" means the IP destination address, that's
|
|
|
|
* already going to be in the "destination address" column if you're
|
|
|
|
* displaying that.
|
2005-01-07 12:58:43 +00:00
|
|
|
*/
|
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", "Message");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, hf_jxta_message, tvb, 0, -1, FALSE);
|
|
|
|
jxta_tree = proto_item_add_subtree(ti, ett_jxta_udp);
|
|
|
|
}
|
2005-01-07 19:29:54 +00:00
|
|
|
|
2005-01-07 12:58:43 +00:00
|
|
|
if( tree ) {
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item( jxta_tree, hf_jxta_message_sig, tvb, 0, 4, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
if( tvb_memeql(tvb, 0, "jxmg", 4) == 0) {
|
2005-01-07 12:58:43 +00:00
|
|
|
guint8 messageVersion;
|
|
|
|
|
|
|
|
messageVersion = tvb_get_guint8( tvb, sizeof(guint32) );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint( jxta_tree, hf_jxta_message_version, tvb, sizeof(guint32), 1, messageVersion );
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
if( 0 == messageVersion ) {
|
|
|
|
int eachNamespace;
|
|
|
|
guint16 numberOfElements;
|
|
|
|
unsigned int offset = 7;
|
|
|
|
guint16 messageNamespaceCount = tvb_get_ntohs( tvb, 5 );
|
|
|
|
|
|
|
|
/* parse namespaces */
|
|
|
|
/* TODO 20050103 bondolo Should record the namespaces and number them. */
|
|
|
|
for( eachNamespace = 0; eachNamespace < messageNamespaceCount; eachNamespace++ ) {
|
|
|
|
guint8 namespaceLen = tvb_get_guint8( tvb, offset );
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint(jxta_tree, hf_jxta_message_namespace_len, tvb, offset++, namespaceLen, namespaceLen );
|
2005-01-07 12:58:43 +00:00
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_tree, hf_jxta_message_namespace_name, tvb, offset, namespaceLen, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
offset += namespaceLen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* parse elements */
|
|
|
|
numberOfElements = tvb_get_ntohs( tvb, offset );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_tree, hf_jxta_message_element_count, tvb, offset, sizeof(guint16), FALSE );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += sizeof(guint16);
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
while( offset < tvb_reported_length(tvb) ) {
|
2005-01-07 12:58:43 +00:00
|
|
|
proto_tree *jxta_elem_tree = NULL;
|
|
|
|
proto_item *elem_ti;
|
|
|
|
|
|
|
|
elem_ti = proto_tree_add_item(jxta_tree, hf_jxta_element, tvb, 0, -1, FALSE);
|
|
|
|
jxta_elem_tree = proto_item_add_subtree(elem_ti, ett_jxta_elem);
|
|
|
|
|
|
|
|
/* gross hack for parsing of signature element */
|
|
|
|
element_parse :
|
|
|
|
{
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item( jxta_tree, hf_jxta_element_sig, tvb, offset, 4, FALSE );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += 4;
|
2005-01-07 19:29:54 +00:00
|
|
|
if( tvb_memeql(tvb, offset - 4, "jxel", 4) == 0 ) {
|
2005-01-07 12:58:43 +00:00
|
|
|
guint8 namespaceID;
|
|
|
|
guint8 flags;
|
|
|
|
guint16 nameLen;
|
|
|
|
guint32 elemContentLength;
|
|
|
|
|
|
|
|
namespaceID = tvb_get_guint8( tvb, offset );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint( jxta_elem_tree, hf_jxta_element_namespaceid, tvb, offset, sizeof(guint8), namespaceID );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += sizeof(guint8);
|
|
|
|
|
|
|
|
flags = tvb_get_guint8( tvb, offset );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint( jxta_elem_tree, hf_jxta_element_flags, tvb, offset, sizeof(guint8), flags );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += sizeof(guint8);
|
|
|
|
|
|
|
|
nameLen = tvb_get_ntohs( tvb, offset );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint( jxta_elem_tree, hf_jxta_element_name_len, tvb, offset, sizeof(guint16), nameLen );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += sizeof(guint16);
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_elem_tree, hf_jxta_element_name, tvb, offset, nameLen, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
offset += nameLen;
|
|
|
|
|
|
|
|
/* process type */
|
|
|
|
if( (flags & 0x01) != 0 ) {
|
|
|
|
guint16 typeLen = tvb_get_ntohs( tvb, offset );
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_uint( jxta_elem_tree, hf_jxta_element_type_len, tvb, offset, sizeof(guint16), typeLen );
|
2005-01-07 12:58:43 +00:00
|
|
|
offset += sizeof(guint16);
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_elem_tree, hf_jxta_element_type, tvb, offset, typeLen, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
offset += typeLen;
|
2005-01-07 19:29:54 +00:00
|
|
|
}
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
/* process encoding */
|
|
|
|
if( (flags & 0x02) != 0 ) {
|
|
|
|
guint16 encodingLen = tvb_get_ntohs( tvb, offset );
|
|
|
|
ti = proto_tree_add_item( jxta_elem_tree, hf_jxta_element_encoding_len, tvb, offset, sizeof(guint16), FALSE );
|
|
|
|
offset += sizeof(guint16);
|
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_tree_add_item(jxta_elem_tree, hf_jxta_element_encoding, tvb, offset, encodingLen, FALSE);
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
offset += encodingLen;
|
2005-01-07 19:29:54 +00:00
|
|
|
}
|
2005-01-07 12:58:43 +00:00
|
|
|
|
|
|
|
/* content */
|
|
|
|
elemContentLength = tvb_get_ntohl( tvb, offset );
|
|
|
|
ti = proto_tree_add_item( jxta_elem_tree, hf_jxta_element_content_len, tvb, offset, sizeof(guint32), FALSE );
|
|
|
|
offset += sizeof(guint32);
|
|
|
|
|
|
|
|
ti = proto_tree_add_item( jxta_elem_tree, hf_jxta_element_content, tvb, offset, elemContentLength, FALSE );
|
|
|
|
offset += elemContentLength;
|
|
|
|
|
|
|
|
/* XXX Evil Hack Warning : handle parsing of signature element. Would be better with recursion.*/
|
|
|
|
if( (flags & 0x04) != 0 ) {
|
|
|
|
goto element_parse;
|
|
|
|
}
|
2005-01-07 19:29:54 +00:00
|
|
|
}
|
2005-01-07 12:58:43 +00:00
|
|
|
|
2005-01-07 19:29:54 +00:00
|
|
|
proto_item_set_end( elem_ti, tvb, offset - 1 );
|
2005-01-07 12:58:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void proto_register_jxta(void)
|
|
|
|
{
|
|
|
|
module_t *jxta_module;
|
|
|
|
|
|
|
|
proto_jxta = proto_register_protocol("JXTA P2P", "JXTA", "jxta");
|
|
|
|
|
|
|
|
/* Register header fields */
|
|
|
|
proto_register_field_array(proto_jxta, hf, array_length(hf));
|
|
|
|
|
|
|
|
/* Register JXTA Sub-tree */
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
|
|
|
|
/* Register preferences */
|
|
|
|
jxta_module = prefs_register_protocol(proto_jxta, proto_reg_handoff_jxta);
|
|
|
|
|
|
|
|
prefs_register_uint_preference(jxta_module, "tcp.port", "JXTA TCP Port",
|
|
|
|
"Set the port for JXTA TCP messages",
|
|
|
|
10, &gTCP_PORT_JXTA);
|
|
|
|
|
|
|
|
prefs_register_uint_preference(jxta_module, "http.port", "JXTA HTTP Port",
|
|
|
|
"Set the port for JXTA HTTP messages",
|
|
|
|
10, &gHTTP_PORT_JXTA);
|
|
|
|
|
|
|
|
prefs_register_uint_preference(jxta_module, "udp.port", "JXTA UDP Multicast Port",
|
|
|
|
"Set the port for JXTA UDP Multicast messages",
|
|
|
|
10, &gUDP_MULTICAST_PORT_JXTA);
|
|
|
|
}
|
|
|
|
|
|
|
|
void proto_reg_handoff_jxta(void) {
|
|
|
|
static gboolean jxta_prefs_initialized = FALSE;
|
|
|
|
|
|
|
|
if (!jxta_prefs_initialized) {
|
|
|
|
udpm_jxta_handle = create_dissector_handle(dissect_jxta_udp, proto_jxta);
|
|
|
|
tcp_jxta_handle = create_dissector_handle(dissect_jxta_tcp, proto_jxta);
|
|
|
|
http_jxta_handle = create_dissector_handle(dissect_jxta_message, proto_jxta);
|
|
|
|
|
|
|
|
jxta_prefs_initialized = TRUE;
|
|
|
|
} else {
|
|
|
|
dissector_delete("udp.port", regUDP_MULTICAST_PORT_JXTA, udpm_jxta_handle);
|
|
|
|
|
|
|
|
dissector_delete("tcp.port", regTCP_PORT_JXTA, tcp_jxta_handle);
|
|
|
|
|
|
|
|
dissector_delete("http.port", regHTTP_PORT_JXTA, http_jxta_handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remember what ports we registered on for later removal */
|
|
|
|
regUDP_MULTICAST_PORT_JXTA = gUDP_MULTICAST_PORT_JXTA;
|
|
|
|
regTCP_PORT_JXTA = gTCP_PORT_JXTA;
|
|
|
|
regHTTP_PORT_JXTA = gHTTP_PORT_JXTA;
|
|
|
|
|
|
|
|
/* register as a sub-dissector of UDP tagged on port field */
|
|
|
|
dissector_add("udp.port", regUDP_MULTICAST_PORT_JXTA, udpm_jxta_handle);
|
|
|
|
|
|
|
|
/* register as a sub-dissector of TCP tagged on port field*/
|
|
|
|
dissector_add("tcp.port", regTCP_PORT_JXTA, tcp_jxta_handle);
|
|
|
|
|
|
|
|
/* register as a sub-dissector of HTTP tagged on port field */
|
|
|
|
dissector_add("http.port", regHTTP_PORT_JXTA, http_jxta_handle);
|
|
|
|
}
|