/* packet-xip-serval.c
 * Routines for XIP Serval dissection
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * Serval is a service-centric architecture that has been ported to XIA to
 * allow applications to communicate using service names.
 */

#include "config.h"
#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/in_cksum.h>
#include <epan/tfs.h>
#include <epan/unit_strings.h>

#include <wsutil/array.h>
#include <ipproto.h>

void proto_register_xip_serval(void);
void proto_reg_handoff_xip_serval(void);

static dissector_handle_t tcp_handle;
static dissector_handle_t udp_handle;

static int proto_xip_serval;

/* XIP Serval header. */
static int hf_xip_serval_hl;
static int hf_xip_serval_proto;
static int hf_xip_serval_check;
static int hf_xip_serval_check_status;

/* XIP Serval general extension header. */
static int hf_xip_serval_ext_type;
static int hf_xip_serval_ext_length;

/* XIP Serval control extension header. */
static int hf_xip_serval_cext;
static int hf_xip_serval_cext_flags;
static int hf_xip_serval_cext_syn;
static int hf_xip_serval_cext_rsyn;
static int hf_xip_serval_cext_ack;
static int hf_xip_serval_cext_nack;
static int hf_xip_serval_cext_rst;
static int hf_xip_serval_cext_fin;
static int hf_xip_serval_cext_verno;
static int hf_xip_serval_cext_ackno;
static int hf_xip_serval_cext_nonce;

static int ett_xip_serval_tree;
static int ett_xip_serval_cext;
static int ett_xip_serval_cext_flags;

static expert_field ei_xip_serval_bad_len;
static expert_field ei_xip_serval_bad_proto;
static expert_field ei_xip_serval_bad_checksum;
static expert_field ei_xip_serval_bad_ext;

#define XIP_SERVAL_PROTO_DATA		0
static const value_string xip_serval_proto_vals[] = {
	{ XIP_SERVAL_PROTO_DATA,	"Data" },
	{ IP_PROTO_TCP,			"TCP" },
	{ IP_PROTO_UDP,			"UDP" },
	{ 0,				NULL },
};

static int * const xip_serval_cext_flags[] = {
	&hf_xip_serval_cext_syn,
	&hf_xip_serval_cext_rsyn,
	&hf_xip_serval_cext_ack,
	&hf_xip_serval_cext_nack,
	&hf_xip_serval_cext_rst,
	&hf_xip_serval_cext_fin,
	NULL
};

#define XIP_SERVAL_MIN_LEN		4

#define XIP_SERVAL_EXT_MIN_LEN		2
#define XIP_SERVAL_EXT_TYPE_MASK	0xF0
#define XIP_SERVAL_EXT_TYPE_CONTROL	0

#define XIP_SERVAL_CEXT_FLAGS_WIDTH	8
#define XIP_SERVAL_CEXT_NONCE_SIZE	8
#define XIP_SERVAL_CEXT_LEN		20

#define XSRVL_LEN			0
#define XSRVL_PRO			1
#define XSRVL_CHK			2
#define XSRVL_EXT			4

static uint8_t
display_xip_serval_control_ext(tvbuff_t *tvb, proto_tree *xip_serval_tree,
	int offset, uint8_t type, uint8_t length)
{
	proto_tree *cext_tree;
	proto_item *ti;

	/* Create Serval Control Extension tree. */
	ti = proto_tree_add_item(xip_serval_tree, hf_xip_serval_cext, tvb,
		offset, length, ENC_NA);
	cext_tree = proto_item_add_subtree(ti, ett_xip_serval_cext);

	/* Add XIP Serval extension type. */
	proto_tree_add_uint(cext_tree, hf_xip_serval_ext_type, tvb,
		offset, 1, type);
	offset++;

	/* Add XIP Serval extension length. */
	proto_tree_add_item(cext_tree, hf_xip_serval_ext_length, tvb,
		offset, 1, ENC_BIG_ENDIAN);
	offset++;

	/* Create XIP Serval Control Extension flags tree. */
	proto_tree_add_bitmask(cext_tree, tvb, offset,
		hf_xip_serval_cext_flags, ett_xip_serval_cext_flags,
		xip_serval_cext_flags, ENC_BIG_ENDIAN);

	/* Skip two bits for res1. */
	offset++;

	/* Skip a byte for res2. */
	offset++;

	/* Add verification number. */
	proto_tree_add_item(cext_tree, hf_xip_serval_cext_verno,
		tvb, offset, 4, ENC_BIG_ENDIAN);
	offset += 4;

	/* Add acknowledgement number. */
	proto_tree_add_item(cext_tree, hf_xip_serval_cext_ackno,
		tvb, offset, 4, ENC_BIG_ENDIAN);
	offset += 4;

	/* Add nonce. */
	proto_tree_add_item(cext_tree, hf_xip_serval_cext_nonce,
		tvb, offset, 8, ENC_NA);

	/* Displayed XIP_SERVAL_CEXT_LEN bytes. */
	return XIP_SERVAL_CEXT_LEN;
}

static uint8_t
display_xip_serval_ext(tvbuff_t *tvb, packet_info *pinfo, proto_item *ti,
	proto_tree *xip_serval_tree, int offset)
{
	uint8_t type = tvb_get_uint8(tvb, offset) & XIP_SERVAL_EXT_TYPE_MASK;
	uint8_t length = tvb_get_uint8(tvb, offset + 1);

	/* For now, the only type of extension header in XIP Serval is
	 * the control extension header.
	 */
	switch (type) {
	case XIP_SERVAL_EXT_TYPE_CONTROL:
		return display_xip_serval_control_ext(tvb, xip_serval_tree,
			offset, type, length);
	default:
		expert_add_info_format(pinfo, ti, &ei_xip_serval_bad_ext,
			"Unrecognized Serval extension header type: 0x%02x",
			type);
		return 0;
	}
}

static void
display_xip_serval(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
	proto_tree *xip_serval_tree;
	proto_item *ti, *hl_ti;
	tvbuff_t *next_tvb;

	vec_t cksum_vec;
	int offset;
	uint8_t xsh_len, protocol, bytes_remaining;

	/* Get XIP Serval header length, stored as number of 32-bit words. */
	xsh_len = tvb_get_uint8(tvb, XSRVL_LEN) << 2;

	/* Create XIP Serval header tree. */
	ti = proto_tree_add_item(tree, proto_xip_serval, tvb,
		0, xsh_len, ENC_NA);
	xip_serval_tree = proto_item_add_subtree(ti, ett_xip_serval_tree);

	/* Add XIP Serval header length. */
	hl_ti = proto_tree_add_item(xip_serval_tree, hf_xip_serval_hl, tvb,
		XSRVL_LEN, 1, ENC_BIG_ENDIAN);
	if (tvb_captured_length(tvb) < xsh_len)
		expert_add_info_format(pinfo, hl_ti, &ei_xip_serval_bad_len,
			"Header Length field (%d bytes) cannot be greater than actual number of bytes left in packet (%d bytes)",
			xsh_len, tvb_captured_length(tvb));

	/* Add XIP Serval protocol. If it's not data, TCP, or UDP, the
	 * packet is malformed.
	 */
	proto_tree_add_item(xip_serval_tree, hf_xip_serval_proto, tvb,
		XSRVL_PRO, 1, ENC_BIG_ENDIAN);
	protocol = tvb_get_uint8(tvb, XSRVL_PRO);
	if (!try_val_to_str(protocol, xip_serval_proto_vals))
		expert_add_info_format(pinfo, ti, &ei_xip_serval_bad_proto,
			"Unrecognized protocol type: %d", protocol);

	/* Compute checksum. */
	SET_CKSUM_VEC_TVB(cksum_vec, tvb, 0, xsh_len);

	proto_tree_add_checksum(xip_serval_tree, tvb, XSRVL_CHK, hf_xip_serval_check, hf_xip_serval_check_status, &ei_xip_serval_bad_checksum, pinfo, in_cksum(&cksum_vec, 1),
							ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
	offset = XSRVL_EXT;

	/* If there's still more room, check for extension headers. */
	bytes_remaining = xsh_len - offset;
	while (bytes_remaining >= XIP_SERVAL_EXT_MIN_LEN) {
		int8_t bytes_displayed = display_xip_serval_ext(tvb, pinfo, ti,
			xip_serval_tree, offset);

		/* Extension headers are malformed, so we can't say
		 * what the rest of the packet holds. Stop dissecting.
		 */
		if (bytes_displayed <= 0)
			return;

		offset += bytes_displayed;
		bytes_remaining -= bytes_displayed;
	}

	switch (protocol) {
	case XIP_SERVAL_PROTO_DATA:
		next_tvb = tvb_new_subset_remaining(tvb, offset);
		call_data_dissector(next_tvb, pinfo, tree);
		break;
	case IP_PROTO_TCP: {
		/* Get the Data Offset field of the TCP header, which is
		 * the high nibble of the 12th octet and represents the
		 * size of the TCP header of 32-bit words.
		 */
		uint8_t tcp_len = hi_nibble(tvb_get_uint8(tvb, offset + 12))*4;
		next_tvb = tvb_new_subset_length(tvb, offset, tcp_len);
		call_dissector(tcp_handle, next_tvb, pinfo, tree);
		break;
	}
	case IP_PROTO_UDP:
		/* The UDP header is always 8 bytes. */
		next_tvb = tvb_new_subset_length(tvb, offset, 8);
		call_dissector(udp_handle, next_tvb, pinfo, tree);
		break;
	default:
		break;
	}
}

static int
dissect_xip_serval(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
	void *data _U_)
{
	if (tvb_reported_length(tvb) < XIP_SERVAL_MIN_LEN)
		return 0;

	col_append_str(pinfo->cinfo, COL_INFO, " (with Serval)");

	display_xip_serval(tvb, pinfo, tree);
	return tvb_captured_length(tvb);
}

void
proto_register_xip_serval(void)
{
	static hf_register_info hf[] = {

		/* Serval Header. */

		{ &hf_xip_serval_hl,
		{ "Header Length", "xip_serval.hl", FT_UINT8,
		   BASE_DEC|BASE_UNIT_STRING, UNS(&units_byte_bytes), 0x0,	NULL, HFILL }},

		{ &hf_xip_serval_proto,
		{ "Protocol", "xip_serval.proto", FT_UINT8,
		   BASE_DEC, VALS(xip_serval_proto_vals), 0x0, NULL, HFILL }},

		{ &hf_xip_serval_check,
		{ "Checksum", "xip_serval.check", FT_UINT16,
		   BASE_HEX, NULL, 0x0,	NULL, HFILL }},

		{ &hf_xip_serval_check_status,
		{ "Checksum Status", "xip_serval.check.status", FT_UINT8,
		   BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},

		/* Serval Extension Header. */

		{ &hf_xip_serval_ext_type,
		{ "Extension Type", "xip_serval.ext_type", FT_UINT8,
		   BASE_DEC, NULL, 0x0,	NULL, HFILL }},

		{ &hf_xip_serval_ext_length,
		{ "Extension Length", "xip_serval.ext_length", FT_UINT8,
		   BASE_DEC|BASE_UNIT_STRING, UNS(&units_byte_bytes), 0x0,	NULL, HFILL }},

		/* Serval Control Extension Header. */

		{ &hf_xip_serval_cext,
		{ "Serval Control Extension", "xip_serval.cext",
		   FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},

		{ &hf_xip_serval_cext_flags,
		{ "Flags", "xip_serval.cext_flags", FT_UINT8, BASE_HEX,
		  NULL, 0x0, NULL, HFILL }},

		{ &hf_xip_serval_cext_syn,
		{ "SYN", "xip_serval.cext_syn", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x80, NULL, HFILL }},

		{ &hf_xip_serval_cext_rsyn,
		{ "RSYN", "xip_serval.cext_rsyn", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x40, NULL, HFILL }},

		{ &hf_xip_serval_cext_ack,
		{ "ACK", "xip_serval.cext_ack", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x20, NULL, HFILL }},

		{ &hf_xip_serval_cext_nack,
		{ "NACK", "xip_serval.cext_nack", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x10, NULL, HFILL }},

		{ &hf_xip_serval_cext_rst,
		{ "RST", "xip_serval.cext_rst", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x08, NULL, HFILL }},

		{ &hf_xip_serval_cext_fin,
		{ "FIN", "xip_serval.cext_fin", FT_BOOLEAN, 8,
		  TFS(&tfs_set_notset), 0x04, NULL, HFILL }},

		{ &hf_xip_serval_cext_verno,
		{ "Version Number", "xip_serval.cext_verno", FT_UINT32,
		  BASE_DEC, NULL, 0x0, NULL, HFILL }},

		{ &hf_xip_serval_cext_ackno,
		{ "Acknowledgement Number", "xip_serval.cext_ackno",
		  FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},

		{ &hf_xip_serval_cext_nonce,
		{ "Nonce", "xip_serval.cext_nonce", FT_BYTES,
		  SEP_SPACE, NULL, 0x0, NULL, HFILL }}
	};

	static int *ett[] = {
		&ett_xip_serval_tree,
		&ett_xip_serval_cext,
		&ett_xip_serval_cext_flags
	};

	static ei_register_info ei[] = {

		{ &ei_xip_serval_bad_len,
		{ "xip_serval.bad_len", PI_MALFORMED, PI_ERROR,
		  "Bad header length", EXPFILL }},

		{ &ei_xip_serval_bad_ext,
		{ "xip_serval.bad_ext", PI_MALFORMED, PI_ERROR,
		  "Bad extension header type", EXPFILL }},

		{ &ei_xip_serval_bad_proto,
		{ "xip_serval.bad_proto", PI_MALFORMED, PI_ERROR,
		  "Bad protocol type", EXPFILL }},

		{ &ei_xip_serval_bad_checksum,
		{ "xip_serval.bad_checksum", PI_MALFORMED, PI_ERROR,
		  "Incorrect checksum", EXPFILL }}
	};

	expert_module_t* expert_xip_serval;

	proto_xip_serval = proto_register_protocol("XIP Serval", "XIP Serval", "xipserval");
	register_dissector("xipserval", dissect_xip_serval,
		proto_xip_serval);
	proto_register_field_array(proto_xip_serval, hf, array_length(hf));
	proto_register_subtree_array(ett, array_length(ett));

	expert_xip_serval = expert_register_protocol(proto_xip_serval);
	expert_register_field_array(expert_xip_serval, ei, array_length(ei));
}

void
proto_reg_handoff_xip_serval(void)
{
	tcp_handle = find_dissector_add_dependency("tcp", proto_xip_serval);
	udp_handle = find_dissector_add_dependency("udp", proto_xip_serval);
}

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