Add getting un decoded arrays and maps (#117)
This adds QCBORDecode_GetArray() and QCBORDecode_GetMap() plus friends. They return undecoded arrays and maps so they can be passed on to other decoder instances or such.
This also adds UsefulBuf_OffsetToPointer() and UsefulInputBuf_PointerToOffset() to UsefulBuf.
Consume no longer validates standard tags like big floats when it is consuming stuff. It still checks for CBOR that is not well formed.
There was some internal restructuring of array and map processing, but the tests are thorough and they are all passing.
This is to address #112
* getting started on returning arrays
* progress...
* returning maps and arrays mostly working
* Checkpoint progress
* Checkpoint: mostly working
* checkpoint -- it is working
* OffsetToPtr documentation and test
* test and documentation
* Fix Get() of nested indef arrays and maps
* Test tags; doc fixes
* Fix #ifdef test fan out
* Last bit of documentation update
---------
Co-authored-by: Laurence Lundblade <lgl@securitytheory.com>
diff --git a/inc/qcbor/UsefulBuf.h b/inc/qcbor/UsefulBuf.h
index 5f53044..b322e39 100644
--- a/inc/qcbor/UsefulBuf.h
+++ b/inc/qcbor/UsefulBuf.h
@@ -1,6 +1,6 @@
/* =========================================================================
* Copyright (c) 2016-2018, The Linux Foundation.
- * Copyright (c) 2018-2022, Laurence Lundblade.
+ * Copyright (c) 2018-2024, Laurence Lundblade.
* Copyright (c) 2021, Arm Limited. All rights reserved.
* All rights reserved.
*
@@ -43,6 +43,7 @@
when who what, where, why
-------- ---- --------------------------------------------------
+ 10/05/2024 llundblade Add Xxx_OffsetToPointer.
19/12/2022 llundblade Document that adding empty data is allowed.
4/11/2022 llundblade Add GetOutPlace and Advance to UsefulOutBuf.
9/21/2021 llundbla Clarify UsefulOutBuf size calculation mode
@@ -647,16 +648,27 @@
/**
- @brief Convert a pointer to an offset with bounds checking.
-
- @param[in] UB Pointer to the UsefulInputBuf.
- @param[in] p Pointer to convert to offset.
-
- @return SIZE_MAX if @c p is out of range, the byte offset if not.
+ * @brief Convert a pointer to an offset with bounds checking.
+ *
+ * @param[in] UB A UsefulBuf.
+ * @param[in] p Pointer to convert to offset.
+ *
+ * @return SIZE_MAX if @c p is out of range, the byte offset if not.
*/
static inline size_t UsefulBuf_PointerToOffset(UsefulBufC UB, const void *p);
+/**
+ * @brief Convert an offset to a pointer with bounds checking.
+ *
+ * @param[in] UB A UsefulBuf.
+ * @param[in] uOffset Offset in @c pUInBuf.
+ *
+ * @return @c NULL if @c uOffset is out of range, a pointer into the buffer if not.
+ */
+static inline const void *UsefulBuf_OffsetToPointer(UsefulBufC UB, size_t uOffset);
+
+
#ifndef USEFULBUF_DISABLE_DEPRECATED
/** Deprecated macro; use @ref UsefulBuf_FROM_SZ_LITERAL instead */
#define SZLiteralToUsefulBufC(szString) UsefulBuf_FROM_SZ_LITERAL(szString)
@@ -1491,7 +1503,18 @@
*
* @return SIZE_MAX if @c p is out of range, the byte offset if not.
*/
-static inline size_t UsefulInputBuf_PointerToOffset(UsefulInputBuf *pUInBuf, const void *p);
+static size_t UsefulInputBuf_PointerToOffset(UsefulInputBuf *pUInBuf, const void *p);
+
+
+/**
+ * @brief Convert an offset to a pointer with bounds checking.
+ *
+ * @param[in] pUInBuf Pointer to the @ref UsefulInputBuf.
+ * @param[in] uOffset Offset in @c pUInBuf.
+ *
+ * @return @c NULL if @c uOffset is out of range, a pointer into the buffer if not.
+ */
+static const void *UsefulInputBuf_OffsetToPointer(UsefulInputBuf *pUInBuf, size_t uOffset);
/**
@@ -1857,6 +1880,18 @@
}
+static inline const void *UsefulBuf_OffsetToPointer(UsefulBufC UB, size_t uOffset)
+{
+ if(UsefulBuf_IsNULLC(UB) || uOffset >= UB.len) {
+ return NULL;
+ }
+
+ return (const uint8_t *)UB.ptr + uOffset;
+}
+
+
+
+
#ifndef USEFULBUF_DISABLE_ALL_FLOAT
static inline uint32_t UsefulBufUtil_CopyFloatToUint32(float f)
{
@@ -2263,6 +2298,12 @@
}
+static inline const void *UsefulInputBuf_OffsetToPointer(UsefulInputBuf *pUInBuf, size_t uOffset)
+ {
+ return UsefulBuf_OffsetToPointer(pUInBuf->UB, uOffset);
+ }
+
+
static inline UsefulBufC UsefulInputBuf_GetUsefulBuf(UsefulInputBuf *pMe, size_t uNum)
{
const void *pResult = UsefulInputBuf_GetBytes(pMe, uNum);
diff --git a/inc/qcbor/qcbor_decode.h b/inc/qcbor/qcbor_decode.h
index 6fdb70f..b56bb16 100644
--- a/inc/qcbor/qcbor_decode.h
+++ b/inc/qcbor/qcbor_decode.h
@@ -981,10 +981,19 @@
* @param[in] pCtx The decoder context.
* @param[out] pDecodedItem The decoded CBOR item.
*
- * This is the same as QCBORDecode_VGetNext() but the contents of the
- * entire map or array will be consumed if the item is a map or array.
+ * @c pItem returned is the same as QCBORDecode_VGetNext(). If the
+ * item is an array or map, the entire contents of the array or map
+ * will be consumed leaving the cursor after the array or map.
*
- * In order to go back to decode the contents of a map or array
+ * If an array or map is being consumed by this, an error will occur
+ * if any of the items in the array or map are in error.
+ *
+ * If the item is a tag the contents of which is an array or map, like
+ * a big float, @c pItem will identify it as such and the contents
+ * will be consumed, but the validity of the tag won't be checked
+ * other than for being well-formed.
+ *
+ * In order to go back to decode the contents of an array or map
* consumed by this, the decoder must be rewound using
* QCBORDecode_Rewind().
*/
diff --git a/inc/qcbor/qcbor_spiffy_decode.h b/inc/qcbor/qcbor_spiffy_decode.h
index b374e9e..ebb4b65 100644
--- a/inc/qcbor/qcbor_spiffy_decode.h
+++ b/inc/qcbor/qcbor_spiffy_decode.h
@@ -675,8 +675,8 @@
* Nested arrays and maps may be entered to a depth of
* @ref QCBOR_MAX_ARRAY_NESTING.
*
- * See also QCBORDecode_ExitArray(), QCBORDecode_EnterMap() and
- * QCBORDecode_EnterBstrWrapped().
+ * See also QCBORDecode_ExitArray(), QCBORDecode_EnterMap(),
+ * QCBORDecode_EnterBstrWrapped() and QCBORDecode_GetArray().
*/
static void
QCBORDecode_EnterArray(QCBORDecodeContext *pCtx, QCBORItem *pItem);
@@ -710,6 +710,65 @@
+/**
+ * @brief Get the encoded bytes that make up an array.
+ *
+ * @param[in] pCtx The decode context.
+ * @param[out] pItem Place to return the item.
+ * @param[out] pEncodedCBOR Place to return pointer and length of the array.
+ *
+ * The next item to decode must be an array.
+ *
+ * The encoded bytes of the array will be returned. They can be
+ * decoded by another decoder instance.
+ *
+ * @c pItem will have the label and tags for the array. It is filled
+ * in the same as if QCBORDecode_GetNext() were called on the array item. In
+ * particular, the array count will be filled in for definite-length
+ * arrays and set to @c UINT16_MAX for indefinite-length arrays.
+ *
+ * This works on both definite and indefinite length arrays (unless
+ * indefinite length array decoding has been disabled).
+ *
+ * The pointer returned is to the data item that opens the array. The
+ * length in bytes includes it and all the member data items. If the array
+ * occurs in another map and thus has a label, the label is not included
+ * in what is returned.
+ *
+ * If the array is preceeded by tags, those encoded tags are included
+ * in the encoded CBOR that is returned.
+ *
+ * QCBORDecode_GetArray() consumes the entire array and leaves the
+ * traversal cursor at the item after the array.
+ * QCBORDecode_GetArrayFromMapN() and QCBORDecode_GetArrayFromMapSZ()
+ * don't affect the traversal cursor.
+ *
+ * This traverses the whole array and every subordinate array or map in
+ * it. This is necessary to determine the length of the array.
+ *
+ * This will fail if any item in the array is not well-formed.
+ *
+ * This uses a few hundred bytes of stack, more than most methods.
+ *
+ * See also QCBORDecode_EnterArray().
+ */
+static void
+QCBORDecode_GetArray(QCBORDecodeContext *pCtx,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+static void
+QCBORDecode_GetArrayFromMapN(QCBORDecodeContext *pCtx,
+ int64_t nLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+static void
+QCBORDecode_GetArrayFromMapSZ(QCBORDecodeContext *pCtx,
+ const char *szLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
/**
* @brief Enter a map for decoding and searching.
@@ -762,6 +821,8 @@
* QCBORDecode_EnterBstrWrapped(). Entering and exiting any nested
* combination of maps, arrays and bstr-wrapped CBOR is supported up
* to the maximum of @ref QCBOR_MAX_ARRAY_NESTING.
+ *
+ * See also QCBORDecode_GetMap().
*/
static void
QCBORDecode_EnterMap(QCBORDecodeContext *pCtx, QCBORItem *pItem);
@@ -795,6 +856,67 @@
/**
+ * @brief Get the bytes that make up a map.
+ *
+ * @param[in] pCtx The decode context.
+ * @param[out] pItem Place to return the item.
+ * @param[out] pEncodedCBOR Place to return pointer and length of the map.
+ *
+ * The next item to decode must be a map.
+ *
+ * The encoded bytes of the map will be returned. They can be
+ * decoded by another decoder instance.
+ *
+ * @c pItem will have the label and tags for the array. It is filled
+ * in the same as if QCBORDecode_GetNext() were called on the map item. In
+ * particular, the map count will be filled in for definite-length
+ * maps and set to @c UINT16_MAX for indefinite-length maps.
+ *
+ * This works on both definite and indefinite length maps (unless
+ * indefinite length map decoding has been disabled).
+ *
+ * The pointer returned is to the data item that opens the map. The
+ * length in bytes includes it and all the member data items. If the map
+ * occurs in another map and thus has a label, the label is not included
+ * in what is returned.
+ *
+ * If the map is preceeded by tags, those encoded tags are included in
+ * the encoded CBOR that is returned.
+ *
+ * QCBORDecode_GetMap() consumes the entire array and leaves the
+ * traversal cursor at the item after the map.
+ * QCBORDecode_GetMapFromMapN() and QCBORDecode_GetMapFromMapSZ()
+ * don't affect the traversal cursor.
+ *
+ * This traverses the whole map and every subordinate array or map in
+ * it. This is necessary to determine the length of the map. The
+ * traversal cursor is left at the first item after the map.
+ *
+ * This will fail if any item in the map is not well-formed.
+ *
+ * This uses a few hundred bytes of stack, more than most methods.
+ *
+ * See also QCBORDecode_EnterMap().
+ */
+static void
+QCBORDecode_GetMap(QCBORDecodeContext *pCtx,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+static void
+QCBORDecode_GetMapFromMapN(QCBORDecodeContext *pCtx,
+ int64_t nLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+static void
+QCBORDecode_GetMapFromMapSZ(QCBORDecodeContext *pCtx,
+ const char *szLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+
+/**
* @brief Reset traversal cursor to start of map, array, byte-string
* wrapped CBOR or start of input.
*
@@ -2067,6 +2189,103 @@
}
+/* Semi-private funcion used by public inline functions. See qcbor_decode.c */
+void
+QCBORDecode_Private_GetArrayOrMap(QCBORDecodeContext *pCtx,
+ uint8_t uType,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+
+/* Semi-private funcion used by public inline functions. See qcbor_decode.c */
+void
+QCBORDecode_Private_SearchAndGetArrayOrMap(QCBORDecodeContext *pCtx,
+ QCBORItem *pTarget,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR);
+
+
+static inline void
+QCBORDecode_GetArray(QCBORDecodeContext *pMe,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORDecode_Private_GetArrayOrMap(pMe, QCBOR_TYPE_ARRAY, pItem, pEncodedCBOR);
+}
+
+
+static inline void
+QCBORDecode_GetArrayFromMapN(QCBORDecodeContext *pMe,
+ int64_t nLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORItem OneItemSeach[2];
+ OneItemSeach[0].uLabelType = QCBOR_TYPE_INT64;
+ OneItemSeach[0].label.int64 = nLabel;
+ OneItemSeach[0].uDataType = QCBOR_TYPE_ARRAY;
+ OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
+
+ QCBORDecode_Private_SearchAndGetArrayOrMap(pMe, OneItemSeach, pItem, pEncodedCBOR);
+}
+
+
+static inline void
+QCBORDecode_GetArrayFromMapSZ(QCBORDecodeContext *pMe,
+ const char *szLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORItem OneItemSeach[2];
+ OneItemSeach[0].uLabelType = QCBOR_TYPE_TEXT_STRING;
+ OneItemSeach[0].label.string = UsefulBuf_FromSZ(szLabel);
+ OneItemSeach[0].uDataType = QCBOR_TYPE_ARRAY;
+ OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
+
+ QCBORDecode_Private_SearchAndGetArrayOrMap(pMe, OneItemSeach, pItem, pEncodedCBOR);
+}
+
+static inline void
+QCBORDecode_GetMap(QCBORDecodeContext *pMe,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORDecode_Private_GetArrayOrMap(pMe, QCBOR_TYPE_MAP, pItem, pEncodedCBOR);
+}
+
+
+static inline void
+QCBORDecode_GetMapFromMapN(QCBORDecodeContext *pMe,
+ int64_t nLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORItem OneItemSeach[2];
+ OneItemSeach[0].uLabelType = QCBOR_TYPE_INT64;
+ OneItemSeach[0].label.int64 = nLabel;
+ OneItemSeach[0].uDataType = QCBOR_TYPE_MAP;
+ OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
+
+ QCBORDecode_Private_SearchAndGetArrayOrMap(pMe, OneItemSeach, pItem, pEncodedCBOR);
+}
+
+
+static inline void
+QCBORDecode_GetMapFromMapSZ(QCBORDecodeContext *pMe,
+ const char *szLabel,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORItem OneItemSeach[2];
+ OneItemSeach[0].uLabelType = QCBOR_TYPE_TEXT_STRING;
+ OneItemSeach[0].label.string = UsefulBuf_FromSZ(szLabel);
+ OneItemSeach[0].uDataType = QCBOR_TYPE_MAP;
+ OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
+
+ QCBORDecode_Private_SearchAndGetArrayOrMap(pMe, OneItemSeach, pItem, pEncodedCBOR);
+}
+
+
static inline void
QCBORDecode_GetInt64Convert(QCBORDecodeContext *pMe,
diff --git a/src/qcbor_decode.c b/src/qcbor_decode.c
index 56f15f7..74465d0 100644
--- a/src/qcbor_decode.c
+++ b/src/qcbor_decode.c
@@ -1803,18 +1803,30 @@
*
* @param[in] pMe The decode context.
* @param[in] bMarkEnd If true mark end of maps/arrays with count of zero.
+ * @param[out] pbBreak Set to true if extra break was consumed.
*
* An item was just consumed, now figure out if it was the
* end of an array/map map that can be closed out. That
* may in turn close out the above array/map...
-*/
+ *
+ * When ascending indefinite-length arrays and maps, this will correctly
+ * consume the break for the level above. This is a problem for the
+ * implementation of QCBORDecode_GetArray() that must not return
+ * that break. @c pbBreak is set to true to indicate that one
+ * byte should be removed.
+ *
+ * Improvement: this could reduced further if indef is disabled
+ */
static QCBORError
-QCBORDecode_Private_NestLevelAscender(QCBORDecodeContext *pMe, bool bMarkEnd)
+QCBORDecode_Private_NestLevelAscender(QCBORDecodeContext *pMe, bool bMarkEnd, bool *pbBreak)
{
QCBORError uReturn;
/* Loop ascending nesting levels as long as there is ascending to do */
while(!DecodeNesting_IsCurrentAtTop(&(pMe->nesting))) {
+ if(pbBreak) {
+ *pbBreak = false;
+ }
if(DecodeNesting_IsCurrentBstrWrapped(&(pMe->nesting))) {
/* Nesting level is bstr-wrapped CBOR */
@@ -1856,6 +1868,9 @@
/* It was a break in an indefinitelength map / array so
* it is time to ascend one level.
*/
+ if(pbBreak) {
+ *pbBreak = true;
+ }
#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
}
@@ -1895,6 +1910,7 @@
* @brief Ascending & Descending out of nesting levels (decode layer 2).
*
* @param[in] pMe Decoder context
+ * @param[out] pbBreak Set to true if extra break was consumed.
* @param[out] pDecodedItem The decoded item that work is done on.
* @retval QCBOR_ERR_UNSUPPORTED Encountered unsupported/reserved
@@ -1935,6 +1951,7 @@
*/
static QCBORError
QCBORDecode_Private_GetNextMapOrArray(QCBORDecodeContext *pMe,
+ bool *pbBreak,
QCBORItem *pDecodedItem)
{
QCBORError uReturn;
@@ -2024,7 +2041,7 @@
* to the top level.
*/
QCBORError uAscendErr;
- uAscendErr = QCBORDecode_Private_NestLevelAscender(pMe, true);
+ uAscendErr = QCBORDecode_Private_NestLevelAscender(pMe, true, pbBreak);
if(uAscendErr != QCBOR_SUCCESS) {
/* This error is probably a traversal error and it overrides
* the non-traversal error.
@@ -2295,7 +2312,7 @@
/* --- Get the exponent --- */
QCBORItem exponentItem;
- uReturn = QCBORDecode_Private_GetNextMapOrArray(pMe, &exponentItem);
+ uReturn = QCBORDecode_Private_GetNextMapOrArray(pMe, NULL, &exponentItem);
if(uReturn != QCBOR_SUCCESS) {
goto Done;
}
@@ -2543,7 +2560,7 @@
{
QCBORError uReturn;
- uReturn = QCBORDecode_Private_GetNextMapOrArray(pMe, pDecodedItem);
+ uReturn = QCBORDecode_Private_GetNextMapOrArray(pMe, NULL, pDecodedItem);
if(uReturn != QCBOR_SUCCESS) {
goto Done;
}
@@ -3078,6 +3095,7 @@
static QCBORError
QCBORDecode_Private_ConsumeItem(QCBORDecodeContext *pMe,
const QCBORItem *pItemToConsume,
+ bool *pbBreak,
uint8_t *puNextNestLevel)
{
QCBORError uReturn;
@@ -3093,7 +3111,7 @@
* arrays by using the nesting level
*/
do {
- uReturn = QCBORDecode_GetNext(pMe, &Item);
+ uReturn = QCBORDecode_Private_GetNextMapOrArray(pMe, pbBreak, &Item);
if(QCBORDecode_IsUnrecoverableError(uReturn) ||
uReturn == QCBOR_ERR_NO_MORE_ITEMS) {
goto Done;
@@ -3105,7 +3123,7 @@
uReturn = QCBOR_SUCCESS;
} else {
- /* pItemToConsume is not a map or array. Just pass the nesting
+ /* pItemToConsume is not a map or array. Just pass the nesting
* level through. */
*puNextNestLevel = pItemToConsume->uNextNestLevel;
@@ -3126,7 +3144,7 @@
QCBORDecode_VGetNext(pMe, pDecodedItem);
if(pMe->uLastError == QCBOR_SUCCESS) {
- pMe->uLastError = (uint8_t)QCBORDecode_Private_ConsumeItem(pMe, pDecodedItem,
+ pMe->uLastError = (uint8_t)QCBORDecode_Private_ConsumeItem(pMe, pDecodedItem, NULL,
&pDecodedItem->uNextNestLevel);
}
}
@@ -3215,14 +3233,25 @@
+typedef struct {
+ void *pCBContext;
+ QCBORItemCallback pfCallback;
+} MapSearchCallBack;
+
+typedef struct {
+ size_t uStartOffset;
+ uint16_t uItemCount;
+} MapSearchInfo;
+
+
/**
* @brief Search a map for a set of items.
*
* @param[in] pMe The decode context to search.
* @param[in,out] pItemArray The items to search for and the items found.
- * @param[out] puOffset Byte offset of last item matched.
- * @param[in] pCBContext Context for the not-found item call back.
- * @param[in] pfCallback Function to call on items not matched in pItemArray.
+ * @param[out] pInfo Several bits of meta-info returned by search.
+ * @param[in] pCallBack Callback object or @c NULL.
+ * TODO: fix params
*
* @retval QCBOR_ERR_NOT_ENTERED Trying to search without entering a map.
*
@@ -3250,9 +3279,8 @@
static QCBORError
QCBORDecode_Private_MapSearch(QCBORDecodeContext *pMe,
QCBORItem *pItemArray,
- size_t *puOffset,
- void *pCBContext,
- QCBORItemCallback pfCallback)
+ MapSearchInfo *pInfo,
+ MapSearchCallBack *pCallBack)
{
QCBORError uReturn;
uint64_t uFoundItemBitMap = 0;
@@ -3309,6 +3337,9 @@
that error code is returned.
*/
const uint8_t uMapNestLevel = DecodeNesting_GetBoundedModeLevel(&(pMe->nesting));
+ if(pInfo) {
+ pInfo->uItemCount = 0;
+ }
uint8_t uNextNestLevel;
do {
/* Remember offset of the item because sometimes it has to be returned */
@@ -3318,12 +3349,12 @@
QCBORItem Item;
QCBORError uResult = QCBORDecode_Private_GetNextTagContent(pMe, &Item);
if(QCBORDecode_IsUnrecoverableError(uResult)) {
- /* Unrecoverable error so map can't even be decoded. */
+ /* The map/array can't be decoded when unrecoverable errors occur */
uReturn = uResult;
goto Done;
}
if(uResult == QCBOR_ERR_NO_MORE_ITEMS) {
- // Unexpected end of map or array.
+ /* Unexpected end of map or array. */
uReturn = uResult;
goto Done;
}
@@ -3338,7 +3369,9 @@
goto Done;
}
if(uResult != QCBOR_SUCCESS) {
- /* The label matches, but the data item is in error */
+ /* The label matches, but the data item is in error.
+ * It is OK to have recoverable errors on items that are not
+ * matched. */
uReturn = uResult;
goto Done;
}
@@ -3351,22 +3384,22 @@
/* Successful match. Return the item. */
pItemArray[nIndex] = Item;
uFoundItemBitMap |= 0x01ULL << nIndex;
- if(puOffset) {
- *puOffset = uOffset;
+ if(pInfo) {
+ pInfo->uStartOffset = uOffset;
}
bMatched = true;
}
}
- if(!bMatched && pfCallback != NULL) {
+ if(!bMatched && pCallBack != NULL) {
/*
Call the callback on unmatched labels.
(It is tempting to do duplicate detection here, but that would
require dynamic memory allocation because the number of labels
that might be encountered is unbounded.)
*/
- uReturn = (*pfCallback)(pCBContext, &Item);
+ uReturn = (*(pCallBack->pfCallback))(pCallBack->pCBContext, &Item);
if(uReturn != QCBOR_SUCCESS) {
goto Done;
}
@@ -3379,10 +3412,15 @@
items at the current nesting level are examined
to match the labels.
*/
- uReturn = QCBORDecode_Private_ConsumeItem(pMe, &Item, &uNextNestLevel);
+ uReturn = QCBORDecode_Private_ConsumeItem(pMe, &Item, NULL, &uNextNestLevel);
if(uReturn != QCBOR_SUCCESS) {
goto Done;
}
+
+ if(pInfo) {
+ pInfo->uItemCount++;
+ }
+
} while (uNextNestLevel >= uMapNestLevel);
uReturn = QCBOR_SUCCESS;
@@ -3436,7 +3474,7 @@
OneItemSeach[0].uDataType = uQcborType;
OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE; // Indicates end of array
- QCBORError uReturn = QCBORDecode_Private_MapSearch(pMe, OneItemSeach, NULL, NULL, NULL);
+ QCBORError uReturn = QCBORDecode_Private_MapSearch(pMe, OneItemSeach, NULL, NULL);
*pItem = OneItemSeach[0];
@@ -3471,7 +3509,8 @@
OneItemSeach[0].uDataType = uQcborType;
OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE; // Indicates end of array
- QCBORError uReturn = QCBORDecode_Private_MapSearch(pMe, OneItemSeach, NULL, NULL, NULL);
+ QCBORError uReturn = QCBORDecode_Private_MapSearch(pMe, OneItemSeach, NULL, NULL);
+
if(uReturn != QCBOR_SUCCESS) {
goto Done;
}
@@ -3487,6 +3526,146 @@
}
+
+/**
+ * @brief Semi-private. Get pointer, length and item for an array or map.
+ *
+ * @param[in] pMe The decode context.
+ * @param[in] uType CBOR major type, either array/map.
+ * @param[out] pItem The item for the array/map.
+ * @param[out] pEncodedCBOR Pointer and length of the encoded map or array.
+ *
+ * The next item to be decoded must be a map or array as specified by \c uType.
+ *
+ * \c pItem will be filled in with the label and tags of the array or map
+ * in addition to \c pEncodedCBOR giving the pointer and length of the
+ * encoded CBOR.
+ *
+ * When this is complete, the traversal cursor is at the end of the array or
+ * map that was retrieved.
+ */
+void
+QCBORDecode_Private_GetArrayOrMap(QCBORDecodeContext *pMe,
+ const uint8_t uType,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ QCBORError uErr;
+ uint8_t uNestLevel;
+ size_t uStartingCursor;
+ size_t uStartOfReturned;
+ size_t uEndOfReturned;
+ size_t uTempSaveCursor;
+ bool bInMap;
+ QCBORItem LabelItem;
+ bool EndedByBreak;
+
+ uStartingCursor = UsefulInputBuf_Tell(&(pMe->InBuf));
+ bInMap = DecodeNesting_IsCurrentTypeMap(&(pMe->nesting));
+
+ /* Could call GetNext here, but don't need to because this
+ * is only interested in arrays and maps. */
+ uErr = QCBORDecode_Private_GetNextMapOrArray(pMe, NULL, pItem);
+ if(uErr != QCBOR_SUCCESS) {
+ pMe->uLastError = (uint8_t)uErr;
+ return;
+ }
+
+ if(pItem->uDataType != uType) {
+ pMe->uLastError = QCBOR_ERR_UNEXPECTED_TYPE;
+ return;
+ }
+
+ if(bInMap) {
+ /* If the item is in a map, the start of the array/map
+ * itself, not the label, must be found. Do this by
+ * rewinding to the starting position and fetching
+ * just the label data item. QCBORDecode_Private_GetNextTagNumber()
+ * doesn't do any of the array/map item counting or nesting
+ * level tracking. Used here it will just fetech the label
+ * data item.
+ *
+ * Have to save the cursor and put it back to the position
+ * after the full item once the label as been fetched by
+ * itself.
+ */
+ uTempSaveCursor = UsefulInputBuf_Tell(&(pMe->InBuf));
+ UsefulInputBuf_Seek(&(pMe->InBuf), uStartingCursor);
+
+ /* Item has been fetched once so safe to ignore error */
+ (void)QCBORDecode_Private_GetNextTagNumber(pMe, &LabelItem);
+
+ uStartOfReturned = UsefulInputBuf_Tell(&(pMe->InBuf));
+ UsefulInputBuf_Seek(&(pMe->InBuf), uTempSaveCursor);
+ } else {
+ uStartOfReturned = uStartingCursor;
+ }
+
+ /* Consume the entire array/map to find the end */
+ uErr = QCBORDecode_Private_ConsumeItem(pMe, pItem, &EndedByBreak, &uNestLevel);
+ if(uErr != QCBOR_SUCCESS) {
+ pMe->uLastError = (uint8_t)uErr;
+ goto Done;
+ }
+
+ /* Fill in returned values */
+ uEndOfReturned = UsefulInputBuf_Tell(&(pMe->InBuf));
+ if(EndedByBreak) {
+ /* When ascending nesting levels, a break for the level above
+ * was consumed. That break is not a part of what is consumed here. */
+ uEndOfReturned--;
+ }
+ pEncodedCBOR->ptr = UsefulInputBuf_OffsetToPointer(&(pMe->InBuf), uStartOfReturned);
+ pEncodedCBOR->len = uEndOfReturned - uStartOfReturned;
+
+Done:
+ return;
+}
+
+
+/**
+ * @brief Semi-private. Get pointer, length and item count of an array or map.
+ *
+ * @param[in] pMe The decode context.
+ * @param[in] pTarget The label and type of the array or map to retrieve.
+ * @param[out] pItem The item for the array/map.
+ * @param[out] pEncodedCBOR Pointer and length of the encoded map or array.
+ *
+ * The next item to be decoded must be a map or array as specified by \c uType.
+ *
+ * When this is complete, the traversal cursor is unchanged.
+ */void
+QCBORDecode_Private_SearchAndGetArrayOrMap(QCBORDecodeContext *pMe,
+ QCBORItem *pTarget,
+ QCBORItem *pItem,
+ UsefulBufC *pEncodedCBOR)
+{
+ MapSearchInfo Info;
+ QCBORDecodeNesting SaveNesting;
+ size_t uSaveCursor;
+
+ pMe->uLastError = (uint8_t)QCBORDecode_Private_MapSearch(pMe, pTarget, &Info, NULL);
+ if(pMe->uLastError != QCBOR_SUCCESS) {
+ return;
+ }
+
+ /* Save the whole position of things so they can be restored.
+ * so the cursor position is unchanged by this operation, like
+ * all the other GetXxxxInMap() operations. */
+ DecodeNesting_PrepareForMapSearch(&(pMe->nesting), &SaveNesting);
+ uSaveCursor = UsefulInputBuf_Tell(&(pMe->InBuf));
+
+ DecodeNesting_ResetMapOrArrayCount(&(pMe->nesting));
+ UsefulInputBuf_Seek(&(pMe->InBuf), Info.uStartOffset);
+ QCBORDecode_Private_GetArrayOrMap(pMe, pTarget[0].uDataType, pItem, pEncodedCBOR);
+
+ UsefulInputBuf_Seek(&(pMe->InBuf), uSaveCursor);
+ DecodeNesting_RestoreFromMapSearch(&(pMe->nesting), &SaveNesting);
+}
+
+
+
+
/**
* @brief Is a QCBOR_TYPE in the type list?
*
@@ -3697,7 +3876,7 @@
void
QCBORDecode_GetItemsInMap(QCBORDecodeContext *pMe, QCBORItem *pItemList)
{
- QCBORError uErr = QCBORDecode_Private_MapSearch(pMe, pItemList, NULL, NULL, NULL);
+ QCBORError uErr = QCBORDecode_Private_MapSearch(pMe, pItemList, NULL, NULL);
pMe->uLastError = (uint8_t)uErr;
}
@@ -3710,7 +3889,12 @@
void *pCallbackCtx,
QCBORItemCallback pfCB)
{
- QCBORError uErr = QCBORDecode_Private_MapSearch(pMe, pItemList, NULL, pCallbackCtx, pfCB);
+ MapSearchCallBack CallBack;
+ CallBack.pCBContext = pCallbackCtx;
+ CallBack.pfCallback = pfCB;
+
+ QCBORError uErr = QCBORDecode_Private_MapSearch(pMe, pItemList, NULL, &CallBack);
+
pMe->uLastError = (uint8_t)uErr;
}
@@ -3738,8 +3922,8 @@
return;
}
- size_t uOffset;
- pMe->uLastError = (uint8_t)QCBORDecode_Private_MapSearch(pMe, pSearch, &uOffset, NULL, NULL);
+ MapSearchInfo Info;
+ pMe->uLastError = (uint8_t)QCBORDecode_Private_MapSearch(pMe, pSearch, &Info, NULL);
if(pMe->uLastError != QCBOR_SUCCESS) {
return;
}
@@ -3769,7 +3953,7 @@
* to be used to get one item and MapSearch() has already found it
* confirming it exists.
*/
- UsefulInputBuf_Seek(&(pMe->InBuf), uOffset);
+ UsefulInputBuf_Seek(&(pMe->InBuf), Info.uStartOffset);
DecodeNesting_ResetMapOrArrayCount(&(pMe->nesting));
@@ -3951,7 +4135,7 @@
* level is reached. It may do nothing, or ascend all the way to
* the top level.
*/
- uErr = QCBORDecode_Private_NestLevelAscender(pMe, false);
+ uErr = QCBORDecode_Private_NestLevelAscender(pMe, NULL, false);
if(uErr != QCBOR_SUCCESS) {
goto Done;
}
@@ -4004,7 +4188,7 @@
if(pMe->uMapEndOffsetCache == QCBOR_MAP_OFFSET_CACHE_INVALID) {
QCBORItem Dummy;
Dummy.uLabelType = QCBOR_TYPE_NONE;
- uErr = QCBORDecode_Private_MapSearch(pMe, &Dummy, NULL, NULL, NULL);
+ uErr = QCBORDecode_Private_MapSearch(pMe, &Dummy, NULL, NULL);
if(uErr != QCBOR_SUCCESS) {
goto Done;
}
diff --git a/test/UsefulBuf_Tests.c b/test/UsefulBuf_Tests.c
index e93a011..7e83f24 100644
--- a/test/UsefulBuf_Tests.c
+++ b/test/UsefulBuf_Tests.c
@@ -673,6 +673,22 @@
return "Incorrect pointer offset for start";
}
+ if(UsefulBuf_OffsetToPointer(Boo, 0) != &pB[0]) {
+ return "Wrong OffsetToPointer";
+ }
+
+ if(UsefulBuf_OffsetToPointer(Boo, 3) != NULL) {
+ return "Didn't validate offset correctly";
+ }
+
+ if(UsefulBuf_OffsetToPointer(Boo, 2) != &pB[2]) {
+ return "Wrong OffsetToPointer 2";
+ }
+
+ if(UsefulBuf_OffsetToPointer(NULLUsefulBufC, 2) != NULL) {
+ return "Failed OffsetToPtr on NULLUsefulBufC";
+ }
+
return NULL;
}
@@ -800,6 +816,20 @@
return "PointerToOffset not working";
}
+
+ const uint8_t pB[] = {0x01, 0x02, 0x03};
+ UsefulBufC Boo = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pB);
+
+ UsefulInputBuf_Init(&UIB, Boo);
+
+ if(UsefulInputBuf_OffsetToPointer(&UIB, 0) != &pB[0]) {
+ return "OffsetToPointer fail";
+ }
+
+ if(UsefulInputBuf_OffsetToPointer(&UIB, SIZE_MAX) != NULL) {
+ return "OffsetToPointer SIZE_MAX fail";
+ }
+
return NULL;
}
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 7fedf91..1a83452 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -5945,9 +5945,6 @@
00
};
-const unsigned char spBadConsumeInput3[] = {
- 0x81, 0xc0, 0x81, 0x00
-};
const unsigned char spBadConsumeInput4[] = {
0x81, 0x9f, 0x00, 0xff
@@ -6003,6 +6000,9 @@
QCBORDecode_EnterMap(&DCtx, NULL);
QCBORDecode_GetInt64InMapN (&DCtx, 3, &nInt);
uErr = QCBORDecode_GetNext(&DCtx, &Item1);
+ if(uErr != QCBOR_SUCCESS) {
+ return 701;
+ }
if(Item1.uDataType != QCBOR_TYPE_INT64) {
return 700;
}
@@ -6424,12 +6424,6 @@
if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
return 2700;
}
-
- QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBadConsumeInput3), 0);
- QCBORDecode_VGetNextConsume(&DCtx, &Item1);
- if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_UNRECOVERABLE_TAG_CONTENT) {
- return 2800;
- }
#endif
@@ -8841,6 +8835,333 @@
}
+
+static const uint8_t spExpectedArray2s[] = {
+ 0x82, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x31, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x32};
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+static const uint8_t spExpectedArray2sIndef[] = {
+ 0x9f, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x31, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x32, 0xff};
+#endif
+
+static const uint8_t spExpectedMap4[] = {
+ 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
+
+static const uint8_t spExpectedMap4Indef[] = {
+ 0xbf, 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};
+
+/*
+ * [[[[[0, []]]]], 0]
+ */
+static const uint8_t spDefAndIndef[] = {
+ 0x82,
+ 0x9f, 0x9f, 0x9f, 0x82, 0x00, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x00
+};
+#endif /* !QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
+
+
+#ifndef QCBOR_DISABLE_TAGS
+/* An exp / mant tag in two nested arrays */
+static const uint8_t spExpMant[] = {0x81, 0x81, 0xC4, 0x82, 0x20, 0x03};
+#endif /* !QCBOR_DISABLE_TAGS */
+
+
+int32_t GetMapAndArrayTest(void)
+{
+ QCBORDecodeContext DCtx;
+ size_t uPosition ;
+ QCBORItem Item;
+ UsefulBufC ReturnedEncodedCBOR;
+
+
+ QCBORDecode_Init(&DCtx,
+ UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded),
+ 0);
+
+ QCBORDecode_EnterMap(&DCtx, NULL);
+ QCBORDecode_VGetNextConsume(&DCtx, &Item);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 1;
+ }
+ if(Item.val.uCount != 2) {
+ return 2;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedArray2s))) {
+ return 3;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ UsefulBuf_Compare(Item.label.string, UsefulBuf_FROM_SZ_LITERAL("an array of two strings"))) {
+ return 4;
+ }
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+
+
+ QCBORDecode_GetMap(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 10;
+ }
+ if(Item.val.uCount != 4) {
+ return 11;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedMap4))) {
+ return 12;
+ }
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetArrayFromMapSZ(&DCtx,
+ "an array of two strings",
+ &Item,
+ &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 20;
+ }
+ if(Item.val.uCount != 2) {
+ return 21;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedArray2s))) {
+ return 22;
+ }
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 23;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetMapFromMapSZ(&DCtx, "map in a map", &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 30;
+ }
+ if(Item.val.uCount != 4) {
+ return 31;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedMap4))) {
+ return 32;
+ }
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 33;
+ }
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetArrayFromMapSZ(&DCtx, "map in a map", &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_UNEXPECTED_TYPE) {
+ return 40;
+ }
+ if(UINT32_MAX != QCBORDecode_Tell(&DCtx)) {
+ return 41;
+ }
+ QCBORDecode_GetAndResetError(&DCtx);
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 42;
+ }
+
+
+#ifndef QCBOR_DISABLE_TAGS
+ UsefulBufC ExpMant = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpMant);
+ QCBORDecode_Init(&DCtx, ExpMant, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 200;
+ }
+ if(Item.uDataType != QCBOR_TYPE_ARRAY) {
+ return 201;
+ }
+ if(!QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_DECIMAL_FRACTION)) {
+ return 202;
+ }
+ if(Item.val.uCount != 2) {
+ return 201;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(ExpMant, 2))) {
+ return 205;
+ }
+#endif /* !QCBOR_DISABLE_TAGS */
+
+
+#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
+
+ UsefulBufC DefAndIndef = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spDefAndIndef);
+ QCBORDecode_Init(&DCtx, DefAndIndef, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 50;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(UsefulBuf_Head(DefAndIndef, 11), 1))) {
+ return 51;
+ }
+
+ QCBORDecode_Init(&DCtx, DefAndIndef, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 52;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(UsefulBuf_Head(DefAndIndef, 10), 2))) {
+ return 53;
+ }
+
+ QCBORDecode_Init(&DCtx, DefAndIndef, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 54;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(UsefulBuf_Head(DefAndIndef, 9), 3))) {
+ return 55;
+ }
+ QCBORDecode_Init(&DCtx, DefAndIndef, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 56;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(UsefulBuf_Head(DefAndIndef, 8), 4))) {
+ return 57;
+ }
+
+ QCBORDecode_Init(&DCtx, DefAndIndef, 0);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_EnterArray(&DCtx, NULL);
+ QCBORDecode_VGetNextConsume(&DCtx, &Item);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
+ return 58;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_Tail(UsefulBuf_Head(DefAndIndef, 8), 6))) {
+ return 59;
+ }
+
+
+ QCBORDecode_Init(&DCtx,
+ UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapIndefEncoded),
+ 0);
+
+ QCBORDecode_EnterMap(&DCtx, NULL);
+ QCBORDecode_VGetNextConsume(&DCtx, &Item);
+ QCBORDecode_GetArray(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 60;
+ }
+ if(Item.val.uCount != UINT16_MAX) {
+ return 61;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedArray2sIndef))) {
+ return 62;
+ }
+
+ if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
+ UsefulBuf_Compare(Item.label.string, UsefulBuf_FROM_SZ_LITERAL("an array of two strings"))) {
+ return 63;
+ }
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+
+
+ QCBORDecode_GetMap(&DCtx, &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 70;
+ }
+ if(Item.val.uCount != UINT16_MAX) {
+ return 71;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedMap4Indef))) {
+ return 72;
+ }
+
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetArrayFromMapSZ(&DCtx,
+ "an array of two strings",
+ &Item,
+ &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 80;
+ }
+ if(Item.val.uCount != UINT16_MAX) {
+ return 81;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedArray2sIndef))) {
+ return 82;
+ }
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 83;
+ }
+
+ QCBORDecode_Rewind(&DCtx);
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetMapFromMapSZ(&DCtx, "map in a map", &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx)) {
+ return 90;
+ }
+ if(Item.val.uCount != UINT16_MAX) {
+ return 91;
+ }
+ if(UsefulBuf_Compare(ReturnedEncodedCBOR, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedMap4Indef))) {
+ return 92;
+ }
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 93;
+ }
+
+ uPosition = QCBORDecode_Tell(&DCtx);
+ QCBORDecode_GetArrayFromMapSZ(&DCtx, "map in a map", &Item, &ReturnedEncodedCBOR);
+ if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_UNEXPECTED_TYPE) {
+ return 100;
+ }
+ if(UINT32_MAX != QCBORDecode_Tell(&DCtx)) {
+ return 101;
+ }
+ QCBORDecode_GetAndResetError(&DCtx);
+ if(uPosition != QCBORDecode_Tell(&DCtx)) {
+ return 102;
+ }
+#endif /* !QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
+
+ return 0;
+}
+
+
int32_t
ErrorHandlingTests(void)
{
diff --git a/test/qcbor_decode_tests.h b/test/qcbor_decode_tests.h
index 8d26c98..b23149a 100644
--- a/test/qcbor_decode_tests.h
+++ b/test/qcbor_decode_tests.h
@@ -323,6 +323,11 @@
int32_t ErrorHandlingTests(void);
+/*
+ * Test QCBORDecode_GetArray and QCBORDecode_GetMap
+ */
+int32_t GetMapAndArrayTest(void);
+
int32_t TellTests(void);
diff --git a/test/run_tests.c b/test/run_tests.c
index 5d17cde..ce3db14 100644
--- a/test/run_tests.c
+++ b/test/run_tests.c
@@ -66,6 +66,7 @@
static test_entry s_tests[] = {
+ TEST_ENTRY(GetMapAndArrayTest),
TEST_ENTRY(TellTests),
TEST_ENTRY(ErrorHandlingTests),
TEST_ENTRY(OpenCloseBytesTest),