/* packet-tcpros.c
 * Routines for Robot Operating System TCP protocol (TCPROS)
 * Copyright 2015, Guillaume Autran  (see AUTHORS file)
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"

#include <epan/packet.h>
#include <epan/etypes.h>
#include <epan/prefs.h>

#include "packet-tcp.h"


#define SIZE_OF_LENGTH_FIELD 4
#define SIZE_OF_LENGTH_STAMP (4 + 4)

void proto_register_tcpros(void);
void proto_reg_handoff_tcpros(void);


static int proto_tcpros;
static dissector_handle_t tcpros_handle;

/** desegmentation of TCPROS over TCP */
static bool tcpros_desegment = true;


static int hf_tcpros_connection_header;
static int hf_tcpros_connection_header_length;
static int hf_tcpros_connection_header_content;
static int hf_tcpros_connection_header_field;
static int hf_tcpros_connection_header_field_length;
static int hf_tcpros_connection_header_field_data;
static int hf_tcpros_connection_header_field_name;
static int hf_tcpros_connection_header_field_value;
static int hf_tcpros_clock;
static int hf_tcpros_clock_length;
static int hf_tcpros_message;
static int hf_tcpros_message_length;
static int hf_tcpros_message_body;
static int hf_tcpros_message_header;
static int hf_tcpros_message_header_seq;
static int hf_tcpros_message_header_stamp;
static int hf_tcpros_message_header_stamp_sec;
static int hf_tcpros_message_header_stamp_nsec;
static int hf_tcpros_message_header_frame;
static int hf_tcpros_message_header_frame_length;
static int hf_tcpros_message_header_frame_value;
static int hf_tcpros_message_payload;

static int ett_tcpros;

/**
 * This is the ROS connection header dissector. The general packet format is described
 * here: http://wiki.ros.org/ROS/TCPROS
 * In short, a connection header looks like such: '4-byte length + [4-byte field length + "field=value" ]*'
 */
static unsigned
dissect_ros_connection_header_field(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *field_tree;

	uint32_t fLen = 0;
	unsigned   sep, ret = 0;

	/** Do we have enough for a length field? (ie: 4 bytes) */
	if( tvb_reported_length_remaining(tvb, offset) > SIZE_OF_LENGTH_FIELD ) {
		/** Get the length of the next field */
		fLen = tvb_get_letohl(tvb, offset);

		/** Display the field as a utf-8 string */
		ti = proto_tree_add_item(tree, hf_tcpros_connection_header_field, tvb, offset, SIZE_OF_LENGTH_FIELD, ENC_UTF_8|ENC_LITTLE_ENDIAN);
		field_tree = proto_item_add_subtree(ti, ett_tcpros);


		proto_tree_add_item(field_tree, hf_tcpros_connection_header_field_length, tvb, offset, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
		offset += SIZE_OF_LENGTH_FIELD;
		ti = proto_tree_add_item(field_tree, hf_tcpros_connection_header_field_data, tvb, offset, fLen, ENC_UTF_8);

		/** Look for the '=' separator */
		bool sep_found = tvb_find_uint8_length(tvb, offset, fLen, '=', &sep);
		sep = sep - offset;

		/** If we find a separator, then split field name and value */
		if((sep_found == false) ||( sep > 0 )) {
			const char* field;
			field_tree = proto_item_add_subtree(ti, ett_tcpros);
			proto_tree_add_item_ret_string(field_tree, hf_tcpros_connection_header_field_name, tvb, offset, sep, ENC_UTF_8|ENC_NA, pinfo->pool, (const uint8_t**)&field);
			proto_tree_add_item(field_tree, hf_tcpros_connection_header_field_value, tvb, offset+sep+1, fLen - sep - 1, ENC_UTF_8);

			col_append_str(pinfo->cinfo, COL_INFO, field);
		}
		ret = fLen + SIZE_OF_LENGTH_FIELD;
	}

	return ret;
}

static unsigned
dissect_ros_connection_header(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *sub_tree;

	unsigned consumed_len = 0;
	uint32_t header_len = tvb_get_letohl(tvb, offset);

	col_append_str(pinfo->cinfo, COL_INFO, "[ROS Conn] Metadata: [");

	/** We got a connection header */
	ti = proto_tree_add_item(root_tree, hf_tcpros_connection_header, tvb, offset, SIZE_OF_LENGTH_FIELD, ENC_NA|ENC_LITTLE_ENDIAN);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	proto_tree_add_item(sub_tree, hf_tcpros_connection_header_length, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	ti = proto_tree_add_item(sub_tree, hf_tcpros_connection_header_content, tvb, offset + consumed_len, header_len, ENC_NA);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	header_len += SIZE_OF_LENGTH_FIELD;

	while( consumed_len < header_len ) {
		unsigned len = dissect_ros_connection_header_field(tvb, sub_tree, pinfo, offset + consumed_len);
		consumed_len += len;
		if( len == 0 ) {
			break;
		}
		if( consumed_len < header_len ) {
			col_append_str(pinfo->cinfo, COL_INFO, ",");
		}
	}
	col_append_str(pinfo->cinfo, COL_INFO, "]");

	return consumed_len;
}


static unsigned
dissect_ros_message_header_stamp(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *sub_tree;

	unsigned consumed_len = 0;
	uint32_t sec, nsec;

	ti = proto_tree_add_item(root_tree, hf_tcpros_message_header_stamp, tvb, offset + consumed_len, SIZE_OF_LENGTH_STAMP, ENC_LITTLE_ENDIAN);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	/** Seconds */
	proto_tree_add_item_ret_uint(sub_tree, hf_tcpros_message_header_stamp_sec, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN, &sec);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	/** Nano seconds */
	proto_tree_add_item_ret_uint(sub_tree, hf_tcpros_message_header_stamp_nsec, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN, &nsec);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	/** Info */
	col_append_fstr(pinfo->cinfo, COL_INFO, "Timestamp: %d.%09d ", sec, nsec);

	return consumed_len;
}

static unsigned
dissect_ros_clock(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *sub_tree;

	unsigned consumed_len = 0;

	col_append_str(pinfo->cinfo, COL_INFO, "[ROS Clock] ");

	/** We got a ROS Clock msg */
	ti = proto_tree_add_item(root_tree, hf_tcpros_clock, tvb, offset, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	proto_tree_add_item(sub_tree, hf_tcpros_clock_length, tvb, offset, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	consumed_len += dissect_ros_message_header_stamp(tvb, sub_tree, pinfo, offset + consumed_len);

	return consumed_len;
}

static unsigned
dissect_ros_message_header(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *sub_tree;

	unsigned consumed_len = 0;
	uint32_t frame_id_len;
	uint32_t seq;
	unsigned header_len;
	const uint8_t* frame_str;

	frame_id_len = tvb_get_letohl(tvb, offset + consumed_len + SIZE_OF_LENGTH_FIELD + SIZE_OF_LENGTH_STAMP);
	header_len = SIZE_OF_LENGTH_FIELD + SIZE_OF_LENGTH_STAMP + SIZE_OF_LENGTH_FIELD + frame_id_len;

	/** Header */
	ti = proto_tree_add_item(root_tree, hf_tcpros_message_header, tvb, offset + consumed_len, header_len, ENC_NA);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	/** Sequence number */
	proto_tree_add_item_ret_uint(sub_tree, hf_tcpros_message_header_seq, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN, &seq);
	consumed_len += SIZE_OF_LENGTH_FIELD;
	col_append_fstr(pinfo->cinfo, COL_INFO, "Seq: %d ", seq);

	/** Timestamp */
	consumed_len += dissect_ros_message_header_stamp(tvb, sub_tree, pinfo, offset + consumed_len);

	/** Frame ID */
	ti = proto_tree_add_item(sub_tree, hf_tcpros_message_header_frame, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_UTF_8|ENC_LITTLE_ENDIAN);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	proto_tree_add_item(sub_tree, hf_tcpros_message_header_frame_length, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	proto_tree_add_item_ret_string(sub_tree, hf_tcpros_message_header_frame_value, tvb, offset + consumed_len, frame_id_len, ENC_UTF_8|ENC_NA, pinfo->pool, &frame_str);
	col_append_fstr(pinfo->cinfo, COL_INFO, "Frame ID: '%s' ", frame_str);
	consumed_len += frame_id_len;

	return consumed_len;
}


/**
 * This is the ROS message dissector. A ROS message contains two parts: a msg header; a msg payload.
 * Because the packet is all in binary format, we don't really know the payload format (we don't know the payload type either).
 * However, every packet has the same header as defined here: http://docs.ros.org/api/std_msgs/html/msg/Header.html
 * So, we can break this one down and display it.
 */
static unsigned
dissect_ros_message(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, unsigned offset)
{
	proto_item *ti;
	proto_tree *sub_tree;

	unsigned consumed_len = 0;
	uint32_t total_len = tvb_get_letohl(tvb, offset);
	unsigned payload_len;

	col_append_str(pinfo->cinfo, COL_INFO, "[ROS Msg] ");

	/** We got a ROS msg */
	ti = proto_tree_add_item(root_tree, hf_tcpros_message, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_NA | ENC_LITTLE_ENDIAN);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	proto_tree_add_item(sub_tree, hf_tcpros_message_length, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN);
	consumed_len += SIZE_OF_LENGTH_FIELD;

	/** Body */
	ti = proto_tree_add_item(sub_tree, hf_tcpros_message_body, tvb, offset + consumed_len, total_len, ENC_NA);
	sub_tree = proto_item_add_subtree(ti, ett_tcpros);

	/** Body.Header */
	consumed_len += dissect_ros_message_header(tvb, sub_tree, pinfo, offset + consumed_len);

	/** Body.Payload */
	payload_len = (total_len + SIZE_OF_LENGTH_FIELD) - consumed_len;
	proto_tree_add_item(sub_tree, hf_tcpros_message_payload, tvb, offset + consumed_len, payload_len, ENC_NA);
	consumed_len += payload_len;


	return consumed_len;
}


/**
 * This is the poor man's way to differentiate between a connection header packet and a message packet.
 */
static bool
is_connection_header(tvbuff_t *tvb, packet_info *pinfo _U_ , unsigned offset)
{
	bool is_con_header = false;
	uint32_t len1 = tvb_get_letohl(tvb, offset);
	uint32_t len2 = tvb_get_letohl(tvb, offset + SIZE_OF_LENGTH_FIELD);


	if( len1 > len2 ) {
		is_con_header = true;
	}


	return is_con_header;
}

static bool
is_rosheaderfield(tvbuff_t *tvb, packet_info *pinfo _U_ , unsigned offset)
{
	/** ROS Header Field:
	    4-byte len + string */
	unsigned available = tvb_reported_length_remaining(tvb, offset);
	uint32_t string_len = 0;
	uint32_t i;

	if( available < 4 )
		return false;

	string_len = tvb_get_letohl(tvb, offset);

	/** If we don't have enough data for the whole string, assume its not */
	if( available < (string_len + 4) )
		return false;
	/** Check for a valid ascii character and not nil */
	for( i = 0; i < string_len; i++ ) {
		int8_t ch = tvb_get_uint8(tvb, offset + 4 + i);
		if( !g_ascii_isalnum(ch) || 0x00 == ch )
			return false;
	}

	/** Assume it is */
	return true;
}

static bool
is_rosconnection_header(tvbuff_t *tvb, packet_info *pinfo _U_ , unsigned offset)
{
	/** ROS Connection Headers: http://wiki.ros.org/ROS/Connection%20Header
	    4-byte length + [4-byte length + string] */
	unsigned available = tvb_reported_length_remaining(tvb, offset);
	uint32_t msg_len = 0;

	if( available < 8+1 )
		return false;

	msg_len = tvb_get_letohl(tvb, offset);
	if( msg_len < 4+1 )
		return false;

	/** Check first header field */
	if( !is_rosheaderfield(tvb, pinfo, offset + 4) )
		return false;


	return true;
}

static bool
is_rosclock(tvbuff_t *tvb, packet_info *pinfo _U_ , unsigned offset)
{
	/** ROS Clock message: http://docs.ros.org/api/rosgraph_msgs/html/msg/Clock.html
	    4-byte length + 8-byte timestamp == 12 bytes exactly */
	unsigned available = tvb_reported_length_remaining(tvb, offset);
	if( available != 12 )
		return false;

	if( tvb_get_letohl(tvb, offset) != 8 )
		return false;

	/** This is highly likely a clock message. */
	return true;
}

static bool
is_rosmsg(tvbuff_t *tvb, packet_info *pinfo _U_ , unsigned offset)
{
	/** Most ROS messages start with a header: http://docs.ros.org/jade/api/std_msgs/html/msg/Header.html
	    4-byte size + 4-byte sequence id + 8-byte timestamp + 4-byte frame id length + frame id */
	unsigned available = tvb_reported_length_remaining(tvb, offset);
	uint32_t string_len = 0;
	uint32_t msg_len = 0;

	if( available < 20 )
		return false;

	msg_len = tvb_get_letohl(tvb, offset);
	if( msg_len < 16 )
		return false;

	/** Check to see if the frame id length is reasonable */
	string_len = tvb_get_letohl(tvb, offset + 4 + 4 + 8);
	if( string_len > (msg_len - (4 + 8 + 4)) )
		return false;

	/** If we don't have enough data for the whole string, assume its not */
	if( (unsigned)available < (string_len + 4) )
		return false;

	/** This is highly likely a ROS message. */
	return true;
}

static void
dissect_ros_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, bool is_tcp _U_ )
{
	proto_item *ti;
	proto_tree *root_tree;

	unsigned offset;


	/** Clear out stuff in the info column */
	col_clear(pinfo->cinfo, COL_INFO);

	ti = proto_tree_add_item(tree, proto_tcpros, tvb, 0, -1, ENC_NA);
	root_tree = proto_item_add_subtree(ti, ett_tcpros);

	offset = 0;

	while(offset < tvb_reported_length(tvb)) {
		int available = tvb_reported_length_remaining(tvb, offset);

		if( (available < SIZE_OF_LENGTH_FIELD) || ((unsigned)available < tvb_get_letohl(tvb, offset)) ) {
			/** we ran out of data: ask for more */
			pinfo->desegment_offset = offset;
			pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
			return;
		}
		/** There are two types of packet: Connection Headers and ROS Message. Which one is it? */
		if( is_rosclock(tvb, pinfo, offset) ) {
			/** This is a ROS Clock message. */
			offset += dissect_ros_clock(tvb, root_tree, pinfo, offset);
		} else if( is_rosmsg(tvb, pinfo, offset) ) {
			/** We have a ROS message. */
			offset += dissect_ros_message(tvb, root_tree, pinfo, offset);
		} else if( is_rosconnection_header(tvb, pinfo, offset) ) {
			/** Check for a connection header */
			offset += dissect_ros_connection_header(tvb, root_tree, pinfo, offset);
		} else if( is_connection_header(tvb, pinfo, offset) ) {
			/** We have a ROS connection header. */
			offset += dissect_ros_connection_header(tvb, root_tree, pinfo, offset);
		} else {
			/** We have a ROS message. */
			offset += dissect_ros_message(tvb, root_tree, pinfo, offset);
		}

	}
}


static unsigned
get_tcpros_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)
{
	uint32_t plen;

	/*
	 * Get the length of the TCPROS packet.
	 */
	plen = tvb_get_letohl(tvb, offset);

	/*
	 * That length doesn't include the length field itself; add that in.
	 */
	return plen + SIZE_OF_LENGTH_FIELD;
}


static int
dissect_tcpros_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	col_set_str(pinfo->cinfo, COL_PROTOCOL, "TCPROS");

	dissect_ros_common(tvb, pinfo, tree, true);
	return tvb_reported_length(tvb);
}

static int
dissect_tcpros(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
{
	tcp_dissect_pdus(tvb, pinfo, tree, tcpros_desegment, SIZE_OF_LENGTH_FIELD, get_tcpros_pdu_len,
			 dissect_tcpros_pdu, data);
	return tvb_reported_length(tvb);
}


void
proto_register_tcpros(void)
{
	static hf_register_info hf[] = {
		{ &hf_tcpros_connection_header,             { "ROS Connection", "tcpros.header",
							      FT_UINT_BYTES, BASE_NONE, NULL, 0,
							      "Message Header", HFILL } },
		{ &hf_tcpros_connection_header_length,      { "Header Length", "tcpros.header_length",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "Message Header Length", HFILL } },
		{ &hf_tcpros_connection_header_content,     { "Header Content", "tcpros.header_content",
							      FT_BYTES, BASE_NONE, NULL, 0,
							      "Message Header Content", HFILL } },

		{ &hf_tcpros_connection_header_field,       { "Field", "tcpros.header_field",
							      FT_UINT_STRING, BASE_NONE, NULL, 0,
							      "Message Header Field", HFILL } },
		{ &hf_tcpros_connection_header_field_length, { "Field Length", "tcpros.header_field_length",
							       FT_UINT32, BASE_DEC, NULL, 0,
							       "Message Header Field Length", HFILL } },
		{ &hf_tcpros_connection_header_field_data, { "Field Content", "tcpros.header_field_data",
							     FT_STRING, BASE_NONE, NULL, 0,
							     "Message Header Field Content", HFILL } },
		{ &hf_tcpros_connection_header_field_name,  { "Name", "tcpros.header_field_name",
							      FT_STRING, BASE_NONE, NULL, 0,
							      "Message Header Field Name", HFILL } },
		{ &hf_tcpros_connection_header_field_value, { "Value", "tcpros.header_field_value",
							      FT_STRING, BASE_NONE, NULL, 0,
							      "Message Header Field Value", HFILL } },

		{ &hf_tcpros_clock,                         { "ROS Clock", "tcpros.clock",
							      FT_UINT_BYTES, BASE_NONE, NULL, 0,
							      "ROS Clock Packet", HFILL } },
		{ &hf_tcpros_clock_length,                  { "Clock Length", "tcpros.clock.length",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Clock Packet length", HFILL } },

		{ &hf_tcpros_message,                       { "ROS Message", "tcpros.message",
							      FT_UINT_BYTES, BASE_NONE, NULL, 0,
							      "ROS Message Packet", HFILL } },
		{ &hf_tcpros_message_length,                { "Message Length", "tcpros.message.length",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Message Packet length", HFILL } },
		{ &hf_tcpros_message_body,                   { "Message Content", "tcpros.message.body",
							       FT_BYTES, BASE_NONE, NULL, 0,
							       "ROS Message Packet Body", HFILL } },

		{ &hf_tcpros_message_header,                { "Header", "tcpros.message.header",
							      FT_BYTES, BASE_NONE, NULL, 0,
							      "ROS Message Header", HFILL } },
		{ &hf_tcpros_message_header_seq,            { "Sequence ID", "tcpros.message.header.seq",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Message Header Sequence", HFILL } },
		{ &hf_tcpros_message_header_stamp,          { "Timestamp", "tcpros.message.header.stamp",
							      FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0,
							      "ROS Message Header Stamp", HFILL } },
		{ &hf_tcpros_message_header_stamp_sec,      { "Seconds", "tcpros.message.header.stamp.sec",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Message Header Stamp Sec", HFILL } },
		{ &hf_tcpros_message_header_stamp_nsec,     { "Nanoseconds", "tcpros.message.header.stamp.nsec",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Message Header Stamp NSec", HFILL } },

		{ &hf_tcpros_message_header_frame,          { "Frame ID", "tcpros.message.header.frame",
							      FT_UINT_STRING, BASE_NONE, NULL, 0,
							      "ROS Message Header Frame ID", HFILL } },
		{ &hf_tcpros_message_header_frame_length,   { "Length", "tcpros.message.header.frame.len",
							      FT_UINT32, BASE_DEC, NULL, 0,
							      "ROS Message Header Frame ID Length", HFILL } },
		{ &hf_tcpros_message_header_frame_value,     { "Value", "tcpros.message.header.frame.value",
							       FT_STRING, BASE_NONE, NULL, 0,
							       "ROS Message Header Frame ID Value", HFILL } },

		{ &hf_tcpros_message_payload,               { "Payload", "tcpros.message.payload",
							      FT_BYTES, BASE_NONE, NULL, 0,
							      "ROS Message Packet Payload", HFILL } },

	};

	static int *ett[] = {
		&ett_tcpros,
	};

	module_t *tcpros_module;

	proto_tcpros = proto_register_protocol("TCP based Robot Operating System protocol (TCPROS)", "TCPROS", "tcpros");

	proto_register_field_array(proto_tcpros, hf, array_length(hf));
	proto_register_subtree_array(ett, array_length(ett));

	tcpros_handle = register_dissector("tcpros", dissect_tcpros, proto_tcpros);

	tcpros_module = prefs_register_protocol(proto_tcpros, NULL);

	prefs_register_bool_preference(tcpros_module, "desegment_tcpros_messages",
				       "Reassemble TCPROS messages spanning multiple TCP segments",
				       "Whether the TCPROS dissector should reassemble messages spanning multiple TCP segments."
				       " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
				       &tcpros_desegment);


}

/* Heuristics test */
static bool
test_tcpros(packet_info *pinfo, tvbuff_t *tvb, unsigned offset, void *data _U_)
{
	if (tvb_captured_length(tvb) < 8)
		return false;

	if( is_rosclock(tvb, pinfo, offset) )
		return true;
	if( is_rosmsg(tvb, pinfo, offset) )
		return true;
	if( is_rosconnection_header(tvb, pinfo, offset) )
		return true;

	return false;
}

static bool
dissect_tcpros_heur_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{
	conversation_t *conversation;

	if (!test_tcpros(pinfo, tvb, 0, data))
		return false;

	conversation = find_or_create_conversation(pinfo);
	conversation_set_dissector(conversation, tcpros_handle);

	dissect_tcpros(tvb, pinfo, tree, data);

	return true;
}



void
proto_reg_handoff_tcpros(void)
{
	dissector_add_for_decode_as_with_preference("tcp.port", tcpros_handle);   /* for "decode-as" */

	/* register as heuristic dissector */
	heur_dissector_add("tcp", dissect_tcpros_heur_tcp, "TCPROS over TCP",
				"tcpros_tcp", proto_tcpros, HEURISTIC_DISABLE);
}



/*
 * 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:
 */
