Adding upstream version 4.2.2.upstream/4.2.2

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

1 files changed, 1398 insertions, 0 deletions

diff --git a/epan/dissectors/packet-xtp.c b/epan/dissectors/packet-xtp.c
new file mode 100644
index 00000000..b85abf16
--- /dev/null
+++ b/epan/dissectors/packet-xtp.c
@@ -0,0 +1,1398 @@
+/* packet-xtp.c
+ * Routines for Xpress Transport Protocol dissection
+ * Copyright 2008, Shigeo Nakamura <naka_shigeo@yahoo.co.jp>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * Ref: http://www.packeteer.com/resources/prod-sol/XTP.pdf
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/exceptions.h>
+#include <epan/expert.h>
+#include <epan/ipproto.h>
+#include <epan/in_cksum.h>
+
+#define XTP_VERSION_4	0x001
+
+/* XTP type of Service */
+#define XTP_TOS_UNSPEC		0
+#define XTP_TOS_UNACKED_DGRAM	1
+#define	XTP_TOS_ACKED_DGRAM	2
+#define	XTP_TOS_TRANS		3
+#define	XTP_TOS_UNICAST_STREAM	4
+#define	XTP_TOS_UNACKED_MULTICAST_STREAM 5
+#define	XTP_TOS_MULTICAST_STREAM 6
+
+/* Address Format */
+#define XTP_ADDR_NULL		0
+#define XTP_ADDR_IP		1
+#define XTP_ADDR_ISO		2
+#define XTP_ADDR_XEROX		3
+#define XTP_ADDR_IPX		4
+#define XTP_ADDR_LOCAL		5
+#define XTP_ADDR_IP6		6
+
+/* packet type */
+#define XTP_DATA_PKT	0
+#define XTP_CNTL_PKT	1
+#define XTP_FIRST_PKT	2
+#define XTP_ECNTL_PKT	3
+#define XTP_TCNTL_PKT	5
+#define XTP_JOIN_PKT	6
+#define XTP_JCNTL_PKT	7
+#define XTP_DIAG_PKT	8
+
+/* cmd options mask */
+#define XTP_CMD_OPTIONS_NOCHECK		0x400000
+#define XTP_CMD_OPTIONS_EDGE		0x200000
+#define XTP_CMD_OPTIONS_NOERR		0x100000
+#define XTP_CMD_OPTIONS_MULTI		0x080000
+#define XTP_CMD_OPTIONS_RES		0x040000
+#define XTP_CMD_OPTIONS_SORT		0x020000
+#define XTP_CMD_OPTIONS_NOFLOW		0x010000
+#define XTP_CMD_OPTIONS_FASTNAK		0x008000
+#define XTP_CMD_OPTIONS_SREQ		0x004000
+#define XTP_CMD_OPTIONS_DREQ		0x002000
+#define XTP_CMD_OPTIONS_RCLOSE		0x001000
+#define XTP_CMD_OPTIONS_WCLOSE		0x000800
+#define XTP_CMD_OPTIONS_EOM		0x000400
+#define XTP_CMD_OPTIONS_END		0x000200
+#define XTP_CMD_OPTIONS_BTAG		0x000100
+
+#define XTP_KEY_RTN			((guint64)1<<63)
+
+void proto_register_xtp(void);
+void proto_reg_handoff_xtp(void);
+
+static dissector_handle_t xtp_handle;
+
+/** packet structures definition **/
+struct xtp_cntl {
+	guint64		rseq;
+	guint64		alloc;
+	guint32		echo;
+};
+#define XTP_CNTL_PKT_LEN	20
+
+struct xtp_ecntl {
+	guint64		rseq;
+	guint64		alloc;
+	guint32		echo;
+	guint32		nspan;
+};
+#define MIN_XTP_ECNTL_PKT_LEN	24
+
+struct xtp_traffic_cntl {
+	guint64		rseq;
+	guint64		alloc;
+	guint32		echo;
+	guint32		rsvd;
+	guint64		xkey;
+};
+#define XTP_TRAFFIC_CNTL_LEN	32
+
+/* tformat = 0x00 */
+struct xtp_traffic_spec0 {
+	guint16		tlen;
+	guint8		service;
+	guint8		tformat;
+	guint32		none;
+};
+#define XTP_TRAFFIC_SPEC0_LEN	8
+
+/* tformat = 0x01 */
+struct xtp_traffic_spec1 {
+	guint16		tlen;
+	guint8		service;
+	guint8		tformat;
+	guint32		maxdata;
+	guint32		inrate;
+	guint32		inburst;
+	guint32		outrate;
+	guint32		outburst;
+};
+#define XTP_TRAFFIC_SPEC1_LEN	24
+
+struct xtp_ip_addr_seg {
+	guint16		alen;
+	guint8		adomain;
+	guint8		aformat;
+	guint32		dsthost;
+	guint32		srchost;
+	guint16		dstport;
+	guint16		srcport;
+};
+#define XTP_IP_ADDR_SEG_LEN	16
+#define XTP_NULL_ADDR_SEG_LEN	8
+
+struct xtp_diag {
+	guint32		code;
+	guint32		val;
+	gchar		*msg;
+};
+#define XTP_DIAG_PKT_HEADER_LEN	8
+
+struct xtphdr {
+	guint64		key;
+	guint32		cmd;
+	guint32		cmd_options;		/* 24 bits */
+	guint8		cmd_ptype;
+	guint8		cmd_ptype_ver;		/* 3 bits */
+	guint8		cmd_ptype_pformat;	/* 5 bits */
+	guint32		dlen;
+	guint16		check;
+	guint16		sort;
+	guint32		sync;
+	guint64		seq;
+};
+#define XTP_HEADER_LEN		32
+
+
+static const value_string version_vals[] = {
+	{ XTP_VERSION_4, "XTP version 4.0" },
+	{ 0, NULL }
+};
+
+static const value_string service_vals[] = {
+	{ XTP_TOS_UNSPEC,                   "Unspecified" },
+	{ XTP_TOS_UNACKED_DGRAM,            "Traditional Unacknowledged Datagram Service" },
+	{ XTP_TOS_ACKED_DGRAM,              "Acknowledged Datagram Service" },
+	{ XTP_TOS_TRANS,                    "Transaction Service" },
+	{ XTP_TOS_UNICAST_STREAM,           "Traditional Reliable Unicast Stream Service" },
+	{ XTP_TOS_UNACKED_MULTICAST_STREAM, "Unacknowledged Multicast Stream Service" },
+	{ XTP_TOS_MULTICAST_STREAM,         "Reliable Multicast Stream Service" },
+	{ 0, NULL }
+};
+
+static const value_string aformat_vals[] = {
+	{ XTP_ADDR_NULL,  "Null Address" },
+	{ XTP_ADDR_IP,    "Internet Protocol Address" },
+	{ XTP_ADDR_ISO,   "ISO Connectionless Network Layer Protocol Address" },
+	{ XTP_ADDR_XEROX, "Xerox Network System Address" },
+	{ XTP_ADDR_IPX,   "IPX Address" },
+	{ XTP_ADDR_LOCAL, "Local Address" },
+	{ XTP_ADDR_IP6,   "Internet Protocol Version 6 Address"  },
+	{ 0, NULL }
+};
+
+static const value_string pformat_vals[] = {
+	{ XTP_DATA_PKT,  "DATA" },
+	{ XTP_CNTL_PKT,  "CNTL" },
+	{ XTP_FIRST_PKT, "FIRST" },
+	{ XTP_ECNTL_PKT, "ECNTL" },
+	{ XTP_TCNTL_PKT, "TCNTL" },
+	{ XTP_JOIN_PKT,  "JOIN<obsolete>" },
+	{ XTP_JCNTL_PKT, "JCNTL" },
+	{ XTP_DIAG_PKT,  "DIAG" },
+	{ 0, NULL }
+};
+
+static const value_string diag_code_vals[] = {
+	{ 1, "Context Refused" },
+	{ 2, "Context Abandoned" },
+	{ 3, "Invalid Context" },
+	{ 4, "Request Refused" },
+	{ 5, "Join Refused" },
+	{ 6, "Protocol Error" },
+	{ 7, "Maximum Packet Size Error" },
+	{ 0, NULL }
+};
+
+static const value_string diag_val_vals[] = {
+	{  0, "Unspecified" },
+	{  1, "No listener" },
+	{  2, "Options refused" },
+	{  3, "Address format not supported" },
+	{  4, "Malformed address format" },
+	{  5, "Traffic format not supported" },
+	{  6, "Traffic specification refused" },
+	{  7, "Malformed traffic format" },
+	{  8, "No provider for service" },
+	{  9, "No resource" },
+	{ 10, "Host going down" },
+	{ 11, "Invalid retransmission request" },
+	{ 12, "Context in improper state" },
+	{ 13, "Join request denied" },
+	{ 0, NULL }
+};
+
+/* Initialize the protocol and registered fields */
+static int proto_xtp = -1;
+/* common header */
+static int hf_xtp_key = -1;
+static int hf_xtp_cmd = -1;
+static int hf_xtp_cmd_options = -1;
+static int hf_xtp_cmd_options_nocheck = -1;
+static int hf_xtp_cmd_options_edge = -1;
+static int hf_xtp_cmd_options_noerr = -1;
+static int hf_xtp_cmd_options_multi = -1;
+static int hf_xtp_cmd_options_res = -1;
+static int hf_xtp_cmd_options_sort = -1;
+static int hf_xtp_cmd_options_noflow = -1;
+static int hf_xtp_cmd_options_fastnak = -1;
+static int hf_xtp_cmd_options_sreq = -1;
+static int hf_xtp_cmd_options_dreq = -1;
+static int hf_xtp_cmd_options_rclose = -1;
+static int hf_xtp_cmd_options_wclose = -1;
+static int hf_xtp_cmd_options_eom = -1;
+static int hf_xtp_cmd_options_end = -1;
+static int hf_xtp_cmd_options_btag = -1;
+static int hf_xtp_cmd_ptype = -1;
+static int hf_xtp_cmd_ptype_ver = -1;
+static int hf_xtp_cmd_ptype_pformat = -1;
+static int hf_xtp_dlen = -1;
+static int hf_xtp_sort = -1;
+static int hf_xtp_sync = -1;
+static int hf_xtp_seq = -1;
+/* control segment */
+static int hf_xtp_cntl_rseq = -1;
+static int hf_xtp_cntl_alloc = -1;
+static int hf_xtp_cntl_echo = -1;
+static int hf_xtp_ecntl_rseq = -1;
+static int hf_xtp_ecntl_alloc = -1;
+static int hf_xtp_ecntl_echo = -1;
+static int hf_xtp_ecntl_nspan = -1;
+static int hf_xtp_ecntl_span_left = -1;
+static int hf_xtp_ecntl_span_right = -1;
+static int hf_xtp_tcntl_rseq = -1;
+static int hf_xtp_tcntl_alloc = -1;
+static int hf_xtp_tcntl_echo = -1;
+static int hf_xtp_tcntl_rsvd = -1;
+static int hf_xtp_tcntl_xkey = -1;
+/* traffic specifier */
+static int hf_xtp_tspec_tlen = -1;
+static int hf_xtp_tspec_service = -1;
+static int hf_xtp_tspec_tformat = -1;
+static int hf_xtp_tspec_traffic = -1;
+static int hf_xtp_tspec_maxdata = -1;
+static int hf_xtp_tspec_inrate = -1;
+static int hf_xtp_tspec_outrate = -1;
+static int hf_xtp_tspec_inburst = -1;
+static int hf_xtp_tspec_outburst = -1;
+/* address segment */
+static int hf_xtp_aseg_alen = -1;
+static int hf_xtp_aseg_adomain = -1;
+static int hf_xtp_aseg_aformat = -1;
+static int hf_xtp_aseg_address = -1;
+static int hf_xtp_aseg_dsthost = -1;
+static int hf_xtp_aseg_srchost = -1;
+static int hf_xtp_aseg_dstport = -1;
+static int hf_xtp_aseg_srcport = -1;
+/* others */
+static int hf_xtp_btag = -1;
+static int hf_xtp_diag_code = -1;
+static int hf_xtp_diag_val = -1;
+static int hf_xtp_diag_msg = -1;
+static int hf_xtp_checksum = -1;
+static int hf_xtp_checksum_status = -1;
+static int hf_xtp_data = -1;
+
+/* Initialize the subtree pointers */
+static gint ett_xtp = -1;
+static gint ett_xtp_cmd = -1;
+static gint ett_xtp_cmd_options = -1;
+static gint ett_xtp_cmd_ptype = -1;
+static gint ett_xtp_cntl = -1;
+static gint ett_xtp_ecntl = -1;
+static gint ett_xtp_tcntl = -1;
+static gint ett_xtp_tspec = -1;
+static gint ett_xtp_jcntl = -1;
+static gint ett_xtp_first = -1;
+static gint ett_xtp_aseg = -1;
+static gint ett_xtp_data = -1;
+static gint ett_xtp_diag = -1;
+
+static expert_field ei_xtp_spans_bad = EI_INIT;
+static expert_field ei_xtp_checksum = EI_INIT;
+
+/* dissector of each payload */
+static int
+dissect_xtp_aseg(tvbuff_t *tvb, proto_tree *tree, guint32 offset) {
+	guint32                 len   = tvb_reported_length_remaining(tvb, offset);
+	guint32                 start = offset;
+	proto_item             *ti, *ti2, *top_ti;
+	proto_tree             *xtp_subtree;
+	struct xtp_ip_addr_seg  aseg[1];
+	int                     error = 0;
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len, ett_xtp_aseg, &top_ti, "Address Segment");
+
+	if (len < XTP_NULL_ADDR_SEG_LEN) {
+		proto_item_append_text(top_ti, ", bogus length(%u, must be at least %u)",
+			len, XTP_NULL_ADDR_SEG_LEN);
+		return 0;
+	}
+
+	/** parse common fields **/
+	/* alen(2) */
+	aseg->alen = tvb_get_ntohs(tvb, offset);
+	offset += 2;
+	/* adomain(1) */
+	aseg->adomain = tvb_get_guint8(tvb, offset);
+	offset++;
+	/* aformat(1) */
+	aseg->aformat = tvb_get_guint8(tvb, offset);
+
+	/** display common fields **/
+	offset = start;
+	/* alen(2) */
+	ti = proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_alen,
+				tvb, offset, 2, aseg->alen);
+	offset += 2;
+	if (aseg->alen > len) {
+		proto_item_append_text(ti, ", bogus length(%u, must be at most %u)",
+			aseg->alen, len);
+		error = 1;
+	}
+	/* adomain(1) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_adomain,
+			tvb, offset, 1, aseg->adomain);
+	offset++;
+	/* aformat(1) */
+	ti2 = proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_aformat,
+			tvb, offset, 1, aseg->aformat);
+	offset++;
+	switch (aseg->aformat) {
+	case 0:
+		if (aseg->alen != XTP_NULL_ADDR_SEG_LEN) {
+			proto_item_append_text(ti, ", bogus length(%u, must be %u)",
+				aseg->alen, XTP_NULL_ADDR_SEG_LEN);
+			error = 1;
+		}
+		break;
+	case 1:
+		if (aseg->alen != XTP_IP_ADDR_SEG_LEN) {
+			proto_item_append_text(ti, ", bogus length(%u, must be %u)",
+				aseg->alen, XTP_IP_ADDR_SEG_LEN);
+			error = 1;
+		}
+		break;
+	default:
+		if (aseg->aformat < 128) {
+			proto_item_append_text(ti2,
+				", Unsupported aformat(%u)", aseg->aformat);
+			error = 1;
+		}
+		break;
+	}
+
+	if (error)
+		return (offset - start);
+
+	/** parse and display each address fileds */
+	switch (aseg->aformat) {
+	case 0:
+		/* address(4) */
+		aseg->dsthost = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_address,
+				tvb, offset, 4, aseg->dsthost);
+		offset += 4;
+		break;
+	case 1:
+		/* dsthost(4) */
+		aseg->dsthost = tvb_get_ipv4(tvb, offset);
+		proto_tree_add_ipv4(xtp_subtree, hf_xtp_aseg_dsthost,
+				tvb, offset, 4, aseg->dsthost);
+		offset += 4;
+		/* srchost(4) */
+		aseg->srchost = tvb_get_ipv4(tvb, offset);
+		proto_tree_add_ipv4(xtp_subtree, hf_xtp_aseg_srchost,
+				tvb, offset, 4, aseg->srchost);
+		offset += 4;
+		/* dstport(2) */
+		aseg->dstport = tvb_get_ntohs(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_dstport,
+				tvb, offset, 2, aseg->dstport);
+		offset += 2;
+		/* srcport(2) */
+		aseg->srcport = tvb_get_ntohs(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_aseg_srcport,
+				tvb, offset, 2, aseg->srcport);
+		offset += 2;
+
+		/** add summary **/
+		proto_item_append_text(top_ti, ", Dst Port: %u", aseg->dstport);
+		proto_item_append_text(top_ti, ", Src Port: %u", aseg->srcport);
+		break;
+	default:
+		break;
+	}
+
+	return (offset - start);
+}
+
+static int
+dissect_xtp_traffic_cntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+		guint32 offset) {
+	guint32                  len   = tvb_reported_length_remaining(tvb, offset);
+	guint32                  start = offset;
+	proto_item              *top_ti;
+	proto_tree              *xtp_subtree;
+	struct xtp_traffic_cntl  tcntl[1];
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len,
+				ett_xtp_tcntl, &top_ti, "Traffic Control Segment");
+
+	if (len < XTP_TRAFFIC_CNTL_LEN) {
+		proto_item_append_text(top_ti,
+				", bogus length(%u, must be at least %u)",
+				len, XTP_TRAFFIC_CNTL_LEN);
+		return 0;
+	}
+
+	/** parse **/
+	/* rseq(8) */
+	tcntl->rseq = tvb_get_ntohl(tvb, offset);
+	tcntl->rseq <<= 32;
+	tcntl->rseq += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* alloc(8) */
+	tcntl->alloc = tvb_get_ntohl(tvb, offset);
+	tcntl->alloc <<= 32;
+	tcntl->alloc += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* echo(4) */
+	tcntl->echo = tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	/* rsvd(4) */
+	tcntl->rsvd = tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	/* xkey(8) */
+	tcntl->xkey = tvb_get_ntohl(tvb, offset);
+	tcntl->xkey <<= 32;
+	tcntl->xkey += tvb_get_ntohl(tvb, offset+4);
+
+	/** add summary **/
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+			" Recv-Seq=%" PRIu64, tcntl->rseq);
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+			" Alloc=%" PRIu64, tcntl->alloc);
+
+	proto_item_append_text(top_ti,
+			", Recv-Seq: %" PRIu64, tcntl->rseq);
+
+	/** display **/
+	offset = start;
+	/* rseq(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_tcntl_rseq,
+			tvb, offset, 8, tcntl->rseq);
+	offset += 8;
+	/* alloc(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_tcntl_alloc,
+			tvb, offset, 8, tcntl->alloc);
+	offset += 4;
+	/* echo(4) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_tcntl_echo,
+			tvb, offset, 4, tcntl->echo);
+	offset += 4;
+	/* rsvd(4) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_tcntl_rsvd,
+			tvb, offset, 4, tcntl->rsvd);
+	offset += 4;
+	/* xkey(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_tcntl_xkey,
+			tvb, offset, 8, tcntl->xkey);
+	offset += 8;
+
+	return (offset - start);
+}
+
+static int
+dissect_xtp_tspec(tvbuff_t *tvb, proto_tree *tree, guint32 offset) {
+	guint32                   len   = tvb_reported_length_remaining(tvb, offset);
+	guint32                   start = offset;
+	proto_item               *ti, *ti2;
+	proto_tree               *xtp_subtree;
+	struct xtp_traffic_spec1  tspec[1];
+	int                       error = 0;
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len, ett_xtp_tspec, &ti, "Traffic Specifier");
+
+	if (len < XTP_TRAFFIC_SPEC0_LEN) {
+		proto_item_append_text(ti,
+			", bogus length(%u, must be at least %u)",
+			len, XTP_TRAFFIC_SPEC0_LEN);
+		return 0;
+	}
+
+	/** parse common fields **/
+	/* tlen(2) */
+	tspec->tlen = tvb_get_ntohs(tvb, offset);
+	offset += 2;
+	/* service(1) */
+	tspec->service = tvb_get_guint8(tvb, offset);
+	offset++;
+	/* tformat(1) */
+	tspec->tformat = tvb_get_guint8(tvb, offset);
+
+	/** display common fields */
+	offset = start;
+	/* tlen(2) */
+	ti = proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_tlen,
+			tvb, offset, 2, tspec->tlen);
+	offset += 2;
+	if (tspec->tlen > len) {
+		proto_item_append_text(ti, ", bogus length(%u, must be at most %u)",
+			tspec->tlen, len);
+		error = 1;
+	}
+	/* service(1) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_service,
+			tvb, offset, 1, tspec->service);
+	offset++;
+	/* tformat(1) */
+	ti2 = proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_tformat,
+			tvb, offset, 1, tspec->tformat);
+	offset++;
+	switch (tspec->tformat) {
+	case 0:
+		if (tspec->tlen != XTP_TRAFFIC_SPEC0_LEN) {
+			proto_item_append_text(ti, ", bogus length(%u, must be %u)",
+				tspec->tlen, XTP_TRAFFIC_SPEC0_LEN);
+			error = 1;
+		}
+		break;
+	case 1:
+		if (tspec->tlen != XTP_TRAFFIC_SPEC1_LEN) {
+			proto_item_append_text(ti, ", bogus length(%u, must be %u)",
+				tspec->tlen, XTP_TRAFFIC_SPEC1_LEN);
+			error = 1;
+		}
+		break;
+	default:
+		proto_item_append_text(ti2, ", Unsupported tformat(%u)",
+				tspec->tformat);
+		error = 1;
+		break;
+	}
+
+	if (error)
+		return (offset - start);
+
+	/** parse and display each traffic fields **/
+	switch (tspec->tformat) {
+	case 0:
+		/* traffic(4) */
+		tspec->maxdata = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_traffic,
+				tvb, offset, 4, tspec->maxdata);
+		offset += 4;
+		break;
+	case 1:
+		/* maxdata(4) */
+		tspec->maxdata = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_maxdata,
+				tvb, offset, 4, tspec->maxdata);
+		offset += 4;
+		/* inrate(4) */
+		tspec->inrate = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_inrate,
+				tvb, offset, 4, tspec->inrate);
+		offset += 4;
+		/* inburst(4) */
+		tspec->inburst = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_inburst,
+				tvb, offset, 4, tspec->inburst);
+		offset += 4;
+		/* outrate(4) */
+		tspec->outrate = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_outrate,
+				tvb, offset, 4, tspec->outrate);
+		offset += 4;
+		/* outburst(4) */
+		tspec->outburst = tvb_get_ntohl(tvb, offset);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_tspec_outburst,
+				tvb, offset, 4, tspec->outburst);
+		offset += 4;
+		break;
+	default:
+		break;
+	}
+
+	return (offset - start);
+}
+
+static void
+dissect_xtp_data(tvbuff_t *tvb, proto_tree *tree, guint32 offset, gboolean have_btag) {
+	guint32     len = tvb_reported_length_remaining(tvb, offset);
+	proto_tree *xtp_subtree;
+	guint64     btag;
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len, ett_xtp_data, NULL, "Data Segment");
+
+	if (have_btag) {
+		btag = tvb_get_ntohl(tvb, offset);
+		btag <<= 32;
+		btag += tvb_get_ntohl(tvb, offset+4);
+		proto_tree_add_uint64(xtp_subtree, hf_xtp_btag, tvb, offset, 8, btag);
+		offset += 8;
+		len -= 8;
+	}
+
+	proto_tree_add_item(xtp_subtree, hf_xtp_data, tvb, offset, len, ENC_NA);
+
+	return;
+}
+
+static void
+dissect_xtp_cntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+		guint32 offset) {
+	guint32          len   = tvb_reported_length_remaining(tvb, offset);
+	guint32          start = offset;
+	proto_item      *top_ti;
+	proto_tree      *xtp_subtree;
+	struct xtp_cntl  cntl[1];
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len,
+				ett_xtp_cntl, &top_ti, "Common Control Segment");
+
+	if (len != XTP_CNTL_PKT_LEN) {
+		proto_item_append_text(top_ti, ", bogus length(%u, must be %u)",
+			len, XTP_CNTL_PKT_LEN);
+		return;
+	}
+
+	/** parse **/
+	/* rseq(8) */
+	cntl->rseq = tvb_get_ntohl(tvb, offset);
+	cntl->rseq <<= 32;
+	cntl->rseq += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* alloc(8) */
+	cntl->alloc = tvb_get_ntohl(tvb, offset);
+	cntl->alloc <<= 32;
+	cntl->alloc += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* echo(4) */
+	cntl->echo = tvb_get_ntohl(tvb, offset);
+
+	/** add summary **/
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+			" Recv-Seq=%" PRIu64, cntl->rseq);
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+			" Alloc=%" PRIu64, cntl->alloc);
+
+	proto_item_append_text(top_ti,
+			", Recv-Seq: %" PRIu64, cntl->rseq);
+
+	/** display **/
+	offset = start;
+	/* rseq(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_cntl_rseq,
+			tvb, offset, 8, cntl->rseq);
+	offset += 8;
+	/* alloc(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_cntl_alloc,
+			tvb, offset, 8, cntl->alloc);
+	offset += 4;
+	/* echo(4) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_cntl_echo,
+			tvb, offset, 4, cntl->echo);
+
+	return;
+}
+
+static void
+dissect_xtp_first(tvbuff_t *tvb, proto_tree *tree, guint32 offset) {
+
+	if (!dissect_xtp_aseg(tvb, tree, offset))
+		return;
+
+	offset += XTP_IP_ADDR_SEG_LEN;
+	dissect_xtp_tspec(tvb, tree, offset);
+
+	return;
+}
+
+#define XTP_MAX_NSPANS 10000 /* Arbitrary. (Documentation link is dead.) */
+static void
+dissect_xtp_ecntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+		guint32 offset) {
+	guint32           len   = tvb_reported_length_remaining(tvb, offset);
+	guint32           start = offset;
+	proto_item       *top_ti;
+	proto_tree       *xtp_subtree;
+	struct xtp_ecntl  ecntl[1];
+	guint             spans_len;
+	guint             i;
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len,
+				ett_xtp_ecntl, &top_ti, "Error Control Segment");
+
+	if (len < MIN_XTP_ECNTL_PKT_LEN) {
+		proto_item_append_text(top_ti,
+				", bogus length (%u, must be at least %u)",
+				len, MIN_XTP_ECNTL_PKT_LEN);
+		return;
+	}
+
+	/** parse **/
+	/* rseq(8) */
+	ecntl->rseq = tvb_get_ntohl(tvb, offset);
+	ecntl->rseq <<= 32;
+	ecntl->rseq += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* alloc(8) */
+	ecntl->alloc = tvb_get_ntohl(tvb, offset);
+	ecntl->alloc <<= 32;
+	ecntl->alloc += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* echo(4) */
+	ecntl->echo = tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	/* nspan(4) */
+	ecntl->nspan = tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	len = len + XTP_HEADER_LEN - offset;
+	spans_len = 16 * ecntl->nspan;
+
+	if (len != spans_len) {
+		expert_add_info_format(pinfo, top_ti, &ei_xtp_spans_bad, "Number of spans (%u) incorrect. Should be %u.", ecntl->nspan, len);
+		return;
+	}
+
+	if (ecntl->nspan > XTP_MAX_NSPANS) {
+		expert_add_info_format(pinfo, top_ti, &ei_xtp_spans_bad, "Too many spans: %u", ecntl->nspan);
+		return;
+	}
+
+	/** add summary **/
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+				" Recv-Seq=%" PRIu64, ecntl->rseq);
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+				" Alloc=%" PRIu64, ecntl->alloc);
+
+	proto_item_append_text(top_ti,
+				", Recv-Seq: %" PRIu64, ecntl->rseq);
+
+	/** display **/
+	offset = start;
+	/* rseq(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_ecntl_rseq,
+				tvb, offset, 8, ecntl->rseq);
+	offset += 8;
+	/* alloc(8) */
+	proto_tree_add_uint64(xtp_subtree, hf_xtp_ecntl_alloc,
+				tvb, offset, 8, ecntl->alloc);
+	offset += 8;
+	/* echo(4) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_ecntl_echo,
+				tvb, offset, 4, ecntl->echo);
+	offset += 4;
+	/* nspan(4) */
+	proto_tree_add_uint(xtp_subtree, hf_xtp_ecntl_nspan,
+				tvb, offset, 4, ecntl->nspan);
+	offset += 4;
+	/* spans(16n) */
+	for (i = 0; i < ecntl->nspan; i++) {
+		proto_tree_add_item(xtp_subtree, hf_xtp_ecntl_span_left,
+				tvb, offset, 8, ENC_LITTLE_ENDIAN);
+		offset += 8;
+		proto_tree_add_item(xtp_subtree, hf_xtp_ecntl_span_right,
+				tvb, offset, 8, ENC_LITTLE_ENDIAN);
+		offset += 8;
+	}
+
+	return;
+}
+
+static void
+dissect_xtp_tcntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+		guint32 offset) {
+
+	if (!dissect_xtp_traffic_cntl(tvb, pinfo, tree, offset))
+		return;
+
+	offset += XTP_TRAFFIC_CNTL_LEN;
+	dissect_xtp_tspec(tvb, tree, offset);
+
+	return;
+}
+
+static void
+dissect_xtp_jcntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+		guint32 offset) {
+
+	if (!dissect_xtp_traffic_cntl(tvb, pinfo, tree, offset))
+		return;
+
+	offset += XTP_TRAFFIC_CNTL_LEN;
+	if (!dissect_xtp_aseg(tvb, tree, offset))
+		return;
+
+	offset += XTP_IP_ADDR_SEG_LEN;
+	dissect_xtp_tspec(tvb, tree, offset);
+
+	return;
+}
+
+static void
+dissect_xtp_diag(tvbuff_t *tvb, proto_tree *tree, guint32 offset) {
+	guint32          len   = tvb_reported_length_remaining(tvb, offset);
+	proto_item      *ti;
+	proto_tree      *xtp_subtree;
+
+	xtp_subtree = proto_tree_add_subtree(tree, tvb, offset, len, ett_xtp_diag, &ti, "Diagnostic Segment");
+
+	if (len < XTP_DIAG_PKT_HEADER_LEN) {
+		proto_item_append_text(ti,
+				", bogus length (%u, must be at least %u)",
+				len, XTP_DIAG_PKT_HEADER_LEN);
+		return;
+	}
+
+	/* code(4) */
+	proto_tree_add_item(xtp_subtree, hf_xtp_diag_code,
+			tvb, offset, 4, ENC_BIG_ENDIAN);
+	offset += 4;
+	/* val(4) */
+	proto_tree_add_item(xtp_subtree, hf_xtp_diag_val,
+			tvb, offset, 4, ENC_BIG_ENDIAN);
+	offset += 4;
+	/* message(n) */
+	proto_tree_add_item(xtp_subtree, hf_xtp_diag_msg,
+			tvb, offset, tvb_reported_length_remaining(tvb, offset), ENC_ASCII);
+
+	return;
+}
+
+/* main dissector */
+static int
+dissect_xtp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) {
+	guint32        offset, len;
+	proto_item    *ti;
+	proto_tree    *xtp_tree, *xtp_cmd_tree, *xtp_subtree;
+	struct xtphdr  xtph[1];
+	int            error      = 0;
+	gchar         *options;
+	static const char *fstr[] = { "<None>", "NOCHECK", "EDGE", "NOERR", "MULTI", "RES",
+				      "SORT", "NOFLOW", "FASTNAK", "SREQ", "DREQ",
+				      "RCLOSE", "WCLOSE", "EOM", "END", "BTAG" };
+	gint           fpos       = 0, returned_length;
+	guint          i, bpos;
+	guint          cmd_options;
+	vec_t          cksum_vec[1];
+	gboolean       have_btag;
+	static int * const cmd_options_flags[] = {
+		&hf_xtp_cmd_options_nocheck,
+		&hf_xtp_cmd_options_edge,
+		&hf_xtp_cmd_options_noerr,
+		&hf_xtp_cmd_options_multi,
+		&hf_xtp_cmd_options_res,
+		&hf_xtp_cmd_options_sort,
+		&hf_xtp_cmd_options_noflow,
+		&hf_xtp_cmd_options_fastnak,
+		&hf_xtp_cmd_options_sreq,
+		&hf_xtp_cmd_options_dreq,
+		&hf_xtp_cmd_options_rclose,
+		&hf_xtp_cmd_options_wclose,
+		&hf_xtp_cmd_options_eom,
+		&hf_xtp_cmd_options_end,
+		&hf_xtp_cmd_options_btag,
+		NULL
+	};
+
+	if ((len = tvb_reported_length(tvb)) < XTP_HEADER_LEN)
+		return 0;
+
+	col_set_str(pinfo->cinfo, COL_PROTOCOL, "XTP");
+	col_clear(pinfo->cinfo, COL_INFO);
+
+	/** parse header **/
+	offset = 0;
+	/* key(8) */
+	xtph->key		= tvb_get_ntohl(tvb, offset);
+	xtph->key <<= 32;
+	xtph->key += tvb_get_ntohl(tvb, offset+4);
+	offset += 8;
+	/* cmd(4) */
+	xtph->cmd		= tvb_get_ntohl(tvb, offset);
+	xtph->cmd_options	= xtph->cmd >> 8;
+	xtph->cmd_ptype		= xtph->cmd & 0xff;
+	xtph->cmd_ptype_ver	= (xtph->cmd_ptype & 0xe0) >> 5;
+	xtph->cmd_ptype_pformat	= xtph->cmd_ptype & 0x1f;
+	offset += 4;
+	/* dlen(4) */
+	xtph->dlen		= tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	/* check(2) */
+	xtph->check		= tvb_get_ntohs(tvb, offset);
+	offset += 2;
+	/* sort(2) */
+	xtph->sort		= tvb_get_ntohs(tvb, offset);
+	offset += 2;
+	/* sync(4) */
+	xtph->sync		= tvb_get_ntohl(tvb, offset);
+	offset += 4;
+	/* seq(8) */
+	xtph->seq		= tvb_get_ntohl(tvb, offset);
+	xtph->seq <<= 32;
+	xtph->seq += tvb_get_ntohl(tvb, offset+4);
+
+#define MAX_OPTIONS_LEN	128
+	options=(gchar *)wmem_alloc(pinfo->pool, MAX_OPTIONS_LEN);
+	options[0]=0;
+	cmd_options = xtph->cmd_options >> 8;
+	for (i = 0; i < 16; i++) {
+		bpos = 1 << (15 - i);
+		if (cmd_options & bpos) {
+			returned_length = snprintf(&options[fpos],
+			MAX_OPTIONS_LEN-fpos, "%s%s",
+			fpos?", ":"",
+			fstr[i]);
+			fpos += MIN(returned_length, MAX_OPTIONS_LEN-fpos);
+		}
+	}
+
+	col_add_str(pinfo->cinfo, COL_INFO,
+			    val_to_str(xtph->cmd_ptype_pformat,
+					pformat_vals, "Unknown pformat (%u)"));
+	col_append_fstr(pinfo->cinfo, COL_INFO, " [%s]", options);
+	col_append_fstr(pinfo->cinfo, COL_INFO,
+				" Seq=%" PRIu64, xtph->seq);
+	col_append_fstr(pinfo->cinfo, COL_INFO, " Len=%u", xtph->dlen);
+
+	/* if (tree) */ {
+		ti = proto_tree_add_item(tree, proto_xtp, tvb, 0, -1, ENC_NA);
+		/** add summary **/
+		proto_item_append_text(ti,
+				", Key: 0x%016" PRIX64, xtph->key);
+		proto_item_append_text(ti,
+				", Seq: %" PRIu64, xtph->seq);
+		proto_item_append_text(ti, ", Len: %u", xtph->dlen);
+
+		xtp_tree = proto_item_add_subtree(ti, ett_xtp);
+		/* key(8) */
+		offset = 0;
+		proto_tree_add_uint64(xtp_tree, hf_xtp_key,
+					tvb, offset, 8, xtph->key);
+		offset += 8;
+		/* cmd(4) */
+		ti = proto_tree_add_uint(xtp_tree, hf_xtp_cmd,
+					tvb, offset, 4, xtph->cmd);
+		xtp_cmd_tree = proto_item_add_subtree(ti, ett_xtp_cmd);
+		proto_tree_add_bitmask(xtp_cmd_tree, tvb, offset, hf_xtp_cmd_options, ett_xtp_cmd_options, cmd_options_flags, ENC_BIG_ENDIAN);
+		offset += 3;
+
+		ti = proto_tree_add_uint(xtp_cmd_tree, hf_xtp_cmd_ptype,
+					tvb, offset, 1, xtph->cmd_ptype);
+		xtp_subtree = proto_item_add_subtree(ti, ett_xtp_cmd_ptype);
+		proto_tree_add_uint(xtp_subtree, hf_xtp_cmd_ptype_ver,
+					tvb, offset, 1, xtph->cmd_ptype_ver);
+		if (xtph->cmd_ptype_ver != XTP_VERSION_4) {
+			proto_item_append_text(ti,
+				", Unknown XTP version (%03X)", xtph->cmd_ptype_ver);
+			error = 1;
+		}
+		proto_tree_add_uint(xtp_subtree, hf_xtp_cmd_ptype_pformat,
+				tvb, offset, 1, xtph->cmd_ptype_pformat);
+		offset++;
+		/* dlen(4) */
+		ti = proto_tree_add_uint(xtp_tree, hf_xtp_dlen,
+				tvb, offset, 4, xtph->dlen);
+		if (xtph->dlen != len - XTP_HEADER_LEN) {
+			proto_item_append_text(ti, ", bogus length (%u, must be %u)",
+				xtph->dlen, len - XTP_HEADER_LEN);
+			error = 1;
+		}
+		offset += 4;
+		/* check(2) */
+		if (!pinfo->fragmented) {
+			guint32 check_len = XTP_HEADER_LEN;
+			if (!(xtph->cmd_options & XTP_CMD_OPTIONS_NOCHECK))
+				check_len += xtph->dlen;
+			SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, check_len);
+			proto_tree_add_checksum(xtp_tree, tvb, offset, hf_xtp_checksum, hf_xtp_checksum_status, &ei_xtp_checksum,
+									pinfo, in_cksum(cksum_vec, 1), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
+		}
+		else {
+			proto_tree_add_checksum(xtp_tree, tvb, offset, hf_xtp_checksum, hf_xtp_checksum_status, &ei_xtp_checksum,
+									pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
+		}
+		offset += 2;
+		/* sort(2) */
+		proto_tree_add_uint(xtp_tree, hf_xtp_sort, tvb, offset, 2, xtph->sort);
+		offset += 2;
+		/* sync(4) */
+		proto_tree_add_uint(xtp_tree, hf_xtp_sync, tvb, offset, 4, xtph->sync);
+		offset += 4;
+		/* seq(8) */
+		proto_tree_add_uint64(xtp_tree, hf_xtp_seq, tvb, offset, 8, xtph->seq);
+		offset += 8;
+
+		if (!error) {
+			switch (xtph->cmd_ptype_pformat) {
+			case XTP_DATA_PKT:
+				have_btag = !!(xtph->cmd_options & XTP_CMD_OPTIONS_BTAG);
+				dissect_xtp_data(tvb, xtp_tree, offset, have_btag);
+				break;
+			case XTP_CNTL_PKT:
+				dissect_xtp_cntl(tvb, pinfo, xtp_tree, offset);
+				break;
+			case XTP_FIRST_PKT:
+				dissect_xtp_first(tvb, xtp_tree, offset);
+				break;
+			case XTP_ECNTL_PKT:
+				dissect_xtp_ecntl(tvb, pinfo, xtp_tree, offset);
+				break;
+			case XTP_TCNTL_PKT:
+				dissect_xtp_tcntl(tvb, pinfo, xtp_tree, offset);
+				break;
+			case XTP_JOIN_PKT:
+				/* obsolete */
+				break;
+			case XTP_JCNTL_PKT:
+				dissect_xtp_jcntl(tvb, pinfo, xtp_tree, offset);
+				break;
+			case XTP_DIAG_PKT:
+				dissect_xtp_diag(tvb, xtp_tree, offset);
+				break;
+			default:
+				/* error */
+				break;
+			}
+		}
+	}
+
+	return tvb_reported_length(tvb);
+}
+
+void
+proto_register_xtp(void)
+{
+	static hf_register_info hf[] = {
+		/* command header */
+		{ &hf_xtp_key,
+		  { "Key",           "xtp.key",
+		    FT_UINT64, BASE_HEX, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_xtp_cmd,
+		  { "Command", "xtp.cmd",
+		    FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options,
+		  { "Options", "xtp.cmd.options",
+		    FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_nocheck,
+		  { "NOCHECK", "xtp.cmd.options.nocheck",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_NOCHECK, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_edge,
+		  { "EDGE", "xtp.cmd.options.edge",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_EDGE, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_noerr,
+		  { "NOERR", "xtp.cmd.options.noerr",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_NOERR, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_multi,
+		  { "MULTI", "xtp.cmd.options.multi",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_MULTI, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_res,
+		  { "RES", "xtp.cmd.options.res",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_RES, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_sort,
+		  { "SORT", "xtp.cmd.options.sort",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_SORT, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_noflow,
+		  { "NOFLOW", "xtp.cmd.options.noflow",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_NOFLOW, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_fastnak,
+		  { "FASTNAK", "xtp.cmd.options.fastnak",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_FASTNAK, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_sreq,
+		  { "SREQ", "xtp.cmd.options.sreq",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_SREQ, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_dreq,
+		  { "DREQ", "xtp.cmd.options.dreq",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_DREQ, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_rclose,
+		  { "RCLOSE", "xtp.cmd.options.rclose",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_RCLOSE, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_wclose,
+		  { "WCLOSE", "xtp.cmd.options.wclose",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_WCLOSE, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_eom,
+		  { "EOM", "xtp.cmd.options.eom",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_EOM, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_end,
+		  { "END", "xtp.cmd.options.end",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_END, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_options_btag,
+		  { "BTAG", "xtp.cmd.options.btag",
+		    FT_BOOLEAN, 24, TFS(&tfs_set_notset),
+		    XTP_CMD_OPTIONS_BTAG, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_ptype,
+		  { "Packet type", "xtp.cmd.ptype",
+		    FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_ptype_ver,
+		  { "Version", "xtp.cmd.ptype.ver",
+		    FT_UINT8, BASE_DEC, VALS(version_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cmd_ptype_pformat,
+		  { "Format", "xtp.cmd.ptype.pformat",
+		    FT_UINT8, BASE_DEC, VALS(pformat_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_dlen,
+		  { "Data length", "xtp.dlen",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_sort,
+		  { "Sort", "xtp.sort",
+		    FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_sync,
+		  { "Synchronizing handshake", "xtp.sync",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_seq,
+		  { "Sequence number", "xtp.seq",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		/* control segment */
+		{ &hf_xtp_cntl_rseq,
+		  { "Received sequence number", "xtp.cntl.rseq",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cntl_alloc,
+		  { "Allocation", "xtp.cntl.alloc",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_cntl_echo,
+		  { "Synchronizing handshake echo", "xtp.cntl.echo",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_rseq,
+		  { "Received sequence number", "xtp.ecntl.rseq",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_alloc,
+		  { "Allocation", "xtp.ecntl.alloc",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_echo,
+		  { "Synchronizing handshake echo", "xtp.ecntl.echo",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_nspan,
+		  { "Number of spans", "xtp.ecntl.nspan",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_span_left,
+		  { "Span left edge", "xtp.ecntl.span_le",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_ecntl_span_right,
+		  { "Span right edge", "xtp.ecntl.span_re",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tcntl_rseq,
+		  { "Received sequence number", "xtp.tcntl.rseq",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tcntl_alloc,
+		  { "Allocation", "xtp.tcntl.alloc",
+		    FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tcntl_echo,
+		  { "Synchronizing handshake echo", "xtp.tcntl.echo",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tcntl_rsvd,
+		  { "Reserved", "xtp.tcntl.rsvd",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tcntl_xkey,
+		  { "Exchange key", "xtp.tcntl.xkey",
+		    FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		/* traffic specifier */
+		{ &hf_xtp_tspec_tlen,
+		  { "Length", "xtp.tspec.tlen",
+		    FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_service,
+		  { "Service", "xtp.tspec.service",
+		    FT_UINT8, BASE_DEC, VALS(service_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_tformat,
+		  { "Format", "xtp.tspec.format",
+		    FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_traffic,
+		  { "Traffic", "xtp.tspec.traffic",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_maxdata,
+		  { "Maxdata", "xtp.tspec.maxdata",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_inrate,
+		  { "Incoming rate", "xtp.tspec.inrate",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_inburst,
+		  { "Incoming burst size", "xtp.tspec.inburst",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_outrate,
+		  { "Outgoing rate", "xtp.tspec.outrate",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_tspec_outburst,
+		  { "Outgoing burst size", "xtp.tspec.outburst",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		/* address segment */
+		{ &hf_xtp_aseg_alen,
+		  { "Length", "xtp.aseg.alen",
+		    FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_adomain,
+		  { "Domain", "xtp.aseg.adomain",
+		    FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_aformat,
+		  { "Format", "xtp.aseg.aformat",
+		    FT_UINT8, BASE_DEC, VALS(aformat_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_address,
+		  { "Traffic", "xtp.aseg.address",
+		    FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_dsthost,
+		  { "Destination host", "xtp.aseg.dsthost",
+		    FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_srchost,
+		  { "Source host", "xtp.aseg.srchost",
+		    FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_dstport,
+		  { "Destination port", "xtp.aseg.dstport",
+		    FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_aseg_srcport,
+		  { "Source port", "xtp.aseg.srcport",
+		    FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
+		},
+		/* others */
+		{ &hf_xtp_btag,
+		  { "Beginning tag", "xtp.data.btag",
+		    FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_diag_code,
+		  { "Diagnostic code", "xtp.diag.code",
+		    FT_UINT32, BASE_DEC, VALS(diag_code_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_diag_val,
+		  { "Diagnostic value", "xtp.diag.val",
+		    FT_UINT32, BASE_DEC, VALS(diag_val_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_diag_msg,
+		  { "Message", "xtp.diag.msg",
+		    FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_checksum,
+		  { "Checksum", "xtp.checksum",
+		    FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_checksum_status,
+		  { "Checksum Status", "xtp.checksum.status",
+		    FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL }
+		},
+		{ &hf_xtp_data,
+		  { "Data", "xtp.data",
+		    FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
+		},
+	};
+
+	static gint *ett[] = {
+		&ett_xtp,
+		&ett_xtp_cmd,
+		&ett_xtp_cmd_options,
+		&ett_xtp_cmd_ptype,
+		&ett_xtp_cntl,
+		&ett_xtp_ecntl,
+		&ett_xtp_tcntl,
+		&ett_xtp_tspec,
+		&ett_xtp_jcntl,
+		&ett_xtp_first,
+		&ett_xtp_aseg,
+		&ett_xtp_data,
+		&ett_xtp_diag,
+	};
+
+	static ei_register_info ei[] = {
+		{ &ei_xtp_spans_bad,
+		  { "xtp.spans_bad", PI_MALFORMED, PI_ERROR, "Number of spans incorrect", EXPFILL }},
+		{ &ei_xtp_checksum,
+		  { "xtp.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
+	};
+
+	expert_module_t* expert_xtp;
+
+	proto_xtp = proto_register_protocol("Xpress Transport Protocol", "XTP", "xtp");
+	proto_register_field_array(proto_xtp, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+
+	expert_xtp = expert_register_protocol(proto_xtp);
+	expert_register_field_array(expert_xtp, ei, array_length(ei));
+
+	xtp_handle = register_dissector("xtp", dissect_xtp, proto_xtp);
+}
+
+void
+proto_reg_handoff_xtp(void)
+{
+	dissector_add_uint("ip.proto", IP_PROTO_XTP, xtp_handle);
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */