From 2100097ef1be98a338b583f15bb5f529690829ff Mon Sep 17 00:00:00 2001 From: Neels Hofmeyr Date: Wed, 12 Jan 2022 02:38:39 +0100 Subject: 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 --- tests/Makefile.am | 1 + tests/libosmo-gtlv/Makefile.am | 30 +++ tests/libosmo-gtlv/gtlv_test.c | 513 ++++++++++++++++++++++++++++++++++++++++ tests/libosmo-gtlv/gtlv_test.ok | 256 ++++++++++++++++++++ tests/testsuite.at | 6 + 5 files changed, 806 insertions(+) create mode 100644 tests/libosmo-gtlv/Makefile.am create mode 100644 tests/libosmo-gtlv/gtlv_test.c create mode 100644 tests/libosmo-gtlv/gtlv_test.ok (limited to 'tests') diff --git a/tests/Makefile.am b/tests/Makefile.am index 280c468..01cbed5 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -1,4 +1,5 @@ SUBDIRS = \ + libosmo-gtlv \ $(NULL) # The `:;' works around a Bash 3.2 bug when the output is not writeable. 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 + * All Rights Reserved. + * + * Author: Neels Janosch Hofmeyr + * + * 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 . + * + */ + +#include +#include + +#include +#include +#include + +#include + +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(>lv, 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(>lv) == 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(>lv); + + for (ie = ies; ie->val; ie++) { + int rc = osmo_gtlv_load_next(>lv); + 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(>lv); + + ie = ies; + while (1) { + int rc; + int next_tag = osmo_gtlv_load_peek_tag(>lv); + 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(>lv); + 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(>lv); + rc = osmo_gtlv_load_next_by_tag(>lv, 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(>lv, 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(>lv); + for (ie = ies; ie->val; ie++) { + /* skip one tag */ + ie++; + if (!ie->val) + break; + + rc = osmo_gtlv_load_next_by_tag(>lv, 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(>lv, 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(>lv, 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] diff --git a/tests/testsuite.at b/tests/testsuite.at index 09a77c3..711f981 100644 --- a/tests/testsuite.at +++ b/tests/testsuite.at @@ -1,2 +1,8 @@ AT_INIT AT_BANNER([Regression tests.]) + +AT_SETUP([gtlv]) +AT_KEYWORDS([gtlv]) +cat $abs_srcdir/libosmo-gtlv/gtlv_test.ok > expout +AT_CHECK([$abs_top_builddir/tests/libosmo-gtlv/gtlv_test], [], [expout], [ignore]) +AT_CLEANUP -- cgit v1.2.3