blob: c7b2044356552d32d828e4262fe23e28c0e05f33 [file] [log] [blame]
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001/*==============================================================================
Laurence Lundbladed92a6162018-11-01 11:38:35 +07002 Copyright (c) 2016-2018, The Linux Foundation.
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08003 Copyright (c) 2018-2021, Laurence Lundblade.
Laurence Lundbladed92a6162018-11-01 11:38:35 +07004 All rights reserved.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08005
Laurence Lundblade0dbc9172018-11-01 14:17:21 +07006Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are
8met:
9 * Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11 * Redistributions in binary form must reproduce the above
12 copyright notice, this list of conditions and the following
13 disclaimer in the documentation and/or other materials provided
14 with the distribution.
15 * Neither the name of The Linux Foundation nor the names of its
16 contributors, nor the name "Laurence Lundblade" may be used to
17 endorse or promote products derived from this software without
18 specific prior written permission.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -080019
Laurence Lundblade0dbc9172018-11-01 14:17:21 +070020THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
21WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
23ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
24BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
30IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Laurence Lundbladeee851742020-01-08 08:37:05 -080031 =============================================================================*/
Laurence Lundblade624405d2018-09-18 20:10:47 -070032
Laurence Lundblade3aee3a32018-12-17 16:17:45 -080033
Laurence Lundblade844bb5c2020-03-01 17:27:25 -080034#include "qcbor/qcbor_decode.h"
Laurence Lundblade67257dc2020-07-27 03:33:37 -070035#include "qcbor/qcbor_spiffy_decode.h"
Laurence Lundblade3f1318a2021-01-04 18:26:44 -080036#include "ieee754.h" /* Does not use math.h */
Laurence Lundbladec7114722020-08-13 05:11:40 -070037
38#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade3f1318a2021-01-04 18:26:44 -080039
40#include <math.h> /* For isnan(), llround(), llroudf(), round(), roundf(),
41 * pow(), exp2()
42 */
43#include <fenv.h> /* feclearexcept(), fetestexcept() */
44
Laurence Lundbladee2c893c2020-12-26 17:41:53 -080045#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -070046
Laurence Lundbladeb69cad72018-09-13 11:09:01 -070047
Laurence Lundbladeb69cad72018-09-13 11:09:01 -070048
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +053049/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -080050 * This casts away the const-ness of a pointer, usually so it can be
51 * freed or realloced.
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +053052 */
53#define UNCONST_POINTER(ptr) ((void *)(ptr))
54
Laurence Lundbladea9489f82020-09-12 13:50:56 -070055#define SIZEOF_C_ARRAY(array,type) (sizeof(array)/sizeof(type))
Laurence Lundbladeb69cad72018-09-13 11:09:01 -070056
Laurence Lundbladeb69cad72018-09-13 11:09:01 -070057
Laurence Lundblade3f1318a2021-01-04 18:26:44 -080058
59
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -070060static inline bool
Laurence Lundblade02625d42020-06-25 14:41:41 -070061QCBORItem_IsMapOrArray(const QCBORItem *pMe)
62{
63 const uint8_t uDataType = pMe->uDataType;
64 return uDataType == QCBOR_TYPE_MAP ||
65 uDataType == QCBOR_TYPE_ARRAY ||
66 uDataType == QCBOR_TYPE_MAP_AS_ARRAY;
67}
68
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -070069static inline bool
Laurence Lundblade02625d42020-06-25 14:41:41 -070070QCBORItem_IsEmptyDefiniteLengthMapOrArray(const QCBORItem *pMe)
71{
72 if(!QCBORItem_IsMapOrArray(pMe)){
73 return false;
74 }
75
76 if(pMe->val.uCount != 0) {
77 return false;
78 }
79 return true;
80}
81
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -070082static inline bool
Laurence Lundblade02625d42020-06-25 14:41:41 -070083QCBORItem_IsIndefiniteLengthMapOrArray(const QCBORItem *pMe)
84{
Laurence Lundbladee2c893c2020-12-26 17:41:53 -080085#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
Laurence Lundblade02625d42020-06-25 14:41:41 -070086 if(!QCBORItem_IsMapOrArray(pMe)){
87 return false;
88 }
89
90 if(pMe->val.uCount != QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH) {
91 return false;
92 }
93 return true;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -080094#else /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
95 (void)pMe;
96 return false;
97#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
Laurence Lundblade02625d42020-06-25 14:41:41 -070098}
99
100
Laurence Lundbladeee851742020-01-08 08:37:05 -0800101/*===========================================================================
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700102 DecodeNesting -- Tracking array/map/sequence/bstr-wrapped nesting
Laurence Lundbladeee851742020-01-08 08:37:05 -0800103 ===========================================================================*/
104
Laurence Lundblade9c905e82020-04-25 11:31:38 -0700105/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800106 * See comments about and typedef of QCBORDecodeNesting in qcbor_private.h,
107 * the data structure all these functions work on.
Laurence Lundblade9c905e82020-04-25 11:31:38 -0700108 */
109
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700110
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700111static inline uint8_t
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700112DecodeNesting_GetCurrentLevel(const QCBORDecodeNesting *pNesting)
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700113{
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700114 const ptrdiff_t nLevel = pNesting->pCurrent - &(pNesting->pLevels[0]);
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800115 /* Limit in DecodeNesting_Descend against more than
116 * QCBOR_MAX_ARRAY_NESTING gaurantees cast is safe
Laurence Lundblade02625d42020-06-25 14:41:41 -0700117 */
Laurence Lundblade5e87da62020-06-07 03:24:28 -0700118 return (uint8_t)nLevel;
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700119}
120
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700121
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700122static inline uint8_t
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700123DecodeNesting_GetBoundedModeLevel(const QCBORDecodeNesting *pNesting)
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700124{
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700125 const ptrdiff_t nLevel = pNesting->pCurrentBounded - &(pNesting->pLevels[0]);
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800126 /* Limit in DecodeNesting_Descend against more than
127 * QCBOR_MAX_ARRAY_NESTING gaurantees cast is safe
Laurence Lundblade02625d42020-06-25 14:41:41 -0700128 */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700129 return (uint8_t)nLevel;
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700130}
131
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700132
Laurence Lundblade5f4e8712020-07-25 11:44:43 -0700133static inline uint32_t
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700134DecodeNesting_GetMapOrArrayStart(const QCBORDecodeNesting *pNesting)
Laurence Lundblade02625d42020-06-25 14:41:41 -0700135{
136 return pNesting->pCurrentBounded->u.ma.uStartOffset;
137}
138
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700139
Laurence Lundblade085d7952020-07-24 10:26:30 -0700140static inline bool
141DecodeNesting_IsBoundedEmpty(const QCBORDecodeNesting *pNesting)
142{
143 if(pNesting->pCurrentBounded->u.ma.uCountCursor == QCBOR_COUNT_INDICATES_ZERO_LENGTH) {
144 return true;
145 } else {
146 return false;
147 }
148}
149
150
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700151static inline bool
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700152DecodeNesting_IsCurrentAtTop(const QCBORDecodeNesting *pNesting)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700153{
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700154 if(pNesting->pCurrent == &(pNesting->pLevels[0])) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -0700155 return true;
156 } else {
157 return false;
158 }
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700159}
160
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700161
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700162static inline bool
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700163DecodeNesting_IsCurrentDefiniteLength(const QCBORDecodeNesting *pNesting)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700164{
165 if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800166 /* Not a map or array */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700167 return false;
168 }
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800169
170#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700171 if(pNesting->pCurrent->u.ma.uCountTotal == QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800172 /* Is indefinite */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700173 return false;
174 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800175
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800176#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
177
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800178 /* All checks passed; is a definte length map or array */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700179 return true;
180}
181
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700182static inline bool
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700183DecodeNesting_IsCurrentBstrWrapped(const QCBORDecodeNesting *pNesting)
Laurence Lundblade642282a2020-06-23 12:00:33 -0700184{
185 if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800186 /* is a byte string */
Laurence Lundblade642282a2020-06-23 12:00:33 -0700187 return true;
188 }
189 return false;
190}
191
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700192
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700193static inline bool DecodeNesting_IsCurrentBounded(const QCBORDecodeNesting *pNesting)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700194{
195 if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
196 return true;
197 }
Laurence Lundblade02625d42020-06-25 14:41:41 -0700198 if(pNesting->pCurrent->u.ma.uStartOffset != QCBOR_NON_BOUNDED_OFFSET) {
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700199 return true;
200 }
201 return false;
202}
203
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700204
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700205static inline void DecodeNesting_SetMapOrArrayBoundedMode(QCBORDecodeNesting *pNesting, bool bIsEmpty, size_t uStart)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700206{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800207 /* Should be only called on maps and arrays */
Laurence Lundbladeabf5c572020-06-29 21:21:29 -0700208 /*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800209 * DecodeNesting_EnterBoundedMode() checks to be sure uStart is not
210 * larger than DecodeNesting_EnterBoundedMode which keeps it less than
211 * uin32_t so the cast is safe.
Laurence Lundbladeabf5c572020-06-29 21:21:29 -0700212 */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700213 pNesting->pCurrent->u.ma.uStartOffset = (uint32_t)uStart;
Laurence Lundblade085d7952020-07-24 10:26:30 -0700214
215 if(bIsEmpty) {
216 pNesting->pCurrent->u.ma.uCountCursor = QCBOR_COUNT_INDICATES_ZERO_LENGTH;
217 }
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700218}
219
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700220
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700221static inline void DecodeNesting_ClearBoundedMode(QCBORDecodeNesting *pNesting)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700222{
Laurence Lundblade02625d42020-06-25 14:41:41 -0700223 pNesting->pCurrent->u.ma.uStartOffset = QCBOR_NON_BOUNDED_OFFSET;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700224}
225
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700226
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700227static inline bool
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700228DecodeNesting_IsAtEndOfBoundedLevel(const QCBORDecodeNesting *pNesting)
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700229{
230 if(pNesting->pCurrentBounded == NULL) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800231 /* No bounded map or array set up */
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700232 return false;
233 }
234 if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800235 /* Not a map or array; end of those is by byte count */
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700236 return false;
237 }
Laurence Lundblade6ab01fb2020-10-01 13:04:49 -0700238 if(!DecodeNesting_IsCurrentBounded(pNesting)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800239 /* In a traveral at a level deeper than the bounded level */
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700240 return false;
241 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800242 /* Works for both definite- and indefinitelength maps/arrays */
Laurence Lundbladeddebabe2020-11-22 11:32:17 -0800243 if(pNesting->pCurrentBounded->u.ma.uCountCursor != 0 &&
244 pNesting->pCurrentBounded->u.ma.uCountCursor != QCBOR_COUNT_INDICATES_ZERO_LENGTH) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800245 /* Count is not zero, still unconsumed item */
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700246 return false;
247 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800248 /* All checks passed, got to the end of an array or map*/
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700249 return true;
250}
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700251
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700252
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700253static inline bool
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700254DecodeNesting_IsEndOfDefiniteLengthMapOrArray(const QCBORDecodeNesting *pNesting)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700255{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800256 /* Must only be called on map / array */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700257 if(pNesting->pCurrent->u.ma.uCountCursor == 0) {
258 return true;
Laurence Lundblade9c905e82020-04-25 11:31:38 -0700259 } else {
Laurence Lundblade3f9ef042020-04-14 13:15:51 -0700260 return false;
261 }
Laurence Lundblade3f9ef042020-04-14 13:15:51 -0700262}
263
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700264
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700265static inline bool
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700266DecodeNesting_IsCurrentTypeMap(const QCBORDecodeNesting *pNesting)
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700267{
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700268 if(pNesting->pCurrent->uLevelType == CBOR_MAJOR_TYPE_MAP) {
269 return true;
270 } else {
271 return false;
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700272 }
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700273}
274
Laurence Lundblade410c7e02020-06-25 23:35:29 -0700275
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700276static inline bool
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -0700277DecodeNesting_IsBoundedType(const QCBORDecodeNesting *pNesting, uint8_t uType)
Laurence Lundblade2b843b52020-06-16 20:51:03 -0700278{
Laurence Lundblade02625d42020-06-25 14:41:41 -0700279 if(pNesting->pCurrentBounded == NULL) {
Laurence Lundblade2b843b52020-06-16 20:51:03 -0700280 return false;
281 }
Laurence Lundblade02625d42020-06-25 14:41:41 -0700282
283 if(pNesting->pCurrentBounded->uLevelType != uType) {
284 return false;
285 }
286
287 return true;
Laurence Lundblade2b843b52020-06-16 20:51:03 -0700288}
289
Laurence Lundblade02625d42020-06-25 14:41:41 -0700290
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700291static inline void
Laurence Lundblade6c8a4442020-06-22 22:16:11 -0700292DecodeNesting_DecrementDefiniteLengthMapOrArrayCount(QCBORDecodeNesting *pNesting)
Laurence Lundblade041ffa52018-10-07 11:43:51 +0700293{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800294 /* Only call on a definite-length array / map */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700295 pNesting->pCurrent->u.ma.uCountCursor--;
Laurence Lundbladed8c82c52020-06-12 22:15:52 -0700296}
Laurence Lundblade0a042a92020-06-12 14:09:50 -0700297
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700298
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700299static inline void
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700300DecodeNesting_ReverseDecrement(QCBORDecodeNesting *pNesting)
301{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800302 /* Only call on a definite-length array / map */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700303 pNesting->pCurrent->u.ma.uCountCursor++;
304}
305
306
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700307static inline void
Laurence Lundblade0a042a92020-06-12 14:09:50 -0700308DecodeNesting_Ascend(QCBORDecodeNesting *pNesting)
309{
310 pNesting->pCurrent--;
311}
312
Laurence Lundblade02625d42020-06-25 14:41:41 -0700313
314static QCBORError
Laurence Lundbladee6f15112020-07-23 18:44:16 -0700315DecodeNesting_Descend(QCBORDecodeNesting *pNesting, uint8_t uType)
Laurence Lundblade02625d42020-06-25 14:41:41 -0700316{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800317 /* Error out if nesting is too deep */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700318 if(pNesting->pCurrent >= &(pNesting->pLevels[QCBOR_MAX_ARRAY_NESTING])) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -0700319 return QCBOR_ERR_ARRAY_DECODE_NESTING_TOO_DEEP;
Laurence Lundblade02625d42020-06-25 14:41:41 -0700320 }
321
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800322 /* The actual descend */
Laurence Lundblade02625d42020-06-25 14:41:41 -0700323 pNesting->pCurrent++;
324
325 pNesting->pCurrent->uLevelType = uType;
326
327 return QCBOR_SUCCESS;
328}
329
330
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700331static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800332DecodeNesting_EnterBoundedMapOrArray(QCBORDecodeNesting *pNesting,
333 bool bIsEmpty,
334 size_t uOffset)
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -0700335{
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700336 /*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800337 * Should only be called on map/array.
338 *
339 * Have descended into this before this is called. The job here is
340 * just to mark it in bounded mode.
341 *
342 * Check against QCBOR_MAX_DECODE_INPUT_SIZE make sure that
343 * uOffset doesn't collide with QCBOR_NON_BOUNDED_OFFSET.
344 *
345 * Cast of uOffset to uint32_t for cases where SIZE_MAX < UINT32_MAX.
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700346 */
Laurence Lundblade9c1b7b42020-12-12 11:44:16 -0800347 if((uint32_t)uOffset >= QCBOR_MAX_DECODE_INPUT_SIZE) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -0700348 return QCBOR_ERR_INPUT_TOO_LARGE;
Laurence Lundbladeabf5c572020-06-29 21:21:29 -0700349 }
350
Laurence Lundblade0750fc42020-06-20 21:02:34 -0700351 pNesting->pCurrentBounded = pNesting->pCurrent;
Laurence Lundblade085d7952020-07-24 10:26:30 -0700352
353 DecodeNesting_SetMapOrArrayBoundedMode(pNesting, bIsEmpty, uOffset);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -0700354
355 return QCBOR_SUCCESS;
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -0700356}
357
Laurence Lundblade64b607e2020-05-13 13:05:57 -0700358
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700359static inline QCBORError
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700360DecodeNesting_DescendMapOrArray(QCBORDecodeNesting *pNesting,
Laurence Lundblade02625d42020-06-25 14:41:41 -0700361 uint8_t uQCBORType,
362 uint64_t uCount)
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700363{
Laurence Lundblade02625d42020-06-25 14:41:41 -0700364 QCBORError uError = QCBOR_SUCCESS;
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700365
366 if(uCount == 0) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800367 /* Nothing to do for empty definite-length arrays. They are just are
368 * effectively the same as an item that is not a map or array.
369 */
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700370 goto Done;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800371 /* Empty indefinite-length maps and arrays are handled elsewhere */
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700372 }
373
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800374 /* Error out if arrays is too long to handle */
Laurence Lundblade02625d42020-06-25 14:41:41 -0700375 if(uCount != QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH &&
376 uCount > QCBOR_MAX_ITEMS_IN_ARRAY) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -0700377 uError = QCBOR_ERR_ARRAY_DECODE_TOO_LONG;
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700378 goto Done;
379 }
380
Laurence Lundbladee6f15112020-07-23 18:44:16 -0700381 uError = DecodeNesting_Descend(pNesting, uQCBORType);
Laurence Lundblade02625d42020-06-25 14:41:41 -0700382 if(uError != QCBOR_SUCCESS) {
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700383 goto Done;
384 }
385
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800386 /* Fill in the new map/array level. Check above makes casts OK. */
Laurence Lundblade6c8a4442020-06-22 22:16:11 -0700387 pNesting->pCurrent->u.ma.uCountCursor = (uint16_t)uCount;
388 pNesting->pCurrent->u.ma.uCountTotal = (uint16_t)uCount;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700389
390 DecodeNesting_ClearBoundedMode(pNesting);
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700391
392Done:
Laurence Lundblade02625d42020-06-25 14:41:41 -0700393 return uError;;
394}
395
396
397static inline void
398DecodeNesting_LevelUpCurrent(QCBORDecodeNesting *pNesting)
399{
400 pNesting->pCurrent = pNesting->pCurrentBounded - 1;
401}
402
403
404static inline void
405DecodeNesting_LevelUpBounded(QCBORDecodeNesting *pNesting)
406{
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700407 while(pNesting->pCurrentBounded != &(pNesting->pLevels[0])) {
Laurence Lundblade02625d42020-06-25 14:41:41 -0700408 pNesting->pCurrentBounded--;
409 if(DecodeNesting_IsCurrentBounded(pNesting)) {
410 break;
411 }
412 }
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700413}
414
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800415
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700416static inline void
417DecodeNesting_SetCurrentToBoundedLevel(QCBORDecodeNesting *pNesting)
418{
419 pNesting->pCurrent = pNesting->pCurrentBounded;
420}
421
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700422
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700423static inline QCBORError
Laurence Lundblade02625d42020-06-25 14:41:41 -0700424DecodeNesting_DescendIntoBstrWrapped(QCBORDecodeNesting *pNesting,
Laurence Lundbladebd209782021-02-17 10:44:42 -0700425 uint32_t uEndOffset,
426 uint32_t uStartOffset)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700427{
Laurence Lundbladebd209782021-02-17 10:44:42 -0700428 QCBORError uError;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700429
Laurence Lundbladee6f15112020-07-23 18:44:16 -0700430 uError = DecodeNesting_Descend(pNesting, QCBOR_TYPE_BYTE_STRING);
Laurence Lundblade02625d42020-06-25 14:41:41 -0700431 if(uError != QCBOR_SUCCESS) {
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700432 goto Done;
433 }
434
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800435 /* Fill in the new byte string level */
Laurence Lundbladebd209782021-02-17 10:44:42 -0700436 pNesting->pCurrent->u.bs.uSavedEndOffset = uEndOffset;
437 pNesting->pCurrent->u.bs.uBstrStartOffset = uStartOffset;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700438
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800439 /* Bstr wrapped levels are always bounded */
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700440 pNesting->pCurrentBounded = pNesting->pCurrent;
441
442Done:
Laurence Lundblade02625d42020-06-25 14:41:41 -0700443 return uError;;
444}
445
Laurence Lundbladed0304932020-06-27 10:59:38 -0700446
447static inline void
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700448DecodeNesting_ZeroMapOrArrayCount(QCBORDecodeNesting *pNesting)
Laurence Lundblade02625d42020-06-25 14:41:41 -0700449{
450 pNesting->pCurrent->u.ma.uCountCursor = 0;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700451}
452
Laurence Lundblade24d509a2020-06-06 18:43:15 -0700453
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700454static inline void
Laurence Lundbladeddebabe2020-11-22 11:32:17 -0800455DecodeNesting_ResetMapOrArrayCount(QCBORDecodeNesting *pNesting)
456{
457 pNesting->pCurrentBounded->u.ma.uCountCursor = pNesting->pCurrentBounded->u.ma.uCountTotal;
458}
459
460
461static inline void
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700462DecodeNesting_Init(QCBORDecodeNesting *pNesting)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700463{
Laurence Lundblade02625d42020-06-25 14:41:41 -0700464 /* Assumes that *pNesting has been zero'd before this call. */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700465 pNesting->pLevels[0].uLevelType = QCBOR_TYPE_BYTE_STRING;
466 pNesting->pCurrent = &(pNesting->pLevels[0]);
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700467}
468
469
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700470static inline void
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800471DecodeNesting_PrepareForMapSearch(QCBORDecodeNesting *pNesting,
472 QCBORDecodeNesting *pSave)
Laurence Lundbladeb340ba72020-05-14 11:41:10 -0700473{
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -0700474 *pSave = *pNesting;
Laurence Lundblade0750fc42020-06-20 21:02:34 -0700475 pNesting->pCurrent = pNesting->pCurrentBounded;
Laurence Lundbladeddebabe2020-11-22 11:32:17 -0800476 DecodeNesting_ResetMapOrArrayCount(pNesting);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -0700477}
478
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700479
Laurence Lundblade02625d42020-06-25 14:41:41 -0700480static inline void
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800481DecodeNesting_RestoreFromMapSearch(QCBORDecodeNesting *pNesting,
482 const QCBORDecodeNesting *pSave)
Laurence Lundbladeb340ba72020-05-14 11:41:10 -0700483{
484 *pNesting = *pSave;
485}
486
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700487
Laurence Lundblade02625d42020-06-25 14:41:41 -0700488static inline uint32_t
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700489DecodeNesting_GetPreviousBoundedEnd(const QCBORDecodeNesting *pMe)
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700490{
Laurence Lundblade0b1a7532020-11-22 22:22:17 -0800491 return pMe->pCurrentBounded->u.bs.uSavedEndOffset;
Laurence Lundblade1d85d522020-06-22 13:24:59 -0700492}
493
494
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700495
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800496
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800497#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundbladeee851742020-01-08 08:37:05 -0800498/*===========================================================================
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800499 QCBORStringAllocate -- STRING ALLOCATOR INVOCATION
500
501 The following four functions are pretty wrappers for invocation of
502 the string allocator supplied by the caller.
503
Laurence Lundbladeee851742020-01-08 08:37:05 -0800504 ===========================================================================*/
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800505
Laurence Lundbladeee851742020-01-08 08:37:05 -0800506static inline void
Laurence Lundblade3a691a02020-12-28 04:15:16 -0800507StringAllocator_Free(const QCBORInternalAllocator *pMe, void *pMem)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800508{
509 (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, 0);
510}
511
Laurence Lundbladeee851742020-01-08 08:37:05 -0800512// StringAllocator_Reallocate called with pMem NULL is
513// equal to StringAllocator_Allocate()
514static inline UsefulBuf
Laurence Lundblade3a691a02020-12-28 04:15:16 -0800515StringAllocator_Reallocate(const QCBORInternalAllocator *pMe,
Laurence Lundbladeee851742020-01-08 08:37:05 -0800516 void *pMem,
517 size_t uSize)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800518{
519 return (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, uSize);
520}
521
Laurence Lundbladeee851742020-01-08 08:37:05 -0800522static inline UsefulBuf
Laurence Lundblade3a691a02020-12-28 04:15:16 -0800523StringAllocator_Allocate(const QCBORInternalAllocator *pMe, size_t uSize)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800524{
525 return (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, uSize);
526}
527
Laurence Lundbladeee851742020-01-08 08:37:05 -0800528static inline void
Laurence Lundblade3a691a02020-12-28 04:15:16 -0800529StringAllocator_Destruct(const QCBORInternalAllocator *pMe)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800530{
531 if(pMe->pfAllocator) {
532 (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, 0);
533 }
534}
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800535#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800536
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800537
538
539
Laurence Lundbladeee851742020-01-08 08:37:05 -0800540/*===========================================================================
541 QCBORDecode -- The main implementation of CBOR decoding
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700542
Laurence Lundblade844bb5c2020-03-01 17:27:25 -0800543 See qcbor/qcbor_decode.h for definition of the object
544 used here: QCBORDecodeContext
Laurence Lundbladeee851742020-01-08 08:37:05 -0800545 ===========================================================================*/
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700546/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800547 * Public function, see header file
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700548 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800549void QCBORDecode_Init(QCBORDecodeContext *pMe,
550 UsefulBufC EncodedCBOR,
551 QCBORDecodeMode nDecodeMode)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700552{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800553 memset(pMe, 0, sizeof(QCBORDecodeContext));
554 UsefulInputBuf_Init(&(pMe->InBuf), EncodedCBOR);
555 /* Don't bother with error check on decode mode. If a bad value is
556 * passed it will just act as if the default normal mode of 0 was set.
557 */
558 pMe->uDecodeMode = (uint8_t)nDecodeMode;
559 DecodeNesting_Init(&(pMe->nesting));
560
561 /* Inialize me->auMappedTags to CBOR_TAG_INVALID16. See
562 * GetNext_TaggedItem() and MapTagNumber(). */
563 memset(pMe->auMappedTags, 0xff, sizeof(pMe->auMappedTags));
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700564}
565
566
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800567#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
568
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700569/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800570 * Public function, see header file
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700571 */
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800572void QCBORDecode_SetUpAllocator(QCBORDecodeContext *pMe,
573 QCBORStringAllocate pfAllocateFunction,
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800574 void *pAllocateContext,
575 bool bAllStrings)
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700576{
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800577 pMe->StringAllocator.pfAllocator = pfAllocateFunction;
578 pMe->StringAllocator.pAllocateCxt = pAllocateContext;
579 pMe->bStringAllocateAll = bAllStrings;
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700580}
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800581#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700582
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800583
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700584
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800585
586/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800587 * Deprecated public function, see header file
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800588 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800589void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *pMe,
Laurence Lundbladeee851742020-01-08 08:37:05 -0800590 const QCBORTagListIn *pTagList)
Laurence Lundbladedbe6f212018-10-28 11:37:53 +0700591{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800592 /* This does nothing now. It is retained for backwards compatibility */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -0700593 (void)pMe;
594 (void)pTagList;
Laurence Lundbladedbe6f212018-10-28 11:37:53 +0700595}
596
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700597
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800598
599
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700600/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800601 * Decoding items is done in six layers, one calling the next one
602 * down. If a layer has no work to do for a particular item, it
603 * returns quickly.
604 *
605 * 1. QCBORDecode_GetNextTagContent - The top layer processes tagged
606 * data items, turning them into the local C representation. For the
607 * most simple it is just associating a QCBOR_TYPE with the data. For
608 * the complex ones that an aggregate of data items, there is some
609 * further decoding and some limited recursion.
610 *
611 * 2. QCBORDecode_GetNextMapOrArray - This manages the beginnings and
612 * ends of maps and arrays. It tracks descending into and ascending
613 * out of maps/arrays. It processes breaks that terminate
614 * indefinite-length maps and arrays.
615 *
616 * 3. QCBORDecode_GetNextMapEntry - This handles the combining of two
617 * items, the label and the data, that make up a map entry. It only
618 * does work on maps. It combines the label and data items into one
619 * labeled item.
620 *
621 * 4. QCBORDecode_GetNextTagNumber - This decodes type 6 tag
622 * numbers. It turns the tag numbers into bit flags associated with
623 * the data item. No actual decoding of the contents of the tag is
624 * performed here.
625 *
626 * 5. QCBORDecode_GetNextFullString - This assembles the sub-items
627 * that make up an indefinite-length string into one string item. It
628 * uses the string allocator to create contiguous space for the
629 * item. It processes all breaks that are part of indefinite-length
630 * strings.
631 *
632 * 6. DecodeAtomicDataItem - This decodes the atomic data items in
633 * CBOR. Each atomic data item has a "major type", an integer
634 * "argument" and optionally some content. For text and byte strings,
635 * the content is the bytes that make up the string. These are the
636 * smallest data items that are considered to be well-formed. The
637 * content may also be other data items in the case of aggregate
638 * types. They are not handled in this layer.
639 *
640 * Roughly this takes 300 bytes of stack for vars. TODO: evaluate this
641 * more carefully and correctly.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700642 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800643
644
645/*
646 * Note about use of int and unsigned variables.
647 *
648 * See http://www.unix.org/whitepapers/64bit.html for reasons int is
649 * used carefully here, and in particular why it isn't used in the
650 * public interface. Also see
651 * https://stackoverflow.com/questions/17489857/why-is-int-typically-32-bit-on-64-bit-compilers
652 *
653 * Int is used for values that need less than 16-bits and would be
654 * subject to integer promotion and result in complaining from static
655 * analyzers.
656 */
657
658
659/**
660 * @brief Decode the CBOR head, the type and argument.
661 *
662 * @param[in] pUInBuf The input buffer to read from.
663 * @param[out] pnMajorType The decoded major type.
664 * @param[out] puArgument The decoded argument.
665 * @param[out] pnAdditionalInfo The decoded Lower 5 bits of initial byte.
666 *
667 * @retval QCBOR_ERR_UNSUPPORTED
668 * @retval QCBOR_ERR_HIT_END
669 *
670 * This decodes the CBOR "head" that every CBOR data item has. See
671 * longer explaination of the head in documentation for
672 * QCBOREncode_EncodeHead().
673 *
674 * This does the network->host byte order conversion. The conversion
675 * here also results in the conversion for floats in addition to that
676 * for lengths, tags and integer values.
677 *
678 * The int type is preferred to uint8_t for some variables as this
679 * avoids integer promotions, can reduce code size and makes static
680 * analyzers happier.
681 */
682static inline QCBORError
683DecodeHead(UsefulInputBuf *pUInBuf,
684 int *pnMajorType,
685 uint64_t *puArgument,
686 int *pnAdditionalInfo)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700687{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800688 QCBORError uReturn;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800689
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800690 /* Get the initial byte that every CBOR data item has and break it
691 * down. */
692 const int nInitialByte = (int)UsefulInputBuf_GetByte(pUInBuf);
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800693 const int nTmpMajorType = nInitialByte >> 5;
694 const int nAdditionalInfo = nInitialByte & 0x1f;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800695
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800696 /* Where the argument accumulates */
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800697 uint64_t uArgument;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800698
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800699 if(nAdditionalInfo >= LEN_IS_ONE_BYTE && nAdditionalInfo <= LEN_IS_EIGHT_BYTES) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800700 /* Need to get 1,2,4 or 8 additional argument bytes. Map
701 * LEN_IS_ONE_BYTE..LEN_IS_EIGHT_BYTES to actual length.
702 */
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800703 static const uint8_t aIterate[] = {1,2,4,8};
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800704
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800705 /* Loop getting all the bytes in the argument */
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800706 uArgument = 0;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800707 for(int i = aIterate[nAdditionalInfo - LEN_IS_ONE_BYTE]; i; i--) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800708 /* This shift and add gives the endian conversion. */
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800709 uArgument = (uArgument << 8) + UsefulInputBuf_GetByte(pUInBuf);
710 }
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800711 } else if(nAdditionalInfo >= ADDINFO_RESERVED1 && nAdditionalInfo <= ADDINFO_RESERVED3) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800712 /* The reserved and thus-far unused additional info values */
713 uReturn = QCBOR_ERR_UNSUPPORTED;
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800714 goto Done;
715 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800716 /* Less than 24, additional info is argument or 31, an
717 * indefinite-length. No more bytes to get.
718 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800719 uArgument = (uint64_t)nAdditionalInfo;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700720 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800721
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700722 if(UsefulInputBuf_GetError(pUInBuf)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800723 uReturn = QCBOR_ERR_HIT_END;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700724 goto Done;
725 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800726
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800727 /* All successful if arrived here. */
728 uReturn = QCBOR_SUCCESS;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800729 *pnMajorType = nTmpMajorType;
Laurence Lundblade4c0cf842019-01-12 03:25:44 -0800730 *puArgument = uArgument;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800731 *pnAdditionalInfo = nAdditionalInfo;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800732
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700733Done:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800734 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700735}
736
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800737
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800738/**
739 * @brief Decode integer types, major types 0 and 1.
740 *
741 * @param[in] nMajorType The CBOR major type (0 or 1).
742 * @param[in] uArgument The argument from the head.
743 * @param[out] pDecodedItem The filled in decoded item.
744 *
745 * @retval QCBOR_ERR_INT_OVERFLOW
746 *
747 * Must only be called when major type is 0 or 1.
748 *
749 * CBOR doesn't explicitly specify two's compliment for integers but
750 * all CPUs use it these days and the test vectors in the RFC are
751 * so. All integers in the CBOR structure are positive and the major
752 * type indicates positive or negative. CBOR can express positive
753 * integers up to 2^x - 1 where x is the number of bits and negative
754 * integers down to 2^x. Note that negative numbers can be one more
755 * away from zero than positive. Stdint, as far as I can tell, uses
756 * two's compliment to represent negative integers.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700757 */
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -0700758static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800759DecodeInteger(int nMajorType, uint64_t uArgument, QCBORItem *pDecodedItem)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700760{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800761 QCBORError uReturn = QCBOR_SUCCESS;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800762
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700763 if(nMajorType == CBOR_MAJOR_TYPE_POSITIVE_INT) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800764 if (uArgument <= INT64_MAX) {
765 pDecodedItem->val.int64 = (int64_t)uArgument;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700766 pDecodedItem->uDataType = QCBOR_TYPE_INT64;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800767
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700768 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800769 pDecodedItem->val.uint64 = uArgument;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700770 pDecodedItem->uDataType = QCBOR_TYPE_UINT64;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700771 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800772
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700773 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800774 if(uArgument <= INT64_MAX) {
775 /* CBOR's representation of negative numbers lines up with
776 * the two-compliment representation. A negative integer has
777 * one more in range than a positive integer. INT64_MIN is
778 * equal to (-INT64_MAX) - 1.
779 */
780 pDecodedItem->val.int64 = (-(int64_t)uArgument) - 1;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700781 pDecodedItem->uDataType = QCBOR_TYPE_INT64;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800782
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700783 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800784 /* C can't represent a negative integer in this range so it
785 * is an error.
786 */
787 uReturn = QCBOR_ERR_INT_OVERFLOW;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700788 }
789 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800790
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800791 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700792}
793
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800794
795/* Make sure #define value line up as DecodeSimple counts on this. */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700796#if QCBOR_TYPE_FALSE != CBOR_SIMPLEV_FALSE
797#error QCBOR_TYPE_FALSE macro value wrong
798#endif
799
800#if QCBOR_TYPE_TRUE != CBOR_SIMPLEV_TRUE
801#error QCBOR_TYPE_TRUE macro value wrong
802#endif
803
804#if QCBOR_TYPE_NULL != CBOR_SIMPLEV_NULL
805#error QCBOR_TYPE_NULL macro value wrong
806#endif
807
808#if QCBOR_TYPE_UNDEF != CBOR_SIMPLEV_UNDEF
809#error QCBOR_TYPE_UNDEF macro value wrong
810#endif
811
Laurence Lundblade0f99d692018-09-26 14:39:28 -0700812#if QCBOR_TYPE_BREAK != CBOR_SIMPLE_BREAK
813#error QCBOR_TYPE_BREAK macro value wrong
814#endif
815
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700816#if QCBOR_TYPE_DOUBLE != DOUBLE_PREC_FLOAT
817#error QCBOR_TYPE_DOUBLE macro value wrong
818#endif
819
820#if QCBOR_TYPE_FLOAT != SINGLE_PREC_FLOAT
821#error QCBOR_TYPE_FLOAT macro value wrong
822#endif
823
Laurence Lundblade9b334962020-08-27 10:55:53 -0700824
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800825/**
826 * @brief Decode major type 7 -- true, false, floating-point, break...
827 *
828 * @param[in] nAdditionalInfo The lower five bits from the initial byte.
829 * @param[in] uArgument The argument from the head.
830 * @param[out] pDecodedItem The filled in decoded item.
831 *
832 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
833 * @retval QCBOR_ERR_BAD_TYPE_7
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700834 */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800835
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800836static inline QCBORError
837DecodeType7(int nAdditionalInfo, uint64_t uArgument, QCBORItem *pDecodedItem)
838{
839 QCBORError uReturn = QCBOR_SUCCESS;
840
841 /* uAdditionalInfo is 5 bits from the initial byte. Compile time
842 * checks above make sure uAdditionalInfo values line up with
843 * uDataType values. DecodeHead() never returns an AdditionalInfo
844 * > 0x1f so cast is safe.
845 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800846 pDecodedItem->uDataType = (uint8_t)nAdditionalInfo;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800847
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800848 switch(nAdditionalInfo) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800849 /* No check for ADDINFO_RESERVED1 - ADDINFO_RESERVED3 as they
850 * are caught before this is called.
851 */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800852
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800853 case HALF_PREC_FLOAT: /* 25 */
Laurence Lundbladeb275cdc2020-07-12 12:34:38 -0700854#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800855 /* Half-precision is returned as a double. The cast to
856 * uint16_t is safe because the encoded value was 16 bits. It
857 * was widened to 64 bits to be passed in here.
858 */
859 pDecodedItem->val.dfnum = IEEE754_HalfToDouble((uint16_t)uArgument);
Laurence Lundblade67bd5512018-11-02 21:44:06 +0700860 pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800861#else /* QCBOR_DISABLE_PREFERRED_FLOAT */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800862 uReturn = QCBOR_ERR_HALF_PRECISION_DISABLED;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800863#endif /* QCBOR_DISABLE_PREFERRED_FLOAT */
Laurence Lundblade12d32c52018-09-19 11:25:27 -0700864 break;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800865 case SINGLE_PREC_FLOAT: /* 26 */
866 /* Single precision is normally returned as a double since
867 * double is widely supported, there is no loss of precision,
868 * it makes it easy for the caller in most cases and it can
869 * be converted back to single with no loss of precision
870 *
871 * The cast to uint32_t is safe because the encoded value was
872 * 32 bits. It was widened to 64 bits to be passed in here.
873 */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700874 {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800875 const float f = UsefulBufUtil_CopyUint32ToFloat((uint32_t)uArgument);
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700876#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800877 /* In the normal case, use HW to convert float to
878 * double. */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700879 pDecodedItem->val.dfnum = (double)f;
880 pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800881#else /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800882 /* Use of float HW is disabled, return as a float. */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700883 pDecodedItem->val.fnum = f;
884 pDecodedItem->uDataType = QCBOR_TYPE_FLOAT;
885
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800886 /* IEEE754_FloatToDouble() could be used here to return as
887 * a double, but it adds object code and most likely
888 * anyone disabling FLOAT HW use doesn't care about floats
889 * and wants to save object code.
890 */
Laurence Lundbladee2c893c2020-12-26 17:41:53 -0800891#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700892 }
Laurence Lundblade12d32c52018-09-19 11:25:27 -0700893 break;
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -0700894
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800895 case DOUBLE_PREC_FLOAT: /* 27 */
896 pDecodedItem->val.dfnum = UsefulBufUtil_CopyUint64ToDouble(uArgument);
Laurence Lundblade67bd5512018-11-02 21:44:06 +0700897 pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE;
Laurence Lundblade12d32c52018-09-19 11:25:27 -0700898 break;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800899
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800900 case CBOR_SIMPLEV_FALSE: /* 20 */
901 case CBOR_SIMPLEV_TRUE: /* 21 */
902 case CBOR_SIMPLEV_NULL: /* 22 */
903 case CBOR_SIMPLEV_UNDEF: /* 23 */
904 case CBOR_SIMPLE_BREAK: /* 31 */
905 break; /* nothing to do */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800906
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800907 case CBOR_SIMPLEV_ONEBYTE: /* 24 */
908 if(uArgument <= CBOR_SIMPLE_BREAK) {
909 /* This takes out f8 00 ... f8 1f which should be encoded
910 * as e0 … f7
911 */
912 uReturn = QCBOR_ERR_BAD_TYPE_7;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700913 goto Done;
914 }
Laurence Lundblade5e390822019-01-06 12:35:01 -0800915 /* FALLTHROUGH */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800916
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800917 default: /* 0-19 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700918 pDecodedItem->uDataType = QCBOR_TYPE_UKNOWN_SIMPLE;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800919 /* DecodeHead() will make uArgument equal to
920 * nAdditionalInfo when nAdditionalInfo is < 24. This cast is
921 * safe because the 2, 4 and 8 byte lengths of uNumber are in
922 * the double/float cases above
Laurence Lundbladeee851742020-01-08 08:37:05 -0800923 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800924 pDecodedItem->val.uSimple = (uint8_t)uArgument;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700925 break;
926 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800927
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700928Done:
Laurence Lundblade9b334962020-08-27 10:55:53 -0700929 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700930}
931
932
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800933/**
934 * @brief Decode text and byte strings
935 *
936 * @param[in] pAllocator The string allocator or NULL.
937 * @param[in] uStrLen The length of the string.
938 * @param[in] pUInBuf The surce from which to read the string's bytes.
939 * @param[out] pDecodedItem The filled in decoded item.
940 *
941 * @retval QCBOR_ERR_HIT_END
942 * @retval QCBOR_ERR_STRING_ALLOCATE
943 * @retval QCBOR_ERR_STRING_TOO_LONG
944 *
945 * The reads @c uStrlen bytes from @c pUInBuf and fills in @c
946 * pDecodedItem. If @c pAllocator is not NULL then memory for the
947 * string is allocated.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700948 */
Laurence Lundbladeee851742020-01-08 08:37:05 -0800949static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800950DecodeBytes(const QCBORInternalAllocator *pAllocator,
951 uint64_t uStrLen,
952 UsefulInputBuf *pUInBuf,
953 QCBORItem *pDecodedItem)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700954{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800955 QCBORError uReturn = QCBOR_SUCCESS;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800956
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800957 /* CBOR lengths can be 64 bits, but size_t is not 64 bits on all
958 * CPUs. This check makes the casts to size_t below safe.
959 *
960 * The max is 4 bytes less than the largest sizeof() so this can be
961 * tested by putting a SIZE_MAX length in the CBOR test input (no
962 * one will care the limit on strings is 4 bytes shorter).
963 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700964 if(uStrLen > SIZE_MAX-4) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800965 uReturn = QCBOR_ERR_STRING_TOO_LONG;
Laurence Lundblade742df4a2018-10-13 20:07:17 +0800966 goto Done;
967 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800968
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700969 const UsefulBufC Bytes = UsefulInputBuf_GetUsefulBuf(pUInBuf, (size_t)uStrLen);
970 if(UsefulBuf_IsNULLC(Bytes)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800971 /* Failed to get the bytes for this string item */
972 uReturn = QCBOR_ERR_HIT_END;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700973 goto Done;
974 }
Laurence Lundbladed61cbf32018-12-09 11:42:21 -0800975
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800976#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800977 /* Note that this is not where allocation to coalesce
978 * indefinite-length strings is done. This is for when the caller
979 * has requested all strings be allocated. Disabling indefinite
980 * length strings also disables this allocate-all option.
981 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700982 if(pAllocator) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800983 /* request to use the string allocator to make a copy */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700984 UsefulBuf NewMem = StringAllocator_Allocate(pAllocator, (size_t)uStrLen);
985 if(UsefulBuf_IsNULL(NewMem)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800986 uReturn = QCBOR_ERR_STRING_ALLOCATE;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700987 goto Done;
988 }
989 pDecodedItem->val.string = UsefulBuf_Copy(NewMem, Bytes);
990 pDecodedItem->uDataAlloc = 1;
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800991 goto Done;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700992 }
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800993#else /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
994 (void)pAllocator;
995#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundbladed61cbf32018-12-09 11:42:21 -0800996
Laurence Lundblade3f1318a2021-01-04 18:26:44 -0800997 /* Normal case with no string allocator */
Laurence Lundbladef6da33c2020-11-26 18:15:05 -0800998 pDecodedItem->val.string = Bytes;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -0700999
1000Done:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001001 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001002}
1003
1004
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001005/**
1006 * @brief Map the CBOR major types for strings to the QCBOR types.
1007 *
1008 * @param[in] nCBORMajorType The CBOR major type to convert.
1009 * @retturns QCBOR type number.
1010 *
1011 * This only works for the two string types.
1012 */
1013static inline uint8_t ConvertStringMajorTypes(int nCBORMajorType)
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001014{
1015 #if CBOR_MAJOR_TYPE_BYTE_STRING + 4 != QCBOR_TYPE_BYTE_STRING
1016 #error QCBOR_TYPE_BYTE_STRING no lined up with major type
1017 #endif
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001018
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001019 #if CBOR_MAJOR_TYPE_TEXT_STRING + 4 != QCBOR_TYPE_TEXT_STRING
1020 #error QCBOR_TYPE_TEXT_STRING no lined up with major type
1021 #endif
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001022
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001023 return (uint8_t)(nCBORMajorType + 4);
1024}
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001025
1026
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001027/**
1028 * @brief Map the CBOR major types for arrays/maps to the QCBOR types.
1029 *
1030 * @param[in] nCBORMajorType The CBOR major type to convert.
1031 * @retturns QCBOR type number.
1032 *
1033 * This only works for the two aggregate types.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001034 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001035static inline uint8_t ConvertArrayOrMapType(int nCBORMajorType)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001036{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001037 #if QCBOR_TYPE_ARRAY != CBOR_MAJOR_TYPE_ARRAY
1038 #error QCBOR_TYPE_ARRAY value not lined up with major type
1039 #endif
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001040
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001041 #if QCBOR_TYPE_MAP != CBOR_MAJOR_TYPE_MAP
1042 #error QCBOR_TYPE_MAP value not lined up with major type
1043 #endif
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001044
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001045 return (uint8_t)(nCBORMajorType);
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001046}
1047
1048
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001049/**
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001050 * @brief Decode a single primitive data item (decode layer 6).
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001051 *
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001052 * @param[in] pUInBuf Input buffer to read data item from.
1053 * @param[out] pDecodedItem The filled-in decoded item.
1054 * @param[in] pAllocator The allocator to use for strings or NULL.
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001055 *
1056 * @retval QCBOR_ERR_UNSUPPORTED
1057 * @retval QCBOR_ERR_HIT_END
1058 * @retval QCBOR_ERR_INT_OVERFLOW
1059 * @retval QCBOR_ERR_STRING_ALLOCATE
1060 * @retval QCBOR_ERR_STRING_TOO_LONG
1061 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
1062 * @retval QCBOR_ERR_BAD_TYPE_7
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001063 * @retval QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED
1064 *
1065 * This decodes the most primitive / atomic data item. It does
1066 * no combing of data items.
1067 */
1068static QCBORError
1069DecodeAtomicDataItem(UsefulInputBuf *pUInBuf,
1070 QCBORItem *pDecodedItem,
1071 const QCBORInternalAllocator *pAllocator)
1072{
1073 QCBORError uReturn;
1074
1075 /* Get the major type and the argument. The argument could be
1076 * length of more bytes or the value depending on the major
1077 * type. nAdditionalInfo is an encoding of the length of the
1078 * uNumber and is needed to decode floats and doubles.
1079 */
1080 int nMajorType = 0;
1081 uint64_t uArgument = 0;
1082 int nAdditionalInfo = 0;
1083
1084 memset(pDecodedItem, 0, sizeof(QCBORItem));
1085
1086 uReturn = DecodeHead(pUInBuf, &nMajorType, &uArgument, &nAdditionalInfo);
1087 if(uReturn) {
1088 goto Done;
1089 }
1090
1091 /* At this point the major type and the argument are valid. We've
1092 * got the type and the argument that starts every CBOR data item.
1093 */
1094 switch (nMajorType) {
1095 case CBOR_MAJOR_TYPE_POSITIVE_INT: /* Major type 0 */
1096 case CBOR_MAJOR_TYPE_NEGATIVE_INT: /* Major type 1 */
1097 if(nAdditionalInfo == LEN_IS_INDEFINITE) {
1098 uReturn = QCBOR_ERR_BAD_INT;
1099 } else {
1100 uReturn = DecodeInteger(nMajorType, uArgument, pDecodedItem);
1101 }
1102 break;
1103
1104 case CBOR_MAJOR_TYPE_BYTE_STRING: /* Major type 2 */
1105 case CBOR_MAJOR_TYPE_TEXT_STRING: /* Major type 3 */
1106 pDecodedItem->uDataType = ConvertStringMajorTypes(nMajorType);
1107 if(nAdditionalInfo == LEN_IS_INDEFINITE) {
1108 pDecodedItem->val.string = (UsefulBufC){NULL, QCBOR_STRING_LENGTH_INDEFINITE};
1109 } else {
1110 uReturn = DecodeBytes(pAllocator, uArgument, pUInBuf, pDecodedItem);
1111 }
1112 break;
1113
1114 case CBOR_MAJOR_TYPE_ARRAY: /* Major type 4 */
1115 case CBOR_MAJOR_TYPE_MAP: /* Major type 5 */
1116 if(nAdditionalInfo == LEN_IS_INDEFINITE) {
1117 /* Indefinite-length string. */
1118#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
1119 pDecodedItem->val.uCount = QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH;
1120#else /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
1121 uReturn = QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED;
1122 break;
1123#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
1124 } else {
1125 /* Definite-length string. */
1126 if(uArgument > QCBOR_MAX_ITEMS_IN_ARRAY) {
1127 uReturn = QCBOR_ERR_ARRAY_DECODE_TOO_LONG;
1128 goto Done;
1129 }
1130 /* cast OK because of check above */
1131 pDecodedItem->val.uCount = (uint16_t)uArgument;
1132 }
1133 pDecodedItem->uDataType = ConvertArrayOrMapType(nMajorType);
1134 break;
1135
1136 case CBOR_MAJOR_TYPE_TAG: /* Major type 6, tag numbers */
1137 if(nAdditionalInfo == LEN_IS_INDEFINITE) {
1138 uReturn = QCBOR_ERR_BAD_INT;
1139 } else {
1140 pDecodedItem->val.uTagV = uArgument;
1141 pDecodedItem->uDataType = QCBOR_TYPE_TAG;
1142 }
1143 break;
1144
1145 case CBOR_MAJOR_TYPE_SIMPLE:
1146 /* Major type 7: float, double, true, false, null... */
1147 uReturn = DecodeType7(nAdditionalInfo, uArgument, pDecodedItem);
1148 break;
1149
1150 default:
1151 /* Never happens because DecodeHead() should never return > 7 */
1152 uReturn = QCBOR_ERR_UNSUPPORTED;
1153 break;
1154 }
1155
1156Done:
1157 return uReturn;
1158}
1159
1160
1161/**
1162 * @brief Process indefinite-length strings (decode layer 5).
1163 *
1164 * @param[in] pMe Decoder context
1165 * @param[out] pDecodedItem The decoded item that work is done on.
1166 *
1167 * @retval QCBOR_ERR_UNSUPPORTED
1168 * @retval QCBOR_ERR_HIT_END
1169 * @retval QCBOR_ERR_INT_OVERFLOW
1170 * @retval QCBOR_ERR_STRING_ALLOCATE
1171 * @retval QCBOR_ERR_STRING_TOO_LONG
1172 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
1173 * @retval QCBOR_ERR_BAD_TYPE_7
1174 * @retval QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001175 * @retval QCBOR_ERR_NO_STRING_ALLOCATOR
1176 * @retval QCBOR_ERR_INDEFINITE_STRING_CHUNK
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001177 * @retval QCBOR_ERR_INDEF_LEN_STRINGS_DISABLED
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001178 *
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001179 * If @c pDecodedItem is not an indefinite-length string, this does nothing.
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001180 *
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001181 * If it is, this loops getting the subsequent chunk data items that
1182 * make up the string. The string allocator is used to make a
1183 * contiguous buffer for the chunks. When this completes @c
1184 * pDecodedItem contains the put-together string.
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001185 *
1186 * Code Reviewers: THIS FUNCTION DOES A LITTLE POINTER MATH
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001187 */
1188static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001189QCBORDecode_GetNextFullString(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001190{
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001191 /* Aproximate stack usage
1192 * 64-bit 32-bit
1193 * local vars 32 16
1194 * 2 UsefulBufs 32 16
1195 * QCBORItem 56 52
1196 * TOTAL 120 74
1197 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001198
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001199 /* The string allocator is used here for two purposes: 1)
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001200 * coalescing the chunks of an indefinite-length string, 2)
1201 * allocating storage for every string returned when requested.
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001202 *
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001203 * The first use is below in this function. Indefinite-length
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001204 * strings cannot be processed at all without a string allocator.
1205 *
1206 * The second used is in DecodeBytes() which is called by
1207 * GetNext_Item() below. This second use unneccessary for most use
1208 * and only happens when requested in the call to
1209 * QCBORDecode_SetMemPool(). If the second use not requested then
1210 * NULL is passed for the string allocator to GetNext_Item().
1211 *
1212 * QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS disables the string
1213 * allocator altogether and thus both of these uses. It reduced the
1214 * decoder object code by about 400 bytes.
1215 */
Laurence Lundblade3a691a02020-12-28 04:15:16 -08001216 const QCBORInternalAllocator *pAllocatorForGetNext = NULL;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001217
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001218#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundblade3a691a02020-12-28 04:15:16 -08001219 const QCBORInternalAllocator *pAllocator = NULL;
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001220
1221 if(pMe->StringAllocator.pfAllocator) {
1222 pAllocator = &(pMe->StringAllocator);
1223 if(pMe->bStringAllocateAll) {
1224 pAllocatorForGetNext = pAllocator;
1225 }
1226 }
1227#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
1228
1229 QCBORError uReturn;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001230 uReturn = DecodeAtomicDataItem(&(pMe->InBuf), pDecodedItem, pAllocatorForGetNext);
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001231 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001232 goto Done;
1233 }
1234
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001235 /* Only do indefinite-length processing on strings */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001236 const uint8_t uStringType = pDecodedItem->uDataType;
1237 if(uStringType!= QCBOR_TYPE_BYTE_STRING && uStringType != QCBOR_TYPE_TEXT_STRING) {
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001238 goto Done;
1239 }
1240
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001241 /* Is this a string with an indefinite length? */
1242 if(pDecodedItem->val.string.len != QCBOR_STRING_LENGTH_INDEFINITE) {
1243 goto Done;
1244 }
1245
1246#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001247 /* Can't decode indefinite-length strings without a string allocator */
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001248 if(pAllocator == NULL) {
1249 uReturn = QCBOR_ERR_NO_STRING_ALLOCATOR;
1250 goto Done;
1251 }
1252
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001253 /* Loop getting chunks of the indefinite-length string */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001254 UsefulBufC FullString = NULLUsefulBufC;
1255
1256 for(;;) {
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001257 /* Get QCBORItem for next chunk */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001258 QCBORItem StringChunkItem;
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001259 /* Pass a NULL string allocator to GetNext_Item() because the
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001260 * individual string chunks in an indefinite-length should not
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001261 * be allocated. They are always copied in the the contiguous
1262 * buffer allocated here.
1263 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001264 uReturn = DecodeAtomicDataItem(&(pMe->InBuf), &StringChunkItem, NULL);
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001265 if(uReturn) {
1266 break;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001267 }
1268
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001269 /* Is item is the marker for end of the indefinite-length string? */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001270 if(StringChunkItem.uDataType == QCBOR_TYPE_BREAK) {
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001271 /* String is complete */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001272 pDecodedItem->val.string = FullString;
1273 pDecodedItem->uDataAlloc = 1;
1274 break;
1275 }
1276
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001277 /* All chunks must be of the same type, the type of the item
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001278 * that introduces the indefinite-length string. This also
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001279 * catches errors where the chunk is not a string at all and an
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001280 * indefinite-length string inside an indefinite-length string.
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001281 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001282 if(StringChunkItem.uDataType != uStringType ||
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001283 StringChunkItem.val.string.len == QCBOR_STRING_LENGTH_INDEFINITE) {
1284 uReturn = QCBOR_ERR_INDEFINITE_STRING_CHUNK;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001285 break;
1286 }
1287
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001288 /* The first time throurgh FullString.ptr is NULL and this is
1289 * equivalent to StringAllocator_Allocate(). Subsequently it is
1290 * not NULL and a reallocation happens.
1291 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001292 UsefulBuf NewMem = StringAllocator_Reallocate(pAllocator,
1293 UNCONST_POINTER(FullString.ptr),
1294 FullString.len + StringChunkItem.val.string.len);
1295
1296 if(UsefulBuf_IsNULL(NewMem)) {
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001297 uReturn = QCBOR_ERR_STRING_ALLOCATE;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001298 break;
1299 }
1300
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001301 /* Copy new string chunk to the end of accumulated string */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001302 FullString = UsefulBuf_CopyOffset(NewMem, FullString.len, StringChunkItem.val.string);
1303 }
1304
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001305 if(uReturn != QCBOR_SUCCESS && !UsefulBuf_IsNULLC(FullString)) {
1306 /* Getting the item failed, clean up the allocated memory */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001307 StringAllocator_Free(pAllocator, UNCONST_POINTER(FullString.ptr));
1308 }
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001309#else /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
1310 uReturn = QCBOR_ERR_INDEF_LEN_STRINGS_DISABLED;
1311#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001312
1313Done:
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001314 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001315}
1316
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08001317
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001318/**
1319 * @brief This converts a tag number to a shorter mapped value for storage.
1320 *
1321 * @param[in] pMe The decode context.
1322 * @param[in] uUnMappedTag The tag number to map
1323 * @param[out] puMappedTagNumer The stored tag number.
1324 *
1325 * @return error code.
1326 *
1327 * The main point of mapping tag numbers is make QCBORItem
1328 * smaller. With this mapping storage of 4 tags takes up 8
1329 * bytes. Without, it would take up 32 bytes.
1330 *
1331 * This maps tag numbers greater than QCBOR_LAST_UNMAPPED_TAG.
1332 * QCBOR_LAST_UNMAPPED_TAG is a little smaller than MAX_UINT16.
1333 *
1334 * See also UnMapTagNumber() and @ref QCBORItem.
1335 */
1336static inline QCBORError
1337MapTagNumber(QCBORDecodeContext *pMe, uint64_t uUnMappedTag, uint16_t *puMappedTagNumer)
1338{
1339 if(uUnMappedTag > QCBOR_LAST_UNMAPPED_TAG) {
1340 unsigned uTagMapIndex;
1341 /* Is there room in the tag map, or is it in it already? */
1342 for(uTagMapIndex = 0; uTagMapIndex < QCBOR_NUM_MAPPED_TAGS; uTagMapIndex++) {
1343 if(pMe->auMappedTags[uTagMapIndex] == CBOR_TAG_INVALID64) {
1344 break;
1345 }
1346 if(pMe->auMappedTags[uTagMapIndex] == uUnMappedTag) {
1347 break;
1348 }
1349 }
1350 if(uTagMapIndex >= QCBOR_NUM_MAPPED_TAGS) {
1351 return QCBOR_ERR_TOO_MANY_TAGS;
1352 }
1353
1354 /* Covers the cases where tag is new and were it is already in the map */
1355 pMe->auMappedTags[uTagMapIndex] = uUnMappedTag;
1356 *puMappedTagNumer = (uint16_t)(uTagMapIndex + QCBOR_LAST_UNMAPPED_TAG + 1);
1357
1358 } else {
1359 *puMappedTagNumer = (uint16_t)uUnMappedTag;
1360 }
1361
1362 return QCBOR_SUCCESS;
1363}
1364
1365
1366/**
1367 * @brief This converts a mapped tag number to the actual tag number.
1368 *
1369 * @param[in] pMe The decode context.
1370 * @param[in] uMappedTagNumber The stored tag number.
1371 *
1372 * @return The actual tag number is returned or
1373 * @ref CBOR_TAG_INVALID64 on error.
1374 *
1375 * This is the reverse of MapTagNumber()
1376 */
1377static uint64_t
1378UnMapTagNumber(const QCBORDecodeContext *pMe, uint16_t uMappedTagNumber)
1379{
1380 if(uMappedTagNumber <= QCBOR_LAST_UNMAPPED_TAG) {
1381 return uMappedTagNumber;
1382 } else if(uMappedTagNumber == CBOR_TAG_INVALID16) {
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001383 return CBOR_TAG_INVALID64;
1384 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001385 /* This won't be negative because of code below in
1386 * MapTagNumber()
1387 */
1388 const unsigned uIndex = uMappedTagNumber - (QCBOR_LAST_UNMAPPED_TAG + 1);
1389 return pMe->auMappedTags[uIndex];
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001390 }
1391}
1392
1393
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001394/**
1395 * @brief Aggregate all tags wrapping a data item (decode layer 4).
1396 *
1397 * @param[in] pMe Decoder context
1398 * @param[out] pDecodedItem The decoded item that work is done on.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001399
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001400 * @retval QCBOR_ERR_UNSUPPORTED
1401 * @retval QCBOR_ERR_HIT_END
1402 * @retval QCBOR_ERR_INT_OVERFLOW
1403 * @retval QCBOR_ERR_STRING_ALLOCATE
1404 * @retval QCBOR_ERR_STRING_TOO_LONG
1405 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
1406 * @retval QCBOR_ERR_BAD_TYPE_7
1407 * @retval QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED
1408 * @retval QCBOR_ERR_NO_STRING_ALLOCATOR
1409 * @retval QCBOR_ERR_INDEFINITE_STRING_CHUNK
1410 * @retval QCBOR_ERR_INDEF_LEN_STRINGS_DISABLED
1411 * @retval QCBOR_ERR_TOO_MANY_TAGS
1412 *
1413 * This loops getting atomic data items until one is not a tag
1414 * number. Usually this is largely pass-through because most
1415 * item are not tag numbers.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001416 */
1417static QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001418QCBORDecode_GetNextTagNumber(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001419{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001420 uint16_t auItemsTags[QCBOR_MAX_TAGS_PER_ITEM];
1421
1422 /* Initialize to CBOR_TAG_INVALID16 */
1423 #if CBOR_TAG_INVALID16 != 0xffff
1424 /* Be sure the memset does the right thing. */
1425 #err CBOR_TAG_INVALID16 tag not defined as expected
1426 #endif
1427 memset(auItemsTags, 0xff, sizeof(auItemsTags));
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001428
1429 QCBORError uReturn = QCBOR_SUCCESS;
1430
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001431 /* Loop fetching data items until the item fetched is not a tag */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001432 for(;;) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001433 QCBORError uErr = QCBORDecode_GetNextFullString(pMe, pDecodedItem);
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001434 if(uErr != QCBOR_SUCCESS) {
1435 uReturn = uErr;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001436 goto Done;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001437 }
1438
1439 if(pDecodedItem->uDataType != QCBOR_TYPE_TAG) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001440 /* Successful exit from loop; maybe got some tags, maybe not */
1441 memcpy(pDecodedItem->uTags, auItemsTags, sizeof(auItemsTags));
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001442 break;
1443 }
1444
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001445 if(auItemsTags[QCBOR_MAX_TAGS_PER_ITEM - 1] != CBOR_TAG_INVALID16) {
1446 /* No room in the tag list */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001447 uReturn = QCBOR_ERR_TOO_MANY_TAGS;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001448 /* Continue on to get all tags wrapping this item even though
1449 * it is erroring out in the end. This allows decoding to
1450 * continue. This is a resource limit error, not a problem
1451 * with being well-formed CBOR.
1452 */
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001453 continue;
1454 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001455 /* Slide tags over one in the array to make room at index 0.
1456 * Must use memmove because the move source and destination
1457 * overlap.
1458 */
1459 memmove(&auItemsTags[1], auItemsTags, sizeof(auItemsTags) - sizeof(auItemsTags[0]));
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001460
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001461 /* Map the tag */
1462 uint16_t uMappedTagNumer;
1463 uReturn = MapTagNumber(pMe, pDecodedItem->val.uTagV, &uMappedTagNumer);
1464 /* Continue even on error so as to consume all tags wrapping
1465 * this data item so decoding can go on. If MapTagNumber()
1466 * errors once it will continue to error.
1467 */
1468 auItemsTags[0] = uMappedTagNumer;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001469 }
1470
1471Done:
1472 return uReturn;
1473}
1474
1475
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001476/**
1477 * @brief Combine a map entry label and value into one item (decode layer 3).
1478 *
1479 * @param[in] pMe Decoder context
1480 * @param[out] pDecodedItem The decoded item that work is done on.
1481 *
1482 * @retval QCBOR_ERR_UNSUPPORTED
1483 * @retval QCBOR_ERR_HIT_END
1484 * @retval QCBOR_ERR_INT_OVERFLOW
1485 * @retval QCBOR_ERR_STRING_ALLOCATE
1486 * @retval QCBOR_ERR_STRING_TOO_LONG
1487 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
1488 * @retval QCBOR_ERR_BAD_TYPE_7
1489 * @retval QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED
1490 * @retval QCBOR_ERR_NO_STRING_ALLOCATOR
1491 * @retval QCBOR_ERR_INDEFINITE_STRING_CHUNK
1492 * @retval QCBOR_ERR_INDEF_LEN_STRINGS_DISABLED
1493 * @retval QCBOR_ERR_TOO_MANY_TAGS
1494 * @retval QCBOR_ERR_ARRAY_DECODE_TOO_LONG
1495 * @retval QCBOR_ERR_MAP_LABEL_TYPE
1496 *
1497 * If a the current nesting level is a map, then this
1498 * combines pairs of items into one data item with a label
1499 * and value.
1500 *
1501 * This is pass-through if the current nesting leve is
1502 * not a map.
1503 *
1504 * This also implements maps-as-array mode where a map
1505 * is treated like an array to allow caller to do their
1506 * own label processing.
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001507 */
1508static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001509QCBORDecode_GetNextMapEntry(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001510{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001511 QCBORError uReturn = QCBORDecode_GetNextTagNumber(pMe, pDecodedItem);
1512 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade742df4a2018-10-13 20:07:17 +08001513 goto Done;
1514 }
1515
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001516 if(pDecodedItem->uDataType == QCBOR_TYPE_BREAK) {
1517 /* Break can't be a map entry */
1518 goto Done;
1519 }
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001520
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001521 if(pMe->uDecodeMode != QCBOR_DECODE_MODE_MAP_AS_ARRAY) {
1522 /* Normal decoding of maps -- combine label and value into one item. */
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001523
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001524 if(DecodeNesting_IsCurrentTypeMap(&(pMe->nesting))) {
1525 /* Save label in pDecodedItem and get the next which will
1526 * be the real data item.
1527 */
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001528 QCBORItem LabelItem = *pDecodedItem;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001529 uReturn = QCBORDecode_GetNextTagNumber(pMe, pDecodedItem);
1530 if(QCBORDecode_IsUnrecoverableError(uReturn)) {
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001531 goto Done;
Laurence Lundblade93d3f532020-09-28 21:09:12 -07001532 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001533
Laurence Lundblade57dd1442018-10-15 20:26:28 +05301534 pDecodedItem->uLabelAlloc = LabelItem.uDataAlloc;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001535
1536 if(LabelItem.uDataType == QCBOR_TYPE_TEXT_STRING) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001537 /* strings are always good labels */
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001538 pDecodedItem->label.string = LabelItem.val.string;
1539 pDecodedItem->uLabelType = QCBOR_TYPE_TEXT_STRING;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001540 } else if (QCBOR_DECODE_MODE_MAP_STRINGS_ONLY == pMe->uDecodeMode) {
1541 /* It's not a string and we only want strings */
1542 uReturn = QCBOR_ERR_MAP_LABEL_TYPE;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001543 goto Done;
1544 } else if(LabelItem.uDataType == QCBOR_TYPE_INT64) {
1545 pDecodedItem->label.int64 = LabelItem.val.int64;
1546 pDecodedItem->uLabelType = QCBOR_TYPE_INT64;
1547 } else if(LabelItem.uDataType == QCBOR_TYPE_UINT64) {
1548 pDecodedItem->label.uint64 = LabelItem.val.uint64;
1549 pDecodedItem->uLabelType = QCBOR_TYPE_UINT64;
1550 } else if(LabelItem.uDataType == QCBOR_TYPE_BYTE_STRING) {
1551 pDecodedItem->label.string = LabelItem.val.string;
1552 pDecodedItem->uLabelAlloc = LabelItem.uDataAlloc;
1553 pDecodedItem->uLabelType = QCBOR_TYPE_BYTE_STRING;
1554 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001555 /* label is not an int or a string. It is an arrray
1556 * or a float or such and this implementation doesn't handle that.
1557 * Also, tags on labels are ignored.
1558 */
1559 uReturn = QCBOR_ERR_MAP_LABEL_TYPE;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001560 goto Done;
1561 }
Laurence Lundbladed61cbf32018-12-09 11:42:21 -08001562 }
1563 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001564 /* Decoding of maps as arrays to let the caller decide what to do
1565 * about labels, particularly lables that are not integers or
1566 * strings.
1567 */
Laurence Lundbladed61cbf32018-12-09 11:42:21 -08001568 if(pDecodedItem->uDataType == QCBOR_TYPE_MAP) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001569 if(pDecodedItem->val.uCount > QCBOR_MAX_ITEMS_IN_ARRAY/2) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001570 uReturn = QCBOR_ERR_ARRAY_DECODE_TOO_LONG;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001571 goto Done;
1572 }
Laurence Lundbladed61cbf32018-12-09 11:42:21 -08001573 pDecodedItem->uDataType = QCBOR_TYPE_MAP_AS_ARRAY;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001574 /* Cast is safe because of check against QCBOR_MAX_ITEMS_IN_ARRAY/2.
1575 * Cast is needed because of integer promotion.
1576 */
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001577 pDecodedItem->val.uCount = (uint16_t)(pDecodedItem->val.uCount * 2);
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001578 }
1579 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001580
Laurence Lundblade041ffa52018-10-07 11:43:51 +07001581Done:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001582 return uReturn;
Laurence Lundblade041ffa52018-10-07 11:43:51 +07001583}
1584
1585
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001586#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001587/**
1588 * @brief Peek and see if next data item is a break;
1589 *
1590 * @param[in] pUIB UsefulInputBuf to read from.
1591 * @param[out] pbNextIsBreak Indicate if next was a break or not.
1592 *
1593 * @return Any decoding error.
1594 *
1595 * See if next item is a CBOR break. If it is, it is consumed,
1596 * if not it is not consumed.
Laurence Lundblade02625d42020-06-25 14:41:41 -07001597*/
Laurence Lundblade642282a2020-06-23 12:00:33 -07001598static inline QCBORError
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001599NextIsBreak(UsefulInputBuf *pUIB, bool *pbNextIsBreak)
1600{
1601 *pbNextIsBreak = false;
1602 if(UsefulInputBuf_BytesUnconsumed(pUIB) != 0) {
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001603 QCBORItem Peek;
1604 size_t uPeek = UsefulInputBuf_Tell(pUIB);
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001605 QCBORError uReturn = DecodeAtomicDataItem(pUIB, &Peek, NULL);
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001606 if(uReturn != QCBOR_SUCCESS) {
1607 return uReturn;
1608 }
1609 if(Peek.uDataType != QCBOR_TYPE_BREAK) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001610 /* It is not a break, rewind so it can be processed normally. */
Laurence Lundblade02625d42020-06-25 14:41:41 -07001611 UsefulInputBuf_Seek(pUIB, uPeek);
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001612 } else {
1613 *pbNextIsBreak = true;
1614 }
1615 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07001616
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001617 return QCBOR_SUCCESS;
1618}
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001619#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001620
1621
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001622/**
1623 * @brief Ascend up nesting levels if all items in them have been consumed.
1624 *
1625 * @param[in] pMe The decode context.
1626 * @param[in] bMarkEnd If true mark end of maps/arrays with count of zero.
1627 *
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001628 * An item was just consumed, now figure out if it was the
1629 * end of an array/map map that can be closed out. That
1630 * may in turn close out the above array/map...
Laurence Lundblade642282a2020-06-23 12:00:33 -07001631*/
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001632static QCBORError
1633QCBORDecode_NestLevelAscender(QCBORDecodeContext *pMe, bool bMarkEnd)
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001634{
1635 QCBORError uReturn;
Laurence Lundblade1d85d522020-06-22 13:24:59 -07001636
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001637 /* Loop ascending nesting levels as long as there is ascending to do */
Laurence Lundblade642282a2020-06-23 12:00:33 -07001638 while(!DecodeNesting_IsCurrentAtTop(&(pMe->nesting))) {
1639
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001640 if(DecodeNesting_IsCurrentBstrWrapped(&(pMe->nesting))) {
1641 /* Nesting level is bstr-wrapped CBOR */
1642
1643 /* Ascent for bstr-wrapped CBOR is always by explicit call
1644 * so no further ascending can happen.
1645 */
1646 break;
1647
1648 } else if(DecodeNesting_IsCurrentDefiniteLength(&(pMe->nesting))) {
1649 /* Level is a definite-length array/map */
1650
1651 /* Decrement the item count the definite-length array/map */
Laurence Lundblade642282a2020-06-23 12:00:33 -07001652 DecodeNesting_DecrementDefiniteLengthMapOrArrayCount(&(pMe->nesting));
1653 if(!DecodeNesting_IsEndOfDefiniteLengthMapOrArray(&(pMe->nesting))) {
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001654 /* Didn't close out array/map, so all work here is done */
Laurence Lundblade642282a2020-06-23 12:00:33 -07001655 break;
1656 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001657 /* All items in a definite-length array were consumed so it
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001658 * is time to ascend one level. This happens below.
1659 */
Laurence Lundblade642282a2020-06-23 12:00:33 -07001660
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001661#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001662 } else {
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001663 /* Level is an indefinite-length array/map. */
1664
1665 /* Check for a break which is what ends indefinite-length arrays/maps */
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001666 bool bIsBreak = false;
1667 uReturn = NextIsBreak(&(pMe->InBuf), &bIsBreak);
1668 if(uReturn != QCBOR_SUCCESS) {
1669 goto Done;
1670 }
Laurence Lundblade642282a2020-06-23 12:00:33 -07001671
1672 if(!bIsBreak) {
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001673 /* Not a break so array/map does not close out. All work is done */
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001674 break;
1675 }
Laurence Lundblade642282a2020-06-23 12:00:33 -07001676
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001677 /* It was a break in an indefinitelength map / array so
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001678 * it is time to ascend one level.
1679 */
Laurence Lundblade9b334962020-08-27 10:55:53 -07001680
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001681#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001682 }
Laurence Lundblade642282a2020-06-23 12:00:33 -07001683
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001684
1685 /* All items in the array/map have been consumed. */
Laurence Lundblade642282a2020-06-23 12:00:33 -07001686
Laurence Lundblade93d89472020-10-03 22:30:50 -07001687 /* But ascent in bounded mode is only by explicit call to
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001688 * QCBORDecode_ExitBoundedMode().
1689 */
Laurence Lundblade6c8a4442020-06-22 22:16:11 -07001690 if(DecodeNesting_IsCurrentBounded(&(pMe->nesting))) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001691 /* Set the count to zero for definite-length arrays to indicate
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001692 * cursor is at end of bounded array/map */
Laurence Lundbladed0304932020-06-27 10:59:38 -07001693 if(bMarkEnd) {
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001694 /* Used for definite and indefinite to signal end */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07001695 DecodeNesting_ZeroMapOrArrayCount(&(pMe->nesting));
Laurence Lundbladed0304932020-06-27 10:59:38 -07001696
Laurence Lundblade2c1faf92020-06-26 22:43:56 -07001697 }
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001698 break;
1699 }
1700
1701 /* Finally, actually ascend one level. */
1702 DecodeNesting_Ascend(&(pMe->nesting));
1703 }
Laurence Lundblade642282a2020-06-23 12:00:33 -07001704
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001705 uReturn = QCBOR_SUCCESS;
1706
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001707#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001708Done:
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001709#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_ARRAYS */
1710
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001711 return uReturn;
1712}
1713
1714
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001715/**
1716 * @brief Ascending & Descending out of nesting levels (decode layer 2).
1717 *
1718 * @param[in] pMe Decoder context
1719 * @param[out] pDecodedItem The decoded item that work is done on.
1720 *
1721 * @retval QCBOR_ERR_UNSUPPORTED
1722 * @retval QCBOR_ERR_HIT_END
1723 * @retval QCBOR_ERR_INT_OVERFLOW
1724 * @retval QCBOR_ERR_STRING_ALLOCATE
1725 * @retval QCBOR_ERR_STRING_TOO_LONG
1726 * @retval QCBOR_ERR_HALF_PRECISION_DISABLED
1727 * @retval QCBOR_ERR_BAD_TYPE_7
1728 * @retval QCBOR_ERR_INDEF_LEN_ARRAYS_DISABLED
1729 * @retval QCBOR_ERR_NO_STRING_ALLOCATOR
1730 * @retval QCBOR_ERR_INDEFINITE_STRING_CHUNK
1731 * @retval QCBOR_ERR_INDEF_LEN_STRINGS_DISABLED
1732 * @retval QCBOR_ERR_TOO_MANY_TAGS
1733 * @retval QCBOR_ERR_ARRAY_DECODE_TOO_LONG
1734 * @retval QCBOR_ERR_MAP_LABEL_TYPE
1735 * @retval QCBOR_ERR_NO_MORE_ITEMS
1736 * @retval QCBOR_ERR_BAD_BREAK
1737 * @retval QCBOR_ERR_ARRAY_DECODE_NESTING_TOO_DEEP
1738 *
1739 * This handles the traversal descending into and asecnding out of
1740 * maps, arrays and bstr-wrapped CBOR. It figures out the ends of
1741 * definite- and indefinte-length maps and arrays by looking at the
1742 * item count or finding CBOR breaks. It detects the ends of the
1743 * top-level sequence and of bstr-wrapped CBOR by byte count.
Laurence Lundblade041ffa52018-10-07 11:43:51 +07001744 */
Laurence Lundblade830fbf92020-05-31 17:22:33 -07001745static QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001746QCBORDecode_GetNextMapOrArray(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundblade041ffa52018-10-07 11:43:51 +07001747{
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001748 QCBORError uReturn;
Laurence Lundbladeeaa75a52020-07-09 18:13:23 -07001749 /* ==== First: figure out if at the end of a traversal ==== */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001750
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001751 /* If out of bytes to consume, it is either the end of the
1752 * top-level sequence of some bstr-wrapped CBOR that was entered.
1753 *
1754 * In the case of bstr-wrapped CBOR, the length of the
1755 * UsefulInputBuf was set to that of the bstr-wrapped CBOR. When
1756 * the bstr-wrapped CBOR is exited, the length is set back to the
1757 * top-level's length or to the next highest bstr-wrapped CBOR.
Laurence Lundblade642282a2020-06-23 12:00:33 -07001758 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001759 if(UsefulInputBuf_BytesUnconsumed(&(pMe->InBuf)) == 0) {
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001760 uReturn = QCBOR_ERR_NO_MORE_ITEMS;
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001761 goto Done;
1762 }
Laurence Lundblade937ea812020-05-08 11:38:23 -07001763
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001764 /* Check to see if at the end of a bounded definite-length map or
1765 * array. The check for a break ending indefinite-length array is
1766 * later in QCBORDecode_NestLevelAscender().
Laurence Lundblade24d509a2020-06-06 18:43:15 -07001767 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001768 if(DecodeNesting_IsAtEndOfBoundedLevel(&(pMe->nesting))) {
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001769 uReturn = QCBOR_ERR_NO_MORE_ITEMS;
Laurence Lundblade3f9ef042020-04-14 13:15:51 -07001770 goto Done;
1771 }
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001772
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08001773 /* ==== Next: not at the end, so get another item ==== */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001774 uReturn = QCBORDecode_GetNextMapEntry(pMe, pDecodedItem);
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001775 if(QCBORDecode_IsUnrecoverableError(uReturn)) {
1776 /* Error is so bad that traversal is not possible. */
Laurence Lundblade20b533d2018-10-08 20:44:53 +08001777 goto Done;
Laurence Lundblade041ffa52018-10-07 11:43:51 +07001778 }
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05301779
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001780 /* Breaks ending arrays/maps are processed later in the call to
1781 * QCBORDecode_NestLevelAscender(). They should never show up here.
Laurence Lundblade642282a2020-06-23 12:00:33 -07001782 */
Laurence Lundblade6de37062018-10-15 12:22:42 +05301783 if(pDecodedItem->uDataType == QCBOR_TYPE_BREAK) {
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001784 uReturn = QCBOR_ERR_BAD_BREAK;
Laurence Lundblade6de37062018-10-15 12:22:42 +05301785 goto Done;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05301786 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001787
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001788 /* Record the nesting level for this data item before processing
1789 * any of decrementing and descending.
Laurence Lundblade642282a2020-06-23 12:00:33 -07001790 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001791 pDecodedItem->uNestingLevel = DecodeNesting_GetCurrentLevel(&(pMe->nesting));
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001792
Laurence Lundblade642282a2020-06-23 12:00:33 -07001793
Laurence Lundbladeeaa75a52020-07-09 18:13:23 -07001794 /* ==== Next: Process the item for descent, ascent, decrement... ==== */
Laurence Lundblade02625d42020-06-25 14:41:41 -07001795 if(QCBORItem_IsMapOrArray(pDecodedItem)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001796 /* If the new item is a map or array, descend.
1797 *
1798 * Empty indefinite-length maps and arrays are descended into,
1799 * but then ascended out of in the next chunk of code.
1800 *
1801 * Maps and arrays do count as items in the map/array that
1802 * encloses them so a decrement needs to be done for them too,
1803 * but that is done only when all the items in them have been
1804 * processed, not when they are opened with the exception of an
1805 * empty map or array.
Laurence Lundblade642282a2020-06-23 12:00:33 -07001806 */
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001807 QCBORError uDescendErr;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001808 uDescendErr = DecodeNesting_DescendMapOrArray(&(pMe->nesting),
Laurence Lundblade642282a2020-06-23 12:00:33 -07001809 pDecodedItem->uDataType,
1810 pDecodedItem->val.uCount);
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001811 if(uDescendErr != QCBOR_SUCCESS) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001812 /* This error is probably a traversal error and it overrides
1813 * the non-traversal error.
1814 */
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001815 uReturn = uDescendErr;
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001816 goto Done;
1817 }
Laurence Lundblade5e87da62020-06-07 03:24:28 -07001818 }
1819
Laurence Lundblade02625d42020-06-25 14:41:41 -07001820 if(!QCBORItem_IsMapOrArray(pDecodedItem) ||
1821 QCBORItem_IsEmptyDefiniteLengthMapOrArray(pDecodedItem) ||
1822 QCBORItem_IsIndefiniteLengthMapOrArray(pDecodedItem)) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001823 /* The following cases are handled here:
1824 * - A non-aggregate item like an integer or string
1825 * - An empty definite-length map or array
1826 * - An indefinite-length map or array that might be empty or might not.
1827 *
1828 * QCBORDecode_NestLevelAscender() does the work of decrementing the count
1829 * for an definite-length map/array and break detection for an
1830 * indefinite-0length map/array. If the end of the map/array was
1831 * reached, then it ascends nesting levels, possibly all the way
1832 * to the top level.
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001833 */
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001834 QCBORError uAscendErr;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001835 uAscendErr = QCBORDecode_NestLevelAscender(pMe, true);
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001836 if(uAscendErr != QCBOR_SUCCESS) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001837 /* This error is probably a traversal error and it overrides
1838 * the non-traversal error.
1839 */
Laurence Lundbladea9489f82020-09-12 13:50:56 -07001840 uReturn = uAscendErr;
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07001841 goto Done;
Laurence Lundblade5e87da62020-06-07 03:24:28 -07001842 }
Laurence Lundblade6de37062018-10-15 12:22:42 +05301843 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001844
Laurence Lundbladeeaa75a52020-07-09 18:13:23 -07001845 /* ==== Last: tell the caller the nest level of the next item ==== */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001846 /* Tell the caller what level is next. This tells them what
1847 * maps/arrays were closed out and makes it possible for them to
1848 * reconstruct the tree with just the information returned in a
1849 * QCBORItem.
Laurence Lundblade642282a2020-06-23 12:00:33 -07001850 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001851 if(DecodeNesting_IsAtEndOfBoundedLevel(&(pMe->nesting))) {
Laurence Lundblade02625d42020-06-25 14:41:41 -07001852 /* At end of a bounded map/array; uNextNestLevel 0 to indicate this */
Laurence Lundblade9c905e82020-04-25 11:31:38 -07001853 pDecodedItem->uNextNestLevel = 0;
1854 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001855 pDecodedItem->uNextNestLevel = DecodeNesting_GetCurrentLevel(&(pMe->nesting));
Laurence Lundblade9c905e82020-04-25 11:31:38 -07001856 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001857
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001858Done:
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001859 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07001860}
1861
Laurence Lundblade9b334962020-08-27 10:55:53 -07001862
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001863/**
1864 * @brief Shift 0th tag out of the tag list.
1865 *
1866 * pDecodedItem[in,out] The data item to convert.
1867 *
1868 * The 0th tag is discarded. \ref CBOR_TAG_INVALID16 is
1869 * shifted into empty slot at the end of the tag list.
Laurence Lundblade59289e52019-12-30 13:44:37 -08001870 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001871static inline void ShiftTags(QCBORItem *pDecodedItem)
Laurence Lundblade59289e52019-12-30 13:44:37 -08001872{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001873 for(int i = 0; i < QCBOR_MAX_TAGS_PER_ITEM-1; i++) {
1874 pDecodedItem->uTags[i] = pDecodedItem->uTags[i+1];
Laurence Lundblade59289e52019-12-30 13:44:37 -08001875 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001876 pDecodedItem->uTags[QCBOR_MAX_TAGS_PER_ITEM-1] = CBOR_TAG_INVALID16;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001877}
1878
1879
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001880/**
1881 * @brief Convert different epoch date formats in to the QCBOR epoch date format
1882 *
1883 * pDecodedItem[in,out] The data item to convert.
1884 *
1885 * @retval QCBOR_ERR_DATE_OVERFLOW
1886 * @retval QCBOR_ERR_FLOAT_DATE_DISABLED
1887 * @retval QCBOR_ERR_BAD_TAG_CONTENT
1888 *
1889 * The epoch date tag defined in QCBOR allows for floating-point
1890 * dates. It even allows a protocol to flop between date formats when
1891 * ever it wants. Floating-point dates aren't that useful as they are
1892 * only needed for dates beyond the age of the earth.
1893 *
1894 * This converts all the date formats into one format of an unsigned
1895 * integer plus a floating-point fraction.
Laurence Lundblade59289e52019-12-30 13:44:37 -08001896 */
Laurence Lundblade06350ea2020-01-27 19:32:40 -08001897static QCBORError DecodeDateEpoch(QCBORItem *pDecodedItem)
Laurence Lundblade59289e52019-12-30 13:44:37 -08001898{
Laurence Lundbladec7114722020-08-13 05:11:40 -07001899 QCBORError uReturn = QCBOR_SUCCESS;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001900
1901 pDecodedItem->val.epochDate.fSecondsFraction = 0;
1902
1903 switch (pDecodedItem->uDataType) {
1904
1905 case QCBOR_TYPE_INT64:
1906 pDecodedItem->val.epochDate.nSeconds = pDecodedItem->val.int64;
1907 break;
1908
1909 case QCBOR_TYPE_UINT64:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001910 /* This only happens for CBOR type 0 > INT64_MAX so it is
1911 * always an overflow.
1912 */
Laurence Lundbladec7114722020-08-13 05:11:40 -07001913 uReturn = QCBOR_ERR_DATE_OVERFLOW;
1914 goto Done;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001915 break;
1916
1917 case QCBOR_TYPE_DOUBLE:
Laurence Lundblade9682a532020-06-06 18:33:04 -07001918 case QCBOR_TYPE_FLOAT:
1919#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade59289e52019-12-30 13:44:37 -08001920 {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001921 /* Convert working value to double if input was a float */
Laurence Lundblade3ed0bca2020-07-14 22:50:10 -07001922 const double d = pDecodedItem->uDataType == QCBOR_TYPE_DOUBLE ?
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001923 pDecodedItem->val.dfnum :
1924 (double)pDecodedItem->val.fnum;
1925
1926 /* The conversion from float to integer requires overflow
1927 * detection since floats can be much larger than integers.
1928 * This implementation errors out on these large float values
1929 * since they are beyond the age of the earth.
1930 *
1931 * These constants for the overflow check are computed by the
1932 * compiler. They are not computed at run time.
1933 *
1934 * The factor of 0x7ff is added/subtracted to avoid a
1935 * rounding error in the wrong direction when the compiler
1936 * computes these constants. There is rounding because an
1937 * 64-bit integer has 63 bits of precision where a double
1938 * only has 53 bits. Without the 0x7ff factor, the compiler
1939 * may round up and produce a double for the bounds check
1940 * that is larger than can be stored in a 64-bit integer. The
1941 * amount of 0x7ff is picked because it has 11 bits set.
1942 *
1943 * Without the 0x7ff there is a ~30 minute range of time
1944 * values 10 billion years in the past and in the future
1945 * where this code could go wrong. Some compilers correctly
1946 * generate a warning or error without the 0x7ff.
1947 */
1948 const double dDateMax = (double)(INT64_MAX - 0x7ff);
1949 const double dDateMin = (double)(INT64_MIN + 0x7ff);
1950
1951 if(isnan(d) || d > dDateMax || d < dDateMin) {
Laurence Lundbladec7114722020-08-13 05:11:40 -07001952 uReturn = QCBOR_ERR_DATE_OVERFLOW;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001953 goto Done;
1954 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001955
1956 /* The actual conversion */
Laurence Lundblade59289e52019-12-30 13:44:37 -08001957 pDecodedItem->val.epochDate.nSeconds = (int64_t)d;
Laurence Lundblade2feb1e12020-07-15 03:50:45 -07001958 pDecodedItem->val.epochDate.fSecondsFraction =
1959 d - (double)pDecodedItem->val.epochDate.nSeconds;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001960 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001961#else /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade4b270642020-08-14 12:53:07 -07001962
Laurence Lundbladec7114722020-08-13 05:11:40 -07001963 uReturn = QCBOR_ERR_FLOAT_DATE_DISABLED;
Laurence Lundblade4b270642020-08-14 12:53:07 -07001964 goto Done;
1965
Laurence Lundblade9682a532020-06-06 18:33:04 -07001966#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade59289e52019-12-30 13:44:37 -08001967 break;
1968
1969 default:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001970 uReturn = QCBOR_ERR_BAD_TAG_CONTENT;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001971 goto Done;
1972 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07001973
Laurence Lundblade59289e52019-12-30 13:44:37 -08001974 pDecodedItem->uDataType = QCBOR_TYPE_DATE_EPOCH;
1975
1976Done:
Laurence Lundbladec7114722020-08-13 05:11:40 -07001977 return uReturn;
Laurence Lundblade59289e52019-12-30 13:44:37 -08001978}
1979
1980
1981#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08001982/**
1983 * @brief Decode decimal fractions and big floats.
1984 *
1985 * @param[in] pMe The decode context.
1986 * @param[in,out] pDecodedItem On input the array data item that
1987 * holds the mantissa and exponent. On
1988 * output the decoded mantissa and
1989 * exponent.
1990 *
1991 * @returns Decoding errors from getting primitive data items or
1992 * \ref QCBOR_ERR_BAD_EXP_AND_MANTISSA.
1993 *
1994 * When called pDecodedItem must be the array that is tagged as a big
1995 * float or decimal fraction, the array that has the two members, the
1996 * exponent and mantissa.
1997 *
1998 * This will fetch and decode the exponent and mantissa and put the
1999 * result back into pDecodedItem.
Laurence Lundblade59289e52019-12-30 13:44:37 -08002000 */
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002001static inline QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002002QCBORDecode_MantissaAndExponent(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundblade59289e52019-12-30 13:44:37 -08002003{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002004 QCBORError uReturn;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002005
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002006 /* --- Make sure it is an array; track nesting level of members --- */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002007 if(pDecodedItem->uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002008 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002009 goto Done;
2010 }
2011
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002012 /* A check for pDecodedItem->val.uCount == 2 would work for
2013 * definite-length arrays, but not for indefnite. Instead remember
2014 * the nesting level the two integers must be at, which is one
2015 * deeper than that of the array.
2016 */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002017 const int nNestLevel = pDecodedItem->uNestingLevel + 1;
2018
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002019 /* --- Which is it, decimal fraction or a bigfloat? --- */
2020 const bool bIsTaggedDecimalFraction = QCBORDecode_IsTagged(pMe, pDecodedItem, CBOR_TAG_DECIMAL_FRACTION);
Laurence Lundblade59289e52019-12-30 13:44:37 -08002021 pDecodedItem->uDataType = bIsTaggedDecimalFraction ? QCBOR_TYPE_DECIMAL_FRACTION : QCBOR_TYPE_BIGFLOAT;
2022
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002023 /* --- Get the exponent --- */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002024 QCBORItem exponentItem;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002025 uReturn = QCBORDecode_GetNextMapOrArray(pMe, &exponentItem);
2026 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08002027 goto Done;
2028 }
2029 if(exponentItem.uNestingLevel != nNestLevel) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002030 /* Array is empty or a map/array encountered when expecting an int */
2031 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002032 goto Done;
2033 }
2034 if(exponentItem.uDataType == QCBOR_TYPE_INT64) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002035 /* Data arriving as an unsigned int < INT64_MAX has been
2036 * converted to QCBOR_TYPE_INT64 and thus handled here. This is
2037 * also means that the only data arriving here of type
2038 * QCBOR_TYPE_UINT64 data will be too large for this to handle
2039 * and thus an error that will get handled in the next else.
2040 */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002041 pDecodedItem->val.expAndMantissa.nExponent = exponentItem.val.int64;
2042 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002043 /* Wrong type of exponent or a QCBOR_TYPE_UINT64 > INT64_MAX */
2044 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002045 goto Done;
2046 }
2047
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002048 /* --- Get the mantissa --- */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002049 QCBORItem mantissaItem;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002050 uReturn = QCBORDecode_GetNextWithTags(pMe, &mantissaItem, NULL);
2051 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08002052 goto Done;
2053 }
2054 if(mantissaItem.uNestingLevel != nNestLevel) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002055 /* Mantissa missing or map/array encountered when expecting number */
2056 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002057 goto Done;
2058 }
2059 if(mantissaItem.uDataType == QCBOR_TYPE_INT64) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002060 /* Data arriving as an unsigned int < INT64_MAX has been
2061 * converted to QCBOR_TYPE_INT64 and thus handled here. This is
2062 * also means that the only data arriving here of type
2063 * QCBOR_TYPE_UINT64 data will be too large for this to handle
2064 * and thus an error that will get handled in an else below.
2065 */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002066 pDecodedItem->val.expAndMantissa.Mantissa.nInt = mantissaItem.val.int64;
Laurence Lundblade93d89472020-10-03 22:30:50 -07002067 } else if(mantissaItem.uDataType == QCBOR_TYPE_POSBIGNUM ||
2068 mantissaItem.uDataType == QCBOR_TYPE_NEGBIGNUM) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002069 /* Got a good big num mantissa */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002070 pDecodedItem->val.expAndMantissa.Mantissa.bigNum = mantissaItem.val.bigNum;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002071 /* Depends on numbering of QCBOR_TYPE_XXX */
Laurence Lundblade06350ea2020-01-27 19:32:40 -08002072 pDecodedItem->uDataType = (uint8_t)(pDecodedItem->uDataType +
2073 mantissaItem.uDataType - QCBOR_TYPE_POSBIGNUM +
2074 1);
Laurence Lundblade59289e52019-12-30 13:44:37 -08002075 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002076 /* Wrong type of mantissa or a QCBOR_TYPE_UINT64 > INT64_MAX */
2077 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002078 goto Done;
2079 }
2080
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002081 /* --- Check that array only has the two numbers --- */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002082 if(mantissaItem.uNextNestLevel == nNestLevel) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002083 /* Extra items in the decimal fraction / big float */
2084 uReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002085 goto Done;
2086 }
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07002087 pDecodedItem->uNextNestLevel = mantissaItem.uNextNestLevel;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002088
2089Done:
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002090 return uReturn;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002091}
2092#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
2093
2094
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002095#ifndef QCBOR_DISABLE_UNCOMMON_TAGS
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002096/**
2097 * @brief Decode the MIME type tag
2098 *
2099 * @param[in,out] pDecodedItem The item to decode.
2100 *
2101 * Handle the text and binary MIME type tags. Slightly too complicated
2102 * f or ProcessTaggedString() because the RFC 7049 MIME type was
2103 * incorreclty text-only.
2104 */
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002105static inline QCBORError DecodeMIME(QCBORItem *pDecodedItem)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002106{
2107 if(pDecodedItem->uDataType == QCBOR_TYPE_TEXT_STRING) {
2108 pDecodedItem->uDataType = QCBOR_TYPE_MIME;
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07002109 } else if(pDecodedItem->uDataType == QCBOR_TYPE_BYTE_STRING) {
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002110 pDecodedItem->uDataType = QCBOR_TYPE_BINARY_MIME;
2111 } else {
2112 return QCBOR_ERR_BAD_OPT_TAG;
2113 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002114
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002115 return QCBOR_SUCCESS;
2116}
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002117#endif /* QCBOR_DISABLE_UNCOMMON_TAGS */
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002118
2119
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002120/**
Laurence Lundblade99615302020-11-29 11:19:47 -08002121 * Table of CBOR tags whose content is either a text string or a byte
2122 * string. The table maps the CBOR tag to the QCBOR type. The high-bit
2123 * of uQCBORtype indicates the content should be a byte string rather
2124 * than a text string
2125 */
2126struct StringTagMapEntry {
2127 uint16_t uTagNumber;
2128 uint8_t uQCBORtype;
2129};
2130
2131#define IS_BYTE_STRING_BIT 0x80
2132#define QCBOR_TYPE_MASK ~IS_BYTE_STRING_BIT
2133
2134static const struct StringTagMapEntry StringTagMap[] = {
2135 {CBOR_TAG_DATE_STRING, QCBOR_TYPE_DATE_STRING},
2136 {CBOR_TAG_POS_BIGNUM, QCBOR_TYPE_POSBIGNUM | IS_BYTE_STRING_BIT},
2137 {CBOR_TAG_NEG_BIGNUM, QCBOR_TYPE_NEGBIGNUM | IS_BYTE_STRING_BIT},
2138 {CBOR_TAG_CBOR, QBCOR_TYPE_WRAPPED_CBOR | IS_BYTE_STRING_BIT},
2139 {CBOR_TAG_URI, QCBOR_TYPE_URI},
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002140#ifndef QCBOR_DISABLE_UNCOMMON_TAGS
Laurence Lundblade99615302020-11-29 11:19:47 -08002141 {CBOR_TAG_B64URL, QCBOR_TYPE_BASE64URL},
2142 {CBOR_TAG_B64, QCBOR_TYPE_BASE64},
2143 {CBOR_TAG_REGEX, QCBOR_TYPE_REGEX},
2144 {CBOR_TAG_BIN_UUID, QCBOR_TYPE_UUID | IS_BYTE_STRING_BIT},
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002145#endif /* QCBOR_DISABLE_UNCOMMON_TAGS */
Laurence Lundblade99615302020-11-29 11:19:47 -08002146 {CBOR_TAG_CBOR_SEQUENCE, QBCOR_TYPE_WRAPPED_CBOR_SEQUENCE | IS_BYTE_STRING_BIT},
2147 {CBOR_TAG_INVALID16, QCBOR_TYPE_NONE}
2148};
2149
2150
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002151/**
2152 * @brief Process standard CBOR tags whose content is a string
2153 *
2154 * @param[in] uTag The tag.
2155 * @param[in,out] pDecodedItem The data item.
2156 *
2157 * @returns This returns QCBOR_SUCCESS if the tag was procssed,
2158 * \ref QCBOR_ERR_UNSUPPORTED if the tag was not processed and
2159 * \ref QCBOR_ERR_BAD_OPT_TAG if the content type was wrong for the tag.
2160 *
Laurence Lundblade99615302020-11-29 11:19:47 -08002161 * Process the CBOR tags that whose content is a byte string or a text
2162 * string and for which the string is just passed on to the caller.
2163 *
2164 * This maps the CBOR tag to the QCBOR type and checks the content
2165 * type. Nothing more. It may not be the most important
Laurence Lundbladec02e13e2020-12-06 05:45:41 -08002166 * functionality, but it part of implementing as much of RFC 8949 as
Laurence Lundblade99615302020-11-29 11:19:47 -08002167 * possible.
Laurence Lundblade99615302020-11-29 11:19:47 -08002168 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002169static inline QCBORError
2170ProcessTaggedString(uint16_t uTag, QCBORItem *pDecodedItem)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002171{
Laurence Lundblade99615302020-11-29 11:19:47 -08002172 /* This only works on tags that were not mapped; no need for other yet */
2173 if(uTag > QCBOR_LAST_UNMAPPED_TAG) {
2174 return QCBOR_ERR_UNSUPPORTED;
2175 }
2176
2177 unsigned uIndex;
2178 for(uIndex = 0; StringTagMap[uIndex].uTagNumber != CBOR_TAG_INVALID16; uIndex++) {
2179 if(StringTagMap[uIndex].uTagNumber == uTag) {
2180 break;
2181 }
2182 }
2183
2184 const uint8_t uQCBORType = StringTagMap[uIndex].uQCBORtype;
2185 if(uQCBORType == QCBOR_TYPE_NONE) {
2186 /* repurpose this error to mean, not handled here */
2187 return QCBOR_ERR_UNSUPPORTED;
2188 }
2189
2190 uint8_t uExpectedType = QCBOR_TYPE_TEXT_STRING;
2191 if(uQCBORType & IS_BYTE_STRING_BIT) {
2192 uExpectedType = QCBOR_TYPE_BYTE_STRING;
2193 }
2194
2195 if(pDecodedItem->uDataType != uExpectedType) {
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002196 return QCBOR_ERR_BAD_OPT_TAG;
2197 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002198
Laurence Lundblade99615302020-11-29 11:19:47 -08002199 pDecodedItem->uDataType = (uint8_t)(uQCBORType & QCBOR_TYPE_MASK);
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002200 return QCBOR_SUCCESS;
2201}
2202
2203
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002204/**
2205 * @brief Decode tag content for select tags (decoding layer 1).
2206 *
2207 * @param[in] pMe The decode context.
2208 * @param[out] pDecodedItem The decoded item.
2209 *
2210 * @return Decoding error code.
2211 *
Laurence Lundblade99615302020-11-29 11:19:47 -08002212 * CBOR tag numbers for the item were decoded in GetNext_TaggedItem(),
2213 * but the whole tag was not decoded. Here, the whole tags (tag number
2214 * and tag content) that are supported by QCBOR are decoded. This is a
2215 * quick pass through for items that are not tags.
Laurence Lundblade59289e52019-12-30 13:44:37 -08002216 */
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002217static QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002218QCBORDecode_GetNextTagContent(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
Laurence Lundblade59289e52019-12-30 13:44:37 -08002219{
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002220 QCBORError uReturn;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002221
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002222 uReturn = QCBORDecode_GetNextMapOrArray(pMe, pDecodedItem);
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002223 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08002224 goto Done;
2225 }
2226
Laurence Lundblade99615302020-11-29 11:19:47 -08002227 /* When there are no tag numbers for the item, this exits first
2228 * thing and effectively does nothing.
2229 *
2230 * This loops over all the tag numbers accumulated for this item
2231 * trying to decode and interpret them. This stops at the end of
2232 * the list or at the first tag number that can't be interpreted by
2233 * this code. This is effectively a recursive processing of the
2234 * tags number list that handles nested tags.
2235 */
2236 while(1) {
2237 /* Don't bother to unmap tags via QCBORITem.uTags since this
2238 * code only works on tags less than QCBOR_LAST_UNMAPPED_TAG.
2239 */
2240 const uint16_t uTagToProcess = pDecodedItem->uTags[0];
Laurence Lundblade59289e52019-12-30 13:44:37 -08002241
Laurence Lundblade99615302020-11-29 11:19:47 -08002242 if(uTagToProcess == CBOR_TAG_INVALID16) {
2243 /* Hit the end of the tag list. A successful exit. */
Laurence Lundblade59289e52019-12-30 13:44:37 -08002244 break;
2245
Laurence Lundblade99615302020-11-29 11:19:47 -08002246 } else if(uTagToProcess == CBOR_TAG_DATE_EPOCH) {
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002247 uReturn = DecodeDateEpoch(pDecodedItem);
Laurence Lundblade59289e52019-12-30 13:44:37 -08002248
Laurence Lundblade93d89472020-10-03 22:30:50 -07002249#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundblade99615302020-11-29 11:19:47 -08002250 } else if(uTagToProcess == CBOR_TAG_DECIMAL_FRACTION ||
2251 uTagToProcess == CBOR_TAG_BIGFLOAT) {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002252 uReturn = QCBORDecode_MantissaAndExponent(pMe, pDecodedItem);
Laurence Lundblade93d89472020-10-03 22:30:50 -07002253#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002254#ifndef QCBOR_DISABLE_UNCOMMON_TAGS
Laurence Lundblade99615302020-11-29 11:19:47 -08002255 } else if(uTagToProcess == CBOR_TAG_MIME ||
2256 uTagToProcess == CBOR_TAG_BINARY_MIME) {
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002257 uReturn = DecodeMIME(pDecodedItem);
Laurence Lundblade24bd7e12021-01-09 00:05:11 -08002258#endif /* QCBOR_DISABLE_UNCOMMON_TAGS */
Laurence Lundblade91853ae2020-06-15 19:35:58 -07002259
Laurence Lundblade99615302020-11-29 11:19:47 -08002260 } else {
2261 /* See if it is a pass-through byte/text string tag; process if so */
2262 uReturn = ProcessTaggedString(pDecodedItem->uTags[0], pDecodedItem);
Laurence Lundblade0a042a92020-06-12 14:09:50 -07002263
Laurence Lundblade99615302020-11-29 11:19:47 -08002264 if(uReturn == QCBOR_ERR_UNSUPPORTED) {
2265 /* It wasn't a pass-through byte/text string tag so it is
2266 * an unknown tag. This is the exit from the loop on the
2267 * first unknown tag. It is a successful exit.
2268 */
2269 uReturn = QCBOR_SUCCESS;
2270 break;
2271 }
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002272 }
Laurence Lundblade99615302020-11-29 11:19:47 -08002273
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002274 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade99615302020-11-29 11:19:47 -08002275 /* Error exit from the loop */
2276 break;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002277 }
Laurence Lundblade99615302020-11-29 11:19:47 -08002278
2279 /* A tag was successfully processed, shift it out of the list of
2280 * tags returned. This is the loop increment.
2281 */
Laurence Lundblade9b334962020-08-27 10:55:53 -07002282 ShiftTags(pDecodedItem);
Laurence Lundblade59289e52019-12-30 13:44:37 -08002283 }
2284
2285Done:
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002286 return uReturn;
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002287}
2288
2289
Laurence Lundblade2a26abb2020-11-05 19:06:54 -08002290/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002291 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade2a26abb2020-11-05 19:06:54 -08002292 */
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002293QCBORError
2294QCBORDecode_GetNext(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
2295{
2296 QCBORError uErr;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002297 uErr = QCBORDecode_GetNextTagContent(pMe, pDecodedItem);
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002298 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08002299 pDecodedItem->uDataType = QCBOR_TYPE_NONE;
2300 pDecodedItem->uLabelType = QCBOR_TYPE_NONE;
2301 }
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002302 return uErr;
Laurence Lundblade59289e52019-12-30 13:44:37 -08002303}
2304
2305
2306/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002307 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade59289e52019-12-30 13:44:37 -08002308 */
Laurence Lundblade2a26abb2020-11-05 19:06:54 -08002309QCBORError
2310QCBORDecode_PeekNext(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
2311{
2312 const QCBORDecodeNesting SaveNesting = pMe->nesting;
2313 const UsefulInputBuf Save = pMe->InBuf;
2314
2315 QCBORError uErr = QCBORDecode_GetNext(pMe, pDecodedItem);
2316
2317 pMe->nesting = SaveNesting;
2318 pMe->InBuf = Save;
2319
2320 return uErr;
2321}
2322
2323
2324/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002325 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade2a26abb2020-11-05 19:06:54 -08002326 */
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07002327void QCBORDecode_VGetNext(QCBORDecodeContext *pMe, QCBORItem *pDecodedItem)
2328{
2329 if(pMe->uLastError != QCBOR_SUCCESS) {
2330 return;
2331 }
2332
2333 pMe->uLastError = (uint8_t)QCBORDecode_GetNext(pMe, pDecodedItem);
2334}
2335
2336
2337/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002338 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07002339 */
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002340QCBORError
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002341QCBORDecode_GetNextWithTags(QCBORDecodeContext *pMe,
2342 QCBORItem *pDecodedItem,
2343 QCBORTagListOut *pTags)
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002344{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002345 QCBORError uReturn;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002346
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002347 uReturn = QCBORDecode_GetNext(pMe, pDecodedItem);
2348 if(uReturn != QCBOR_SUCCESS) {
2349 return uReturn;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002350 }
2351
2352 if(pTags != NULL) {
2353 pTags->uNumUsed = 0;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002354 /* Reverse the order because pTags is reverse of QCBORItem.uTags. */
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002355 for(int nTagIndex = QCBOR_MAX_TAGS_PER_ITEM-1; nTagIndex >=0; nTagIndex--) {
2356 if(pDecodedItem->uTags[nTagIndex] == CBOR_TAG_INVALID16) {
Laurence Lundblade9b334962020-08-27 10:55:53 -07002357 continue;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002358 }
2359 if(pTags->uNumUsed >= pTags->uNumAllocated) {
2360 return QCBOR_ERR_TOO_MANY_TAGS;
2361 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002362 pTags->puTags[pTags->uNumUsed] = UnMapTagNumber(pMe,pDecodedItem->uTags[nTagIndex]);
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002363 pTags->uNumUsed++;
2364 }
2365 }
2366
2367 return QCBOR_SUCCESS;
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002368}
2369
2370
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07002371/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002372 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade0fb2f642018-10-11 19:33:35 +05302373 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002374bool QCBORDecode_IsTagged(QCBORDecodeContext *pMe,
Laurence Lundblade9b334962020-08-27 10:55:53 -07002375 const QCBORItem *pItem,
2376 uint64_t uTag)
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002377{
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002378 for(unsigned uTagIndex = 0; uTagIndex < QCBOR_MAX_TAGS_PER_ITEM; uTagIndex++) {
2379 if(pItem->uTags[uTagIndex] == CBOR_TAG_INVALID16) {
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002380 break;
2381 }
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002382 if(UnMapTagNumber(pMe, pItem->uTags[uTagIndex]) == uTag) {
Laurence Lundbladef71e1622020-08-06 18:52:13 -07002383 return true;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002384 }
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002385 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002386
Laurence Lundbladef71e1622020-08-06 18:52:13 -07002387 return false;
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002388}
2389
2390
2391/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002392 * Public function, see header qcbor/qcbor_decode.h file
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002393 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002394QCBORError QCBORDecode_Finish(QCBORDecodeContext *pMe)
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07002395{
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002396 QCBORError uReturn = pMe->uLastError;
Laurence Lundblade085d7952020-07-24 10:26:30 -07002397
2398 if(uReturn != QCBOR_SUCCESS) {
2399 goto Done;
2400 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002401
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002402 /* Error out if all the maps/arrays are not closed out */
2403 if(!DecodeNesting_IsCurrentAtTop(&(pMe->nesting))) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002404 uReturn = QCBOR_ERR_ARRAY_OR_MAP_UNCONSUMED;
Laurence Lundblade20b533d2018-10-08 20:44:53 +08002405 goto Done;
2406 }
2407
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002408 /* Error out if not all the bytes are consumed */
2409 if(UsefulInputBuf_BytesUnconsumed(&(pMe->InBuf))) {
Laurence Lundblade085d7952020-07-24 10:26:30 -07002410 uReturn = QCBOR_ERR_EXTRA_BYTES;
Laurence Lundblade20b533d2018-10-08 20:44:53 +08002411 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002412
Laurence Lundblade20b533d2018-10-08 20:44:53 +08002413Done:
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08002414#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002415 /* Call the destructor for the string allocator if there is one.
2416 * Always called, even if there are errors; always have to clean up.
2417 */
2418 StringAllocator_Destruct(&(pMe->StringAllocator));
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08002419#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002420
Laurence Lundblade085d7952020-07-24 10:26:30 -07002421 return uReturn;
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07002422}
2423
2424
Laurence Lundbladec75e68b2020-06-15 20:34:46 -07002425/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002426 * Public function, see header qcbor/qcbor_decode.h file
2427 */
Laurence Lundblade9b334962020-08-27 10:55:53 -07002428// Improvement: make these inline?
Laurence Lundblade2b843b52020-06-16 20:51:03 -07002429uint64_t QCBORDecode_GetNthTag(QCBORDecodeContext *pMe,
2430 const QCBORItem *pItem,
Laurence Lundblade9b334962020-08-27 10:55:53 -07002431 uint32_t uIndex)
Laurence Lundbladec75e68b2020-06-15 20:34:46 -07002432{
Laurence Lundblade88e9db22020-11-02 03:56:33 -08002433 if(pItem->uDataType == QCBOR_TYPE_NONE) {
2434 return CBOR_TAG_INVALID64;
2435 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002436 if(uIndex >= QCBOR_MAX_TAGS_PER_ITEM) {
2437 return CBOR_TAG_INVALID64;
Laurence Lundbladec75e68b2020-06-15 20:34:46 -07002438 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002439 return UnMapTagNumber(pMe, pItem->uTags[uIndex]);
Laurence Lundbladec75e68b2020-06-15 20:34:46 -07002440 }
2441}
2442
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002443
Laurence Lundblade9b334962020-08-27 10:55:53 -07002444/*
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002445 * Public function, see header qcbor/qcbor_decode.h file
2446 */
Laurence Lundblade9b334962020-08-27 10:55:53 -07002447uint64_t QCBORDecode_GetNthTagOfLast(const QCBORDecodeContext *pMe,
2448 uint32_t uIndex)
2449{
Laurence Lundblade88e9db22020-11-02 03:56:33 -08002450 if(pMe->uLastError != QCBOR_SUCCESS) {
2451 return CBOR_TAG_INVALID64;
2452 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002453 if(uIndex >= QCBOR_MAX_TAGS_PER_ITEM) {
2454 return CBOR_TAG_INVALID64;
2455 } else {
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002456 return UnMapTagNumber(pMe, pMe->uLastTags[uIndex]);
Laurence Lundblade9b334962020-08-27 10:55:53 -07002457 }
2458}
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07002459
Laurence Lundbladeb69cad72018-09-13 11:09:01 -07002460
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002461
2462
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08002463#ifndef QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS
Laurence Lundbladef6531662018-12-04 10:42:22 +09002464
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002465/* ===========================================================================
2466 MemPool -- BUILT-IN SIMPLE STRING ALLOCATOR
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002467
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002468 This implements a simple sting allocator for indefinite-length
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002469 strings that can be enabled by calling QCBORDecode_SetMemPool(). It
2470 implements the function type QCBORStringAllocate and allows easy
2471 use of it.
Laurence Lundbladef6531662018-12-04 10:42:22 +09002472
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002473 This particular allocator is built-in for convenience. The caller
2474 can implement their own. All of this following code will get
2475 dead-stripped if QCBORDecode_SetMemPool() is not called.
2476
2477 This is a very primitive memory allocator. It does not track
2478 individual allocations, only a high-water mark. A free or
2479 reallocation must be of the last chunk allocated.
2480
2481 The size of the pool and offset to free memory are packed into the
2482 first 8 bytes of the memory pool so we don't have to keep them in
2483 the decode context. Since the address of the pool may not be
2484 aligned, they have to be packed and unpacked as if they were
2485 serialized data of the wire or such.
2486
2487 The sizes packed in are uint32_t to be the same on all CPU types
2488 and simplify the code.
Laurence Lundbladeee851742020-01-08 08:37:05 -08002489 ========================================================================== */
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002490
2491
Laurence Lundbladeee851742020-01-08 08:37:05 -08002492static inline int
2493MemPool_Unpack(const void *pMem, uint32_t *puPoolSize, uint32_t *puFreeOffset)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002494{
2495 // Use of UsefulInputBuf is overkill, but it is convenient.
2496 UsefulInputBuf UIB;
2497
Laurence Lundbladeee851742020-01-08 08:37:05 -08002498 // Just assume the size here. It was checked during SetUp so
2499 // the assumption is safe.
Laurence Lundblade93d89472020-10-03 22:30:50 -07002500 UsefulInputBuf_Init(&UIB, (UsefulBufC){pMem,QCBOR_DECODE_MIN_MEM_POOL_SIZE});
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002501 *puPoolSize = UsefulInputBuf_GetUint32(&UIB);
2502 *puFreeOffset = UsefulInputBuf_GetUint32(&UIB);
2503 return UsefulInputBuf_GetError(&UIB);
2504}
2505
2506
Laurence Lundbladeee851742020-01-08 08:37:05 -08002507static inline int
2508MemPool_Pack(UsefulBuf Pool, uint32_t uFreeOffset)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002509{
2510 // Use of UsefulOutBuf is overkill, but convenient. The
2511 // length check performed here is useful.
2512 UsefulOutBuf UOB;
2513
2514 UsefulOutBuf_Init(&UOB, Pool);
2515 UsefulOutBuf_AppendUint32(&UOB, (uint32_t)Pool.len); // size of pool
2516 UsefulOutBuf_AppendUint32(&UOB, uFreeOffset); // first free position
2517 return UsefulOutBuf_GetError(&UOB);
2518}
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002519
2520
2521/*
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002522 Internal function for an allocation, reallocation free and destuct.
2523
2524 Having only one function rather than one each per mode saves space in
2525 QCBORDecodeContext.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002526
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002527 Code Reviewers: THIS FUNCTION DOES POINTER MATH
2528 */
Laurence Lundbladeee851742020-01-08 08:37:05 -08002529static UsefulBuf
2530MemPool_Function(void *pPool, void *pMem, size_t uNewSize)
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002531{
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002532 UsefulBuf ReturnValue = NULLUsefulBuf;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002533
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002534 uint32_t uPoolSize;
2535 uint32_t uFreeOffset;
2536
2537 if(uNewSize > UINT32_MAX) {
2538 // This allocator is only good up to 4GB. This check should
2539 // optimize out if sizeof(size_t) == sizeof(uint32_t)
2540 goto Done;
2541 }
2542 const uint32_t uNewSize32 = (uint32_t)uNewSize;
2543
2544 if(MemPool_Unpack(pPool, &uPoolSize, &uFreeOffset)) {
2545 goto Done;
2546 }
2547
2548 if(uNewSize) {
2549 if(pMem) {
2550 // REALLOCATION MODE
2551 // Calculate pointer to the end of the memory pool. It is
2552 // assumed that pPool + uPoolSize won't wrap around by
2553 // assuming the caller won't pass a pool buffer in that is
2554 // not in legitimate memory space.
2555 const void *pPoolEnd = (uint8_t *)pPool + uPoolSize;
2556
2557 // Check that the pointer for reallocation is in the range of the
2558 // pool. This also makes sure that pointer math further down
2559 // doesn't wrap under or over.
2560 if(pMem >= pPool && pMem < pPoolEnd) {
2561 // Offset to start of chunk for reallocation. This won't
2562 // wrap under because of check that pMem >= pPool. Cast
2563 // is safe because the pool is always less than UINT32_MAX
2564 // because of check in QCBORDecode_SetMemPool().
2565 const uint32_t uMemOffset = (uint32_t)((uint8_t *)pMem - (uint8_t *)pPool);
2566
2567 // Check to see if the allocation will fit. uPoolSize -
2568 // uMemOffset will not wrap under because of check that
2569 // pMem is in the range of the uPoolSize by check above.
2570 if(uNewSize <= uPoolSize - uMemOffset) {
2571 ReturnValue.ptr = pMem;
2572 ReturnValue.len = uNewSize;
2573
2574 // Addition won't wrap around over because uNewSize was
2575 // checked to be sure it is less than the pool size.
2576 uFreeOffset = uMemOffset + uNewSize32;
2577 }
2578 }
2579 } else {
2580 // ALLOCATION MODE
2581 // uPoolSize - uFreeOffset will not underflow because this
2582 // pool implementation makes sure uFreeOffset is always
2583 // smaller than uPoolSize through this check here and
2584 // reallocation case.
2585 if(uNewSize <= uPoolSize - uFreeOffset) {
2586 ReturnValue.len = uNewSize;
2587 ReturnValue.ptr = (uint8_t *)pPool + uFreeOffset;
Laurence Lundblade06350ea2020-01-27 19:32:40 -08002588 uFreeOffset += (uint32_t)uNewSize;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002589 }
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002590 }
2591 } else {
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002592 if(pMem) {
2593 // FREE MODE
2594 // Cast is safe because of limit on pool size in
2595 // QCBORDecode_SetMemPool()
2596 uFreeOffset = (uint32_t)((uint8_t *)pMem - (uint8_t *)pPool);
2597 } else {
2598 // DESTRUCT MODE
2599 // Nothing to do for this allocator
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002600 }
2601 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002602
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002603 UsefulBuf Pool = {pPool, uPoolSize};
2604 MemPool_Pack(Pool, uFreeOffset);
2605
2606Done:
2607 return ReturnValue;
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002608}
2609
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002610
Laurence Lundbladef6531662018-12-04 10:42:22 +09002611/*
Laurence Lundblade844bb5c2020-03-01 17:27:25 -08002612 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundbladef6531662018-12-04 10:42:22 +09002613 */
Laurence Lundbladeee851742020-01-08 08:37:05 -08002614QCBORError QCBORDecode_SetMemPool(QCBORDecodeContext *pMe,
2615 UsefulBuf Pool,
2616 bool bAllStrings)
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002617{
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002618 // The pool size and free mem offset are packed into the beginning
2619 // of the pool memory. This compile time check make sure the
2620 // constant in the header is correct. This check should optimize
2621 // down to nothing.
2622 if(QCBOR_DECODE_MIN_MEM_POOL_SIZE < 2 * sizeof(uint32_t)) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002623 return QCBOR_ERR_MEM_POOL_SIZE;
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002624 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002625
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002626 // The pool size and free offset packed in to the beginning of pool
2627 // memory are only 32-bits. This check will optimize out on 32-bit
2628 // machines.
2629 if(Pool.len > UINT32_MAX) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002630 return QCBOR_ERR_MEM_POOL_SIZE;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002631 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002632
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002633 // This checks that the pool buffer given is big enough.
2634 if(MemPool_Pack(Pool, QCBOR_DECODE_MIN_MEM_POOL_SIZE)) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002635 return QCBOR_ERR_MEM_POOL_SIZE;
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002636 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002637
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08002638 pMe->StringAllocator.pfAllocator = MemPool_Function;
2639 pMe->StringAllocator.pAllocateCxt = Pool.ptr;
2640 pMe->bStringAllocateAll = bAllStrings;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002641
Laurence Lundblade30816f22018-11-10 13:40:22 +07002642 return QCBOR_SUCCESS;
Laurence Lundblade041ffa52018-10-07 11:43:51 +07002643}
Laurence Lundbladef6da33c2020-11-26 18:15:05 -08002644#endif /* QCBOR_DISABLE_INDEFINITE_LENGTH_STRINGS */
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002645
Laurence Lundblade2b843b52020-06-16 20:51:03 -07002646
2647
Laurence Lundblade9b334962020-08-27 10:55:53 -07002648static inline void CopyTags(QCBORDecodeContext *pMe, const QCBORItem *pItem)
2649{
2650 memcpy(pMe->uLastTags, pItem->uTags, sizeof(pItem->uTags));
2651}
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002652
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002653
2654/*
Laurence Lundblade2b843b52020-06-16 20:51:03 -07002655 Consume an entire map or array (and do next to
2656 nothing for non-aggregate types).
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002657 */
Laurence Lundblade9c905e82020-04-25 11:31:38 -07002658static inline QCBORError
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002659ConsumeItem(QCBORDecodeContext *pMe,
2660 const QCBORItem *pItemToConsume,
2661 uint_fast8_t *puNextNestLevel)
2662{
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002663 QCBORError uReturn;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002664 QCBORItem Item;
Laurence Lundblade9b334962020-08-27 10:55:53 -07002665
Laurence Lundbladed40951e2020-08-28 11:11:14 -07002666 // If it is a map or array, this will tell if it is empty.
2667 const bool bIsEmpty = (pItemToConsume->uNextNestLevel <= pItemToConsume->uNestingLevel);
2668
2669 if(QCBORItem_IsMapOrArray(pItemToConsume) && !bIsEmpty) {
2670 /* There is only real work to do for non-empty maps and arrays */
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002671
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002672 /* This works for definite- and indefinite- length
Laurence Lundblade1341c592020-04-11 14:19:05 -07002673 * maps and arrays by using the nesting level
2674 */
2675 do {
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002676 uReturn = QCBORDecode_GetNext(pMe, &Item);
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002677 if(QCBORDecode_IsUnrecoverableError(uReturn)) {
Laurence Lundblade1341c592020-04-11 14:19:05 -07002678 goto Done;
2679 }
2680 } while(Item.uNextNestLevel >= pItemToConsume->uNextNestLevel);
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002681
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002682 *puNextNestLevel = Item.uNextNestLevel;
2683
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002684 uReturn = QCBOR_SUCCESS;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002685
Laurence Lundblade1341c592020-04-11 14:19:05 -07002686 } else {
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002687 /* item_to_consume is not a map or array */
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002688 /* Just pass the nesting level through */
2689 *puNextNestLevel = pItemToConsume->uNextNestLevel;
2690
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002691 uReturn = QCBOR_SUCCESS;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002692 }
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002693
2694Done:
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002695 return uReturn;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002696}
2697
2698
Laurence Lundblade1a59a172020-11-09 11:19:18 -08002699/*
2700 Public function, see header qcbor/qcbor_decode.h file
2701 */
Laurence Lundbladeebed2912020-11-08 22:43:14 -08002702void QCBORDecode_Rewind(QCBORDecodeContext *pMe)
2703{
Laurence Lundblade1a59a172020-11-09 11:19:18 -08002704 size_t uResetOffset;
2705
Laurence Lundbladeb237f062020-11-10 13:31:25 -08002706 if(pMe->nesting.pCurrentBounded != NULL) {
Laurence Lundbladeb237f062020-11-10 13:31:25 -08002707
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08002708 if(DecodeNesting_IsBoundedType(&(pMe->nesting), QCBOR_TYPE_BYTE_STRING)) {
Laurence Lundbladebd209782021-02-17 10:44:42 -07002709 /* Reposition traversal cursor to start of wrapping byte string */
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08002710 uResetOffset = pMe->nesting.pCurrentBounded->u.bs.uBstrStartOffset;
Laurence Lundbladebd209782021-02-17 10:44:42 -07002711 pMe->nesting.pCurrent = pMe->nesting.pCurrentBounded;
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08002712
2713 } else {
2714 /* Reposition traversal cursor to the start of the map/array */
2715 uResetOffset = DecodeNesting_GetMapOrArrayStart(&(pMe->nesting));
2716
2717 /* Reset nesting tracking to the deepest bounded level */
2718 // TODO: combine this with code called by MapSearch?
Laurence Lundbladebd209782021-02-17 10:44:42 -07002719 pMe->nesting.pCurrent = pMe->nesting.pCurrentBounded;
Laurence Lundbladefe3ae642021-02-19 10:45:39 -07002720 if(pMe->nesting.pCurrent->u.ma.uCountCursor != QCBOR_COUNT_INDICATES_ZERO_LENGTH) {
2721 pMe->nesting.pCurrent->u.ma.uCountCursor =
2722 pMe->nesting.pCurrent->u.ma.uCountTotal;
2723 }
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08002724 }
Laurence Lundbladeb237f062020-11-10 13:31:25 -08002725
Laurence Lundblade1a59a172020-11-09 11:19:18 -08002726 } else {
Laurence Lundbladeb237f062020-11-10 13:31:25 -08002727 /* Reposition traversal cursor to the start of input CBOR */
Laurence Lundblade1a59a172020-11-09 11:19:18 -08002728 uResetOffset = 0ULL;
Laurence Lundbladeb237f062020-11-10 13:31:25 -08002729
2730 /* Reset nesting tracking to beginning of input. */
2731 DecodeNesting_Init(&(pMe->nesting));
Laurence Lundblade1a59a172020-11-09 11:19:18 -08002732 }
2733
2734 UsefulInputBuf_Seek(&(pMe->InBuf), uResetOffset);
2735 pMe->uLastError = QCBOR_SUCCESS;
Laurence Lundbladeebed2912020-11-08 22:43:14 -08002736}
2737
2738
Laurence Lundblade1341c592020-04-11 14:19:05 -07002739/* Return true if the labels in Item1 and Item2 are the same.
2740 Works only for integer and string labels. Returns false
2741 for any other type. */
2742static inline bool
2743MatchLabel(QCBORItem Item1, QCBORItem Item2)
2744{
2745 if(Item1.uLabelType == QCBOR_TYPE_INT64) {
2746 if(Item2.uLabelType == QCBOR_TYPE_INT64 && Item1.label.int64 == Item2.label.int64) {
2747 return true;
2748 }
2749 } else if(Item1.uLabelType == QCBOR_TYPE_TEXT_STRING) {
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002750 if(Item2.uLabelType == QCBOR_TYPE_TEXT_STRING && !UsefulBuf_Compare(Item1.label.string, Item2.label.string)) {
Laurence Lundblade1341c592020-04-11 14:19:05 -07002751 return true;
2752 }
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002753 } else if(Item1.uLabelType == QCBOR_TYPE_BYTE_STRING) {
Laurence Lundbladefb492ea2020-05-02 11:14:07 -07002754 if(Item2.uLabelType == QCBOR_TYPE_BYTE_STRING && !UsefulBuf_Compare(Item1.label.string, Item2.label.string)) {
2755 return true;
2756 }
2757 } else if(Item1.uLabelType == QCBOR_TYPE_UINT64) {
2758 if(Item2.uLabelType == QCBOR_TYPE_UINT64 && Item1.label.uint64 == Item2.label.uint64) {
2759 return true;
2760 }
2761 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002762
Laurence Lundblade1341c592020-04-11 14:19:05 -07002763 /* Other label types are never matched */
2764 return false;
2765}
2766
Laurence Lundblade2b843b52020-06-16 20:51:03 -07002767
2768/*
2769 Returns true if Item1 and Item2 are the same type
2770 or if either are of QCBOR_TYPE_ANY.
2771 */
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002772static inline bool
2773MatchType(QCBORItem Item1, QCBORItem Item2)
2774{
2775 if(Item1.uDataType == Item2.uDataType) {
2776 return true;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07002777 } else if(Item1.uDataType == QCBOR_TYPE_ANY) {
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002778 return true;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07002779 } else if(Item2.uDataType == QCBOR_TYPE_ANY) {
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002780 return true;
2781 }
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002782 return false;
2783}
2784
2785
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002786/**
Laurence Lundblade5f53f832020-09-03 12:00:14 -07002787 @brief Search a map for a set of items.
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002788
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002789 @param[in] pMe The decode context to search.
2790 @param[in,out] pItemArray The items to search for and the items found.
2791 @param[out] puOffset Byte offset of last item matched.
2792 @param[in] pCBContext Context for the not-found item call back.
2793 @param[in] pfCallback Function to call on items not matched in pItemArray.
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002794
2795 @retval QCBOR_ERR_NOT_ENTERED Trying to search without having entered a map
2796
Laurence Lundblade93d89472020-10-03 22:30:50 -07002797 @retval QCBOR_ERR_DUPLICATE_LABEL Duplicate items (items with the same label)
2798 were found for one of the labels being
2799 search for. This duplicate detection is
2800 only performed for items in pItemArray,
2801 not every item in the map.
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002802
Laurence Lundblade93d89472020-10-03 22:30:50 -07002803 @retval QCBOR_ERR_UNEXPECTED_TYPE A label was matched, but the type was
2804 wrong for the matchd label.
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002805
2806 @retval Also errors returned by QCBORDecode_GetNext().
2807
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002808 On input pItemArray contains a list of labels and data types
2809 of items to be found.
Laurence Lundblade9b334962020-08-27 10:55:53 -07002810
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002811 On output the fully retrieved items are filled in with
2812 values and such. The label was matched, so it never changes.
Laurence Lundblade9b334962020-08-27 10:55:53 -07002813
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002814 If an item was not found, its data type is set to QCBOR_TYPE_NONE.
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002815
2816 This also finds the ends of maps and arrays when they are exited.
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002817 */
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07002818static QCBORError
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002819MapSearch(QCBORDecodeContext *pMe,
2820 QCBORItem *pItemArray,
2821 size_t *puOffset,
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002822 void *pCBContext,
2823 QCBORItemCallback pfCallback)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002824{
Laurence Lundbladee6f15112020-07-23 18:44:16 -07002825 QCBORError uReturn;
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002826 uint64_t uFoundItemBitMap = 0;
Laurence Lundbladefb492ea2020-05-02 11:14:07 -07002827
Laurence Lundbladec45b5672020-07-25 23:16:36 -07002828 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002829 uReturn = pMe->uLastError;
2830 goto Done2;
Laurence Lundbladec45b5672020-07-25 23:16:36 -07002831 }
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07002832
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002833 if(!DecodeNesting_IsBoundedType(&(pMe->nesting), QCBOR_TYPE_MAP) &&
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07002834 pItemArray->uLabelType != QCBOR_TYPE_NONE) {
2835 /* QCBOR_TYPE_NONE as first item indicates just looking
2836 for the end of an array, so don't give error. */
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002837 uReturn = QCBOR_ERR_MAP_NOT_ENTERED;
2838 goto Done2;
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07002839 }
2840
Laurence Lundblade085d7952020-07-24 10:26:30 -07002841 if(DecodeNesting_IsBoundedEmpty(&(pMe->nesting))) {
2842 // It is an empty bounded array or map
2843 if(pItemArray->uLabelType == QCBOR_TYPE_NONE) {
2844 // Just trying to find the end of the map or array
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07002845 pMe->uMapEndOffsetCache = DecodeNesting_GetMapOrArrayStart(&(pMe->nesting));
Laurence Lundblade085d7952020-07-24 10:26:30 -07002846 uReturn = QCBOR_SUCCESS;
Laurence Lundblade085d7952020-07-24 10:26:30 -07002847 } else {
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07002848 // Nothing is ever found in an empty array or map. All items
2849 // are marked as not found below.
Laurence Lundblade085d7952020-07-24 10:26:30 -07002850 uReturn = QCBOR_SUCCESS;
2851 }
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002852 goto Done2;
Laurence Lundblade085d7952020-07-24 10:26:30 -07002853 }
2854
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002855 QCBORDecodeNesting SaveNesting;
Laurence Lundblade085d7952020-07-24 10:26:30 -07002856 DecodeNesting_PrepareForMapSearch(&(pMe->nesting), &SaveNesting);
2857
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002858 /* Reposition to search from the start of the map / array */
Laurence Lundblade02625d42020-06-25 14:41:41 -07002859 UsefulInputBuf_Seek(&(pMe->InBuf),
2860 DecodeNesting_GetMapOrArrayStart(&(pMe->nesting)));
Laurence Lundblade1341c592020-04-11 14:19:05 -07002861
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002862 /*
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002863 Loop over all the items in the map or array. Each item
2864 could be a map or array, but label matching is only at
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002865 the main level. This handles definite- and indefinite-
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002866 length maps and arrays. The only reason this is ever
2867 called on arrays is to find their end position.
2868
2869 This will always run over all items in order to do
2870 duplicate detection.
2871
2872 This will exit with failure if it encounters an
2873 unrecoverable error, but continue on for recoverable
2874 errors.
2875
2876 If a recoverable error occurs on a matched item, then
2877 that error code is returned.
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002878 */
Laurence Lundblade0a042a92020-06-12 14:09:50 -07002879 const uint8_t uMapNestLevel = DecodeNesting_GetBoundedModeLevel(&(pMe->nesting));
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002880 uint_fast8_t uNextNestLevel;
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002881 do {
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07002882 /* Remember offset of the item because sometimes it has to be returned */
Laurence Lundblade1341c592020-04-11 14:19:05 -07002883 const size_t uOffset = UsefulInputBuf_Tell(&(pMe->InBuf));
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002884
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002885 /* Get the item */
2886 QCBORItem Item;
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08002887 QCBORError uResult = QCBORDecode_GetNextTagContent(pMe, &Item);
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002888 if(QCBORDecode_IsUnrecoverableError(uResult)) {
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07002889 /* Unrecoverable error so map can't even be decoded. */
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002890 uReturn = uResult;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002891 goto Done;
2892 }
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002893 if(uResult == QCBOR_ERR_NO_MORE_ITEMS) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002894 // Unexpected end of map or array.
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002895 uReturn = uResult;
Laurence Lundbladea9489f82020-09-12 13:50:56 -07002896 goto Done;
2897 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002898
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002899 /* See if item has one of the labels that are of interest */
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002900 bool bMatched = false;
2901 for(int nIndex = 0; pItemArray[nIndex].uLabelType != QCBOR_TYPE_NONE; nIndex++) {
2902 if(MatchLabel(Item, pItemArray[nIndex])) {
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002903 /* A label match has been found */
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002904 if(uFoundItemBitMap & (0x01ULL << nIndex)) {
2905 uReturn = QCBOR_ERR_DUPLICATE_LABEL;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002906 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002907 }
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002908 /* Also try to match its type */
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002909 if(!MatchType(Item, pItemArray[nIndex])) {
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002910 uReturn = QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002911 goto Done;
2912 }
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002913
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002914 if(uResult != QCBOR_SUCCESS) {
2915 uReturn = uResult;
2916 goto Done;
2917 }
2918
Laurence Lundblade1341c592020-04-11 14:19:05 -07002919 /* Successful match. Return the item. */
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002920 pItemArray[nIndex] = Item;
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002921 uFoundItemBitMap |= 0x01ULL << nIndex;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002922 if(puOffset) {
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002923 *puOffset = uOffset;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002924 }
Laurence Lundbladec45b5672020-07-25 23:16:36 -07002925 bMatched = true;
2926 }
2927 }
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002928
2929
Laurence Lundbladec45b5672020-07-25 23:16:36 -07002930 if(!bMatched && pfCallback != NULL) {
2931 /*
2932 Call the callback on unmatched labels.
2933 (It is tempting to do duplicate detection here, but that would
2934 require dynamic memory allocation because the number of labels
2935 that might be encountered is unbounded.)
2936 */
2937 uReturn = (*pfCallback)(pCBContext, &Item);
2938 if(uReturn != QCBOR_SUCCESS) {
2939 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002940 }
2941 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002942
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002943 /*
2944 Consume the item whether matched or not. This
2945 does the work of traversing maps and array and
2946 everything in them. In this loop only the
2947 items at the current nesting level are examined
2948 to match the labels.
2949 */
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002950 uReturn = ConsumeItem(pMe, &Item, &uNextNestLevel);
Laurence Lundbladec7114722020-08-13 05:11:40 -07002951 if(uReturn != QCBOR_SUCCESS) {
Laurence Lundblade1341c592020-04-11 14:19:05 -07002952 goto Done;
2953 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07002954
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002955 } while (uNextNestLevel >= uMapNestLevel);
Laurence Lundblade9b334962020-08-27 10:55:53 -07002956
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002957 uReturn = QCBOR_SUCCESS;
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002958
2959 const size_t uEndOffset = UsefulInputBuf_Tell(&(pMe->InBuf));
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07002960
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002961 // Check here makes sure that this won't accidentally be
2962 // QCBOR_MAP_OFFSET_CACHE_INVALID which is larger than
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07002963 // QCBOR_MAX_DECODE_INPUT_SIZE.
Laurence Lundblade9c1b7b42020-12-12 11:44:16 -08002964 // Cast to uint32_t to possibly address cases where SIZE_MAX < UINT32_MAX
2965 if((uint32_t)uEndOffset >= QCBOR_MAX_DECODE_INPUT_SIZE) {
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07002966 uReturn = QCBOR_ERR_INPUT_TOO_LARGE;
2967 goto Done;
2968 }
Laurence Lundblade1d85d522020-06-22 13:24:59 -07002969 /* Cast OK because encoded CBOR is limited to UINT32_MAX */
2970 pMe->uMapEndOffsetCache = (uint32_t)uEndOffset;
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002971
Laurence Lundbladec45b5672020-07-25 23:16:36 -07002972 Done:
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07002973 DecodeNesting_RestoreFromMapSearch(&(pMe->nesting), &SaveNesting);
2974
2975 Done2:
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002976 /* For all items not found, set the data and label type to QCBOR_TYPE_NONE */
Laurence Lundbladec7114722020-08-13 05:11:40 -07002977 for(int i = 0; pItemArray[i].uLabelType != 0; i++) {
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002978 if(!(uFoundItemBitMap & (0x01ULL << i))) {
Laurence Lundblade93d3f532020-09-28 21:09:12 -07002979 pItemArray[i].uDataType = QCBOR_TYPE_NONE;
2980 pItemArray[i].uLabelType = QCBOR_TYPE_NONE;
Laurence Lundblade1341c592020-04-11 14:19:05 -07002981 }
2982 }
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002983
Laurence Lundblade24d509a2020-06-06 18:43:15 -07002984 return uReturn;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002985}
2986
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07002987
Laurence Lundblade4e2da002020-06-13 23:08:31 -07002988/*
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07002989 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07002990*/
Laurence Lundblade843a10c2020-05-23 13:57:00 -07002991void QCBORDecode_GetItemInMapN(QCBORDecodeContext *pMe,
2992 int64_t nLabel,
2993 uint8_t uQcborType,
2994 QCBORItem *pItem)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002995{
Laurence Lundblade843a10c2020-05-23 13:57:00 -07002996 if(pMe->uLastError != QCBOR_SUCCESS) {
2997 return;
2998 }
Laurence Lundbladebb87be22020-04-09 19:15:32 -07002999
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003000 QCBORItem OneItemSeach[2];
3001 OneItemSeach[0].uLabelType = QCBOR_TYPE_INT64;
3002 OneItemSeach[0].label.int64 = nLabel;
3003 OneItemSeach[0].uDataType = uQcborType;
3004 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE; // Indicates end of array
Laurence Lundblade1341c592020-04-11 14:19:05 -07003005
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003006 QCBORError uReturn = MapSearch(pMe, OneItemSeach, NULL, NULL, NULL);
Laurence Lundblade93d3f532020-09-28 21:09:12 -07003007
3008 *pItem = OneItemSeach[0];
3009
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003010 if(uReturn != QCBOR_SUCCESS) {
3011 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003012 }
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003013 if(OneItemSeach[0].uDataType == QCBOR_TYPE_NONE) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003014 uReturn = QCBOR_ERR_LABEL_NOT_FOUND;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003015 }
3016
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003017 Done:
3018 pMe->uLastError = (uint8_t)uReturn;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003019}
3020
3021
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003022/*
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003023 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003024*/
Laurence Lundbladeda095972020-06-06 18:35:33 -07003025void QCBORDecode_GetItemInMapSZ(QCBORDecodeContext *pMe,
3026 const char *szLabel,
Laurence Lundblade323f8a92020-09-06 19:43:09 -07003027 uint8_t uQcborType,
3028 QCBORItem *pItem)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003029{
Laurence Lundbladeda095972020-06-06 18:35:33 -07003030 if(pMe->uLastError != QCBOR_SUCCESS) {
3031 return;
3032 }
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003033
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003034 QCBORItem OneItemSeach[2];
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003035 OneItemSeach[0].uLabelType = QCBOR_TYPE_TEXT_STRING;
3036 OneItemSeach[0].label.string = UsefulBuf_FromSZ(szLabel);
3037 OneItemSeach[0].uDataType = uQcborType;
3038 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE; // Indicates end of array
Laurence Lundblade1341c592020-04-11 14:19:05 -07003039
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003040 QCBORError uReturn = MapSearch(pMe, OneItemSeach, NULL, NULL, NULL);
3041 if(uReturn != QCBOR_SUCCESS) {
3042 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003043 }
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003044 if(OneItemSeach[0].uDataType == QCBOR_TYPE_NONE) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003045 uReturn = QCBOR_ERR_LABEL_NOT_FOUND;
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003046 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003047 }
3048
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003049 *pItem = OneItemSeach[0];
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003050
3051Done:
3052 pMe->uLastError = (uint8_t)uReturn;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003053}
3054
3055
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003056
Laurence Lundblade93d89472020-10-03 22:30:50 -07003057static QCBORError
3058CheckTypeList(int uDataType, const uint8_t puTypeList[QCBOR_TAGSPEC_NUM_TYPES])
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003059{
3060 for(size_t i = 0; i < QCBOR_TAGSPEC_NUM_TYPES; i++) {
3061 if(uDataType == puTypeList[i]) {
3062 return QCBOR_SUCCESS;
3063 }
3064 }
3065 return QCBOR_ERR_UNEXPECTED_TYPE;
3066}
3067
Laurence Lundblade67257dc2020-07-27 03:33:37 -07003068
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003069/**
3070 @param[in] TagSpec Specification for matching tags.
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003071 @param[in] pItem The item to check.
Laurence Lundblade9b334962020-08-27 10:55:53 -07003072
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003073 @retval QCBOR_SUCCESS \c uDataType is allowed by @c TagSpec
3074 @retval QCBOR_ERR_UNEXPECTED_TYPE \c uDataType is not allowed by @c TagSpec
Laurence Lundblade9b334962020-08-27 10:55:53 -07003075
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07003076 The data type must be one of the QCBOR_TYPEs, not the IETF CBOR Registered
3077 tag value.
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003078 */
Laurence Lundblade93d89472020-10-03 22:30:50 -07003079static QCBORError
3080CheckTagRequirement(const TagSpecification TagSpec, const QCBORItem *pItem)
Laurence Lundblade9b334962020-08-27 10:55:53 -07003081{
3082 if(!(TagSpec.uTagRequirement & QCBOR_TAG_REQUIREMENT_ALLOW_ADDITIONAL_TAGS) &&
3083 pItem->uTags[0] != CBOR_TAG_INVALID16) {
3084 /* There are tags that QCBOR couldn't process on this item and
3085 the caller has told us there should not be. */
3086 return QCBOR_ERR_UNEXPECTED_TYPE;
3087 }
3088
3089 const int nTagReq = TagSpec.uTagRequirement & ~QCBOR_TAG_REQUIREMENT_ALLOW_ADDITIONAL_TAGS;
3090 const int nItemType = pItem->uDataType;
3091
3092 if(nTagReq == QCBOR_TAG_REQUIREMENT_TAG) {
3093 // Must match the tag and only the tag
3094 return CheckTypeList(nItemType, TagSpec.uTaggedTypes);
3095 }
3096
3097 QCBORError uReturn = CheckTypeList(nItemType, TagSpec.uAllowedContentTypes);
3098 if(uReturn == QCBOR_SUCCESS) {
3099 return QCBOR_SUCCESS;
3100 }
3101
3102 if(nTagReq == QCBOR_TAG_REQUIREMENT_NOT_A_TAG) {
3103 /* Must match the content type and only the content type.
3104 There was no match just above so it is a fail. */
3105 return QCBOR_ERR_UNEXPECTED_TYPE;
3106 }
3107
3108 /* If here it can match either the tag or the content
3109 and it hasn't matched the content, so the end
3110 result is whether it matches the tag. This is
3111 also the case that the CBOR standard discourages. */
3112
3113 return CheckTypeList(nItemType, TagSpec.uTaggedTypes);
3114}
3115
Laurence Lundblade9b334962020-08-27 10:55:53 -07003116
Laurence Lundblade9b334962020-08-27 10:55:53 -07003117
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07003118// This could be semi-private if need be
3119static inline
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003120void QCBORDecode_GetTaggedItemInMapN(QCBORDecodeContext *pMe,
3121 int64_t nLabel,
3122 TagSpecification TagSpec,
3123 QCBORItem *pItem)
3124{
3125 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, pItem);
3126 if(pMe->uLastError != QCBOR_SUCCESS) {
3127 return;
3128 }
3129
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003130 pMe->uLastError = (uint8_t)CheckTagRequirement(TagSpec, pItem);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003131}
3132
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07003133
3134// This could be semi-private if need be
3135static inline
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003136void QCBORDecode_GetTaggedItemInMapSZ(QCBORDecodeContext *pMe,
3137 const char *szLabel,
3138 TagSpecification TagSpec,
3139 QCBORItem *pItem)
3140{
3141 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, pItem);
3142 if(pMe->uLastError != QCBOR_SUCCESS) {
3143 return;
3144 }
3145
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003146 pMe->uLastError = (uint8_t)CheckTagRequirement(TagSpec, pItem);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003147}
3148
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003149// Semi-private
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003150void QCBORDecode_GetTaggedStringInMapN(QCBORDecodeContext *pMe,
3151 int64_t nLabel,
3152 TagSpecification TagSpec,
3153 UsefulBufC *pString)
3154{
3155 QCBORItem Item;
3156 QCBORDecode_GetTaggedItemInMapN(pMe, nLabel, TagSpec, &Item);
3157 if(pMe->uLastError == QCBOR_SUCCESS) {
3158 *pString = Item.val.string;
3159 }
3160}
3161
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003162// Semi-private
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003163void QCBORDecode_GetTaggedStringInMapSZ(QCBORDecodeContext *pMe,
3164 const char * szLabel,
3165 TagSpecification TagSpec,
3166 UsefulBufC *pString)
3167{
3168 QCBORItem Item;
3169 QCBORDecode_GetTaggedItemInMapSZ(pMe, szLabel, TagSpec, &Item);
3170 if(pMe->uLastError == QCBOR_SUCCESS) {
3171 *pString = Item.val.string;
3172 }
3173}
Laurence Lundblade1341c592020-04-11 14:19:05 -07003174
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003175/*
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003176 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003177*/
Laurence Lundblade5f53f832020-09-03 12:00:14 -07003178void QCBORDecode_GetItemsInMap(QCBORDecodeContext *pMe, QCBORItem *pItemList)
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003179{
Laurence Lundblade5f53f832020-09-03 12:00:14 -07003180 QCBORError uErr = MapSearch(pMe, pItemList, NULL, NULL, NULL);
3181 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003182}
3183
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003184/*
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003185 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003186*/
Laurence Lundblade5f53f832020-09-03 12:00:14 -07003187void QCBORDecode_GetItemsInMapWithCallback(QCBORDecodeContext *pMe,
3188 QCBORItem *pItemList,
3189 void *pCallbackCtx,
3190 QCBORItemCallback pfCB)
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003191{
Laurence Lundblade5f53f832020-09-03 12:00:14 -07003192 QCBORError uErr = MapSearch(pMe, pItemList, NULL, pCallbackCtx, pfCB);
3193 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003194}
3195
3196
Laurence Lundbladeddebabe2020-11-22 11:32:17 -08003197/**
3198 * @brief Search for a map/array by label and enter it
3199 *
3200 * @param[in] pMe The decode context.
3201 * @param[in] pSearch The map/array to search for.
3202 *
3203 * @c pSearch is expected to contain one item of type map or array
3204 * with the label specified. The current bounded map will be searched for
3205 * this and if found will be entered.
3206 *
3207 * If the label is not found, or the item found is not a map or array,
3208 * the error state is set.
3209 */
Laurence Lundblade34691b92020-05-18 22:25:25 -07003210static void SearchAndEnter(QCBORDecodeContext *pMe, QCBORItem pSearch[])
Laurence Lundblade1341c592020-04-11 14:19:05 -07003211{
Laurence Lundblade323f8a92020-09-06 19:43:09 -07003212 // The first item in pSearch is the one that is to be
3213 // entered. It should be the only one filled in. Any other
3214 // will be ignored unless it causes an error.
Laurence Lundblade34691b92020-05-18 22:25:25 -07003215 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundblade34691b92020-05-18 22:25:25 -07003216 return;
3217 }
3218
3219 size_t uOffset;
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003220 pMe->uLastError = (uint8_t)MapSearch(pMe, pSearch, &uOffset, NULL, NULL);
Laurence Lundblade34691b92020-05-18 22:25:25 -07003221 if(pMe->uLastError != QCBOR_SUCCESS) {
3222 return;
3223 }
3224
Laurence Lundblade9b334962020-08-27 10:55:53 -07003225 if(pSearch->uDataType == QCBOR_TYPE_NONE) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003226 pMe->uLastError = QCBOR_ERR_LABEL_NOT_FOUND;
Laurence Lundblade9b334962020-08-27 10:55:53 -07003227 return;
3228 }
3229
Laurence Lundblade9bcadf22021-02-17 10:55:33 -07003230
Laurence Lundbladebd209782021-02-17 10:44:42 -07003231 /* The map or array was found. Now enter it.
Laurence Lundblade9bcadf22021-02-17 10:55:33 -07003232 *
Laurence Lundbladeddebabe2020-11-22 11:32:17 -08003233 * QCBORDecode_EnterBoundedMapOrArray() used here, requires the
3234 * next item for the pre-order traversal cursor to be the map/array
3235 * found by MapSearch(). The next few lines of code force the
3236 * cursor to that.
3237 *
3238 * There is no need to retain the old cursor because
3239 * QCBORDecode_EnterBoundedMapOrArray() will set it to the
3240 * beginning of the map/array being entered.
3241 *
3242 * The cursor is forced by: 1) setting the input buffer position to
3243 * the item offset found by MapSearch(), 2) setting the map/array
3244 * counter to the total in the map/array, 3) setting the nesting
3245 * level. Setting the map/array counter to the total is not
3246 * strictly correct, but this is OK because this cursor only needs
3247 * to be used to get one item and MapSearch() has already found it
3248 * confirming it exists.
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07003249 */
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003250 UsefulInputBuf_Seek(&(pMe->InBuf), uOffset);
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003251
Laurence Lundbladeddebabe2020-11-22 11:32:17 -08003252 DecodeNesting_ResetMapOrArrayCount(&(pMe->nesting));
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08003253
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003254 DecodeNesting_SetCurrentToBoundedLevel(&(pMe->nesting));
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003255
Laurence Lundblade6545d1b2020-10-14 11:13:13 -07003256 QCBORDecode_EnterBoundedMapOrArray(pMe, pSearch->uDataType, NULL);
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003257}
3258
3259
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003260/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003261 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003262*/
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003263void QCBORDecode_EnterMapFromMapN(QCBORDecodeContext *pMe, int64_t nLabel)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003264{
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003265 QCBORItem OneItemSeach[2];
3266 OneItemSeach[0].uLabelType = QCBOR_TYPE_INT64;
3267 OneItemSeach[0].label.int64 = nLabel;
3268 OneItemSeach[0].uDataType = QCBOR_TYPE_MAP;
3269 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003270
Laurence Lundblade9b334962020-08-27 10:55:53 -07003271 /* The map to enter was found, now finish off entering it. */
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003272 SearchAndEnter(pMe, OneItemSeach);
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003273}
3274
3275
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003276/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003277 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003278*/
Laurence Lundblade34691b92020-05-18 22:25:25 -07003279void QCBORDecode_EnterMapFromMapSZ(QCBORDecodeContext *pMe, const char *szLabel)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003280{
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003281 QCBORItem OneItemSeach[2];
3282 OneItemSeach[0].uLabelType = QCBOR_TYPE_TEXT_STRING;
3283 OneItemSeach[0].label.string = UsefulBuf_FromSZ(szLabel);
3284 OneItemSeach[0].uDataType = QCBOR_TYPE_MAP;
3285 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
Laurence Lundblade9b334962020-08-27 10:55:53 -07003286
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003287 SearchAndEnter(pMe, OneItemSeach);
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003288}
3289
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003290/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003291 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003292*/
Laurence Lundblade34691b92020-05-18 22:25:25 -07003293void QCBORDecode_EnterArrayFromMapN(QCBORDecodeContext *pMe, int64_t nLabel)
Laurence Lundblade1341c592020-04-11 14:19:05 -07003294{
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003295 QCBORItem OneItemSeach[2];
3296 OneItemSeach[0].uLabelType = QCBOR_TYPE_INT64;
3297 OneItemSeach[0].label.int64 = nLabel;
3298 OneItemSeach[0].uDataType = QCBOR_TYPE_ARRAY;
3299 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003300
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003301 SearchAndEnter(pMe, OneItemSeach);
Laurence Lundblade34691b92020-05-18 22:25:25 -07003302}
3303
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003304/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003305 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003306*/
Laurence Lundblade34691b92020-05-18 22:25:25 -07003307void QCBORDecode_EnterArrayFromMapSZ(QCBORDecodeContext *pMe, const char *szLabel)
3308{
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003309 QCBORItem OneItemSeach[2];
3310 OneItemSeach[0].uLabelType = QCBOR_TYPE_TEXT_STRING;
3311 OneItemSeach[0].label.string = UsefulBuf_FromSZ(szLabel);
3312 OneItemSeach[0].uDataType = QCBOR_TYPE_ARRAY;
3313 OneItemSeach[1].uLabelType = QCBOR_TYPE_NONE;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003314
Laurence Lundbladeb90f5362020-05-25 12:17:40 -07003315 SearchAndEnter(pMe, OneItemSeach);
Laurence Lundblade1341c592020-04-11 14:19:05 -07003316}
3317
3318
Laurence Lundblade02625d42020-06-25 14:41:41 -07003319// Semi-private function
Laurence Lundblade6545d1b2020-10-14 11:13:13 -07003320void QCBORDecode_EnterBoundedMapOrArray(QCBORDecodeContext *pMe, uint8_t uType, QCBORItem *pItem)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003321{
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003322 QCBORError uErr;
3323
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003324 /* Must only be called on maps and arrays. */
Laurence Lundblade34691b92020-05-18 22:25:25 -07003325 if(pMe->uLastError != QCBOR_SUCCESS) {
3326 // Already in error state; do nothing.
3327 return;
3328 }
Laurence Lundblade1341c592020-04-11 14:19:05 -07003329
Laurence Lundbladed40951e2020-08-28 11:11:14 -07003330 /* Get the data item that is the map or array being entered. */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003331 QCBORItem Item;
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003332 uErr = QCBORDecode_GetNext(pMe, &Item);
3333 if(uErr != QCBOR_SUCCESS) {
3334 goto Done;
Laurence Lundblade3f9ef042020-04-14 13:15:51 -07003335 }
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07003336 if(Item.uDataType != uType) {
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003337 uErr = QCBOR_ERR_UNEXPECTED_TYPE;
3338 goto Done;
Laurence Lundblade1341c592020-04-11 14:19:05 -07003339 }
3340
Laurence Lundbladea4308a82020-10-03 18:08:57 -07003341 CopyTags(pMe, &Item);
Laurence Lundbladed40951e2020-08-28 11:11:14 -07003342
3343
Laurence Lundbladef0499502020-08-01 11:55:57 -07003344 const bool bIsEmpty = (Item.uNextNestLevel <= Item.uNestingLevel);
Laurence Lundblade085d7952020-07-24 10:26:30 -07003345 if(bIsEmpty) {
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07003346 if(DecodeNesting_IsCurrentDefiniteLength(&(pMe->nesting))) {
3347 // Undo decrement done by QCBORDecode_GetNext() so the the
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003348 // the decrement when exiting the map/array works correctly
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07003349 pMe->nesting.pCurrent->u.ma.uCountCursor++;
3350 }
Laurence Lundblade93d89472020-10-03 22:30:50 -07003351 // Special case to increment nesting level for zero-length maps
3352 // and arrays entered in bounded mode.
Laurence Lundbladee6f15112020-07-23 18:44:16 -07003353 DecodeNesting_Descend(&(pMe->nesting), uType);
3354 }
3355
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07003356 pMe->uMapEndOffsetCache = QCBOR_MAP_OFFSET_CACHE_INVALID;
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003357
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003358 uErr = DecodeNesting_EnterBoundedMapOrArray(&(pMe->nesting), bIsEmpty,
3359 UsefulInputBuf_Tell(&(pMe->InBuf)));
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003360
Laurence Lundblade6545d1b2020-10-14 11:13:13 -07003361 if(pItem != NULL) {
3362 *pItem = Item;
3363 }
3364
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003365Done:
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003366 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003367}
3368
Laurence Lundblade02625d42020-06-25 14:41:41 -07003369
3370/*
Laurence Lundblade93d89472020-10-03 22:30:50 -07003371 This is the common work for exiting a level that is a bounded map,
3372 array or bstr wrapped CBOR.
Laurence Lundblade02625d42020-06-25 14:41:41 -07003373
3374 One chunk of work is to set up the pre-order traversal so it is at
3375 the item just after the bounded map, array or bstr that is being
3376 exited. This is somewhat complex.
3377
3378 The other work is to level-up the bounded mode to next higest bounded
3379 mode or the top level if there isn't one.
3380 */
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003381static QCBORError
Laurence Lundblade02625d42020-06-25 14:41:41 -07003382ExitBoundedLevel(QCBORDecodeContext *pMe, uint32_t uEndOffset)
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003383{
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003384 QCBORError uErr;
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003385
Laurence Lundblade02625d42020-06-25 14:41:41 -07003386 /*
3387 First the pre-order-traversal byte offset is positioned to the
3388 item just after the bounded mode item that was just consumed.
3389 */
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003390 UsefulInputBuf_Seek(&(pMe->InBuf), uEndOffset);
3391
Laurence Lundblade02625d42020-06-25 14:41:41 -07003392 /*
3393 Next, set the current nesting level to one above the bounded level
3394 that was just exited.
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003395
Laurence Lundblade02625d42020-06-25 14:41:41 -07003396 DecodeNesting_CheckBoundedType() is always called before this and
3397 makes sure pCurrentBounded is valid.
3398 */
3399 DecodeNesting_LevelUpCurrent(&(pMe->nesting));
3400
3401 /*
3402 This does the complex work of leveling up the pre-order traversal
3403 when the end of a map or array or another bounded level is
3404 reached. It may do nothing, or ascend all the way to the top
3405 level.
3406 */
Laurence Lundblade3f1318a2021-01-04 18:26:44 -08003407 uErr = QCBORDecode_NestLevelAscender(pMe, false);
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003408 if(uErr != QCBOR_SUCCESS) {
3409 goto Done;
3410 }
3411
Laurence Lundblade02625d42020-06-25 14:41:41 -07003412 /*
3413 This makes the next highest bounded level the current bounded
3414 level. If there is no next highest level, then no bounded mode is
3415 in effect.
3416 */
3417 DecodeNesting_LevelUpBounded(&(pMe->nesting));
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003418
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07003419 pMe->uMapEndOffsetCache = QCBOR_MAP_OFFSET_CACHE_INVALID;
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003420
3421Done:
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003422 return uErr;
3423}
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003424
Laurence Lundblade02625d42020-06-25 14:41:41 -07003425
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003426// Semi-private function
Laurence Lundblade02625d42020-06-25 14:41:41 -07003427void QCBORDecode_ExitBoundedMapOrArray(QCBORDecodeContext *pMe, uint8_t uType)
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003428{
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003429 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundblade02625d42020-06-25 14:41:41 -07003430 /* Already in error state; do nothing. */
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003431 return;
3432 }
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003433
Laurence Lundblade02625d42020-06-25 14:41:41 -07003434 QCBORError uErr;
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003435
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07003436 if(!DecodeNesting_IsBoundedType(&(pMe->nesting), uType)) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003437 uErr = QCBOR_ERR_EXIT_MISMATCH;
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003438 goto Done;
3439 }
3440
Laurence Lundblade02625d42020-06-25 14:41:41 -07003441 /*
3442 Have to set the offset to the end of the map/array
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003443 that is being exited. If there is no cached value,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003444 from previous map search, then do a dummy search.
3445 */
Laurence Lundbladebfbf4942020-09-16 23:31:00 -07003446 if(pMe->uMapEndOffsetCache == QCBOR_MAP_OFFSET_CACHE_INVALID) {
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003447 QCBORItem Dummy;
3448 Dummy.uLabelType = QCBOR_TYPE_NONE;
3449 uErr = MapSearch(pMe, &Dummy, NULL, NULL, NULL);
3450 if(uErr != QCBOR_SUCCESS) {
3451 goto Done;
3452 }
3453 }
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003454
Laurence Lundblade02625d42020-06-25 14:41:41 -07003455 uErr = ExitBoundedLevel(pMe, pMe->uMapEndOffsetCache);
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003456
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003457Done:
Laurence Lundblade2b843b52020-06-16 20:51:03 -07003458 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003459}
3460
3461
Laurence Lundblade1341c592020-04-11 14:19:05 -07003462
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003463static QCBORError InternalEnterBstrWrapped(QCBORDecodeContext *pMe,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003464 const QCBORItem *pItem,
3465 uint8_t uTagRequirement,
3466 UsefulBufC *pBstr)
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003467{
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003468 if(pBstr) {
3469 *pBstr = NULLUsefulBufC;
3470 }
3471
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003472 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003473 /* Already in error state; do nothing. */
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003474 return pMe->uLastError;
3475 }
3476
Laurence Lundbladefe3ae642021-02-19 10:45:39 -07003477 QCBORError uError;
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003478
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003479 const TagSpecification TagSpec =
3480 {
3481 uTagRequirement,
3482 {QBCOR_TYPE_WRAPPED_CBOR, QBCOR_TYPE_WRAPPED_CBOR_SEQUENCE, QCBOR_TYPE_NONE},
3483 {QCBOR_TYPE_BYTE_STRING, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
3484 };
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003485
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003486 uError = CheckTagRequirement(TagSpec, pItem);
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003487 if(uError != QCBOR_SUCCESS) {
3488 goto Done;
3489 }
3490
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003491 if(DecodeNesting_IsCurrentDefiniteLength(&(pMe->nesting))) {
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003492 /* Reverse the decrement done by GetNext() for the bstr so the
3493 * increment in QCBORDecode_NestLevelAscender() called by
3494 * ExitBoundedLevel() will work right.
3495 */
Laurence Lundbladea8edadb2020-06-27 22:35:37 -07003496 DecodeNesting_ReverseDecrement(&(pMe->nesting));
Laurence Lundblade6c8a4442020-06-22 22:16:11 -07003497 }
Laurence Lundblade0750fc42020-06-20 21:02:34 -07003498
3499 if(pBstr) {
3500 *pBstr = pItem->val.string;
3501 }
3502
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003503 /* This saves the current length of the UsefulInputBuf and then
3504 * narrows the UsefulInputBuf to start and length of the wrapped
3505 * CBOR that is being entered.
3506 *
3507 * Most of these calls are simple inline accessors so this doesn't
3508 * amount to much code.
3509 */
3510
Laurence Lundbladea4308a82020-10-03 18:08:57 -07003511 const size_t uPreviousLength = UsefulInputBuf_GetBufferLength(&(pMe->InBuf));
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003512 /* This check makes the cast of uPreviousLength to uint32_t below safe. */
3513 if(uPreviousLength >= QCBOR_MAX_DECODE_INPUT_SIZE) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003514 uError = QCBOR_ERR_INPUT_TOO_LARGE;
Laurence Lundbladef76a2622020-08-06 19:51:03 -07003515 goto Done;
3516 }
Laurence Lundblade055111e2021-02-17 13:30:57 -07003517
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003518 const size_t uStartOfBstr = UsefulInputBuf_PointerToOffset(&(pMe->InBuf),
3519 pItem->val.string.ptr);
3520 /* This check makes the cast of uStartOfBstr to uint32_t below safe. */
3521 if(uStartOfBstr == SIZE_MAX || uStartOfBstr > QCBOR_MAX_DECODE_INPUT_SIZE) {
3522 /* This should never happen because pItem->val.string.ptr should
3523 * always be valid since it was just returned.
3524 */
Laurence Lundblade055111e2021-02-17 13:30:57 -07003525 uError = QCBOR_ERR_INPUT_TOO_LARGE;
3526 goto Done;
3527 }
3528
3529 const size_t uEndOfBstr = uStartOfBstr + pItem->val.string.len;
Laurence Lundblade2e1ddd62021-02-17 16:52:03 -07003530
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08003531 UsefulInputBuf_Seek(&(pMe->InBuf), uStartOfBstr);
Laurence Lundblade1ba100d2020-09-19 21:41:02 -07003532 UsefulInputBuf_SetBufferLength(&(pMe->InBuf), uEndOfBstr);
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003533
Laurence Lundblade02625d42020-06-25 14:41:41 -07003534 uError = DecodeNesting_DescendIntoBstrWrapped(&(pMe->nesting),
Laurence Lundbladea4308a82020-10-03 18:08:57 -07003535 (uint32_t)uPreviousLength,
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08003536 (uint32_t)uStartOfBstr);
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003537Done:
3538 return uError;
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003539}
3540
3541
Laurence Lundblade02625d42020-06-25 14:41:41 -07003542/*
3543 Public function, see header qcbor/qcbor_decode.h file
3544 */
3545void QCBORDecode_EnterBstrWrapped(QCBORDecodeContext *pMe,
Laurence Lundbladec45b5672020-07-25 23:16:36 -07003546 uint8_t uTagRequirement,
3547 UsefulBufC *pBstr)
Laurence Lundblade24d509a2020-06-06 18:43:15 -07003548{
3549 if(pMe->uLastError != QCBOR_SUCCESS) {
3550 // Already in error state; do nothing.
3551 return;
3552 }
3553
Laurence Lundbladeb237f062020-11-10 13:31:25 -08003554 /* Get the data item that is the byte string being entered */
Laurence Lundblade0750fc42020-06-20 21:02:34 -07003555 QCBORItem Item;
Laurence Lundblade24d509a2020-06-06 18:43:15 -07003556 pMe->uLastError = (uint8_t)QCBORDecode_GetNext(pMe, &Item);
3557 if(pMe->uLastError != QCBOR_SUCCESS) {
3558 return;
3559 }
Laurence Lundblade24d509a2020-06-06 18:43:15 -07003560
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07003561 pMe->uLastError = (uint8_t)InternalEnterBstrWrapped(pMe,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003562 &Item,
3563 uTagRequirement,
3564 pBstr);
Laurence Lundblade24d509a2020-06-06 18:43:15 -07003565}
3566
3567
Laurence Lundblade02625d42020-06-25 14:41:41 -07003568/*
3569 Public function, see header qcbor/qcbor_decode.h file
3570 */
3571void QCBORDecode_EnterBstrWrappedFromMapN(QCBORDecodeContext *pMe,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003572 int64_t nLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003573 uint8_t uTagRequirement,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003574 UsefulBufC *pBstr)
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003575{
3576 QCBORItem Item;
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003577 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003578
Laurence Lundblade93d89472020-10-03 22:30:50 -07003579 pMe->uLastError = (uint8_t)InternalEnterBstrWrapped(pMe,
3580 &Item,
3581 uTagRequirement,
3582 pBstr);
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003583}
3584
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003585
Laurence Lundblade02625d42020-06-25 14:41:41 -07003586/*
3587 Public function, see header qcbor/qcbor_decode.h file
3588 */
3589void QCBORDecode_EnterBstrWrappedFromMapSZ(QCBORDecodeContext *pMe,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003590 const char *szLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003591 uint8_t uTagRequirement,
Laurence Lundblade02625d42020-06-25 14:41:41 -07003592 UsefulBufC *pBstr)
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003593{
3594 QCBORItem Item;
3595 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
3596
Laurence Lundblade93d89472020-10-03 22:30:50 -07003597 pMe->uLastError = (uint8_t)InternalEnterBstrWrapped(pMe,
3598 &Item,
3599 uTagRequirement,
3600 pBstr);
Laurence Lundbladeaa965d72020-06-17 22:29:22 -07003601}
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003602
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003603
Laurence Lundblade02625d42020-06-25 14:41:41 -07003604/*
3605 Public function, see header qcbor/qcbor_decode.h file
3606 */
Laurence Lundblade0750fc42020-06-20 21:02:34 -07003607void QCBORDecode_ExitBstrWrapped(QCBORDecodeContext *pMe)
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003608{
Laurence Lundblade02625d42020-06-25 14:41:41 -07003609 if(pMe->uLastError != QCBOR_SUCCESS) {
3610 // Already in error state; do nothing.
3611 return;
3612 }
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003613
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07003614 if(!DecodeNesting_IsBoundedType(&(pMe->nesting), QCBOR_TYPE_BYTE_STRING)) {
Laurence Lundbladea9489f82020-09-12 13:50:56 -07003615 pMe->uLastError = QCBOR_ERR_EXIT_MISMATCH;
Laurence Lundblade02625d42020-06-25 14:41:41 -07003616 return;
3617 }
3618
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08003619 const uint32_t uEndOfBstr = (uint32_t)UsefulInputBuf_GetBufferLength(&(pMe->InBuf));
3620
Laurence Lundblade02625d42020-06-25 14:41:41 -07003621 /*
3622 Reset the length of the UsefulInputBuf to what it was before
3623 the bstr wrapped CBOR was entered.
Laurence Lundblade0750fc42020-06-20 21:02:34 -07003624 */
Laurence Lundblade1ba100d2020-09-19 21:41:02 -07003625 UsefulInputBuf_SetBufferLength(&(pMe->InBuf),
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003626 DecodeNesting_GetPreviousBoundedEnd(&(pMe->nesting)));
Laurence Lundblade0750fc42020-06-20 21:02:34 -07003627
3628
Laurence Lundblade0b1a7532020-11-22 22:22:17 -08003629 QCBORError uErr = ExitBoundedLevel(pMe, uEndOfBstr);
Laurence Lundblade1d85d522020-06-22 13:24:59 -07003630 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladed8c82c52020-06-12 22:15:52 -07003631}
3632
Laurence Lundbladebf3c42d2020-04-14 19:08:51 -07003633
Laurence Lundbladee6430642020-03-14 21:15:44 -07003634
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003635
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003636
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003637
Laurence Lundblade11a064e2020-05-07 13:13:42 -07003638
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003639
Laurence Lundblade93d89472020-10-03 22:30:50 -07003640static QCBORError
3641InterpretBool(QCBORDecodeContext *pMe, const QCBORItem *pItem, bool *pBool)
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003642{
3643 switch(pItem->uDataType) {
3644 case QCBOR_TYPE_TRUE:
3645 *pBool = true;
3646 return QCBOR_SUCCESS;
3647 break;
3648
3649 case QCBOR_TYPE_FALSE:
3650 *pBool = false;
3651 return QCBOR_SUCCESS;
3652 break;
3653
3654 default:
3655 return QCBOR_ERR_UNEXPECTED_TYPE;
3656 break;
3657 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07003658 CopyTags(pMe, pItem);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003659}
Laurence Lundbladee6430642020-03-14 21:15:44 -07003660
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003661
Laurence Lundblade9b334962020-08-27 10:55:53 -07003662
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003663/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003664 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003665*/
Laurence Lundbladec4537442020-04-14 18:53:22 -07003666void QCBORDecode_GetBool(QCBORDecodeContext *pMe, bool *pValue)
Laurence Lundbladee6430642020-03-14 21:15:44 -07003667{
Laurence Lundbladebf3c42d2020-04-14 19:08:51 -07003668 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundbladec4537442020-04-14 18:53:22 -07003669 // Already in error state, do nothing
Laurence Lundbladee6430642020-03-14 21:15:44 -07003670 return;
3671 }
3672
Laurence Lundbladec4537442020-04-14 18:53:22 -07003673 QCBORError nError;
3674 QCBORItem Item;
3675
3676 nError = QCBORDecode_GetNext(pMe, &Item);
3677 if(nError != QCBOR_SUCCESS) {
Laurence Lundblade82c2a8f2020-04-29 12:40:19 -07003678 pMe->uLastError = (uint8_t)nError;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003679 return;
3680 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07003681 pMe->uLastError = (uint8_t)InterpretBool(pMe, &Item, pValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07003682}
3683
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003684
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003685/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003686 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003687*/
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003688void QCBORDecode_GetBoolInMapN(QCBORDecodeContext *pMe, int64_t nLabel, bool *pValue)
Laurence Lundbladee6430642020-03-14 21:15:44 -07003689{
3690 QCBORItem Item;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003691 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
Laurence Lundbladee6430642020-03-14 21:15:44 -07003692
Laurence Lundblade9b334962020-08-27 10:55:53 -07003693 pMe->uLastError = (uint8_t)InterpretBool(pMe, &Item, pValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07003694}
3695
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003696
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003697/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003698 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003699*/
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003700void QCBORDecode_GetBoolInMapSZ(QCBORDecodeContext *pMe, const char *szLabel, bool *pValue)
3701{
3702 QCBORItem Item;
3703 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
3704
Laurence Lundblade9b334962020-08-27 10:55:53 -07003705 pMe->uLastError = (uint8_t)InterpretBool(pMe, &Item, pValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003706}
3707
3708
3709
Laurence Lundbladec7114722020-08-13 05:11:40 -07003710
3711static void ProcessEpochDate(QCBORDecodeContext *pMe,
3712 QCBORItem *pItem,
3713 uint8_t uTagRequirement,
3714 int64_t *pnTime)
3715{
3716 if(pMe->uLastError != QCBOR_SUCCESS) {
3717 // Already in error state, do nothing
3718 return;
3719 }
3720
3721 QCBORError uErr;
3722
3723 const TagSpecification TagSpec =
3724 {
3725 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07003726 {QCBOR_TYPE_DATE_EPOCH, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE},
3727 {QCBOR_TYPE_INT64, QCBOR_TYPE_DOUBLE, QCBOR_TYPE_FLOAT, QCBOR_TYPE_UINT64}
Laurence Lundbladec7114722020-08-13 05:11:40 -07003728 };
3729
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003730 uErr = CheckTagRequirement(TagSpec, pItem);
Laurence Lundbladec7114722020-08-13 05:11:40 -07003731 if(uErr != QCBOR_SUCCESS) {
3732 goto Done;
3733 }
3734
3735 if(pItem->uDataType != QCBOR_TYPE_DATE_EPOCH) {
3736 uErr = DecodeDateEpoch(pItem);
3737 if(uErr != QCBOR_SUCCESS) {
3738 goto Done;
3739 }
3740 }
3741
Laurence Lundblade9b334962020-08-27 10:55:53 -07003742 // Save the tags in the last item's tags in the decode context
3743 // for QCBORDecode_GetNthTagOfLast()
3744 CopyTags(pMe, pItem);
3745
Laurence Lundbladec7114722020-08-13 05:11:40 -07003746 *pnTime = pItem->val.epochDate.nSeconds;
3747
3748Done:
3749 pMe->uLastError = (uint8_t)uErr;
3750}
3751
3752
3753void QCBORDecode_GetEpochDate(QCBORDecodeContext *pMe,
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07003754 uint8_t uTagRequirement,
3755 int64_t *pnTime)
Laurence Lundbladec7114722020-08-13 05:11:40 -07003756{
3757 if(pMe->uLastError != QCBOR_SUCCESS) {
3758 // Already in error state, do nothing
3759 return;
3760 }
3761
3762 QCBORItem Item;
3763 pMe->uLastError = (uint8_t)QCBORDecode_GetNext(pMe, &Item);
3764
3765 ProcessEpochDate(pMe, &Item, uTagRequirement, pnTime);
3766}
3767
3768
3769void
3770QCBORDecode_GetEpochDateInMapN(QCBORDecodeContext *pMe,
3771 int64_t nLabel,
3772 uint8_t uTagRequirement,
3773 int64_t *pnTime)
3774{
3775 QCBORItem Item;
3776 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
3777 ProcessEpochDate(pMe, &Item, uTagRequirement, pnTime);
3778}
3779
3780
3781void
3782QCBORDecode_GetEpochDateInMapSZ(QCBORDecodeContext *pMe,
3783 const char *szLabel,
3784 uint8_t uTagRequirement,
3785 int64_t *pnTime)
3786{
3787 QCBORItem Item;
3788 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
3789 ProcessEpochDate(pMe, &Item, uTagRequirement, pnTime);
3790}
3791
3792
3793
3794
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003795void QCBORDecode_GetTaggedStringInternal(QCBORDecodeContext *pMe,
3796 TagSpecification TagSpec,
3797 UsefulBufC *pBstr)
Laurence Lundbladec4537442020-04-14 18:53:22 -07003798{
Laurence Lundbladebf3c42d2020-04-14 19:08:51 -07003799 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundbladec4537442020-04-14 18:53:22 -07003800 // Already in error state, do nothing
3801 return;
3802 }
3803
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07003804 QCBORError uError;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003805 QCBORItem Item;
3806
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07003807 uError = QCBORDecode_GetNext(pMe, &Item);
3808 if(uError != QCBOR_SUCCESS) {
3809 pMe->uLastError = (uint8_t)uError;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003810 return;
3811 }
3812
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003813 pMe->uLastError = (uint8_t)CheckTagRequirement(TagSpec, &Item);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003814
3815 if(pMe->uLastError == QCBOR_SUCCESS) {
3816 *pBstr = Item.val.string;
Laurence Lundbladeab40c6f2020-08-28 11:24:58 -07003817 } else {
3818 *pBstr = NULLUsefulBufC;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003819 }
3820}
3821
Laurence Lundbladec4537442020-04-14 18:53:22 -07003822
3823
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003824
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003825static QCBORError ProcessBigNum(uint8_t uTagRequirement,
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003826 const QCBORItem *pItem,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003827 UsefulBufC *pValue,
3828 bool *pbIsNegative)
Laurence Lundbladec4537442020-04-14 18:53:22 -07003829{
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003830 const TagSpecification TagSpec =
3831 {
3832 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07003833 {QCBOR_TYPE_POSBIGNUM, QCBOR_TYPE_NEGBIGNUM, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE},
3834 {QCBOR_TYPE_BYTE_STRING, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003835 };
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003836
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003837 QCBORError uErr = CheckTagRequirement(TagSpec, pItem);
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003838 if(uErr != QCBOR_SUCCESS) {
3839 return uErr;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003840 }
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003841
3842 *pValue = pItem->val.string;
3843
3844 if(pItem->uDataType == QCBOR_TYPE_POSBIGNUM) {
3845 *pbIsNegative = false;
3846 } else if(pItem->uDataType == QCBOR_TYPE_NEGBIGNUM) {
3847 *pbIsNegative = true;
3848 }
3849
3850 return QCBOR_SUCCESS;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003851}
3852
3853
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003854/*
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003855 Public function, see header qcbor/qcbor_decode.h
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003856 */
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003857void QCBORDecode_GetBignum(QCBORDecodeContext *pMe,
3858 uint8_t uTagRequirement,
3859 UsefulBufC *pValue,
3860 bool *pbIsNegative)
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003861{
3862 if(pMe->uLastError != QCBOR_SUCCESS) {
3863 // Already in error state, do nothing
3864 return;
3865 }
3866
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003867 QCBORItem Item;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003868 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
3869 if(uError != QCBOR_SUCCESS) {
3870 pMe->uLastError = (uint8_t)uError;
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003871 return;
3872 }
3873
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003874 pMe->uLastError = (uint8_t)ProcessBigNum(uTagRequirement, &Item, pValue, pbIsNegative);
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003875}
3876
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003877
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003878/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003879 Public function, see header qcbor/qcbor_decode.h
Laurence Lundblade4e2da002020-06-13 23:08:31 -07003880*/
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003881void QCBORDecode_GetBignumInMapN(QCBORDecodeContext *pMe,
3882 int64_t nLabel,
3883 uint8_t uTagRequirement,
3884 UsefulBufC *pValue,
3885 bool *pbIsNegative)
Laurence Lundbladec4537442020-04-14 18:53:22 -07003886{
Laurence Lundblade843a10c2020-05-23 13:57:00 -07003887 QCBORItem Item;
3888 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003889 if(pMe->uLastError != QCBOR_SUCCESS) {
3890 return;
3891 }
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07003892
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003893 pMe->uLastError = (uint8_t)ProcessBigNum(uTagRequirement, &Item, pValue, pbIsNegative);
Laurence Lundbladec4537442020-04-14 18:53:22 -07003894}
3895
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003896
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003897/*
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003898 Public function, see header qcbor/qcbor_decode.h
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003899*/
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003900void QCBORDecode_GetBignumInMapSZ(QCBORDecodeContext *pMe,
3901 const char *szLabel,
3902 uint8_t uTagRequirement,
3903 UsefulBufC *pValue,
3904 bool *pbIsNegative)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003905{
3906 QCBORItem Item;
3907 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003908 if(pMe->uLastError != QCBOR_SUCCESS) {
3909 return;
3910 }
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003911
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07003912 pMe->uLastError = (uint8_t)ProcessBigNum(uTagRequirement, &Item, pValue, pbIsNegative);
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003913}
3914
3915
3916
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003917
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003918// Semi private
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003919QCBORError QCBORDecode_GetMIMEInternal(uint8_t uTagRequirement,
3920 const QCBORItem *pItem,
3921 UsefulBufC *pMessage,
Laurence Lundblade4982f412020-09-18 23:02:18 -07003922 bool *pbIsTag257)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003923{
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003924 const TagSpecification TagSpecText =
3925 {
3926 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07003927 {QCBOR_TYPE_MIME, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE},
3928 {QCBOR_TYPE_TEXT_STRING, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003929 };
3930 const TagSpecification TagSpecBinary =
3931 {
3932 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07003933 {QCBOR_TYPE_BINARY_MIME, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE},
3934 {QCBOR_TYPE_BYTE_STRING, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003935 };
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07003936
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003937 QCBORError uReturn;
Laurence Lundblade9b334962020-08-27 10:55:53 -07003938
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003939 if(CheckTagRequirement(TagSpecText, pItem) == QCBOR_SUCCESS) {
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003940 *pMessage = pItem->val.string;
Laurence Lundblade4982f412020-09-18 23:02:18 -07003941 if(pbIsTag257 != NULL) {
3942 *pbIsTag257 = false;
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003943 }
3944 uReturn = QCBOR_SUCCESS;
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07003945 } else if(CheckTagRequirement(TagSpecBinary, pItem) == QCBOR_SUCCESS) {
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003946 *pMessage = pItem->val.string;
Laurence Lundblade4982f412020-09-18 23:02:18 -07003947 if(pbIsTag257 != NULL) {
3948 *pbIsTag257 = true;
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003949 }
3950 uReturn = QCBOR_SUCCESS;
3951
3952 } else {
3953 uReturn = QCBOR_ERR_UNEXPECTED_TYPE;
3954 }
Laurence Lundblade9b334962020-08-27 10:55:53 -07003955
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003956 return uReturn;
3957}
3958
Laurence Lundblade93d89472020-10-03 22:30:50 -07003959// Improvement: add methods for wrapped CBOR, a simple alternate
3960// to EnterBstrWrapped
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07003961
Laurence Lundblade91853ae2020-06-15 19:35:58 -07003962
3963
3964
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07003965#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundbladee6430642020-03-14 21:15:44 -07003966
Laurence Lundblade9c905e82020-04-25 11:31:38 -07003967typedef QCBORError (*fExponentiator)(uint64_t uMantissa, int64_t nExponent, uint64_t *puResult);
Laurence Lundbladee6430642020-03-14 21:15:44 -07003968
3969
Laurence Lundblade784b54b2020-08-10 01:24:52 -07003970// The exponentiator that works on only positive numbers
Laurence Lundblade93d89472020-10-03 22:30:50 -07003971static QCBORError
3972Exponentitate10(uint64_t uMantissa, int64_t nExponent, uint64_t *puResult)
Laurence Lundbladec4537442020-04-14 18:53:22 -07003973{
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07003974 uint64_t uResult = uMantissa;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003975
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07003976 if(uResult != 0) {
3977 /* This loop will run a maximum of 19 times because
3978 * UINT64_MAX < 10 ^^ 19. More than that will cause
3979 * exit with the overflow error
3980 */
3981 for(; nExponent > 0; nExponent--) {
3982 if(uResult > UINT64_MAX / 10) {
3983 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW; // Error overflow
3984 }
3985 uResult = uResult * 10;
Laurence Lundbladec4537442020-04-14 18:53:22 -07003986 }
Laurence Lundbladec4537442020-04-14 18:53:22 -07003987
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07003988 for(; nExponent < 0; nExponent++) {
3989 uResult = uResult / 10;
3990 if(uResult == 0) {
3991 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW; // Underflow error
3992 }
Laurence Lundbladec4537442020-04-14 18:53:22 -07003993 }
Laurence Lundbladec4537442020-04-14 18:53:22 -07003994 }
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07003995 /* else, mantissa is zero so this returns zero */
Laurence Lundbladec4537442020-04-14 18:53:22 -07003996
3997 *puResult = uResult;
3998
Laurence Lundblade9c905e82020-04-25 11:31:38 -07003999 return QCBOR_SUCCESS;
Laurence Lundbladec4537442020-04-14 18:53:22 -07004000}
4001
4002
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004003// The exponentiator that works on only positive numbers
Laurence Lundblade93d89472020-10-03 22:30:50 -07004004static QCBORError
4005Exponentitate2(uint64_t uMantissa, int64_t nExponent, uint64_t *puResult)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004006{
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004007 uint64_t uResult;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004008
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004009 uResult = uMantissa;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004010
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004011 /* This loop will run a maximum of 64 times because
Laurence Lundbladee6430642020-03-14 21:15:44 -07004012 * INT64_MAX < 2^31. More than that will cause
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004013 * exit with the overflow error
Laurence Lundbladee6430642020-03-14 21:15:44 -07004014 */
4015 while(nExponent > 0) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004016 if(uResult > UINT64_MAX >> 1) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004017 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW; // Error overflow
Laurence Lundbladee6430642020-03-14 21:15:44 -07004018 }
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004019 uResult = uResult << 1;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004020 nExponent--;
4021 }
4022
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004023 while(nExponent < 0 ) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004024 if(uResult == 0) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004025 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW; // Underflow error
4026 }
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004027 uResult = uResult >> 1;
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004028 nExponent++;
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004029 }
4030
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004031 *puResult = uResult;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004032
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004033 return QCBOR_SUCCESS;
4034}
4035
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004036
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004037/*
Laurence Lundblade93d89472020-10-03 22:30:50 -07004038 Compute value with signed mantissa and signed result. Works with
4039 exponent of 2 or 10 based on exponentiator.
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004040 */
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004041static inline QCBORError ExponentiateNN(int64_t nMantissa,
4042 int64_t nExponent,
4043 int64_t *pnResult,
4044 fExponentiator pfExp)
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004045{
4046 uint64_t uResult;
4047
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004048 // Take the absolute value of the mantissa and convert to unsigned.
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004049 // Improvement: this should be possible in one instruction
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004050 uint64_t uMantissa = nMantissa > 0 ? (uint64_t)nMantissa : (uint64_t)-nMantissa;
4051
4052 // Do the exponentiation of the positive mantissa
4053 QCBORError uReturn = (*pfExp)(uMantissa, nExponent, &uResult);
4054 if(uReturn) {
4055 return uReturn;
4056 }
4057
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004058
Laurence Lundblade983500d2020-05-14 11:49:34 -07004059 /* (uint64_t)INT64_MAX+1 is used to represent the absolute value
4060 of INT64_MIN. This assumes two's compliment representation where
4061 INT64_MIN is one increment farther from 0 than INT64_MAX.
4062 Trying to write -INT64_MIN doesn't work to get this because the
4063 compiler tries to work with an int64_t which can't represent
4064 -INT64_MIN.
4065 */
4066 uint64_t uMax = nMantissa > 0 ? INT64_MAX : (uint64_t)INT64_MAX+1;
4067
4068 // Error out if too large
4069 if(uResult > uMax) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004070 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW;
4071 }
4072
4073 // Casts are safe because of checks above
4074 *pnResult = nMantissa > 0 ? (int64_t)uResult : -(int64_t)uResult;
4075
4076 return QCBOR_SUCCESS;
4077}
4078
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004079
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004080/*
Laurence Lundblade93d89472020-10-03 22:30:50 -07004081 Compute value with signed mantissa and unsigned result. Works with
4082 exponent of 2 or 10 based on exponentiator.
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004083 */
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004084static inline QCBORError ExponentitateNU(int64_t nMantissa,
4085 int64_t nExponent,
4086 uint64_t *puResult,
4087 fExponentiator pfExp)
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004088{
4089 if(nMantissa < 0) {
4090 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4091 }
4092
4093 // Cast to unsigned is OK because of check for negative
4094 // Cast to unsigned is OK because UINT64_MAX > INT64_MAX
4095 // Exponentiation is straight forward
4096 return (*pfExp)((uint64_t)nMantissa, nExponent, puResult);
4097}
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004098
4099
4100/*
Laurence Lundblade93d89472020-10-03 22:30:50 -07004101 Compute value with signed mantissa and unsigned result. Works with
4102 exponent of 2 or 10 based on exponentiator.
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004103 */
4104static inline QCBORError ExponentitateUU(uint64_t uMantissa,
4105 int64_t nExponent,
4106 uint64_t *puResult,
4107 fExponentiator pfExp)
4108{
4109 return (*pfExp)(uMantissa, nExponent, puResult);
4110}
4111
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004112#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
4113
4114
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004115
4116
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004117
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004118static QCBORError ConvertBigNumToUnsigned(const UsefulBufC BigNum, uint64_t uMax, uint64_t *pResult)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004119{
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004120 uint64_t uResult;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004121
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004122 uResult = 0;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004123 const uint8_t *pByte = BigNum.ptr;
4124 size_t uLen = BigNum.len;
4125 while(uLen--) {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004126 if(uResult > (uMax >> 8)) {
Laurence Lundbladec4537442020-04-14 18:53:22 -07004127 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004128 }
Laurence Lundblade313b2862020-05-16 01:23:06 -07004129 uResult = (uResult << 8) + *pByte++;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004130 }
4131
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004132 *pResult = uResult;
4133 return QCBOR_SUCCESS;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004134}
4135
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004136
Laurence Lundblade887add82020-05-17 05:50:34 -07004137static inline QCBORError ConvertPositiveBigNumToUnsigned(const UsefulBufC BigNum, uint64_t *pResult)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004138{
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004139 return ConvertBigNumToUnsigned(BigNum, UINT64_MAX, pResult);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004140}
4141
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004142
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004143static inline QCBORError ConvertPositiveBigNumToSigned(const UsefulBufC BigNum, int64_t *pResult)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004144{
4145 uint64_t uResult;
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004146 QCBORError uError = ConvertBigNumToUnsigned(BigNum, INT64_MAX, &uResult);
4147 if(uError) {
4148 return uError;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004149 }
4150 /* Cast is safe because ConvertBigNum is told to limit to INT64_MAX */
4151 *pResult = (int64_t)uResult;
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004152 return QCBOR_SUCCESS;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004153}
4154
4155
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004156static inline QCBORError ConvertNegativeBigNumToSigned(const UsefulBufC BigNum, int64_t *pnResult)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004157{
4158 uint64_t uResult;
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004159 /* The negative integer furthest from zero for a C int64_t is
4160 INT64_MIN which is expressed as -INT64_MAX - 1. The value of a
4161 negative number in CBOR is computed as -n - 1 where n is the
4162 encoded integer, where n is what is in the variable BigNum. When
4163 converting BigNum to a uint64_t, the maximum value is thus
4164 INT64_MAX, so that when it -n - 1 is applied to it the result will
4165 never be further from 0 than INT64_MIN.
Laurence Lundbladeda095972020-06-06 18:35:33 -07004166
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004167 -n - 1 <= INT64_MIN.
4168 -n - 1 <= -INT64_MAX - 1
4169 n <= INT64_MAX.
4170 */
Laurence Lundbladeda095972020-06-06 18:35:33 -07004171 QCBORError uError = ConvertBigNumToUnsigned(BigNum, INT64_MAX, &uResult);
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004172 if(uError != QCBOR_SUCCESS) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004173 return uError;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004174 }
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004175
4176 /// Now apply -n - 1. The cast is safe because
4177 // ConvertBigNumToUnsigned() is limited to INT64_MAX which does fit
4178 // is the largest positive integer that an int64_t can
4179 // represent. */
4180 *pnResult = -(int64_t)uResult - 1;
4181
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004182 return QCBOR_SUCCESS;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004183}
4184
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004185
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004186
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004187
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004188
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004189/*
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07004190Convert integers and floats to an int64_t.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004191
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004192\param[in] uConvertTypes Bit mask list of conversion options.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004193
Laurence Lundblade93d89472020-10-03 22:30:50 -07004194\retval QCBOR_ERR_UNEXPECTED_TYPE Conversion, possible, but not requested
4195 in uConvertTypes.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004196
4197\retval QCBOR_ERR_UNEXPECTED_TYPE Of a type that can't be converted
4198
Laurence Lundblade93d89472020-10-03 22:30:50 -07004199\retval QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW Conversion result is too large
4200 or too small.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004201*/
Laurence Lundblade93d89472020-10-03 22:30:50 -07004202static QCBORError
4203ConvertInt64(const QCBORItem *pItem, uint32_t uConvertTypes, int64_t *pnValue)
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004204{
4205 switch(pItem->uDataType) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004206 case QCBOR_TYPE_FLOAT:
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004207 case QCBOR_TYPE_DOUBLE:
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004208#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004209 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004210 /* https://pubs.opengroup.org/onlinepubs/009695399/functions/llround.html
4211 http://www.cplusplus.com/reference/cmath/llround/
4212 */
4213 // Not interested in FE_INEXACT
4214 feclearexcept(FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW|FE_DIVBYZERO);
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004215 if(pItem->uDataType == QCBOR_TYPE_DOUBLE) {
4216 *pnValue = llround(pItem->val.dfnum);
4217 } else {
4218 *pnValue = lroundf(pItem->val.fnum);
4219 }
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004220 if(fetestexcept(FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW|FE_DIVBYZERO)) {
4221 // llround() shouldn't result in divide by zero, but catch
4222 // it here in case it unexpectedly does. Don't try to
4223 // distinguish between the various exceptions because it seems
4224 // they vary by CPU, compiler and OS.
4225 return QCBOR_ERR_FLOAT_EXCEPTION;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004226 }
4227 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004228 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004229 }
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004230#else
4231 return QCBOR_ERR_HW_FLOAT_DISABLED;
4232#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004233 break;
4234
4235 case QCBOR_TYPE_INT64:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004236 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004237 *pnValue = pItem->val.int64;
4238 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004239 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004240 }
4241 break;
4242
4243 case QCBOR_TYPE_UINT64:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004244 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004245 if(pItem->val.uint64 < INT64_MAX) {
4246 *pnValue = pItem->val.int64;
4247 } else {
4248 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW;
4249 }
4250 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004251 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004252 }
4253 break;
4254
4255 default:
4256 return QCBOR_ERR_UNEXPECTED_TYPE;
4257 }
4258 return QCBOR_SUCCESS;
4259}
4260
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004261
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004262void QCBORDecode_GetInt64ConvertInternal(QCBORDecodeContext *pMe,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004263 uint32_t uConvertTypes,
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004264 int64_t *pnValue,
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004265 QCBORItem *pItem)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004266{
Laurence Lundbladebf3c42d2020-04-14 19:08:51 -07004267 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundbladec4537442020-04-14 18:53:22 -07004268 return;
4269 }
4270
Laurence Lundbladee6430642020-03-14 21:15:44 -07004271 QCBORItem Item;
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004272 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
4273 if(uError) {
4274 pMe->uLastError = (uint8_t)uError;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004275 return;
4276 }
4277
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004278 if(pItem) {
4279 *pItem = Item;
4280 }
4281
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004282 pMe->uLastError = (uint8_t)ConvertInt64(&Item, uConvertTypes, pnValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004283}
4284
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004285
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004286void QCBORDecode_GetInt64ConvertInternalInMapN(QCBORDecodeContext *pMe,
4287 int64_t nLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004288 uint32_t uConvertTypes,
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004289 int64_t *pnValue,
4290 QCBORItem *pItem)
4291{
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004292 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004293 if(pMe->uLastError != QCBOR_SUCCESS) {
4294 return;
4295 }
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004296
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004297 pMe->uLastError = (uint8_t)ConvertInt64(pItem, uConvertTypes, pnValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004298}
4299
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004300
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004301void QCBORDecode_GetInt64ConvertInternalInMapSZ(QCBORDecodeContext *pMe,
4302 const char * szLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004303 uint32_t uConvertTypes,
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004304 int64_t *pnValue,
4305 QCBORItem *pItem)
4306{
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004307 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004308 if(pMe->uLastError != QCBOR_SUCCESS) {
4309 return;
4310 }
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004311
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004312 pMe->uLastError = (uint8_t)ConvertInt64(pItem, uConvertTypes, pnValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004313}
4314
4315
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004316/*
4317 Convert a large variety of integer types to an int64_t.
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004318
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004319 \param[in] uConvertTypes Bit mask list of conversion options.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004320
Laurence Lundblade93d89472020-10-03 22:30:50 -07004321 \retval QCBOR_ERR_UNEXPECTED_TYPE Conversion, possible, but not requested
4322 in uConvertTypes.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004323
4324 \retval QCBOR_ERR_UNEXPECTED_TYPE Of a type that can't be converted
4325
Laurence Lundblade93d89472020-10-03 22:30:50 -07004326 \retval QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW Conversion result is too large
4327 or too small.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004328 */
Laurence Lundblade93d89472020-10-03 22:30:50 -07004329static QCBORError
4330Int64ConvertAll(const QCBORItem *pItem, uint32_t uConvertTypes, int64_t *pnValue)
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004331{
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004332 switch(pItem->uDataType) {
4333
4334 case QCBOR_TYPE_POSBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004335 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004336 return ConvertPositiveBigNumToSigned(pItem->val.bigNum, pnValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004337 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004338 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004339 }
4340 break;
4341
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004342 case QCBOR_TYPE_NEGBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004343 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004344 return ConvertNegativeBigNumToSigned(pItem->val.bigNum, pnValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004345 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004346 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004347 }
4348 break;
4349
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004350#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
4351 case QCBOR_TYPE_DECIMAL_FRACTION:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004352 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004353 return ExponentiateNN(pItem->val.expAndMantissa.Mantissa.nInt,
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004354 pItem->val.expAndMantissa.nExponent,
4355 pnValue,
4356 &Exponentitate10);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004357 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004358 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004359 }
4360 break;
4361
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004362 case QCBOR_TYPE_BIGFLOAT:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004363 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIGFLOAT) {
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004364 return ExponentiateNN(pItem->val.expAndMantissa.Mantissa.nInt,
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004365 pItem->val.expAndMantissa.nExponent,
4366 pnValue,
4367 Exponentitate2);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004368 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004369 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004370 }
4371 break;
4372
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004373 case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004374 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004375 int64_t nMantissa;
4376 QCBORError uErr;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004377 uErr = ConvertPositiveBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, &nMantissa);
4378 if(uErr) {
4379 return uErr;
4380 }
4381 return ExponentiateNN(nMantissa,
4382 pItem->val.expAndMantissa.nExponent,
4383 pnValue,
4384 Exponentitate10);
4385 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004386 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004387 }
4388 break;
4389
4390 case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004391 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004392 int64_t nMantissa;
4393 QCBORError uErr;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004394 uErr = ConvertNegativeBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, &nMantissa);
4395 if(uErr) {
4396 return uErr;
4397 }
4398 return ExponentiateNN(nMantissa,
4399 pItem->val.expAndMantissa.nExponent,
4400 pnValue,
4401 Exponentitate10);
4402 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004403 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004404 }
4405 break;
4406
4407 case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004408 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004409 int64_t nMantissa;
4410 QCBORError uErr;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004411 uErr = ConvertPositiveBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, &nMantissa);
4412 if(uErr) {
4413 return uErr;
4414 }
4415 return ExponentiateNN(nMantissa,
4416 pItem->val.expAndMantissa.nExponent,
4417 pnValue,
4418 Exponentitate2);
4419 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004420 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004421 }
4422 break;
4423
4424 case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004425 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004426 int64_t nMantissa;
4427 QCBORError uErr;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004428 uErr = ConvertNegativeBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, &nMantissa);
4429 if(uErr) {
4430 return uErr;
4431 }
4432 return ExponentiateNN(nMantissa,
4433 pItem->val.expAndMantissa.nExponent,
4434 pnValue,
4435 Exponentitate2);
4436 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004437 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundbladee6430642020-03-14 21:15:44 -07004438 }
4439 break;
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004440#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
4441
Laurence Lundbladee6430642020-03-14 21:15:44 -07004442
Laurence Lundbladec4537442020-04-14 18:53:22 -07004443 default:
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07004444 return QCBOR_ERR_UNEXPECTED_TYPE; }
Laurence Lundbladec4537442020-04-14 18:53:22 -07004445}
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004446
4447
Laurence Lundbladec4537442020-04-14 18:53:22 -07004448/*
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004449 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004450 */
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004451void QCBORDecode_GetInt64ConvertAll(QCBORDecodeContext *pMe, uint32_t uConvertTypes, int64_t *pnValue)
Laurence Lundbladec4537442020-04-14 18:53:22 -07004452{
4453 QCBORItem Item;
4454
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004455 QCBORDecode_GetInt64ConvertInternal(pMe, uConvertTypes, pnValue, &Item);
Laurence Lundbladec4537442020-04-14 18:53:22 -07004456
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004457 if(pMe->uLastError == QCBOR_SUCCESS) {
4458 // The above conversion succeeded
4459 return;
4460 }
4461
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004462 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004463 // The above conversion failed in a way that code below can't correct
Laurence Lundbladec4537442020-04-14 18:53:22 -07004464 return;
4465 }
4466
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004467 pMe->uLastError = (uint8_t)Int64ConvertAll(&Item, uConvertTypes, pnValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004468}
4469
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004470
4471/*
4472Public function, see header qcbor/qcbor_decode.h file
4473*/
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004474void QCBORDecode_GetInt64ConvertAllInMapN(QCBORDecodeContext *pMe,
4475 int64_t nLabel,
4476 uint32_t uConvertTypes,
4477 int64_t *pnValue)
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004478{
4479 QCBORItem Item;
4480
Laurence Lundblade93d89472020-10-03 22:30:50 -07004481 QCBORDecode_GetInt64ConvertInternalInMapN(pMe,
4482 nLabel,
4483 uConvertTypes,
4484 pnValue,
4485 &Item);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004486
4487 if(pMe->uLastError == QCBOR_SUCCESS) {
4488 // The above conversion succeeded
4489 return;
4490 }
4491
4492 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
4493 // The above conversion failed in a way that code below can't correct
4494 return;
4495 }
4496
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004497 pMe->uLastError = (uint8_t)Int64ConvertAll(&Item, uConvertTypes, pnValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004498}
4499
4500
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004501/*
4502Public function, see header qcbor/qcbor_decode.h file
4503*/
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004504void QCBORDecode_GetInt64ConvertAllInMapSZ(QCBORDecodeContext *pMe,
4505 const char *szLabel,
4506 uint32_t uConvertTypes,
4507 int64_t *pnValue)
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004508{
4509 QCBORItem Item;
Laurence Lundblade93d89472020-10-03 22:30:50 -07004510 QCBORDecode_GetInt64ConvertInternalInMapSZ(pMe,
4511 szLabel,
4512 uConvertTypes,
4513 pnValue,
4514 &Item);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004515
4516 if(pMe->uLastError == QCBOR_SUCCESS) {
4517 // The above conversion succeeded
4518 return;
4519 }
4520
4521 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
4522 // The above conversion failed in a way that code below can't correct
4523 return;
4524 }
4525
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004526 pMe->uLastError = (uint8_t)Int64ConvertAll(&Item, uConvertTypes, pnValue);
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004527}
4528
4529
Laurence Lundblade93d89472020-10-03 22:30:50 -07004530static QCBORError ConvertUInt64(const QCBORItem *pItem, uint32_t uConvertTypes, uint64_t *puValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004531{
4532 switch(pItem->uDataType) {
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004533 case QCBOR_TYPE_DOUBLE:
4534 case QCBOR_TYPE_FLOAT:
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004535#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004536 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004537 // Can't use llround here because it will not convert values
4538 // greater than INT64_MAX and less than UINT64_MAX that
4539 // need to be converted so it is more complicated.
4540 feclearexcept(FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW|FE_DIVBYZERO);
4541 if(pItem->uDataType == QCBOR_TYPE_DOUBLE) {
4542 if(isnan(pItem->val.dfnum)) {
4543 return QCBOR_ERR_FLOAT_EXCEPTION;
4544 } else if(pItem->val.dfnum < 0) {
4545 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4546 } else {
4547 double dRounded = round(pItem->val.dfnum);
4548 // See discussion in DecodeDateEpoch() for
4549 // explanation of - 0x7ff
4550 if(dRounded > (double)(UINT64_MAX- 0x7ff)) {
4551 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW;
4552 }
4553 *puValue = (uint64_t)dRounded;
4554 }
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004555 } else {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004556 if(isnan(pItem->val.fnum)) {
4557 return QCBOR_ERR_FLOAT_EXCEPTION;
4558 } else if(pItem->val.fnum < 0) {
4559 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4560 } else {
4561 float fRounded = roundf(pItem->val.fnum);
4562 // See discussion in DecodeDateEpoch() for
4563 // explanation of - 0x7ff
4564 if(fRounded > (float)(UINT64_MAX- 0x7ff)) {
4565 return QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW;
4566 }
4567 *puValue = (uint64_t)fRounded;
4568 }
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004569 }
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004570 if(fetestexcept(FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW|FE_DIVBYZERO)) {
4571 // round() and roundf() shouldn't result in exceptions here, but
4572 // catch them to be robust and thorough. Don't try to
4573 // distinguish between the various exceptions because it seems
4574 // they vary by CPU, compiler and OS.
4575 return QCBOR_ERR_FLOAT_EXCEPTION;
4576 }
4577
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004578 } else {
4579 return QCBOR_ERR_UNEXPECTED_TYPE;
4580 }
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004581#else
4582 return QCBOR_ERR_HW_FLOAT_DISABLED;
4583#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004584 break;
Laurence Lundblade843a10c2020-05-23 13:57:00 -07004585
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004586 case QCBOR_TYPE_INT64:
4587 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
4588 if(pItem->val.int64 >= 0) {
4589 *puValue = (uint64_t)pItem->val.int64;
4590 } else {
4591 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4592 }
4593 } else {
4594 return QCBOR_ERR_UNEXPECTED_TYPE;
4595 }
4596 break;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004597
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004598 case QCBOR_TYPE_UINT64:
4599 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
4600 *puValue = pItem->val.uint64;
4601 } else {
4602 return QCBOR_ERR_UNEXPECTED_TYPE;
4603 }
4604 break;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004605
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004606 default:
4607 return QCBOR_ERR_UNEXPECTED_TYPE;
4608 }
4609
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004610 return QCBOR_SUCCESS;
4611}
Laurence Lundbladec4537442020-04-14 18:53:22 -07004612
4613
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004614void QCBORDecode_GetUInt64ConvertInternal(QCBORDecodeContext *pMe,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004615 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004616 uint64_t *puValue,
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004617 QCBORItem *pItem)
Laurence Lundbladec4537442020-04-14 18:53:22 -07004618{
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004619 if(pMe->uLastError != QCBOR_SUCCESS) {
4620 return;
4621 }
4622
Laurence Lundbladec4537442020-04-14 18:53:22 -07004623 QCBORItem Item;
Laurence Lundbladec4537442020-04-14 18:53:22 -07004624
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004625 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
4626 if(uError) {
4627 pMe->uLastError = (uint8_t)uError;
Laurence Lundbladec4537442020-04-14 18:53:22 -07004628 return;
4629 }
4630
Laurence Lundbladea826c502020-05-10 21:07:00 -07004631 if(pItem) {
4632 *pItem = Item;
4633 }
4634
Laurence Lundblade93d89472020-10-03 22:30:50 -07004635 pMe->uLastError = (uint8_t)ConvertUInt64(&Item, uConvertTypes, puValue);
Laurence Lundbladec4537442020-04-14 18:53:22 -07004636}
4637
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004638
Laurence Lundblade95b64bb2020-08-30 00:17:38 -07004639void QCBORDecode_GetUInt64ConvertInternalInMapN(QCBORDecodeContext *pMe,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004640 int64_t nLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004641 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004642 uint64_t *puValue,
4643 QCBORItem *pItem)
4644{
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004645 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004646 if(pMe->uLastError != QCBOR_SUCCESS) {
4647 return;
4648 }
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004649
Laurence Lundblade93d89472020-10-03 22:30:50 -07004650 pMe->uLastError = (uint8_t)ConvertUInt64(pItem, uConvertTypes, puValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004651}
4652
4653
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07004654void QCBORDecode_GetUInt64ConvertInternalInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004655 const char * szLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004656 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004657 uint64_t *puValue,
4658 QCBORItem *pItem)
4659{
4660 if(pMe->uLastError != QCBOR_SUCCESS) {
4661 return;
4662 }
4663
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004664 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004665 if(pMe->uLastError != QCBOR_SUCCESS) {
4666 return;
4667 }
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004668
Laurence Lundblade93d89472020-10-03 22:30:50 -07004669 pMe->uLastError = (uint8_t)ConvertUInt64(pItem, uConvertTypes, puValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004670}
4671
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004672
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07004673
Laurence Lundblade93d89472020-10-03 22:30:50 -07004674static QCBORError
4675UInt64ConvertAll(const QCBORItem *pItem, uint32_t uConvertTypes, uint64_t *puValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004676{
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004677 switch(pItem->uDataType) {
4678
4679 case QCBOR_TYPE_POSBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004680 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004681 return ConvertPositiveBigNumToUnsigned(pItem->val.bigNum, puValue);
4682 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004683 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004684 }
4685 break;
4686
4687 case QCBOR_TYPE_NEGBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004688 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004689 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4690 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004691 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004692 }
4693 break;
4694
4695#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
4696
4697 case QCBOR_TYPE_DECIMAL_FRACTION:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004698 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004699 return ExponentitateNU(pItem->val.expAndMantissa.Mantissa.nInt,
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004700 pItem->val.expAndMantissa.nExponent,
4701 puValue,
4702 Exponentitate10);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004703 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004704 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004705 }
4706 break;
4707
4708 case QCBOR_TYPE_BIGFLOAT:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004709 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIGFLOAT) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004710 return ExponentitateNU(pItem->val.expAndMantissa.Mantissa.nInt,
4711 pItem->val.expAndMantissa.nExponent,
4712 puValue,
4713 Exponentitate2);
4714 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004715 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004716 }
4717 break;
4718
4719 case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004720 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004721 uint64_t uMantissa;
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004722 QCBORError uErr;
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004723 uErr = ConvertPositiveBigNumToUnsigned(pItem->val.expAndMantissa.Mantissa.bigNum, &uMantissa);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004724 if(uErr != QCBOR_SUCCESS) {
4725 return uErr;
4726 }
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004727 return ExponentitateUU(uMantissa,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004728 pItem->val.expAndMantissa.nExponent,
4729 puValue,
4730 Exponentitate10);
4731 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004732 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004733 }
4734 break;
4735
4736 case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004737 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004738 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4739 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004740 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004741 }
4742 break;
4743
4744 case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004745 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004746 uint64_t uMantissa;
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004747 QCBORError uErr;
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004748 uErr = ConvertPositiveBigNumToUnsigned(pItem->val.expAndMantissa.Mantissa.bigNum, &uMantissa);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004749 if(uErr != QCBOR_SUCCESS) {
4750 return uErr;
4751 }
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004752 return ExponentitateUU(uMantissa,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004753 pItem->val.expAndMantissa.nExponent,
4754 puValue,
4755 Exponentitate2);
4756 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004757 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004758 }
4759 break;
4760
4761 case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004762 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004763 return QCBOR_ERR_NUMBER_SIGN_CONVERSION;
4764 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004765 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004766 }
4767 break;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08004768#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004769 default:
4770 return QCBOR_ERR_UNEXPECTED_TYPE;
4771 }
4772}
4773
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004774
Laurence Lundblade4e2da002020-06-13 23:08:31 -07004775/*
4776 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07004777 */
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004778void QCBORDecode_GetUInt64ConvertAll(QCBORDecodeContext *pMe, uint32_t uConvertTypes, uint64_t *puValue)
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004779{
4780 QCBORItem Item;
4781
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004782 QCBORDecode_GetUInt64ConvertInternal(pMe, uConvertTypes, puValue, &Item);
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004783
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004784 if(pMe->uLastError == QCBOR_SUCCESS) {
4785 // The above conversion succeeded
4786 return;
4787 }
4788
4789 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
4790 // The above conversion failed in a way that code below can't correct
Laurence Lundbladee6430642020-03-14 21:15:44 -07004791 return;
4792 }
4793
Laurence Lundblade93d89472020-10-03 22:30:50 -07004794 pMe->uLastError = (uint8_t)UInt64ConvertAll(&Item, uConvertTypes, puValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07004795}
4796
Laurence Lundbladec4537442020-04-14 18:53:22 -07004797
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004798/*
Laurence Lundblade4e2da002020-06-13 23:08:31 -07004799 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004800*/
Laurence Lundblade95b64bb2020-08-30 00:17:38 -07004801void QCBORDecode_GetUInt64ConvertAllInMapN(QCBORDecodeContext *pMe,
Laurence Lundblade9b334962020-08-27 10:55:53 -07004802 int64_t nLabel,
4803 uint32_t uConvertTypes,
4804 uint64_t *puValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004805{
4806 QCBORItem Item;
4807
Laurence Lundblade93d89472020-10-03 22:30:50 -07004808 QCBORDecode_GetUInt64ConvertInternalInMapN(pMe,
4809 nLabel,
4810 uConvertTypes,
4811 puValue,
4812 &Item);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004813
4814 if(pMe->uLastError == QCBOR_SUCCESS) {
4815 // The above conversion succeeded
4816 return;
4817 }
4818
4819 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
4820 // The above conversion failed in a way that code below can't correct
4821 return;
4822 }
4823
Laurence Lundblade93d89472020-10-03 22:30:50 -07004824 pMe->uLastError = (uint8_t)UInt64ConvertAll(&Item, uConvertTypes, puValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004825}
4826
4827
4828/*
Laurence Lundblade4e2da002020-06-13 23:08:31 -07004829 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004830*/
Laurence Lundblade95b64bb2020-08-30 00:17:38 -07004831void QCBORDecode_GetUInt64ConvertAllInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundblade9b334962020-08-27 10:55:53 -07004832 const char *szLabel,
4833 uint32_t uConvertTypes,
4834 uint64_t *puValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004835{
4836 QCBORItem Item;
Laurence Lundblade93d89472020-10-03 22:30:50 -07004837 QCBORDecode_GetUInt64ConvertInternalInMapSZ(pMe,
4838 szLabel,
4839 uConvertTypes,
4840 puValue,
4841 &Item);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004842
4843 if(pMe->uLastError == QCBOR_SUCCESS) {
4844 // The above conversion succeeded
4845 return;
4846 }
4847
4848 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
4849 // The above conversion failed in a way that code below can't correct
4850 return;
4851 }
4852
Laurence Lundblade93d89472020-10-03 22:30:50 -07004853 pMe->uLastError = (uint8_t)UInt64ConvertAll(&Item, uConvertTypes, puValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004854}
4855
4856
Laurence Lundbladef7a70bc2020-10-24 12:23:25 -07004857
4858
Laurence Lundblade9b334962020-08-27 10:55:53 -07004859static QCBORError ConvertDouble(const QCBORItem *pItem,
4860 uint32_t uConvertTypes,
4861 double *pdValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004862{
4863 switch(pItem->uDataType) {
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004864 case QCBOR_TYPE_FLOAT:
4865#ifndef QCBOR_DISABLE_FLOAT_HW_USE
4866 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
4867 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004868 // Simple cast does the job.
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004869 *pdValue = (double)pItem->val.fnum;
4870 } else {
4871 return QCBOR_ERR_UNEXPECTED_TYPE;
4872 }
4873 }
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08004874#else /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004875 return QCBOR_ERR_HW_FLOAT_DISABLED;
Laurence Lundbladee2c893c2020-12-26 17:41:53 -08004876#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004877 break;
4878
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004879 case QCBOR_TYPE_DOUBLE:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004880 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
4881 if(uConvertTypes & QCBOR_CONVERT_TYPE_FLOAT) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004882 *pdValue = pItem->val.dfnum;
4883 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004884 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004885 }
4886 }
4887 break;
4888
4889 case QCBOR_TYPE_INT64:
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004890#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004891 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004892 // A simple cast seems to do the job with no worry of exceptions.
4893 // There will be precision loss for some values.
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004894 *pdValue = (double)pItem->val.int64;
4895
4896 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004897 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004898 }
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004899#else
4900 return QCBOR_ERR_HW_FLOAT_DISABLED;
4901#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004902 break;
4903
4904 case QCBOR_TYPE_UINT64:
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004905#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004906 if(uConvertTypes & QCBOR_CONVERT_TYPE_XINT64) {
Laurence Lundbladedfd49fc2020-09-01 14:17:16 -07004907 // A simple cast seems to do the job with no worry of exceptions.
4908 // There will be precision loss for some values.
4909 *pdValue = (double)pItem->val.uint64;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004910 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004911 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004912 }
4913 break;
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004914#else
4915 return QCBOR_ERR_HW_FLOAT_DISABLED;
4916#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004917
4918 default:
4919 return QCBOR_ERR_UNEXPECTED_TYPE;
4920 }
4921
4922 return QCBOR_SUCCESS;
4923}
4924
4925
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004926void QCBORDecode_GetDoubleConvertInternal(QCBORDecodeContext *pMe,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004927 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004928 double *pdValue,
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004929 QCBORItem *pItem)
Laurence Lundbladee6430642020-03-14 21:15:44 -07004930{
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004931 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundbladec4537442020-04-14 18:53:22 -07004932 return;
4933 }
4934
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004935 QCBORItem Item;
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004936
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004937 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004938 if(uError) {
4939 pMe->uLastError = (uint8_t)uError;
4940 return;
4941 }
4942
4943 if(pItem) {
4944 *pItem = Item;
4945 }
Laurence Lundbladec4537442020-04-14 18:53:22 -07004946
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004947 pMe->uLastError = (uint8_t)ConvertDouble(&Item, uConvertTypes, pdValue);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004948}
Laurence Lundbladec4537442020-04-14 18:53:22 -07004949
Laurence Lundbladec4537442020-04-14 18:53:22 -07004950
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004951void QCBORDecode_GetDoubleConvertInternalInMapN(QCBORDecodeContext *pMe,
4952 int64_t nLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004953 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004954 double *pdValue,
4955 QCBORItem *pItem)
4956{
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004957 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004958 if(pMe->uLastError != QCBOR_SUCCESS) {
4959 return;
4960 }
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004961
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004962 pMe->uLastError = (uint8_t)ConvertDouble(pItem, uConvertTypes, pdValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004963}
4964
Laurence Lundblade784b54b2020-08-10 01:24:52 -07004965
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004966void QCBORDecode_GetDoubleConvertInternalInMapSZ(QCBORDecodeContext *pMe,
4967 const char * szLabel,
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004968 uint32_t uConvertTypes,
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004969 double *pdValue,
4970 QCBORItem *pItem)
4971{
4972 if(pMe->uLastError != QCBOR_SUCCESS) {
4973 return;
4974 }
4975
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07004976 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, pItem);
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004977 if(pMe->uLastError != QCBOR_SUCCESS) {
4978 return;
4979 }
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004980
Laurence Lundblade78f7b932020-07-28 20:02:25 -07004981 pMe->uLastError = (uint8_t)ConvertDouble(pItem, uConvertTypes, pdValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07004982}
4983
4984
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07004985#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004986static double ConvertBigNumToDouble(const UsefulBufC BigNum)
4987{
4988 double dResult;
4989
4990 dResult = 0.0;
4991 const uint8_t *pByte = BigNum.ptr;
4992 size_t uLen = BigNum.len;
4993 /* This will overflow and become the float value INFINITY if the number
Laurence Lundblade11fd78b2020-09-01 22:13:27 -07004994 is too large to fit. */
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004995 while(uLen--) {
4996 dResult = (dResult * 256.0) + (double)*pByte++;
4997 }
4998
4999 return dResult;
5000}
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07005001#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
5002
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07005003
Laurence Lundblade93d89472020-10-03 22:30:50 -07005004static QCBORError
5005DoubleConvertAll(const QCBORItem *pItem, uint32_t uConvertTypes, double *pdValue)
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07005006{
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07005007#ifndef QCBOR_DISABLE_FLOAT_HW_USE
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07005008 /*
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07005009 https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
5010
5011 */
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005012 switch(pItem->uDataType) {
Laurence Lundblade410c7e02020-06-25 23:35:29 -07005013
5014#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005015 case QCBOR_TYPE_DECIMAL_FRACTION:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005016 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade51722fd2020-09-02 13:01:33 -07005017 // Underflow gives 0, overflow gives infinity
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005018 *pdValue = (double)pItem->val.expAndMantissa.Mantissa.nInt *
5019 pow(10.0, (double)pItem->val.expAndMantissa.nExponent);
5020 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005021 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005022 }
5023 break;
5024
5025 case QCBOR_TYPE_BIGFLOAT:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005026 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIGFLOAT ) {
Laurence Lundblade51722fd2020-09-02 13:01:33 -07005027 // Underflow gives 0, overflow gives infinity
5028 *pdValue = (double)pItem->val.expAndMantissa.Mantissa.nInt *
5029 exp2((double)pItem->val.expAndMantissa.nExponent);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005030 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005031 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005032 }
5033 break;
Laurence Lundblade410c7e02020-06-25 23:35:29 -07005034#endif /* ndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005035
5036 case QCBOR_TYPE_POSBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005037 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005038 *pdValue = ConvertBigNumToDouble(pItem->val.bigNum);
5039 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005040 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005041 }
5042 break;
5043
5044 case QCBOR_TYPE_NEGBIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005045 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIG_NUM) {
Laurence Lundbladeda095972020-06-06 18:35:33 -07005046 *pdValue = -1-ConvertBigNumToDouble(pItem->val.bigNum);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005047 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005048 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005049 }
5050 break;
5051
Laurence Lundblade410c7e02020-06-25 23:35:29 -07005052#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005053 case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005054 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005055 double dMantissa = ConvertBigNumToDouble(pItem->val.expAndMantissa.Mantissa.bigNum);
5056 *pdValue = dMantissa * pow(10, (double)pItem->val.expAndMantissa.nExponent);
5057 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005058 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005059 }
5060 break;
5061
5062 case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005063 if(uConvertTypes & QCBOR_CONVERT_TYPE_DECIMAL_FRACTION) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005064 double dMantissa = -ConvertBigNumToDouble(pItem->val.expAndMantissa.Mantissa.bigNum);
5065 *pdValue = dMantissa * pow(10, (double)pItem->val.expAndMantissa.nExponent);
5066 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005067 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005068 }
5069 break;
5070
5071 case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005072 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIGFLOAT) {
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005073 double dMantissa = ConvertBigNumToDouble(pItem->val.expAndMantissa.Mantissa.bigNum);
5074 *pdValue = dMantissa * exp2((double)pItem->val.expAndMantissa.nExponent);
5075 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005076 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005077 }
5078 break;
5079
5080 case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005081 if(uConvertTypes & QCBOR_CONVERT_TYPE_BIGFLOAT) {
Laurence Lundbladeda095972020-06-06 18:35:33 -07005082 double dMantissa = -1-ConvertBigNumToDouble(pItem->val.expAndMantissa.Mantissa.bigNum);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005083 *pdValue = dMantissa * exp2((double)pItem->val.expAndMantissa.nExponent);
5084 } else {
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005085 return QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005086 }
5087 break;
Laurence Lundblade410c7e02020-06-25 23:35:29 -07005088#endif /* ndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
5089
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005090 default:
5091 return QCBOR_ERR_UNEXPECTED_TYPE;
5092 }
5093
5094 return QCBOR_SUCCESS;
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07005095
5096#else
5097 (void)pItem;
5098 (void)uConvertTypes;
5099 (void)pdValue;
5100 return QCBOR_ERR_HW_FLOAT_DISABLED;
5101#endif /* QCBOR_DISABLE_FLOAT_HW_USE */
5102
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005103}
5104
5105
5106/*
Laurence Lundblade4e2da002020-06-13 23:08:31 -07005107 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005108*/
Laurence Lundblade9b334962020-08-27 10:55:53 -07005109void QCBORDecode_GetDoubleConvertAll(QCBORDecodeContext *pMe,
5110 uint32_t uConvertTypes,
5111 double *pdValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005112{
5113
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07005114 QCBORItem Item;
5115
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005116 QCBORDecode_GetDoubleConvertInternal(pMe, uConvertTypes, pdValue, &Item);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07005117
5118 if(pMe->uLastError == QCBOR_SUCCESS) {
5119 // The above conversion succeeded
5120 return;
5121 }
5122
5123 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
5124 // The above conversion failed in a way that code below can't correct
5125 return;
5126 }
5127
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005128 pMe->uLastError = (uint8_t)DoubleConvertAll(&Item, uConvertTypes, pdValue);
Laurence Lundbladee6430642020-03-14 21:15:44 -07005129}
5130
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005131
5132/*
Laurence Lundblade4e2da002020-06-13 23:08:31 -07005133 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005134*/
Laurence Lundblade9b334962020-08-27 10:55:53 -07005135void QCBORDecode_GetDoubleConvertAllInMapN(QCBORDecodeContext *pMe,
5136 int64_t nLabel,
5137 uint32_t uConvertTypes,
5138 double *pdValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005139{
5140 QCBORItem Item;
5141
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005142 QCBORDecode_GetDoubleConvertInternalInMapN(pMe, nLabel, uConvertTypes, pdValue, &Item);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005143
5144 if(pMe->uLastError == QCBOR_SUCCESS) {
5145 // The above conversion succeeded
5146 return;
5147 }
5148
5149 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
5150 // The above conversion failed in a way that code below can't correct
5151 return;
5152 }
5153
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005154 pMe->uLastError = (uint8_t)DoubleConvertAll(&Item, uConvertTypes, pdValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005155}
5156
5157
5158/*
Laurence Lundblade4e2da002020-06-13 23:08:31 -07005159 Public function, see header qcbor/qcbor_decode.h file
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005160*/
Laurence Lundblade9b334962020-08-27 10:55:53 -07005161void QCBORDecode_GetDoubleConvertAllInMapSZ(QCBORDecodeContext *pMe,
5162 const char *szLabel,
5163 uint32_t uConvertTypes,
5164 double *pdValue)
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005165{
5166 QCBORItem Item;
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005167 QCBORDecode_GetDoubleConvertInternalInMapSZ(pMe, szLabel, uConvertTypes, pdValue, &Item);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005168
5169 if(pMe->uLastError == QCBOR_SUCCESS) {
5170 // The above conversion succeeded
5171 return;
5172 }
5173
5174 if(pMe->uLastError != QCBOR_ERR_UNEXPECTED_TYPE) {
5175 // The above conversion failed in a way that code below can't correct
5176 return;
5177 }
5178
Laurence Lundblade78f7b932020-07-28 20:02:25 -07005179 pMe->uLastError = (uint8_t)DoubleConvertAll(&Item, uConvertTypes, pdValue);
Laurence Lundblade7e5be1d2020-05-24 21:17:28 -07005180}
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005181
5182
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005183
5184
Laurence Lundblade410c7e02020-06-25 23:35:29 -07005185#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundbladef7c0adb2020-08-08 20:20:58 -07005186static inline UsefulBufC ConvertIntToBigNum(uint64_t uInt, UsefulBuf Buffer)
5187{
5188 while((uInt & 0xff00000000000000UL) == 0) {
5189 uInt = uInt << 8;
5190 };
5191
5192 UsefulOutBuf UOB;
5193
5194 UsefulOutBuf_Init(&UOB, Buffer);
5195
5196 while(uInt) {
5197 const uint64_t xx = uInt & 0xff00000000000000UL;
5198 UsefulOutBuf_AppendByte(&UOB, (uint8_t)((uInt & 0xff00000000000000UL) >> 56));
5199 uInt = uInt << 8;
5200 (void)xx;
5201 }
5202
5203 return UsefulOutBuf_OutUBuf(&UOB);
5204}
5205
5206
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005207static QCBORError MantissaAndExponentTypeHandler(QCBORDecodeContext *pMe,
5208 TagSpecification TagSpec,
5209 QCBORItem *pItem)
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005210{
5211 QCBORError uErr;
5212 // Loops runs at most 1.5 times. Making it a loop saves object code.
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005213 while(1) {
Laurence Lundblade6f3f78e2020-08-31 13:09:14 -07005214 uErr = CheckTagRequirement(TagSpec, pItem);
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005215 if(uErr != QCBOR_SUCCESS) {
5216 goto Done;
5217 }
5218
5219 if(pItem->uDataType != QCBOR_TYPE_ARRAY) {
5220 break; // Successful exit. Moving on to finish decoding.
5221 }
5222
5223 // The item is an array, which means an undecoded
5224 // mantissa and exponent, so decode it. It will then
5225 // have a different type and exit the loop if.
5226 uErr = QCBORDecode_MantissaAndExponent(pMe, pItem);
5227 if(uErr != QCBOR_SUCCESS) {
5228 goto Done;
5229 }
5230
5231 // Second time around, the type must match.
Laurence Lundblade9b334962020-08-27 10:55:53 -07005232 TagSpec.uTagRequirement = QCBOR_TAG_REQUIREMENT_TAG;
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005233 }
5234Done:
5235 return uErr;
5236}
5237
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005238
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005239static void ProcessMantissaAndExponent(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005240 TagSpecification TagSpec,
5241 QCBORItem *pItem,
5242 int64_t *pnMantissa,
5243 int64_t *pnExponent)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005244{
5245 QCBORError uErr;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005246
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005247 uErr = MantissaAndExponentTypeHandler(pMe, TagSpec, pItem);
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005248 if(uErr != QCBOR_SUCCESS) {
5249 goto Done;
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005250 }
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005251
Laurence Lundblade9b334962020-08-27 10:55:53 -07005252 switch (pItem->uDataType) {
5253
5254 case QCBOR_TYPE_DECIMAL_FRACTION:
5255 case QCBOR_TYPE_BIGFLOAT:
5256 *pnMantissa = pItem->val.expAndMantissa.Mantissa.nInt;
5257 *pnExponent = pItem->val.expAndMantissa.nExponent;
5258 break;
5259
5260 case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
5261 case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
5262 *pnExponent = pItem->val.expAndMantissa.nExponent;
5263 uErr = ConvertPositiveBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, pnMantissa);
5264 break;
5265
5266 case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
5267 case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
5268 *pnExponent = pItem->val.expAndMantissa.nExponent;
5269 uErr = ConvertNegativeBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, pnMantissa);
5270 break;
5271
5272 default:
5273 uErr = QCBOR_ERR_UNEXPECTED_TYPE;
5274 }
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005275
5276 Done:
5277 pMe->uLastError = (uint8_t)uErr;
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005278}
5279
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005280
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005281static void ProcessMantissaAndExponentBig(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005282 TagSpecification TagSpec,
5283 QCBORItem *pItem,
5284 UsefulBuf BufferForMantissa,
5285 UsefulBufC *pMantissa,
5286 bool *pbIsNegative,
5287 int64_t *pnExponent)
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005288{
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005289 QCBORError uErr;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005290
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005291 uErr = MantissaAndExponentTypeHandler(pMe, TagSpec, pItem);
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005292 if(uErr != QCBOR_SUCCESS) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005293 goto Done;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005294 }
5295
5296 uint64_t uMantissa;
5297
5298 switch (pItem->uDataType) {
5299
5300 case QCBOR_TYPE_DECIMAL_FRACTION:
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005301 case QCBOR_TYPE_BIGFLOAT:
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005302 if(pItem->val.expAndMantissa.Mantissa.nInt >= 0) {
5303 uMantissa = (uint64_t)pItem->val.expAndMantissa.Mantissa.nInt;
5304 *pbIsNegative = false;
5305 } else {
5306 uMantissa = (uint64_t)-pItem->val.expAndMantissa.Mantissa.nInt;
5307 *pbIsNegative = true;
5308 }
5309 *pMantissa = ConvertIntToBigNum(uMantissa, BufferForMantissa);
5310 *pnExponent = pItem->val.expAndMantissa.nExponent;
5311 break;
5312
5313 case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005314 case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005315 *pnExponent = pItem->val.expAndMantissa.nExponent;
5316 *pMantissa = pItem->val.expAndMantissa.Mantissa.bigNum;
5317 *pbIsNegative = false;
5318 break;
5319
5320 case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005321 case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005322 *pnExponent = pItem->val.expAndMantissa.nExponent;
5323 *pMantissa = pItem->val.expAndMantissa.Mantissa.bigNum;
5324 *pbIsNegative = true;
5325 break;
5326
5327 default:
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005328 uErr = QCBOR_ERR_UNEXPECTED_TYPE;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005329 }
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005330
5331Done:
5332 pMe->uLastError = (uint8_t)uErr;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005333}
5334
5335
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005336/*
5337 Public function, see header qcbor/qcbor_decode.h file
5338*/
5339void QCBORDecode_GetDecimalFraction(QCBORDecodeContext *pMe,
5340 uint8_t uTagRequirement,
5341 int64_t *pnMantissa,
5342 int64_t *pnExponent)
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005343{
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005344 if(pMe->uLastError != QCBOR_SUCCESS) {
5345 return;
5346 }
5347
5348 QCBORItem Item;
5349 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
5350 if(uError) {
5351 pMe->uLastError = (uint8_t)uError;
5352 return;
5353 }
5354
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005355 const TagSpecification TagSpec =
5356 {
5357 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005358 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5359 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5360 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005361 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005362
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005363 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005364}
5365
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005366
5367/*
5368 Public function, see header qcbor/qcbor_decode.h file
5369*/
5370void QCBORDecode_GetDecimalFractionInMapN(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005371 int64_t nLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005372 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005373 int64_t *pnMantissa,
5374 int64_t *pnExponent)
5375{
5376 if(pMe->uLastError != QCBOR_SUCCESS) {
5377 return;
5378 }
5379
5380 QCBORItem Item;
5381 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
5382
5383 const TagSpecification TagSpec =
5384 {
5385 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005386 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5387 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5388 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005389 };
5390
5391 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
5392}
5393
5394
5395/*
5396 Public function, see header qcbor/qcbor_decode.h file
5397*/
5398void QCBORDecode_GetDecimalFractionInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005399 const char *szLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005400 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005401 int64_t *pnMantissa,
5402 int64_t *pnExponent)
5403{
5404 if(pMe->uLastError != QCBOR_SUCCESS) {
5405 return;
5406 }
5407
5408 QCBORItem Item;
5409 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
5410
5411 const TagSpecification TagSpec =
5412 {
5413 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005414 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5415 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5416 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005417 };
Laurence Lundblade9b334962020-08-27 10:55:53 -07005418
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005419 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
5420}
5421
5422
5423/*
5424 Public function, see header qcbor/qcbor_decode.h file
5425*/
5426void QCBORDecode_GetDecimalFractionBig(QCBORDecodeContext *pMe,
5427 uint8_t uTagRequirement,
5428 UsefulBuf MantissaBuffer,
5429 UsefulBufC *pMantissa,
5430 bool *pbMantissaIsNegative,
5431 int64_t *pnExponent)
5432{
5433 if(pMe->uLastError != QCBOR_SUCCESS) {
5434 return;
5435 }
5436
5437 QCBORItem Item;
5438 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
5439 if(uError) {
5440 pMe->uLastError = (uint8_t)uError;
5441 return;
5442 }
5443
5444 const TagSpecification TagSpec =
5445 {
5446 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005447 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5448 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5449 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005450 };
5451
Laurence Lundblade93d89472020-10-03 22:30:50 -07005452 ProcessMantissaAndExponentBig(pMe,
5453 TagSpec,
5454 &Item,
5455 MantissaBuffer,
5456 pMantissa,
5457 pbMantissaIsNegative,
5458 pnExponent);
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005459}
5460
5461
5462/*
5463 Public function, see header qcbor/qcbor_decode.h file
5464*/
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005465void QCBORDecode_GetDecimalFractionBigInMapN(QCBORDecodeContext *pMe,
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005466 int64_t nLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005467 uint8_t uTagRequirement,
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005468 UsefulBuf BufferForMantissa,
5469 UsefulBufC *pMantissa,
5470 bool *pbIsNegative,
5471 int64_t *pnExponent)
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005472{
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005473 if(pMe->uLastError != QCBOR_SUCCESS) {
5474 return;
5475 }
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07005476
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005477 QCBORItem Item;
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005478 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07005479 if(pMe->uLastError != QCBOR_SUCCESS) {
5480 return;
5481 }
5482
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005483 const TagSpecification TagSpec =
5484 {
5485 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005486 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5487 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5488 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005489 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005490
Laurence Lundblade93d89472020-10-03 22:30:50 -07005491 ProcessMantissaAndExponentBig(pMe,
5492 TagSpec,
5493 &Item,
5494 BufferForMantissa,
5495 pMantissa,
5496 pbIsNegative,
5497 pnExponent);
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005498}
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07005499
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005500
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005501/*
5502 Public function, see header qcbor/qcbor_decode.h file
5503*/
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005504void QCBORDecode_GetDecimalFractionBigInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005505 const char *szLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005506 uint8_t uTagRequirement,
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005507 UsefulBuf BufferForMantissa,
5508 UsefulBufC *pMantissa,
5509 bool *pbIsNegative,
5510 int64_t *pnExponent)
5511{
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005512 if(pMe->uLastError != QCBOR_SUCCESS) {
5513 return;
5514 }
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005515
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005516 QCBORItem Item;
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005517 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
5518 if(pMe->uLastError != QCBOR_SUCCESS) {
5519 return;
5520 }
5521
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005522 const TagSpecification TagSpec =
5523 {
5524 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005525 {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM,
5526 QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM, QCBOR_TYPE_NONE},
5527 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005528 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005529
5530 ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
5531}
5532
5533
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005534/*
5535 Public function, see header qcbor/qcbor_decode.h file
5536*/
5537void QCBORDecode_GetBigFloat(QCBORDecodeContext *pMe,
5538 uint8_t uTagRequirement,
5539 int64_t *pnMantissa,
5540 int64_t *pnExponent)
5541{
5542 if(pMe->uLastError != QCBOR_SUCCESS) {
5543 return;
5544 }
5545
5546 QCBORItem Item;
5547 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
5548 if(uError) {
5549 pMe->uLastError = (uint8_t)uError;
5550 return;
5551 }
5552 const TagSpecification TagSpec =
5553 {
5554 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005555 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5556 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5557 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005558 };
5559
5560 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
5561}
5562
5563
5564/*
5565 Public function, see header qcbor/qcbor_decode.h file
5566*/
5567void QCBORDecode_GetBigFloatInMapN(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005568 int64_t nLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005569 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005570 int64_t *pnMantissa,
5571 int64_t *pnExponent)
5572{
5573 if(pMe->uLastError != QCBOR_SUCCESS) {
5574 return;
5575 }
5576
5577 QCBORItem Item;
5578 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
5579 if(pMe->uLastError != QCBOR_SUCCESS) {
5580 return;
5581 }
5582
5583 const TagSpecification TagSpec =
5584 {
5585 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005586 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5587 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5588 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005589 };
5590
5591 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
5592}
5593
5594
5595/*
5596 Public function, see header qcbor/qcbor_decode.h file
5597*/
5598void QCBORDecode_GetBigFloatInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005599 const char *szLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005600 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005601 int64_t *pnMantissa,
5602 int64_t *pnExponent)
5603{
5604 if(pMe->uLastError != QCBOR_SUCCESS) {
5605 return;
5606 }
5607
5608 QCBORItem Item;
5609 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
5610 if(pMe->uLastError != QCBOR_SUCCESS) {
5611 return;
5612 }
5613
5614 const TagSpecification TagSpec =
5615 {
5616 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005617 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5618 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5619 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005620 };
5621
5622 ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
5623}
5624
5625
5626/*
5627 Public function, see header qcbor/qcbor_decode.h file
5628*/
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005629void QCBORDecode_GetBigFloatBig(QCBORDecodeContext *pMe,
5630 uint8_t uTagRequirement,
5631 UsefulBuf MantissaBuffer,
5632 UsefulBufC *pMantissa,
5633 bool *pbMantissaIsNegative,
5634 int64_t *pnExponent)
5635{
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005636 if(pMe->uLastError != QCBOR_SUCCESS) {
5637 return;
5638 }
5639
5640 QCBORItem Item;
5641 QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
5642 if(uError) {
5643 pMe->uLastError = (uint8_t)uError;
5644 return;
5645 }
5646
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005647 const TagSpecification TagSpec =
5648 {
5649 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005650 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5651 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5652 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005653 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005654
5655 ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, MantissaBuffer, pMantissa, pbMantissaIsNegative, pnExponent);
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005656}
5657
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005658
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005659/*
5660 Public function, see header qcbor/qcbor_decode.h file
5661*/
5662void QCBORDecode_GetBigFloatBigInMapN(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005663 int64_t nLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005664 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005665 UsefulBuf BufferForMantissa,
5666 UsefulBufC *pMantissa,
5667 bool *pbIsNegative,
5668 int64_t *pnExponent)
5669{
5670 if(pMe->uLastError != QCBOR_SUCCESS) {
5671 return;
5672 }
5673
5674 QCBORItem Item;
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005675 QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
5676 if(pMe->uLastError != QCBOR_SUCCESS) {
5677 return;
5678 }
5679
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005680 const TagSpecification TagSpec =
5681 {
5682 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005683 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5684 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5685 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005686 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005687
Laurence Lundblade93d89472020-10-03 22:30:50 -07005688 ProcessMantissaAndExponentBig(pMe,
5689 TagSpec,
5690 &Item,
5691 BufferForMantissa,
5692 pMantissa,
5693 pbIsNegative,
5694 pnExponent);
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005695}
5696
5697
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005698/*
5699 Public function, see header qcbor/qcbor_decode.h file
5700*/
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005701void QCBORDecode_GetBigFloatBigInMapSZ(QCBORDecodeContext *pMe,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005702 const char *szLabel,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005703 uint8_t uTagRequirement,
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005704 UsefulBuf BufferForMantissa,
5705 UsefulBufC *pMantissa,
5706 bool *pbIsNegative,
5707 int64_t *pnExponent)
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005708{
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005709 if(pMe->uLastError != QCBOR_SUCCESS) {
5710 return;
5711 }
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005712
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005713 QCBORItem Item;
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005714 QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
5715 if(pMe->uLastError != QCBOR_SUCCESS) {
Laurence Lundblade3cd26eb2020-06-29 23:33:13 -07005716 return;
5717 }
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005718
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005719 const TagSpecification TagSpec =
5720 {
5721 uTagRequirement,
Laurence Lundbladec384d4e2020-10-07 09:46:10 -07005722 {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM,
5723 QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM, QCBOR_TYPE_NONE},
5724 {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005725 };
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07005726
Laurence Lundblade93d89472020-10-03 22:30:50 -07005727 ProcessMantissaAndExponentBig(pMe,
5728 TagSpec,
5729 &Item,
5730 BufferForMantissa,
5731 pMantissa,
5732 pbIsNegative,
5733 pnExponent);
Laurence Lundblade91853ae2020-06-15 19:35:58 -07005734}
Laurence Lundbladed4cd7232020-07-03 19:30:48 -07005735
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07005736#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */