path: root/tools/testing/selftests/net/ioam6_parser.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Author: Justin Iurman (justin.iurman@uliege.be)
 *
 * IOAM tester for IPv6, see ioam6.sh for details on each test case.
 */
#include <arpa/inet.h>
#include <errno.h>
#include <limits.h>
#include <linux/const.h>
#include <linux/if_ether.h>
#include <linux/ioam6.h>
#include <linux/ipv6.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

struct ioam_config {
	__u32 id;
	__u64 wide;
	__u16 ingr_id;
	__u16 egr_id;
	__u32 ingr_wide;
	__u32 egr_wide;
	__u32 ns_data;
	__u64 ns_wide;
	__u32 sc_id;
	__u8 hlim;
	char *sc_data;
};

/*
 * Be careful if you modify structs below - everything MUST be kept synchronized
 * with configurations inside ioam6.sh and always reflect the same.
 */

static struct ioam_config node1 = {
	.id = 1,
	.wide = 11111111,
	.ingr_id = 0xffff, /* default value */
	.egr_id = 101,
	.ingr_wide = 0xffffffff, /* default value */
	.egr_wide = 101101,
	.ns_data = 0xdeadbeef,
	.ns_wide = 0xcafec0caf00dc0de,
	.sc_id = 777,
	.sc_data = "something that will be 4n-aligned",
	.hlim = 64,
};

static struct ioam_config node2 = {
	.id = 2,
	.wide = 22222222,
	.ingr_id = 201,
	.egr_id = 202,
	.ingr_wide = 201201,
	.egr_wide = 202202,
	.ns_data = 0xffffffff, /* default value */
	.ns_wide = 0xffffffffffffffff, /* default value */
	.sc_id = 0xffffff, /* default value */
	.sc_data = NULL,
	.hlim = 63,
};

enum {
	/**********
	 * OUTPUT *
	 **********/
	__TEST_OUT_MIN,

	TEST_OUT_UNDEF_NS,
	TEST_OUT_NO_ROOM,
	TEST_OUT_NO_ROOM_OSS,
	TEST_OUT_BIT0,
	TEST_OUT_BIT1,
	TEST_OUT_BIT2,
	TEST_OUT_BIT3,
	TEST_OUT_BIT4,
	TEST_OUT_BIT5,
	TEST_OUT_BIT6,
	TEST_OUT_BIT7,
	TEST_OUT_BIT8,
	TEST_OUT_BIT9,
	TEST_OUT_BIT10,
	TEST_OUT_BIT11,
	TEST_OUT_BIT22,
	TEST_OUT_SIZE4,
	TEST_OUT_SIZE8,
	TEST_OUT_SIZE12,
	TEST_OUT_SIZE16,
	TEST_OUT_SIZE20,
	TEST_OUT_SIZE24,
	TEST_OUT_SIZE28,
	TEST_OUT_SIZE32,
	TEST_OUT_SIZE36,
	TEST_OUT_SIZE40,
	TEST_OUT_SIZE44,
	TEST_OUT_SIZE48,
	TEST_OUT_SIZE52,
	TEST_OUT_SIZE56,
	TEST_OUT_SIZE60,
	TEST_OUT_SIZE64,
	TEST_OUT_SIZE68,
	TEST_OUT_SIZE72,
	TEST_OUT_SIZE76,
	TEST_OUT_SIZE80,
	TEST_OUT_SIZE84,
	TEST_OUT_SIZE88,
	TEST_OUT_SIZE92,
	TEST_OUT_SIZE96,
	TEST_OUT_SIZE100,
	TEST_OUT_SIZE104,
	TEST_OUT_SIZE108,
	TEST_OUT_SIZE112,
	TEST_OUT_SIZE116,
	TEST_OUT_SIZE120,
	TEST_OUT_SIZE124,
	TEST_OUT_SIZE128,
	TEST_OUT_SIZE132,
	TEST_OUT_SIZE136,
	TEST_OUT_SIZE140,
	TEST_OUT_SIZE144,
	TEST_OUT_SIZE148,
	TEST_OUT_SIZE152,
	TEST_OUT_SIZE156,
	TEST_OUT_SIZE160,
	TEST_OUT_SIZE164,
	TEST_OUT_SIZE168,
	TEST_OUT_SIZE172,
	TEST_OUT_SIZE176,
	TEST_OUT_SIZE180,
	TEST_OUT_SIZE184,
	TEST_OUT_SIZE188,
	TEST_OUT_SIZE192,
	TEST_OUT_SIZE196,
	TEST_OUT_SIZE200,
	TEST_OUT_SIZE204,
	TEST_OUT_SIZE208,
	TEST_OUT_SIZE212,
	TEST_OUT_SIZE216,
	TEST_OUT_SIZE220,
	TEST_OUT_SIZE224,
	TEST_OUT_SIZE228,
	TEST_OUT_SIZE232,
	TEST_OUT_SIZE236,
	TEST_OUT_SIZE240,
	TEST_OUT_SIZE244,
	TEST_OUT_FULL_SUPP_TRACE,

	__TEST_OUT_MAX,

	/*********
	 * INPUT *
	 *********/
	__TEST_IN_MIN,

	TEST_IN_UNDEF_NS,
	TEST_IN_NO_ROOM,
	TEST_IN_NO_ROOM_OSS,
	TEST_IN_DISABLED,
	TEST_IN_OFLAG,
	TEST_IN_BIT0,
	TEST_IN_BIT1,
	TEST_IN_BIT2,
	TEST_IN_BIT3,
	TEST_IN_BIT4,
	TEST_IN_BIT5,
	TEST_IN_BIT6,
	TEST_IN_BIT7,
	TEST_IN_BIT8,
	TEST_IN_BIT9,
	TEST_IN_BIT10,
	TEST_IN_BIT11,
	TEST_IN_BIT22,
	TEST_IN_SIZE4,
	TEST_IN_SIZE8,
	TEST_IN_SIZE12,
	TEST_IN_SIZE16,
	TEST_IN_SIZE20,
	TEST_IN_SIZE24,
	TEST_IN_SIZE28,
	TEST_IN_SIZE32,
	TEST_IN_SIZE36,
	TEST_IN_SIZE40,
	TEST_IN_SIZE44,
	TEST_IN_SIZE48,
	TEST_IN_SIZE52,
	TEST_IN_SIZE56,
	TEST_IN_SIZE60,
	TEST_IN_SIZE64,
	TEST_IN_SIZE68,
	TEST_IN_SIZE72,
	TEST_IN_SIZE76,
	TEST_IN_SIZE80,
	TEST_IN_SIZE84,
	TEST_IN_SIZE88,
	TEST_IN_SIZE92,
	TEST_IN_SIZE96,
	TEST_IN_SIZE100,
	TEST_IN_SIZE104,
	TEST_IN_SIZE108,
	TEST_IN_SIZE112,
	TEST_IN_SIZE116,
	TEST_IN_SIZE120,
	TEST_IN_SIZE124,
	TEST_IN_SIZE128,
	TEST_IN_SIZE132,
	TEST_IN_SIZE136,
	TEST_IN_SIZE140,
	TEST_IN_SIZE144,
	TEST_IN_SIZE148,
	TEST_IN_SIZE152,
	TEST_IN_SIZE156,
	TEST_IN_SIZE160,
	TEST_IN_SIZE164,
	TEST_IN_SIZE168,
	TEST_IN_SIZE172,
	TEST_IN_SIZE176,
	TEST_IN_SIZE180,
	TEST_IN_SIZE184,
	TEST_IN_SIZE188,
	TEST_IN_SIZE192,
	TEST_IN_SIZE196,
	TEST_IN_SIZE200,
	TEST_IN_SIZE204,
	TEST_IN_SIZE208,
	TEST_IN_SIZE212,
	TEST_IN_SIZE216,
	TEST_IN_SIZE220,
	TEST_IN_SIZE224,
	TEST_IN_SIZE228,
	TEST_IN_SIZE232,
	TEST_IN_SIZE236,
	TEST_IN_SIZE240,
	TEST_IN_SIZE244,
	TEST_IN_FULL_SUPP_TRACE,

	__TEST_IN_MAX,

	__TEST_MAX,
};

static int check_header(int tid, struct ioam6_trace_hdr *trace,
			__u32 trace_type, __u8 trace_size, __u16 ioam_ns)
{
	if (__be16_to_cpu(trace->namespace_id) != ioam_ns ||
	    __be32_to_cpu(trace->type_be32) != (trace_type << 8))
		return 1;

	switch (tid) {
	case TEST_OUT_UNDEF_NS:
	case TEST_IN_UNDEF_NS:
	case TEST_IN_DISABLED:
		return trace->overflow == 1 ||
		       trace->nodelen != 1 ||
		       trace->remlen != 1;

	case TEST_OUT_NO_ROOM:
	case TEST_IN_NO_ROOM:
	case TEST_IN_OFLAG:
		return trace->overflow == 0 ||
		       trace->nodelen != 2 ||
		       trace->remlen != 1;

	case TEST_OUT_NO_ROOM_OSS:
		return trace->overflow == 0 ||
		       trace->nodelen != 0 ||
		       trace->remlen != 1;

	case TEST_IN_NO_ROOM_OSS:
	case TEST_OUT_BIT22:
	case TEST_IN_BIT22:
		return trace->overflow == 1 ||
		       trace->nodelen != 0 ||
		       trace->remlen != 0;

	case TEST_OUT_BIT0:
	case TEST_IN_BIT0:
	case TEST_OUT_BIT1:
	case TEST_IN_BIT1:
	case TEST_OUT_BIT2:
	case TEST_IN_BIT2:
	case TEST_OUT_BIT3:
	case TEST_IN_BIT3:
	case TEST_OUT_BIT4:
	case TEST_IN_BIT4:
	case TEST_OUT_BIT5:
	case TEST_IN_BIT5:
	case TEST_OUT_BIT6:
	case TEST_IN_BIT6:
	case TEST_OUT_BIT7:
	case TEST_IN_BIT7:
	case TEST_OUT_BIT11:
	case TEST_IN_BIT11:
		return trace->overflow == 1 ||
		       trace->nodelen != 1 ||
		       trace->remlen != 0;

	case TEST_OUT_BIT8:
	case TEST_IN_BIT8:
	case TEST_OUT_BIT9:
	case TEST_IN_BIT9:
	case TEST_OUT_BIT10:
	case TEST_IN_BIT10:
		return trace->overflow == 1 ||
		       trace->nodelen != 2 ||
		       trace->remlen != 0;

	case TEST_OUT_SIZE4:
	case TEST_OUT_SIZE8:
	case TEST_OUT_SIZE12:
	case TEST_OUT_SIZE16:
	case TEST_OUT_SIZE20:
	case TEST_OUT_SIZE24:
	case TEST_OUT_SIZE28:
	case TEST_OUT_SIZE32:
	case TEST_OUT_SIZE36:
	case TEST_OUT_SIZE40:
	case TEST_OUT_SIZE44:
	case TEST_OUT_SIZE48:
	case TEST_OUT_SIZE52:
	case TEST_OUT_SIZE56:
	case TEST_OUT_SIZE60:
	case TEST_OUT_SIZE64:
	case TEST_OUT_SIZE68:
	case TEST_OUT_SIZE72:
	case TEST_OUT_SIZE76:
	case TEST_OUT_SIZE80:
	case TEST_OUT_SIZE84:
	case TEST_OUT_SIZE88:
	case TEST_OUT_SIZE92:
	case TEST_OUT_SIZE96:
	case TEST_OUT_SIZE100:
	case TEST_OUT_SIZE104:
	case TEST_OUT_SIZE108:
	case TEST_OUT_SIZE112:
	case TEST_OUT_SIZE116:
	case TEST_OUT_SIZE120:
	case TEST_OUT_SIZE124:
	case TEST_OUT_SIZE128:
	case TEST_OUT_SIZE132:
	case TEST_OUT_SIZE136:
	case TEST_OUT_SIZE140:
	case TEST_OUT_SIZE144:
	case TEST_OUT_SIZE148:
	case TEST_OUT_SIZE152:
	case TEST_OUT_SIZE156:
	case TEST_OUT_SIZE160:
	case TEST_OUT_SIZE164:
	case TEST_OUT_SIZE168:
	case TEST_OUT_SIZE172:
	case TEST_OUT_SIZE176:
	case TEST_OUT_SIZE180:
	case TEST_OUT_SIZE184:
	case TEST_OUT_SIZE188:
	case TEST_OUT_SIZE192:
	case TEST_OUT_SIZE196:
	case TEST_OUT_SIZE200:
	case TEST_OUT_SIZE204:
	case TEST_OUT_SIZE208:
	case TEST_OUT_SIZE212:
	case TEST_OUT_SIZE216:
	case TEST_OUT_SIZE220:
	case TEST_OUT_SIZE224:
	case TEST_OUT_SIZE228:
	case TEST_OUT_SIZE232:
	case TEST_OUT_SIZE236:
	case TEST_OUT_SIZE240:
	case TEST_OUT_SIZE244:
		return trace->overflow == 1 ||
		       trace->nodelen != 1 ||
		       trace->remlen != trace_size / 4;

	case TEST_IN_SIZE4:
	case TEST_IN_SIZE8:
	case TEST_IN_SIZE12:
	case TEST_IN_SIZE16:
	case TEST_IN_SIZE20:
	case TEST_IN_SIZE24:
	case TEST_IN_SIZE28:
	case TEST_IN_SIZE32:
	case TEST_IN_SIZE36:
	case TEST_IN_SIZE40:
	case TEST_IN_SIZE44:
	case TEST_IN_SIZE48:
	case TEST_IN_SIZE52:
	case TEST_IN_SIZE56:
	case TEST_IN_SIZE60:
	case TEST_IN_SIZE64:
	case TEST_IN_SIZE68:
	case TEST_IN_SIZE72:
	case TEST_IN_SIZE76:
	case TEST_IN_SIZE80:
	case TEST_IN_SIZE84:
	case TEST_IN_SIZE88:
	case TEST_IN_SIZE92:
	case TEST_IN_SIZE96:
	case TEST_IN_SIZE100:
	case TEST_IN_SIZE104:
	case TEST_IN_SIZE108:
	case TEST_IN_SIZE112:
	case TEST_IN_SIZE116:
	case TEST_IN_SIZE120:
	case TEST_IN_SIZE124:
	case TEST_IN_SIZE128:
	case TEST_IN_SIZE132:
	case TEST_IN_SIZE136:
	case TEST_IN_SIZE140:
	case TEST_IN_SIZE144:
	case TEST_IN_SIZE148:
	case TEST_IN_SIZE152:
	case TEST_IN_SIZE156:
	case TEST_IN_SIZE160:
	case TEST_IN_SIZE164:
	case TEST_IN_SIZE168:
	case TEST_IN_SIZE172:
	case TEST_IN_SIZE176:
	case TEST_IN_SIZE180:
	case TEST_IN_SIZE184:
	case TEST_IN_SIZE188:
	case TEST_IN_SIZE192:
	case TEST_IN_SIZE196:
	case TEST_IN_SIZE200:
	case TEST_IN_SIZE204:
	case TEST_IN_SIZE208:
	case TEST_IN_SIZE212:
	case TEST_IN_SIZE216:
	case TEST_IN_SIZE220:
	case TEST_IN_SIZE224:
	case TEST_IN_SIZE228:
	case TEST_IN_SIZE232:
	case TEST_IN_SIZE236:
	case TEST_IN_SIZE240:
	case TEST_IN_SIZE244:
		return trace->overflow == 1 ||
		       trace->nodelen != 1 ||
		       trace->remlen != (trace_size / 4) - trace->nodelen;

	case TEST_OUT_FULL_SUPP_TRACE:
	case TEST_IN_FULL_SUPP_TRACE:
		return trace->overflow == 1 ||
		       trace->nodelen != 15 ||
		       trace->remlen != 0;

	default:
		break;
	}

	return 1;
}

static int check_data(struct ioam6_trace_hdr *trace, __u8 trace_size,
		      const struct ioam_config cnf, bool is_output)
{
	unsigned int len, i;
	__u8 aligned;
	__u64 raw64;
	__u32 raw32;
	__u8 *p;

	if (trace->type.bit12 | trace->type.bit13 | trace->type.bit14 |
	    trace->type.bit15 | trace->type.bit16 | trace->type.bit17 |
	    trace->type.bit18 | trace->type.bit19 | trace->type.bit20 |
	    trace->type.bit21 | trace->type.bit23)
		return 1;

	for (i = 0; i < trace->remlen * 4; i++) {
		if (trace->data[i] != 0)
			return 1;
	}

	if (trace->remlen * 4 == trace_size)
		return 0;

	p = trace->data + trace->remlen * 4;

	if (trace->type.bit0) {
		raw32 = __be32_to_cpu(*((__u32 *)p));
		if (cnf.hlim != (raw32 >> 24) || cnf.id != (raw32 & 0xffffff))
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit1) {
		raw32 = __be32_to_cpu(*((__u32 *)p));
		if (cnf.ingr_id != (raw32 >> 16) ||
		    cnf.egr_id != (raw32 & 0xffff))
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit2) {
		raw32 = __be32_to_cpu(*((__u32 *)p));
		if ((is_output && raw32 != 0xffffffff) ||
		    (!is_output && (raw32 == 0 || raw32 == 0xffffffff)))
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit3) {
		raw32 = __be32_to_cpu(*((__u32 *)p));
		if ((is_output && raw32 != 0xffffffff) ||
		    (!is_output && (raw32 == 0 || raw32 == 0xffffffff)))
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit4) {
		if (__be32_to_cpu(*((__u32 *)p)) != 0xffffffff)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit5) {
		if (__be32_to_cpu(*((__u32 *)p)) != cnf.ns_data)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit6) {
		if (__be32_to_cpu(*((__u32 *)p)) == 0xffffffff)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit7) {
		if (__be32_to_cpu(*((__u32 *)p)) != 0xffffffff)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit8) {
		raw64 = __be64_to_cpu(*((__u64 *)p));
		if (cnf.hlim != (raw64 >> 56) ||
		    cnf.wide != (raw64 & 0xffffffffffffff))
			return 1;
		p += sizeof(__u64);
	}

	if (trace->type.bit9) {
		if (__be32_to_cpu(*((__u32 *)p)) != cnf.ingr_wide)
			return 1;
		p += sizeof(__u32);

		if (__be32_to_cpu(*((__u32 *)p)) != cnf.egr_wide)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit10) {
		if (__be64_to_cpu(*((__u64 *)p)) != cnf.ns_wide)
			return 1;
		p += sizeof(__u64);
	}

	if (trace->type.bit11) {
		if (__be32_to_cpu(*((__u32 *)p)) != 0xffffffff)
			return 1;
		p += sizeof(__u32);
	}

	if (trace->type.bit22) {
		len = cnf.sc_data ? strlen(cnf.sc_data) : 0;
		aligned = cnf.sc_data ? __ALIGN_KERNEL(len, 4) : 0;

		raw32 = __be32_to_cpu(*((__u32 *)p));
		if (aligned != (raw32 >> 24) * 4 ||
		    cnf.sc_id != (raw32 & 0xffffff))
			return 1;
		p += sizeof(__u32);

		if (cnf.sc_data) {
			if (strncmp((char *)p, cnf.sc_data, len))
				return 1;

			p += len;
			aligned -= len;

			while (aligned--) {
				if (*p != '\0')
					return 1;
				p += sizeof(__u8);
			}
		}
	}

	return 0;
}

static int check_ioam_trace(int tid, struct ioam6_trace_hdr *trace,
			    __u32 trace_type, __u8 trace_size, __u16 ioam_ns)
{
	if (check_header(tid, trace, trace_type, trace_size, ioam_ns))
		return 1;

	if (tid > __TEST_OUT_MIN && tid < __TEST_OUT_MAX)
		return check_data(trace, trace_size, node1, true);

	if (tid > __TEST_IN_MIN && tid < __TEST_IN_MAX)
		return check_data(trace, trace_size, node2, false);

	return 1;
}

static int str2id(const char *tname)
{
	if (!strcmp("output_undef_ns", tname))
		return TEST_OUT_UNDEF_NS;
	if (!strcmp("output_no_room", tname))
		return TEST_OUT_NO_ROOM;
	if (!strcmp("output_no_room_oss", tname))
		return TEST_OUT_NO_ROOM_OSS;
	if (!strcmp("output_bit0", tname))
		return TEST_OUT_BIT0;
	if (!strcmp("output_bit1", tname))
		return TEST_OUT_BIT1;
	if (!strcmp("output_bit2", tname))
		return TEST_OUT_BIT2;
	if (!strcmp("output_bit3", tname))
		return TEST_OUT_BIT3;
	if (!strcmp("output_bit4", tname))
		return TEST_OUT_BIT4;
	if (!strcmp("output_bit5", tname))
		return TEST_OUT_BIT5;
	if (!strcmp("output_bit6", tname))
		return TEST_OUT_BIT6;
	if (!strcmp("output_bit7", tname))
		return TEST_OUT_BIT7;
	if (!strcmp("output_bit8", tname))
		return TEST_OUT_BIT8;
	if (!strcmp("output_bit9", tname))
		return TEST_OUT_BIT9;
	if (!strcmp("output_bit10", tname))
		return TEST_OUT_BIT10;
	if (!strcmp("output_bit11", tname))
		return TEST_OUT_BIT11;
	if (!strcmp("output_bit22", tname))
		return TEST_OUT_BIT22;
	if (!strcmp("output_size4", tname))
		return TEST_OUT_SIZE4;
	if (!strcmp("output_size8", tname))
		return TEST_OUT_SIZE8;
	if (!strcmp("output_size12", tname))
		return TEST_OUT_SIZE12;
	if (!strcmp("output_size16", tname))
		return TEST_OUT_SIZE16;
	if (!strcmp("output_size20", tname))
		return TEST_OUT_SIZE20;
	if (!strcmp("output_size24", tname))
		return TEST_OUT_SIZE24;
	if (!strcmp("output_size28", tname))
		return TEST_OUT_SIZE28;
	if (!strcmp("output_size32", tname))
		return TEST_OUT_SIZE32;
	if (!strcmp("output_size36", tname))
		return TEST_OUT_SIZE36;
	if (!strcmp("output_size40", tname))
		return TEST_OUT_SIZE40;
	if (!strcmp("output_size44", tname))
		return TEST_OUT_SIZE44;
	if (!strcmp("output_size48", tname))
		return TEST_OUT_SIZE48;
	if (!strcmp("output_size52", tname))
		return TEST_OUT_SIZE52;
	if (!strcmp("output_size56", tname))
		return TEST_OUT_SIZE56;
	if (!strcmp("output_size60", tname))
		return TEST_OUT_SIZE60;
	if (!strcmp("output_size64", tname))
		return TEST_OUT_SIZE64;
	if (!strcmp("output_size68", tname))
		return TEST_OUT_SIZE68;
	if (!strcmp("output_size72", tname))
		return TEST_OUT_SIZE72;
	if (!strcmp("output_size76", tname))
		return TEST_OUT_SIZE76;
	if (!strcmp("output_size80", tname))
		return TEST_OUT_SIZE80;
	if (!strcmp("output_size84", tname))
		return TEST_OUT_SIZE84;
	if (!strcmp("output_size88", tname))
		return TEST_OUT_SIZE88;
	if (!strcmp("output_size92", tname))
		return TEST_OUT_SIZE92;
	if (!strcmp("output_size96", tname))
		return TEST_OUT_SIZE96;
	if (!strcmp("output_size100", tname))
		return TEST_OUT_SIZE100;
	if (!strcmp("output_size104", tname))
		return TEST_OUT_SIZE104;
	if (!strcmp("output_size108", tname))
		return TEST_OUT_SIZE108;
	if (!strcmp("output_size112", tname))
		return TEST_OUT_SIZE112;
	if (!strcmp("output_size116", tname))
		return TEST_OUT_SIZE116;
	if (!strcmp("output_size120", tname))
		return TEST_OUT_SIZE120;
	if (!strcmp("output_size124", tname))
		return TEST_OUT_SIZE124;
	if (!strcmp("output_size128", tname))
		return TEST_OUT_SIZE128;
	if (!strcmp("output_size132", tname))
		return TEST_OUT_SIZE132;
	if (!strcmp("output_size136", tname))
		return TEST_OUT_SIZE136;
	if (!strcmp("output_size140", tname))
		return TEST_OUT_SIZE140;
	if (!strcmp("output_size144", tname))
		return TEST_OUT_SIZE144;
	if (!strcmp("output_size148", tname))
		return TEST_OUT_SIZE148;
	if (!strcmp("output_size152", tname))
		return TEST_OUT_SIZE152;
	if (!strcmp("output_size156", tname))
		return TEST_OUT_SIZE156;
	if (!strcmp("output_size160", tname))
		return TEST_OUT_SIZE160;
	if (!strcmp("output_size164", tname))
		return TEST_OUT_SIZE164;
	if (!strcmp("output_size168", tname))
		return TEST_OUT_SIZE168;
	if (!strcmp("output_size172", tname))
		return TEST_OUT_SIZE172;
	if (!strcmp("output_size176", tname))
		return TEST_OUT_SIZE176;
	if (!strcmp("output_size180", tname))
		return TEST_OUT_SIZE180;
	if (!strcmp("output_size184", tname))
		return TEST_OUT_SIZE184;
	if (!strcmp("output_size188", tname))
		return TEST_OUT_SIZE188;
	if (!strcmp("output_size192", tname))
		return TEST_OUT_SIZE192;
	if (!strcmp("output_size196", tname))
		return TEST_OUT_SIZE196;
	if (!strcmp("output_size200", tname))
		return TEST_OUT_SIZE200;
	if (!strcmp("output_size204", tname))
		return TEST_OUT_SIZE204;
	if (!strcmp("output_size208", tname))
		return TEST_OUT_SIZE208;
	if (!strcmp("output_size212", tname))
		return TEST_OUT_SIZE212;
	if (!strcmp("output_size216", tname))
		return TEST_OUT_SIZE216;
	if (!strcmp("output_size220", tname))
		return TEST_OUT_SIZE220;
	if (!strcmp("output_size224", tname))
		return TEST_OUT_SIZE224;
	if (!strcmp("output_size228", tname))
		return TEST_OUT_SIZE228;
	if (!strcmp("output_size232", tname))
		return TEST_OUT_SIZE232;
	if (!strcmp("output_size236", tname))
		return TEST_OUT_SIZE236;
	if (!strcmp("output_size240", tname))
		return TEST_OUT_SIZE240;
	if (!strcmp("output_size244", tname))
		return TEST_OUT_SIZE244;
	if (!strcmp("output_full_supp_trace", tname))
		return TEST_OUT_FULL_SUPP_TRACE;
	if (!strcmp("input_undef_ns", tname))
		return TEST_IN_UNDEF_NS;
	if (!strcmp("input_no_room", tname))
		return TEST_IN_NO_ROOM;
	if (!strcmp("input_no_room_oss", tname))
		return TEST_IN_NO_ROOM_OSS;
	if (!strcmp("input_disabled", tname))
		return TEST_IN_DISABLED;
	if (!strcmp("input_oflag", tname))
		return TEST_IN_OFLAG;
	if (!strcmp("input_bit0", tname))
		return TEST_IN_BIT0;
	if (!strcmp("input_bit1", tname))
		return TEST_IN_BIT1;
	if (!strcmp("input_bit2", tname))
		return TEST_IN_BIT2;
	if (!strcmp("input_bit3", tname))
		return TEST_IN_BIT3;
	if (!strcmp("input_bit4", tname))
		return TEST_IN_BIT4;
	if (!strcmp("input_bit5", tname))
		return TEST_IN_BIT5;
	if (!strcmp("input_bit6", tname))
		return TEST_IN_BIT6;
	if (!strcmp("input_bit7", tname))
		return TEST_IN_BIT7;
	if (!strcmp("input_bit8", tname))
		return TEST_IN_BIT8;
	if (!strcmp("input_bit9", tname))
		return TEST_IN_BIT9;
	if (!strcmp("input_bit10", tname))
		return TEST_IN_BIT10;
	if (!strcmp("input_bit11", tname))
		return TEST_IN_BIT11;
	if (!strcmp("input_bit22", tname))
		return TEST_IN_BIT22;
	if (!strcmp("input_size4", tname))
		return TEST_IN_SIZE4;
	if (!strcmp("input_size8", tname))
		return TEST_IN_SIZE8;
	if (!strcmp("input_size12", tname))
		return TEST_IN_SIZE12;
	if (!strcmp("input_size16", tname))
		return TEST_IN_SIZE16;
	if (!strcmp("input_size20", tname))
		return TEST_IN_SIZE20;
	if (!strcmp("input_size24", tname))
		return TEST_IN_SIZE24;
	if (!strcmp("input_size28", tname))
		return TEST_IN_SIZE28;
	if (!strcmp("input_size32", tname))
		return TEST_IN_SIZE32;
	if (!strcmp("input_size36", tname))
		return TEST_IN_SIZE36;
	if (!strcmp("input_size40", tname))
		return TEST_IN_SIZE40;
	if (!strcmp("input_size44", tname))
		return TEST_IN_SIZE44;
	if (!strcmp("input_size48", tname))
		return TEST_IN_SIZE48;
	if (!strcmp("input_size52", tname))
		return TEST_IN_SIZE52;
	if (!strcmp("input_size56", tname))
		return TEST_IN_SIZE56;
	if (!strcmp("input_size60", tname))
		return TEST_IN_SIZE60;
	if (!strcmp("input_size64", tname))
		return TEST_IN_SIZE64;
	if (!strcmp("input_size68", tname))
		return TEST_IN_SIZE68;
	if (!strcmp("input_size72", tname))
		return TEST_IN_SIZE72;
	if (!strcmp("input_size76", tname))
		return TEST_IN_SIZE76;
	if (!strcmp("input_size80", tname))
		return TEST_IN_SIZE80;
	if (!strcmp("input_size84", tname))
		return TEST_IN_SIZE84;
	if (!strcmp("input_size88", tname))
		return TEST_IN_SIZE88;
	if (!strcmp("input_size92", tname))
		return TEST_IN_SIZE92;
	if (!strcmp("input_size96", tname))
		return TEST_IN_SIZE96;
	if (!strcmp("input_size100", tname))
		return TEST_IN_SIZE100;
	if (!strcmp("input_size104", tname))
		return TEST_IN_SIZE104;
	if (!strcmp("input_size108", tname))
		return TEST_IN_SIZE108;
	if (!strcmp("input_size112", tname))
		return TEST_IN_SIZE112;
	if (!strcmp("input_size116", tname))
		return TEST_IN_SIZE116;
	if (!strcmp("input_size120", tname))
		return TEST_IN_SIZE120;
	if (!strcmp("input_size124", tname))
		return TEST_IN_SIZE124;
	if (!strcmp("input_size128", tname))
		return TEST_IN_SIZE128;
	if (!strcmp("input_size132", tname))
		return TEST_IN_SIZE132;
	if (!strcmp("input_size136", tname))
		return TEST_IN_SIZE136;
	if (!strcmp("input_size140", tname))
		return TEST_IN_SIZE140;
	if (!strcmp("input_size144", tname))
		return TEST_IN_SIZE144;
	if (!strcmp("input_size148", tname))
		return TEST_IN_SIZE148;
	if (!strcmp("input_size152", tname))
		return TEST_IN_SIZE152;
	if (!strcmp("input_size156", tname))
		return TEST_IN_SIZE156;
	if (!strcmp("input_size160", tname))
		return TEST_IN_SIZE160;
	if (!strcmp("input_size164", tname))
		return TEST_IN_SIZE164;
	if (!strcmp("input_size168", tname))
		return TEST_IN_SIZE168;
	if (!strcmp("input_size172", tname))
		return TEST_IN_SIZE172;
	if (!strcmp("input_size176", tname))
		return TEST_IN_SIZE176;
	if (!strcmp("input_size180", tname))
		return TEST_IN_SIZE180;
	if (!strcmp("input_size184", tname))
		return TEST_IN_SIZE184;
	if (!strcmp("input_size188", tname))
		return TEST_IN_SIZE188;
	if (!strcmp("input_size192", tname))
		return TEST_IN_SIZE192;
	if (!strcmp("input_size196", tname))
		return TEST_IN_SIZE196;
	if (!strcmp("input_size200", tname))
		return TEST_IN_SIZE200;
	if (!strcmp("input_size204", tname))
		return TEST_IN_SIZE204;
	if (!strcmp("input_size208", tname))
		return TEST_IN_SIZE208;
	if (!strcmp("input_size212", tname))
		return TEST_IN_SIZE212;
	if (!strcmp("input_size216", tname))
		return TEST_IN_SIZE216;
	if (!strcmp("input_size220", tname))
		return TEST_IN_SIZE220;
	if (!strcmp("input_size224", tname))
		return TEST_IN_SIZE224;
	if (!strcmp("input_size228", tname))
		return TEST_IN_SIZE228;
	if (!strcmp("input_size232", tname))
		return TEST_IN_SIZE232;
	if (!strcmp("input_size236", tname))
		return TEST_IN_SIZE236;
	if (!strcmp("input_size240", tname))
		return TEST_IN_SIZE240;
	if (!strcmp("input_size244", tname))
		return TEST_IN_SIZE244;
	if (!strcmp("input_full_supp_trace", tname))
		return TEST_IN_FULL_SUPP_TRACE;

	return -1;
}

static int ipv6_addr_equal(const struct in6_addr *a1, const struct in6_addr *a2)
{
	return ((a1->s6_addr32[0] ^ a2->s6_addr32[0]) |
		(a1->s6_addr32[1] ^ a2->s6_addr32[1]) |
		(a1->s6_addr32[2] ^ a2->s6_addr32[2]) |
		(a1->s6_addr32[3] ^ a2->s6_addr32[3])) == 0;
}

static int get_u32(__u32 *val, const char *arg, int base)
{
	unsigned long res;
	char *ptr;

	if (!arg || !*arg)
		return -1;
	res = strtoul(arg, &ptr, base);

	if (!ptr || ptr == arg || *ptr)
		return -1;

	if (res == ULONG_MAX && errno == ERANGE)
		return -1;

	if (res > 0xFFFFFFFFUL)
		return -1;

	*val = res;
	return 0;
}

static int get_u16(__u16 *val, const char *arg, int base)
{
	unsigned long res;
	char *ptr;

	if (!arg || !*arg)
		return -1;
	res = strtoul(arg, &ptr, base);

	if (!ptr || ptr == arg || *ptr)
		return -1;

	if (res == ULONG_MAX && errno == ERANGE)
		return -1;

	if (res > 0xFFFFUL)
		return -1;

	*val = res;
	return 0;
}

static int get_u8(__u8 *val, const char *arg, int base)
{
	unsigned long res;
	char *ptr;

	if (!arg || !*arg)
		return -1;
	res = strtoul(arg, &ptr, base);

	if (!ptr || ptr == arg || *ptr)
		return -1;

	if (res == ULONG_MAX && errno == ERANGE)
		return -1;

	if (res > 0xFFUL)
		return -1;

	*val = res;
	return 0;
}

int main(int argc, char **argv)
{
	__u8 buffer[512], *ptr, nexthdr, tr_size;
	struct ioam6_trace_hdr *trace;
	unsigned int hoplen, ret = 1;
	struct ipv6_hopopt_hdr *hbh;
	int fd, size, testname_id;
	struct in6_addr src, dst;
	struct ioam6_hdr *ioam6;
	struct timeval timeout;
	struct ipv6hdr *ipv6;
	__u32 tr_type;
	__u16 ioam_ns;

	if (argc != 9)
		goto out;

	testname_id = str2id(argv[2]);

	if (testname_id < 0 ||
	    inet_pton(AF_INET6, argv[3], &src) != 1 ||
	    inet_pton(AF_INET6, argv[4], &dst) != 1 ||
	    get_u32(&tr_type, argv[5], 16) ||
	    get_u8(&tr_size, argv[6], 0) ||
	    get_u16(&ioam_ns, argv[7], 0))
		goto out;

	nexthdr = (!strcmp(argv[8], "encap") ? IPPROTO_IPV6 : IPPROTO_ICMPV6);

	hoplen = sizeof(*hbh);
	hoplen += 2; // 2-byte padding for alignment
	hoplen += sizeof(*ioam6); // IOAM option header
	hoplen += sizeof(*trace); // IOAM trace header
	hoplen += tr_size; // IOAM trace size
	hoplen += (tr_size % 8); // optional padding

	fd = socket(AF_PACKET, SOCK_DGRAM, __cpu_to_be16(ETH_P_IPV6));
	if (fd < 0)
		goto out;

	if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
		       argv[1], strlen(argv[1])))
		goto close;

	timeout.tv_sec = 1;
	timeout.tv_usec = 0;
	if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO,
		       (const char *)&timeout, sizeof(timeout)))
		goto close;
recv:
	size = recv(fd, buffer, sizeof(buffer), 0);
	if (size <= 0)
		goto close;

	ipv6 = (struct ipv6hdr *)buffer;

	/* Skip packets that do not have the expected src/dst address or that
	 * do not have a Hop-by-hop.
	 */
	if (!ipv6_addr_equal(&ipv6->saddr, &src) ||
	    !ipv6_addr_equal(&ipv6->daddr, &dst) ||
	    ipv6->nexthdr != IPPROTO_HOPOPTS)
		goto recv;

	/* Check Hbh's Next Header and Size. */
	hbh = (struct ipv6_hopopt_hdr *)(buffer + sizeof(*ipv6));
	if (hbh->nexthdr != nexthdr || hbh->hdrlen != (hoplen >> 3) - 1)
		goto close;

	/* Check we have a 2-byte padding for alignment. */
	ptr = (__u8 *)hbh + sizeof(*hbh);
	if (ptr[0] != IPV6_TLV_PADN && ptr[1] != 0)
		goto close;

	/* Check we now have the IOAM option. */
	ptr += 2;
	if (ptr[0] != IPV6_TLV_IOAM)
		goto close;

	/* Check its size and the IOAM option type. */
	ioam6 = (struct ioam6_hdr *)ptr;
	if (ioam6->opt_len != sizeof(*ioam6) - 2 + sizeof(*trace) + tr_size ||
	    ioam6->type != IOAM6_TYPE_PREALLOC)
		goto close;

	trace = (struct ioam6_trace_hdr *)(ptr + sizeof(*ioam6));

	/* Check the trailing 4-byte padding (potentially). */
	ptr = (__u8 *)trace + sizeof(*trace) + tr_size;
	if (tr_size % 8 && ptr[0] != IPV6_TLV_PADN && ptr[1] != 2 &&
	    ptr[2] != 0 && ptr[3] != 0)
		goto close;

	/* Check the IOAM header and data. */
	ret = check_ioam_trace(testname_id, trace, tr_type, tr_size, ioam_ns);
close:
	close(fd);
out:
	return ret;
}