libosmo-gtlv: add generic TLV de- and encoder

An all new TLV parser supporting:

- Any size of T and L (determined by callback function),
- "Grouped IEs", so that an IE payload is a nested IE structure,
- optional/mandatory/multi-occurence IEs,
- decoding unordered tags (or enforcing strict order).

Will be used for PFCP message decoding and encoding, a T16L16V protocol
which requires above features.

Upcoming patches add
- translating PDUs to plain C structs and vice versa
- TLV generator to reduce repetition a in protocol definition
- TLIV capability

Previously, the way we deal with TLVs causes a lot of code
re-implementation: the TL decoding is taken care of by the API, but for
encoding, we essentially re-implement each protocol and each encoded
message in the individual programs. This API is an improvement in that
we only once implement the TL coding (or just use osmo_t8l8v_cfg /
osmo_t16l16v_cfg), get symmetric de- and encoding of the TL, and only
need to deal with the value part of each IE.

The common pattern of
- store TL preliminarily,
- write V data and
- update L after V is complete
is conveniently done by osmo_gtlv_put_update_tl().

Related: SYS#5599
Change-Id: Ib0fd00d9f288ffe13b7e67701f3e47073587404a

3 files changed, 799 insertions, 0 deletions

diff --git a/tests/libosmo-gtlv/Makefile.am b/tests/libosmo-gtlv/Makefile.am
new file mode 100644
index 0000000..7ab4ae0
--- /dev/null
+++ b/tests/libosmo-gtlv/Makefile.am
@@ -0,0 +1,30 @@
+AM_CPPFLAGS = \
+	$(all_includes) \
+	-I$(top_srcdir)/include \
+	$(NULL)
+
+AM_CFLAGS = \
+	-Wall \
+	$(LIBOSMOCORE_CFLAGS) \
+	$(NULL)
+
+noinst_PROGRAMS = \
+	gtlv_test \
+	$(NULL)
+
+EXTRA_DIST = \
+	gtlv_test.ok \
+	$(NULL)
+
+gtlv_test_SOURCES = \
+	gtlv_test.c \
+	$(NULL)
+
+gtlv_test_LDADD = \
+	$(top_builddir)/src/libosmo-gtlv/libosmo-gtlv.a \
+	$(LIBOSMOCORE_LIBS) \
+	$(NULL)
+
+.PHONY: update_exp
+update_exp:
+	$(builddir)/gtlv_test >$(srcdir)/gtlv_test.ok
diff --git a/tests/libosmo-gtlv/gtlv_test.c b/tests/libosmo-gtlv/gtlv_test.c
new file mode 100644
index 0000000..c009850
--- /dev/null
+++ b/tests/libosmo-gtlv/gtlv_test.c
@@ -0,0 +1,513 @@
+/*
+ * (C) 2021-2022 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved.
+ *
+ * Author: Neels Janosch Hofmeyr <nhofmeyr@sysmocom.de>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdio.h>
+#include <errno.h>
+
+#include <osmocom/core/application.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+
+#include <osmocom/gtlv/gtlv.h>
+
+void *ctx;
+
+struct ie {
+	int tag;
+	const char *val;
+};
+
+/* write all IEs to a msgb */
+struct msgb *test_tlv_enc(const struct osmo_gtlv_cfg *cfg, const struct ie *ies)
+{
+	const struct ie *ie;
+	struct osmo_gtlv_put gtlv = {
+		.cfg = cfg,
+		.dst = msgb_alloc(1024, __func__),
+	};
+
+	for (ie = ies; ie->val; ie++) {
+		/* put header without knowing length yet */
+		OSMO_ASSERT(osmo_gtlv_put_tl(&gtlv, ie->tag, 0) == 0);
+		/* put value data, as much as desired */
+		msgb_put(gtlv.dst, osmo_hexparse(ie->val, gtlv.dst->tail, msgb_tailroom(gtlv.dst)));
+		/* update header len from amount of written data */
+		OSMO_ASSERT(osmo_gtlv_put_update_tl(&gtlv) == 0);
+	}
+
+	printf("- encoded: %s.\n", osmo_hexdump(gtlv.dst->data, gtlv.dst->len));
+	return gtlv.dst;
+}
+
+/* read all IEs from the msgb, and verify that it matches the given list of IEs */
+void test_tlv_dec(const struct osmo_gtlv_cfg *cfg, const struct ie *ies, struct msgb *msg)
+{
+	const struct ie *ie;
+	struct osmo_gtlv_load gtlv = {
+		.cfg = cfg,
+		.src = { msg->data, msg->len },
+	};
+
+	printf("- decoding:\n");
+	osmo_gtlv_load_start(&gtlv);
+
+	for (ie = ies; ie->val; ie++) {
+		int rc = osmo_gtlv_load_next(&gtlv);
+		if (rc) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next() rc = %d\n", rc);
+			exit(1);
+		}
+		/* end of TLV structure? */
+		if (!gtlv.val)
+			break;
+		printf("  T=%d L=%zu v=%s\n", gtlv.tag, gtlv.len, osmo_hexdump_nospc(gtlv.val, gtlv.len));
+		if (gtlv.tag != ie->tag) {
+			printf("  ERROR loading TLV structure: expected tag %d, got tag %d\n", ie->tag, gtlv.tag);
+			exit(1);
+		}
+		if (strcmp(ie->val, osmo_hexdump_nospc(gtlv.val, gtlv.len))) {
+			printf("  ERROR loading TLV structure: expected val %s, got val %s\n", ie->val,
+			       osmo_hexdump_nospc(gtlv.val, gtlv.len));
+			exit(1);
+		}
+	}
+}
+
+void test_tlv_peek(const struct osmo_gtlv_cfg *cfg, const struct ie *ies, struct msgb *msg)
+{
+	const struct ie *ie;
+	struct osmo_gtlv_load gtlv = {
+		.cfg = cfg,
+		.src = { msg->data, msg->len },
+	};
+
+	printf("- peeking:\n");
+	osmo_gtlv_load_start(&gtlv);
+
+	ie = ies;
+	while (1) {
+		int rc;
+		int next_tag = osmo_gtlv_load_peek_tag(&gtlv);
+		if (next_tag == -ENOENT)
+			printf("  peek T=-ENOENT\n");
+		else
+			printf("  peek T=%d\n", next_tag);
+
+		if (ie->val && next_tag != ie->tag) {
+			printf("  ERROR peeking tag: expected tag %d, got tag %d\n", ie->tag, next_tag);
+			exit(1);
+		}
+		if (!ie->val && next_tag != -ENOENT) {
+			printf("  ERROR peeking tag: expected -ENOENT, got tag %d\n", next_tag);
+			exit(1);
+		}
+
+		if (next_tag == -ENOENT)
+			break;
+
+		/* go to the next TLV */
+		rc = osmo_gtlv_load_next(&gtlv);
+		if (rc) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next() rc = %d\n", rc);
+			exit(1);
+		}
+		if (ie->val)
+			ie++;
+	}
+}
+
+/* Decode TLV in random order, each time searching for a tag in the raw data */
+void test_tlv_dec_by_tag(const struct osmo_gtlv_cfg *cfg, const struct ie *ies, struct msgb *msg)
+{
+	const struct ie *last_ie;
+	const struct ie *ie;
+	int rc;
+	struct osmo_gtlv_load gtlv = {
+		.cfg = cfg,
+		.src = { msg->data, msg->len },
+	};
+
+	printf("- decoding in reverse order:\n");
+
+	last_ie = ies;
+	while (last_ie->val) last_ie++;
+	last_ie--;
+
+	for (ie = last_ie; ie >= ies; ie--) {
+		/* each time, look from the beginning */
+		osmo_gtlv_load_start(&gtlv);
+		rc = osmo_gtlv_load_next_by_tag(&gtlv, ie->tag);
+		if (rc) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next_by_tag(%d) rc = %d\n", ie->tag, rc);
+			exit(1);
+		}
+		if (!gtlv.val) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next_by_tag(%d) returned NULL val\n",
+			       ie->tag);
+			exit(1);
+		}
+		if (gtlv.tag != ie->tag) {
+			printf("  ERROR loading TLV structure: expected tag %d, got tag %d\n", ie->tag, gtlv.tag);
+			exit(1);
+		}
+		if (strcmp(ie->val, osmo_hexdump_nospc(gtlv.val, gtlv.len))) {
+			while (1) {
+				printf("   (mismatch: T=%d L=%zu v=%s, checking for another occurrence of T=%d)\n",
+				       gtlv.tag, gtlv.len, osmo_hexdump_nospc(gtlv.val, gtlv.len), gtlv.tag);
+				rc = osmo_gtlv_load_next_by_tag(&gtlv, ie->tag);
+				if (rc || !gtlv.val) {
+					printf("  ERROR val not found\n");
+					exit(1);
+				}
+				if (strcmp(ie->val, osmo_hexdump_nospc(gtlv.val, gtlv.len)) == 0) {
+					break;
+				}
+			}
+		}
+		printf("  T=%d L=%zu v=%s\n", gtlv.tag, gtlv.len, osmo_hexdump_nospc(gtlv.val, gtlv.len));
+	}
+
+	printf("- decoding every second tag:\n");
+
+	osmo_gtlv_load_start(&gtlv);
+	for (ie = ies; ie->val; ie++) {
+		/* skip one tag */
+		ie++;
+		if (!ie->val)
+			break;
+
+		rc = osmo_gtlv_load_next_by_tag(&gtlv, ie->tag);
+		if (rc) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next_by_tag(%d) rc = %d\n", ie->tag, rc);
+			exit(1);
+		}
+		if (!gtlv.val) {
+			printf("  ERROR loading TLV structure: osmo_gtlv_load_next_by_tag(%d) returned NULL val\n",
+			       ie->tag);
+			exit(1);
+		}
+		if (gtlv.tag != ie->tag) {
+			printf("  ERROR loading TLV structure: expected tag %d, got tag %d\n", ie->tag, gtlv.tag);
+			exit(1);
+		}
+		if (strcmp(ie->val, osmo_hexdump_nospc(gtlv.val, gtlv.len))) {
+			while (1) {
+				printf("   (mismatch: T=%d L=%zu v=%s, checking for another occurrence of T=%d)\n",
+				       gtlv.tag, gtlv.len, osmo_hexdump_nospc(gtlv.val, gtlv.len), gtlv.tag);
+				rc = osmo_gtlv_load_next_by_tag(&gtlv, ie->tag);
+				if (rc || !gtlv.val) {
+					printf("  ERROR val not found\n");
+					exit(1);
+				}
+				if (strcmp(ie->val, osmo_hexdump_nospc(gtlv.val, gtlv.len)) == 0) {
+					break;
+				}
+			}
+		}
+		printf("  T=%d L=%zu v=%s\n", gtlv.tag, gtlv.len, osmo_hexdump_nospc(gtlv.val, gtlv.len));
+	}
+
+	printf("- enforcing order: without restart, a past tag is not parsed again:\n");
+	/* Try to read the first tag, expect that it isn't found because we're already halfway in the message data */
+	ie = ies;
+	rc = osmo_gtlv_load_next_by_tag(&gtlv, ie->tag);
+	printf("  osmo_gtlv_load_next_by_tag(%d) rc=", ie->tag);
+	if (rc == -ENOENT) {
+		printf("-ENOENT\n");
+	} else {
+		printf("%d\n", rc);
+		printf("  ERROR: expected -ENOENT\n");
+		exit(1);
+	}
+}
+
+void test_tlv(const char *label, struct ie *tests[], size_t tests_len, const struct osmo_gtlv_cfg *cfg)
+{
+	int i;
+	for (i = 0; i < tests_len; i++) {
+		const struct ie *ies = tests[i];
+		struct msgb *msg;
+		printf("\n=== start: %s[%d]\n", label, i);
+
+		msg = test_tlv_enc(cfg, ies);
+		test_tlv_dec(cfg, ies, msg);
+		test_tlv_peek(cfg, ies, msg);
+		test_tlv_dec_by_tag(cfg, ies, msg);
+
+		msgb_free(msg);
+
+		printf("=== end: %s[%d]\n", label, i);
+	}
+}
+
+struct ie t8l8v_test1[] = {
+	/* smallest T */
+	{ 0, "2342" },
+	/* largest T */
+	{ 255, "2342" },
+
+	/* smallest V (no V data) */
+	{ 1, "" },
+	/* largest V, 255 bytes is the largest that an 8bit size length can express. */
+	{ 123, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	},
+
+	/* arbitrary test data */
+	{ 101, "11" },
+	{ 102, "2222" },
+	{ 103, "333333" },
+	{}
+};
+
+struct ie t8l8v_test_multi[] = {
+	{ 42, "42" },
+	{ 2, "0101" },
+	{ 2, "2222" },
+	{ 3, "11" },
+	{ 3, "2222" },
+	{ 3, "333333" },
+	{ 23, "23" },
+	{ 42, "666f72747974776f" },
+	{ 23, "7477656e74797468726565" },
+	{}
+};
+
+struct ie *t8l8v_tests[] = {
+	t8l8v_test1,
+	t8l8v_test_multi,
+};
+
+void test_t8l8v()
+{
+	test_tlv(__func__, t8l8v_tests, ARRAY_SIZE(t8l8v_tests), &osmo_t8l8v_cfg);
+}
+
+struct ie t16l16v_test1[] = {
+	/* smallest T */
+	{ 0, "2342" },
+	/* largest T */
+	{ 65535, "2342" },
+
+	/* smallest V (no V data) */
+	{ 1, "" },
+	/* 256 bytes is one more than an 8bit size length can express. */
+	{ 123, "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	},
+
+	/* arbitrary test data */
+	{ 1001, "11" },
+	{ 1002, "2222" },
+	{ 1003, "333333" },
+	{}
+};
+
+struct ie t16l16v_test_multi[] = {
+	{ 1042, "42" },
+	{ 102, "0101" },
+	{ 102, "2222" },
+	{ 103, "11" },
+	{ 103, "2222" },
+	{ 103, "333333" },
+	{ 1023, "23" },
+	{ 1042, "666f72747974776f" },
+	{ 1023, "7477656e74797468726565" },
+	{}
+};
+
+struct ie *t16l16v_tests[] = {
+	t16l16v_test1,
+	t16l16v_test_multi,
+};
+
+void test_t16l16v()
+{
+	test_tlv(__func__, t16l16v_tests, ARRAY_SIZE(t16l16v_tests), &osmo_t16l16v_cfg);
+}
+
+struct ie txlxv_test1[] = {
+	/* smallest T */
+	{ 0, "2342" },
+	/* largest T that still fits in one encoded octet (highest bit serves as flag) */
+	{ 0x7f, "2342" },
+	/* smallest T that needs two octets to be encoded (first octet = 0x80 flag + 0, second octet = 0x1) */
+	{ 0x80, "2342" },
+	/* largest T that can be encoded in 16bit - one flag bit. */
+	{ 0x7fff, "2342" },
+
+	/* smallest V (no V data) */
+	{ 1, "" },
+	/* 256 bytes is one more than an 8bit size length can express. */
+	{ 123, "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	       "0000000000000000000000000000000000000000000000000000000000000000"
+	},
+
+	/* arbitrary test data */
+	{ 1002, "2222" },
+	{ 1003, "333333" },
+	{}
+};
+
+struct ie txlxv_test_multi[] = {
+	{ 1042, "42" },
+	{ 1002, "0101" },
+	{ 1002, "2222" },
+	{ 103, "11" },
+	{ 103, "2222" },
+	{ 103, "333333" },
+	{ 1023, "23" },
+	{ 1042, "666f72747974776f" },
+	{ 1023, "7477656e74797468726565" },
+	{}
+};
+
+struct ie *txlxv_tests[] = {
+	txlxv_test1,
+	txlxv_test_multi,
+};
+
+/* Example of defining a variable TL, where size of T and L depend on the actual tag and length values: load. */
+int txlxv_load_tl(struct osmo_gtlv_load *gtlv, const uint8_t *src_data, size_t src_data_len)
+{
+	const uint8_t *pos = src_data;
+	const uint8_t *end = src_data + src_data_len;
+	if (pos[0] & 0x80) {
+		if (pos + 2 > end)
+			return -EINVAL;
+		gtlv->tag = (((int)pos[1]) << 7) + (pos[0] & 0x7f);
+		pos += 2;
+	} else {
+		gtlv->tag = pos[0];
+		pos++;
+	}
+
+	switch (gtlv->tag) {
+	case 1002:
+		/* fixed-length IE */
+		gtlv->len = 2;
+		break;
+	case 123:
+		/* 16bit length IE */
+		if (pos + 2 > end)
+			return -EINVAL;
+		gtlv->len = osmo_load16be(pos);
+		pos += 2;
+		break;
+	default:
+		/* 8bit length IE */
+		if (pos + 1 > end)
+			return -EINVAL;
+		gtlv->len = *pos;
+		pos++;
+		break;
+	}
+	gtlv->val = pos;
+	return 0;
+}
+
+/* Example of defining a variable TL, where size of T and L depend on the actual tag and length values: store. */
+int txlxv_store_tl(uint8_t *dst_data, size_t dst_data_avail, unsigned int tag, size_t len, struct osmo_gtlv_put *gtlv)
+{
+	uint8_t *pos = dst_data;
+	uint8_t *end = dst_data + dst_data_avail;
+	if (tag < 0x80) {
+		if (pos + 1 > end)
+			return -ENOSPC;
+		pos[0] = tag;
+		pos++;
+	} else {
+		if (pos + 2 > end)
+			return -ENOSPC;
+		pos[0] = 0x80 + (tag & 0x7f);
+		pos[1] = tag >> 7;
+		pos += 2;
+	}
+
+	switch (tag) {
+	case 1002:
+		/* fixed-length IE, write no len */
+		break;
+	case 123:
+		/* 16bit length IE */
+		if (len > UINT16_MAX)
+			return -ERANGE;
+		if (pos + 2 > end)
+			return -ENOSPC;
+		osmo_store16be(len, pos);
+		pos += 2;
+		break;
+	default:
+		/* 8bit length IE */
+		if (len > UINT8_MAX)
+			return -ERANGE;
+		if (pos + 1 > end)
+			return -ENOSPC;
+		pos[0] = len;
+		pos++;
+		break;
+	}
+	return pos - dst_data;
+}
+
+const struct osmo_gtlv_cfg txlxv_cfg = {
+	.tl_min_size = 1,
+	.load_tl = txlxv_load_tl,
+	.store_tl = txlxv_store_tl,
+};
+
+void test_txlxv()
+{
+	test_tlv("txlxv_tests", txlxv_tests, ARRAY_SIZE(txlxv_tests), &txlxv_cfg);
+}
+
+int main()
+{
+	ctx = talloc_named_const(NULL, 0, "gtlv_test");
+	msgb_talloc_ctx_init(ctx, 0);
+
+	test_t8l8v();
+	test_t16l16v();
+	test_txlxv();
+
+	talloc_free(ctx);
+	return 0;
+}
diff --git a/tests/libosmo-gtlv/gtlv_test.ok b/tests/libosmo-gtlv/gtlv_test.ok
new file mode 100644
index 0000000..3cebd7e
--- /dev/null
+++ b/tests/libosmo-gtlv/gtlv_test.ok
@@ -0,0 +1,256 @@
+
+=== start: test_t8l8v[0]
+- encoded: 00 02 23 42 ff 02 23 42 01 00 7b ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff 65 01 11 66 02 22 22 67 03 33 33 33 .
+- decoding:
+  T=0 L=2 v=2342
+  T=255 L=2 v=2342
+  T=1 L=0 v=
+  T=123 L=255 v=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  T=101 L=1 v=11
+  T=102 L=2 v=2222
+  T=103 L=3 v=333333
+- peeking:
+  peek T=0
+  peek T=255
+  peek T=1
+  peek T=123
+  peek T=101
+  peek T=102
+  peek T=103
+  peek T=-ENOENT
+- decoding in reverse order:
+  T=103 L=3 v=333333
+  T=102 L=2 v=2222
+  T=101 L=1 v=11
+  T=123 L=255 v=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  T=1 L=0 v=
+  T=255 L=2 v=2342
+  T=0 L=2 v=2342
+- decoding every second tag:
+  T=255 L=2 v=2342
+  T=123 L=255 v=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  T=102 L=2 v=2222
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(0) rc=-ENOENT
+=== end: test_t8l8v[0]
+
+=== start: test_t8l8v[1]
+- encoded: 2a 01 42 02 02 01 01 02 02 22 22 03 01 11 03 02 22 22 03 03 33 33 33 17 01 23 2a 08 66 6f 72 74 79 74 77 6f 17 0b 74 77 65 6e 74 79 74 68 72 65 65 .
+- decoding:
+  T=42 L=1 v=42
+  T=2 L=2 v=0101
+  T=2 L=2 v=2222
+  T=3 L=1 v=11
+  T=3 L=2 v=2222
+  T=3 L=3 v=333333
+  T=23 L=1 v=23
+  T=42 L=8 v=666f72747974776f
+  T=23 L=11 v=7477656e74797468726565
+- peeking:
+  peek T=42
+  peek T=2
+  peek T=2
+  peek T=3
+  peek T=3
+  peek T=3
+  peek T=23
+  peek T=42
+  peek T=23
+  peek T=-ENOENT
+- decoding in reverse order:
+   (mismatch: T=23 L=1 v=23, checking for another occurrence of T=23)
+  T=23 L=11 v=7477656e74797468726565
+   (mismatch: T=42 L=1 v=42, checking for another occurrence of T=42)
+  T=42 L=8 v=666f72747974776f
+  T=23 L=1 v=23
+   (mismatch: T=3 L=1 v=11, checking for another occurrence of T=3)
+   (mismatch: T=3 L=2 v=2222, checking for another occurrence of T=3)
+  T=3 L=3 v=333333
+   (mismatch: T=3 L=1 v=11, checking for another occurrence of T=3)
+  T=3 L=2 v=2222
+  T=3 L=1 v=11
+   (mismatch: T=2 L=2 v=0101, checking for another occurrence of T=2)
+  T=2 L=2 v=2222
+  T=2 L=2 v=0101
+  T=42 L=1 v=42
+- decoding every second tag:
+  T=2 L=2 v=0101
+  T=3 L=1 v=11
+   (mismatch: T=3 L=2 v=2222, checking for another occurrence of T=3)
+  T=3 L=3 v=333333
+  T=42 L=8 v=666f72747974776f
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(42) rc=-ENOENT
+=== end: test_t8l8v[1]
+
+=== start: test_t16l16v[0]
+- encoded: 00 00 00 02 23 42 ff ff 00 02 23 42 00 01 00 00 00 7b 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03 e9 00 01 11 03 ea 00 02 22 22 03 eb 00 03 33 33 33 .
+- decoding:
+  T=0 L=2 v=2342
+  T=65535 L=2 v=2342
+  T=1 L=0 v=
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1001 L=1 v=11
+  T=1002 L=2 v=2222
+  T=1003 L=3 v=333333
+- peeking:
+  peek T=0
+  peek T=65535
+  peek T=1
+  peek T=123
+  peek T=1001
+  peek T=1002
+  peek T=1003
+  peek T=-ENOENT
+- decoding in reverse order:
+  T=1003 L=3 v=333333
+  T=1002 L=2 v=2222
+  T=1001 L=1 v=11
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1 L=0 v=
+  T=65535 L=2 v=2342
+  T=0 L=2 v=2342
+- decoding every second tag:
+  T=65535 L=2 v=2342
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1002 L=2 v=2222
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(0) rc=-ENOENT
+=== end: test_t16l16v[0]
+
+=== start: test_t16l16v[1]
+- encoded: 04 12 00 01 42 00 66 00 02 01 01 00 66 00 02 22 22 00 67 00 01 11 00 67 00 02 22 22 00 67 00 03 33 33 33 03 ff 00 01 23 04 12 00 08 66 6f 72 74 79 74 77 6f 03 ff 00 0b 74 77 65 6e 74 79 74 68 72 65 65 .
+- decoding:
+  T=1042 L=1 v=42
+  T=102 L=2 v=0101
+  T=102 L=2 v=2222
+  T=103 L=1 v=11
+  T=103 L=2 v=2222
+  T=103 L=3 v=333333
+  T=1023 L=1 v=23
+  T=1042 L=8 v=666f72747974776f
+  T=1023 L=11 v=7477656e74797468726565
+- peeking:
+  peek T=1042
+  peek T=102
+  peek T=102
+  peek T=103
+  peek T=103
+  peek T=103
+  peek T=1023
+  peek T=1042
+  peek T=1023
+  peek T=-ENOENT
+- decoding in reverse order:
+   (mismatch: T=1023 L=1 v=23, checking for another occurrence of T=1023)
+  T=1023 L=11 v=7477656e74797468726565
+   (mismatch: T=1042 L=1 v=42, checking for another occurrence of T=1042)
+  T=1042 L=8 v=666f72747974776f
+  T=1023 L=1 v=23
+   (mismatch: T=103 L=1 v=11, checking for another occurrence of T=103)
+   (mismatch: T=103 L=2 v=2222, checking for another occurrence of T=103)
+  T=103 L=3 v=333333
+   (mismatch: T=103 L=1 v=11, checking for another occurrence of T=103)
+  T=103 L=2 v=2222
+  T=103 L=1 v=11
+   (mismatch: T=102 L=2 v=0101, checking for another occurrence of T=102)
+  T=102 L=2 v=2222
+  T=102 L=2 v=0101
+  T=1042 L=1 v=42
+- decoding every second tag:
+  T=102 L=2 v=0101
+  T=103 L=1 v=11
+   (mismatch: T=103 L=2 v=2222, checking for another occurrence of T=103)
+  T=103 L=3 v=333333
+  T=1042 L=8 v=666f72747974776f
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(1042) rc=-ENOENT
+=== end: test_t16l16v[1]
+
+=== start: txlxv_tests[0]
+- encoded: 00 02 23 42 7f 02 23 42 80 01 02 23 42 ff ff 02 23 42 01 00 7b 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ea 07 22 22 eb 07 03 33 33 33 .
+- decoding:
+  T=0 L=2 v=2342
+  T=127 L=2 v=2342
+  T=128 L=2 v=2342
+  T=32767 L=2 v=2342
+  T=1 L=0 v=
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1002 L=2 v=2222
+  T=1003 L=3 v=333333
+- peeking:
+  peek T=0
+  peek T=127
+  peek T=128
+  peek T=32767
+  peek T=1
+  peek T=123
+  peek T=1002
+  peek T=1003
+  peek T=-ENOENT
+- decoding in reverse order:
+  T=1003 L=3 v=333333
+  T=1002 L=2 v=2222
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1 L=0 v=
+  T=32767 L=2 v=2342
+  T=128 L=2 v=2342
+  T=127 L=2 v=2342
+  T=0 L=2 v=2342
+- decoding every second tag:
+  T=127 L=2 v=2342
+  T=32767 L=2 v=2342
+  T=123 L=256 v=00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  T=1003 L=3 v=333333
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(0) rc=-ENOENT
+=== end: txlxv_tests[0]
+
+=== start: txlxv_tests[1]
+- encoded: 92 08 01 42 ea 07 01 01 ea 07 22 22 67 01 11 67 02 22 22 67 03 33 33 33 ff 07 01 23 92 08 08 66 6f 72 74 79 74 77 6f ff 07 0b 74 77 65 6e 74 79 74 68 72 65 65 .
+- decoding:
+  T=1042 L=1 v=42
+  T=1002 L=2 v=0101
+  T=1002 L=2 v=2222
+  T=103 L=1 v=11
+  T=103 L=2 v=2222
+  T=103 L=3 v=333333
+  T=1023 L=1 v=23
+  T=1042 L=8 v=666f72747974776f
+  T=1023 L=11 v=7477656e74797468726565
+- peeking:
+  peek T=1042
+  peek T=1002
+  peek T=1002
+  peek T=103
+  peek T=103
+  peek T=103
+  peek T=1023
+  peek T=1042
+  peek T=1023
+  peek T=-ENOENT
+- decoding in reverse order:
+   (mismatch: T=1023 L=1 v=23, checking for another occurrence of T=1023)
+  T=1023 L=11 v=7477656e74797468726565
+   (mismatch: T=1042 L=1 v=42, checking for another occurrence of T=1042)
+  T=1042 L=8 v=666f72747974776f
+  T=1023 L=1 v=23
+   (mismatch: T=103 L=1 v=11, checking for another occurrence of T=103)
+   (mismatch: T=103 L=2 v=2222, checking for another occurrence of T=103)
+  T=103 L=3 v=333333
+   (mismatch: T=103 L=1 v=11, checking for another occurrence of T=103)
+  T=103 L=2 v=2222
+  T=103 L=1 v=11
+   (mismatch: T=1002 L=2 v=0101, checking for another occurrence of T=1002)
+  T=1002 L=2 v=2222
+  T=1002 L=2 v=0101
+  T=1042 L=1 v=42
+- decoding every second tag:
+  T=1002 L=2 v=0101
+  T=103 L=1 v=11
+   (mismatch: T=103 L=2 v=2222, checking for another occurrence of T=103)
+  T=103 L=3 v=333333
+  T=1042 L=8 v=666f72747974776f
+- enforcing order: without restart, a past tag is not parsed again:
+  osmo_gtlv_load_next_by_tag(1042) rc=-ENOENT
+=== end: txlxv_tests[1]