New Rewind method for entered maps...; bug fix for entering tagged wrapping byte strings
The new QCBORDecode_Rewind method allows the pre-order traversal cursor to be reset to the beginning of an entered array, map or byte string. If nothing was entered, then the reset is to the initial state, the beginning of the input encoded CBOR.
This also fixes a bug that prevented tagged wrapping byte strings from being entered.
This also adds a method to UsefulBuf and UsefulInBuf to convert a pointer to an offset.
* first version of rewind
* Make rewind work when not bounded and reset error state
* Rewind working for maps and arrays, but not byte strings
* rewind almost working for byte strings
* src/qcbor_decode.c
* minor tidying
* rewinding wrapped byte strings works, but needs more tests
* Full testing of UsefulBuf pointer to offset functions
* tidy up rewind; tests all passing
* fix bug entering tagged byte-string wrapped CBOR; entering indefinite-length byte-string wrapped is still broken
* one more test; give up on entering indef length wrapping strings
* spelling fix
* ifdefs for disabling tests
* refactor rewind
* more nits
Co-authored-by: Laurence Lundblade <lgl@securitytheory.com>
diff --git a/test/UsefulBuf_Tests.c b/test/UsefulBuf_Tests.c
index 1c2634e..880be02 100644
--- a/test/UsefulBuf_Tests.c
+++ b/test/UsefulBuf_Tests.c
@@ -1,6 +1,6 @@
/*==============================================================================
Copyright (c) 2016-2018, The Linux Foundation.
- Copyright (c) 2018-2020, Laurence Lundblade.
+ Copyright (c) 2018-2021, Laurence Lundblade.
All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -591,13 +591,46 @@
return "Failed to find 3";
}
+
+ const uint8_t pB[] = {0x01, 0x02, 0x03};
+ UsefulBufC Boo = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pB);
+ // Try to map a pointer before
+ if(UsefulBuf_PointerToOffset(Boo, pB-1) != SIZE_MAX) {
+ return "Didn't error on pointer before";
+ }
+
+ // Try to map a pointer after
+ if(UsefulBuf_PointerToOffset(Boo, pB+sizeof(pB)) != SIZE_MAX) {
+ return "Didn't error on pointer after";
+ }
+
+ // Try to map a pointer inside
+ if(UsefulBuf_PointerToOffset(Boo, pB+1) != 1) {
+ return "Incorrect pointer offset";
+ }
+
+ // Try to map a pointer at the start
+ if(UsefulBuf_PointerToOffset(Boo, pB) != 0) {
+ return "Incorrect pointer offset for start";
+ }
+
+ // Try to map a pointer at the end
+ if(UsefulBuf_PointerToOffset(Boo, pB + sizeof(pB)-1) != 2) {
+ return "Incorrect pointer offset for end";
+ }
+
+ // Try to map a pointer on a NULL UB
+ if(UsefulBuf_PointerToOffset(NULLUsefulBufC, pB ) != SIZE_MAX) {
+ return "Incorrect pointer offset for start";
+ }
+
return NULL;
}
const char * UIBTest_IntegerFormat()
{
- UsefulOutBuf_MakeOnStack(UOB,100);
+ UsefulOutBuf_MakeOnStack(UOB, 100);
const uint32_t u32 = 0x0A0B0C0D; // from https://en.wikipedia.org/wiki/Endianness
const uint64_t u64 = 1984738472938472;
@@ -695,6 +728,10 @@
return "expected error after seek";
}
+ if(UsefulInputBuf_PointerToOffset(&UIB, O.ptr) != 0) {
+ return "PointerToOffset not working";
+ }
+
return NULL;
}
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 16f0831..949ccbd 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -1813,7 +1813,7 @@
}
#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
-
+
// Iterate until there is an error of some sort error
QCBORItem Item;
do {
@@ -7026,8 +7026,90 @@
#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
+/*
+ * An array of an integer and an array. The second array contains
+ * a bstr-wrapped map.
+ *
+ * [7, [h'A36D6669... (see next lines) 73']]
+ *
+ * {"first integer": 42,
+ * "an array of two strings": ["string1", "string2"],
+ * "map in a map":
+ * { "bytes 1": h'78787878',
+ * "bytes 2": h'79797979',
+ * "another int": 98,
+ * "text 2": "lies, damn lies and statistics"
+ * }
+ * }
+ */
-int32_t PeekTest()
+static const uint8_t pValidWrappedMapEncoded[] = {
+ 0x82, 0x07, 0x81, 0x58, 0x97,
+ 0xa3, 0x6d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x69, 0x6e,
+ 0x74, 0x65, 0x67, 0x65, 0x72, 0x18, 0x2a, 0x77, 0x61, 0x6e,
+ 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20,
+ 0x74, 0x77, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x73, 0x82, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x31,
+ 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x6c, 0x6d,
+ 0x61, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6d, 0x61,
+ 0x70, 0xa4, 0x67, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x31,
+ 0x44, 0x78, 0x78, 0x78, 0x78, 0x67, 0x62, 0x79, 0x74, 0x65,
+ 0x73, 0x20, 0x32, 0x44, 0x79, 0x79, 0x79, 0x79, 0x6b, 0x61,
+ 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x74,
+ 0x18, 0x62, 0x66, 0x74, 0x65, 0x78, 0x74, 0x20, 0x32, 0x78,
+ 0x1e, 0x6c, 0x69, 0x65, 0x73, 0x2c, 0x20, 0x64, 0x61, 0x6d,
+ 0x6e, 0x20, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64,
+ 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63,
+ 0x73
+};
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+
+/* As above, but the arrays are indefinite length */
+static const uint8_t pValidIndefWrappedMapEncoded[] = {
+ 0x9f, 0x07, 0x9f, 0x58, 0x97,
+ 0xa3, 0x6d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x69, 0x6e,
+ 0x74, 0x65, 0x67, 0x65, 0x72, 0x18, 0x2a, 0x77, 0x61, 0x6e,
+ 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20,
+ 0x74, 0x77, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x73, 0x82, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x31,
+ 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x6c, 0x6d,
+ 0x61, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6d, 0x61,
+ 0x70, 0xa4, 0x67, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x31,
+ 0x44, 0x78, 0x78, 0x78, 0x78, 0x67, 0x62, 0x79, 0x74, 0x65,
+ 0x73, 0x20, 0x32, 0x44, 0x79, 0x79, 0x79, 0x79, 0x6b, 0x61,
+ 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x74,
+ 0x18, 0x62, 0x66, 0x74, 0x65, 0x78, 0x74, 0x20, 0x32, 0x78,
+ 0x1e, 0x6c, 0x69, 0x65, 0x73, 0x2c, 0x20, 0x64, 0x61, 0x6d,
+ 0x6e, 0x20, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64,
+ 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63,
+ 0x73,
+ 0xff, 0xff
+};
+#endif
+
+
+static const uint8_t pWithEmptyMap[] = {0x82, 0x18, 0x64, 0xa0};
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+static const uint8_t pWithEmptyMapInDef[] = {0x9f, 0x18, 0x64, 0xbf, 0xff, 0xff};
+#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
+static const uint8_t pWrappedByIndefiniteLength[] = {
+ 0x81,
+ 0xd8, 0x18,
+ 0x5f,
+ 0x41, 0x83,
+ 0x41, 0x18,
+ 0x43, 0x2A, 0x18, 0x2B,
+ 0x42, 0x18, 0x2C,
+ 0xff
+};
+#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
+
+
+int32_t PeekAndRewindTest()
{
QCBORItem Item;
QCBORError nCBORError;
@@ -7097,8 +7179,9 @@
Item.uLabelAlloc ||
UsefulBufCompareToSZ(Item.label.string, "an array of two strings") ||
Item.uDataType != QCBOR_TYPE_ARRAY ||
- Item.val.uCount != 2)
+ Item.val.uCount != 2) {
return 1400;
+ }
if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
return 1500 + (int32_t)nCBORError;
@@ -7197,8 +7280,9 @@
Item.uLabelAlloc ||
UsefulBufCompareToSZ(Item.label.string, "another int") ||
Item.uDataType != QCBOR_TYPE_INT64 ||
- Item.val.int64 != 98)
+ Item.val.int64 != 98) {
return 2900;
+ }
if((nCBORError = QCBORDecode_PeekNext(&DCtx, &Item))) {
return 3000 + (int32_t)nCBORError;
@@ -7224,5 +7308,399 @@
return 3300;
}
+
+
+ // Rewind to top level after entering several maps
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP ||
+ Item.val.uCount != 3) {
+ return 400;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4000+(int32_t)nCBORError;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataType != QCBOR_TYPE_INT64 ||
+ Item.val.int64 != 42 ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "first integer")) {
+ return 4100;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4100+(int32_t)nCBORError;
+ }
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "an array of two strings") ||
+ Item.uDataType != QCBOR_TYPE_ARRAY ||
+ Item.val.uCount != 2) {
+ return 4200;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4200+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string1")) {
+ return 4300;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4300+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string2")) {
+ return 4400;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4400+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP ||
+ Item.val.uCount != 3) {
+ return 4500;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataType != QCBOR_TYPE_INT64 ||
+ Item.val.int64 != 42 ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "first integer")) {
+ return 4600;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "an array of two strings") ||
+ Item.uDataType != QCBOR_TYPE_ARRAY ||
+ Item.val.uCount != 2) {
+ return 4700;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string1")) {
+ return 4800;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 4900+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string2")) {
+ return 5000;
+ }
+
+
+ // Rewind an entered map
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
+
+ QCBORDecode_EnterMap(&DCtx, NULL);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5100+(int32_t)nCBORError;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataType != QCBOR_TYPE_INT64 ||
+ Item.val.int64 != 42 ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "first integer")) {
+ return 5200;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5200+(int32_t)nCBORError;
+ }
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "an array of two strings") ||
+ Item.uDataType != QCBOR_TYPE_ARRAY ||
+ Item.val.uCount != 2) {
+ return -5300;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5300+(int32_t)nCBORError;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataType != QCBOR_TYPE_INT64 ||
+ Item.val.int64 != 42 ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "first integer")) {
+ return 5400;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5400+(int32_t)nCBORError;
+ }
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.label.string, "an array of two strings") ||
+ Item.uDataType != QCBOR_TYPE_ARRAY ||
+ Item.val.uCount != 2) {
+ return 5500;
+ }
+
+
+ // Rewind and entered array inside an entered map
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
+
+ QCBORDecode_EnterMap(&DCtx, NULL);
+
+ QCBORDecode_EnterArrayFromMapSZ(&DCtx, "an array of two strings");
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5600+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string1")) {
+ return 5700;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5700+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string1")) {
+ return 5800;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string2")) {
+ return 5900;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 5900+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
+ Item.uDataAlloc ||
+ Item.uLabelAlloc ||
+ UsefulBufCompareToSZ(Item.val.string, "string1")) {
+ return 6000;
+ }
+
+
+ // Rewind a byte string inside an array inside an array
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidWrappedMapEncoded), 0);
+
+ QCBORDecode_EnterArray(&DCtx, NULL);
+
+ uint64_t i;
+ QCBORDecode_GetUInt64(&DCtx, &i);
+
+ QCBORDecode_EnterArray(&DCtx, NULL);
+
+ QCBORDecode_EnterBstrWrapped(&DCtx, QCBOR_TAG_REQUIREMENT_NOT_A_TAG, NULL);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 6100;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return (int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP || Item.val.uCount != 3) {
+ return 6200;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 6300+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP || Item.val.uCount != 3) {
+ return 6400;
+ }
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+ // Rewind a byte string inside an indefinite-length array inside
+ // indefinite-length array
+
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidIndefWrappedMapEncoded), 0);
+
+ QCBORDecode_EnterArray(&DCtx, NULL);
+
+ QCBORDecode_GetUInt64(&DCtx, &i);
+
+ QCBORDecode_EnterArray(&DCtx, NULL);
+
+ QCBORDecode_EnterBstrWrapped(&DCtx, QCBOR_TAG_REQUIREMENT_NOT_A_TAG, NULL);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 6500;
+ }
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 6600+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP || Item.val.uCount != 3) {
+ return 6700;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
+ return 6800+(int32_t)nCBORError;
+ }
+ if(Item.uDataType != QCBOR_TYPE_MAP || Item.val.uCount != 3) {
+ return 6900;
+ }
+#endif
+
+ // Rewind an empty map
+ // [100, {}]
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pWithEmptyMap), 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7010;
+ }
+ QCBORDecode_EnterMap(&DCtx, NULL);
+
+ /* Do it 5 times to be sure multiple rewinds work */
+ for(int n = 0; n < 5; n++) {
+ nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
+ if(nCBORError != QCBOR_ERR_NO_MORE_ITEMS) {
+ return 7000 + n;
+ }
+ QCBORDecode_Rewind(&DCtx);
+ }
+ QCBORDecode_ExitMap(&DCtx);
+ QCBORDecode_Rewind(&DCtx);
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7010;
+ }
+ QCBORDecode_ExitArray(&DCtx);
+ QCBORDecode_Rewind(&DCtx);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ i = 9;
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7020;
+ }
+ if(QCBORDecode_GetError(&DCtx)){
+ return 7030;
+ }
+
+ // Rewind an empty indefinite length map
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+ QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pWithEmptyMapInDef), 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7810;
+ }
+ QCBORDecode_EnterMap(&DCtx, NULL);
+
+ /* Do it 5 times to be sure multiple rewinds work */
+ for(int n = 0; n < 5; n++) {
+ nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
+ if(nCBORError != QCBOR_ERR_NO_MORE_ITEMS) {
+ return 7800 + n;
+ }
+ QCBORDecode_Rewind(&DCtx);
+ }
+ QCBORDecode_ExitMap(&DCtx);
+ QCBORDecode_Rewind(&DCtx);
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7810;
+ }
+ QCBORDecode_ExitArray(&DCtx);
+ QCBORDecode_Rewind(&DCtx);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ i = 9;
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 100) {
+ return 7820;
+ }
+ if(QCBORDecode_GetError(&DCtx)){
+ return 7830;
+ }
+#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
+
+ // Rewind an indefnite length byte-string wrapped sequence
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
+ QCBORDecode_Init(&DCtx,
+ UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pWrappedByIndefiniteLength),
+ 0);
+ UsefulBuf_MAKE_STACK_UB(Pool, 100);
+ QCBORDecode_SetMemPool(&DCtx, Pool, 0);
+
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterBstrWrapped(&DCtx, 2, NULL);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_INPUT_TOO_LARGE) {
+ /* this is what happens when trying to enter byte string
+ wrapped CBOR. Tolerate for now. Eventually it needs
+ to be fixed so this works, but that is not simple. */
+ return 7300;
+ }
+
+ /*
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 42) {
+ return 7110;
+ }
+ QCBORDecode_Rewind(&DCtx);
+ QCBORDecode_GetUInt64(&DCtx, &i);
+ if(i != 42) {
+ return 7220;
+ }*/
+#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
+
+
+ // Rewind an indefnite length byte-string wrapped sequence
+
return 0;
}
diff --git a/test/qcbor_decode_tests.h b/test/qcbor_decode_tests.h
index e6a22f6..c2a4165 100644
--- a/test/qcbor_decode_tests.h
+++ b/test/qcbor_decode_tests.h
@@ -305,7 +305,7 @@
/*
Test PeekNext().
*/
-int32_t PeekTest(void);
+int32_t PeekAndRewindTest(void);
diff --git a/test/run_tests.c b/test/run_tests.c
index 5fb0895..314525c 100644
--- a/test/run_tests.c
+++ b/test/run_tests.c
@@ -123,7 +123,7 @@
TEST_ENTRY(CBORSequenceDecodeTests),
TEST_ENTRY(IntToTests),
TEST_ENTRY(DecodeTaggedTypeTests),
- TEST_ENTRY(PeekTest),
+ TEST_ENTRY(PeekAndRewindTest),
#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
TEST_ENTRY(EncodeLengthThirtyoneTest),
TEST_ENTRY(ExponentAndMantissaDecodeTests),