Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1 | /*============================================================================== |
Laurence Lundblade | d92a616 | 2018-11-01 11:38:35 +0700 | [diff] [blame] | 2 | Copyright (c) 2016-2018, The Linux Foundation. |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 3 | Copyright (c) 2018-2020, Laurence Lundblade. |
Laurence Lundblade | d92a616 | 2018-11-01 11:38:35 +0700 | [diff] [blame] | 4 | All rights reserved. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 5 | |
Laurence Lundblade | 0dbc917 | 2018-11-01 14:17:21 +0700 | [diff] [blame] | 6 | Redistribution and use in source and binary forms, with or without |
| 7 | modification, are permitted provided that the following conditions are |
| 8 | met: |
| 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 Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 19 | |
Laurence Lundblade | 0dbc917 | 2018-11-01 14:17:21 +0700 | [diff] [blame] | 20 | THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| 21 | WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 22 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| 23 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| 24 | BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 25 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 26 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| 27 | BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| 28 | WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| 29 | OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| 30 | IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 31 | =============================================================================*/ |
Laurence Lundblade | 624405d | 2018-09-18 20:10:47 -0700 | [diff] [blame] | 32 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 33 | /*============================================================================== |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 34 | FILE: qcbor_decode.c |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 35 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 36 | DESCRIPTION: This file contains the implementation of QCBOR. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 37 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 38 | EDIT HISTORY FOR FILE: |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 39 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 40 | This section contains comments describing changes made to the module. |
| 41 | Notice that changes are listed in reverse chronological order. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 42 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 43 | when who what, where, why |
| 44 | -------- ---- --------------------------------------------------- |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 45 | 01/28/2020 llundblade Refine integer signedness to quiet static analysis. |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 46 | 01/25/2020 llundblade Cleaner handling of too-long encoded string input. |
| 47 | 01/25/2020 llundblade Refine use of integer types to quiet static analysis |
| 48 | 01/08/2020 llundblade Documentation corrections & improved code formatting |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 49 | 12/30/19 llundblade Add support for decimal fractions and bigfloats. |
| 50 | 11/07/19 llundblade Fix long long conversion to double compiler warning |
| 51 | 09/07/19 llundblade Fix bug decoding empty arrays and maps |
| 52 | 07/31/19 llundblade Decode error fixes for some not-well-formed CBOR |
| 53 | 07/31/19 llundblade New error code for better end of data handling |
| 54 | 02/17/19 llundblade Fixed: QCBORItem.u{Data|Label}Alloc when |
| 55 | bAllStrings set |
| 56 | 02/16/19 llundblade Redesign MemPool to fix memory access alignment bug |
| 57 | 01/10/19 llundblade Clever type and argument decoder; 250 bytes smaller |
| 58 | 11/9/18 llundblade Error codes are now enums. |
| 59 | 11/2/18 llundblade Simplify float decoding and align with preferred |
| 60 | float encoding |
| 61 | 10/31/18 llundblade Switch to one license that is almost BSD-3. |
| 62 | 10/28/18 llundblade Reworked tag decoding |
| 63 | 10/15/18 llundblade Indefinite length maps and arrays supported |
| 64 | 10/8/18 llundblade Indefinite length strings supported |
| 65 | 02/04/17 llundbla Work on CPUs that don's require pointer alignment |
| 66 | by making use of changes in UsefulBuf |
| 67 | 03/01/17 llundbla More data types; decoding improvements and fixes |
| 68 | 11/13/16 llundbla Integrate most TZ changes back into github version. |
| 69 | 09/30/16 gkanike Porting to TZ. |
| 70 | 03/15/16 llundbla Initial Version. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 71 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 72 | =============================================================================*/ |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 73 | |
| 74 | #include "qcbor.h" |
Laurence Lundblade | 12d32c5 | 2018-09-19 11:25:27 -0700 | [diff] [blame] | 75 | #include "ieee754.h" |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 76 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 77 | |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 78 | /* |
| 79 | This casts away the const-ness of a pointer, usually so it can be |
| 80 | freed or realloced. |
| 81 | */ |
| 82 | #define UNCONST_POINTER(ptr) ((void *)(ptr)) |
| 83 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 84 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 85 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 86 | /*=========================================================================== |
| 87 | DecodeNesting -- Functions for tracking array/map nesting when decoding |
| 88 | |
| 89 | See qcbor.h for definition of the object used here: QCBORDecodeNesting |
| 90 | ===========================================================================*/ |
| 91 | |
| 92 | inline static int |
| 93 | IsMapOrArray(uint8_t uDataType) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 94 | { |
| 95 | return uDataType == QCBOR_TYPE_MAP || uDataType == QCBOR_TYPE_ARRAY; |
| 96 | } |
| 97 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 98 | inline static int |
| 99 | DecodeNesting_IsNested(const QCBORDecodeNesting *pNesting) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 100 | { |
| 101 | return pNesting->pCurrent != &(pNesting->pMapsAndArrays[0]); |
| 102 | } |
| 103 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 104 | inline static int |
| 105 | DecodeNesting_IsIndefiniteLength(const QCBORDecodeNesting *pNesting) |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 106 | { |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 107 | return pNesting->pCurrent->uCount == UINT16_MAX; |
| 108 | } |
| 109 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 110 | inline static uint8_t |
| 111 | DecodeNesting_GetLevel(QCBORDecodeNesting *pNesting) |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 112 | { |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 113 | // Check in DecodeNesting_Descend and never having |
| 114 | // QCBOR_MAX_ARRAY_NESTING > 255 gaurantee cast is safe |
| 115 | return (uint8_t)(pNesting->pCurrent - &(pNesting->pMapsAndArrays[0])); |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 116 | } |
| 117 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 118 | inline static int |
| 119 | DecodeNesting_TypeIsMap(const QCBORDecodeNesting *pNesting) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 120 | { |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 121 | if(!DecodeNesting_IsNested(pNesting)) { |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 122 | return 0; |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 123 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 124 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 125 | return CBOR_MAJOR_TYPE_MAP == pNesting->pCurrent->uMajorType; |
| 126 | } |
| 127 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 128 | // Process a break. This will either ascend the nesting or error out |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 129 | inline static QCBORError |
| 130 | DecodeNesting_BreakAscend(QCBORDecodeNesting *pNesting) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 131 | { |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 132 | // breaks must always occur when there is nesting |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 133 | if(!DecodeNesting_IsNested(pNesting)) { |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 134 | return QCBOR_ERR_BAD_BREAK; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 135 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 136 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 137 | // breaks can only occur when the map/array is indefinite length |
| 138 | if(!DecodeNesting_IsIndefiniteLength(pNesting)) { |
| 139 | return QCBOR_ERR_BAD_BREAK; |
| 140 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 141 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 142 | // if all OK, the break reduces the level of nesting |
| 143 | pNesting->pCurrent--; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 144 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 145 | return QCBOR_SUCCESS; |
| 146 | } |
| 147 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 148 | // Called on every single item except breaks including open of a map/array |
| 149 | inline static void |
| 150 | DecodeNesting_DecrementCount(QCBORDecodeNesting *pNesting) |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 151 | { |
Laurence Lundblade | 9916b1b | 2019-09-07 22:33:25 -0700 | [diff] [blame] | 152 | while(DecodeNesting_IsNested(pNesting)) { |
| 153 | // Not at the top level, so there is decrementing to be done. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 154 | |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 155 | if(!DecodeNesting_IsIndefiniteLength(pNesting)) { |
Laurence Lundblade | 9916b1b | 2019-09-07 22:33:25 -0700 | [diff] [blame] | 156 | // Decrement the current nesting level if it is not indefinite. |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 157 | pNesting->pCurrent->uCount--; |
| 158 | } |
Laurence Lundblade | 9916b1b | 2019-09-07 22:33:25 -0700 | [diff] [blame] | 159 | |
| 160 | if(pNesting->pCurrent->uCount != 0) { |
| 161 | // Did not close out an array or map, so nothing further |
| 162 | break; |
| 163 | } |
| 164 | |
| 165 | // Closed out an array or map so level up |
| 166 | pNesting->pCurrent--; |
| 167 | |
| 168 | // Continue with loop to see if closing out this doesn't close out more |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 169 | } |
| 170 | } |
| 171 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 172 | // Called on every map/array |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 173 | inline static QCBORError |
| 174 | DecodeNesting_Descend(QCBORDecodeNesting *pNesting, QCBORItem *pItem) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 175 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 176 | QCBORError nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 177 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 178 | if(pItem->val.uCount == 0) { |
| 179 | // Nothing to do for empty definite lenth arrays. They are just are |
| 180 | // effectively the same as an item that is not a map or array |
| 181 | goto Done; |
Laurence Lundblade | a44d506 | 2018-10-17 18:45:12 +0530 | [diff] [blame] | 182 | // Empty indefinite length maps and arrays are handled elsewhere |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 183 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 184 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 185 | // Error out if arrays is too long to handle |
| 186 | if(pItem->val.uCount != UINT16_MAX && pItem->val.uCount > QCBOR_MAX_ITEMS_IN_ARRAY) { |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 187 | nReturn = QCBOR_ERR_ARRAY_TOO_LONG; |
| 188 | goto Done; |
| 189 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 190 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 191 | // Error out if nesting is too deep |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 192 | if(pNesting->pCurrent >= &(pNesting->pMapsAndArrays[QCBOR_MAX_ARRAY_NESTING])) { |
| 193 | nReturn = QCBOR_ERR_ARRAY_NESTING_TOO_DEEP; |
| 194 | goto Done; |
| 195 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 196 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 197 | // The actual descend |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 198 | pNesting->pCurrent++; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 199 | |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 200 | // Record a few details for this nesting level |
| 201 | pNesting->pCurrent->uMajorType = pItem->uDataType; |
| 202 | pNesting->pCurrent->uCount = pItem->val.uCount; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 203 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 204 | Done: |
| 205 | return nReturn;; |
| 206 | } |
| 207 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 208 | inline static void |
| 209 | DecodeNesting_Init(QCBORDecodeNesting *pNesting) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 210 | { |
| 211 | pNesting->pCurrent = &(pNesting->pMapsAndArrays[0]); |
| 212 | } |
| 213 | |
| 214 | |
| 215 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 216 | /* |
| 217 | This list of built-in tags. Only add tags here that are |
| 218 | clearly established and useful. Once a tag is added here |
| 219 | it can't be taken out as that would break backwards compatibility. |
| 220 | There are only 48 slots available forever. |
| 221 | */ |
| 222 | static const uint16_t spBuiltInTagMap[] = { |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 223 | CBOR_TAG_DATE_STRING, // See TAG_MAPPER_FIRST_SIX |
| 224 | CBOR_TAG_DATE_EPOCH, // See TAG_MAPPER_FIRST_SIX |
| 225 | CBOR_TAG_POS_BIGNUM, // See TAG_MAPPER_FIRST_SIX |
| 226 | CBOR_TAG_NEG_BIGNUM, // See TAG_MAPPER_FIRST_SIX |
| 227 | CBOR_TAG_DECIMAL_FRACTION, // See TAG_MAPPER_FIRST_SIX |
| 228 | CBOR_TAG_BIGFLOAT, // See TAG_MAPPER_FIRST_SIX |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 229 | CBOR_TAG_COSE_ENCRYPTO, |
| 230 | CBOR_TAG_COSE_MAC0, |
| 231 | CBOR_TAG_COSE_SIGN1, |
| 232 | CBOR_TAG_ENC_AS_B64URL, |
| 233 | CBOR_TAG_ENC_AS_B64, |
| 234 | CBOR_TAG_ENC_AS_B16, |
| 235 | CBOR_TAG_CBOR, |
| 236 | CBOR_TAG_URI, |
| 237 | CBOR_TAG_B64URL, |
| 238 | CBOR_TAG_B64, |
| 239 | CBOR_TAG_REGEX, |
| 240 | CBOR_TAG_MIME, |
| 241 | CBOR_TAG_BIN_UUID, |
| 242 | CBOR_TAG_CWT, |
| 243 | CBOR_TAG_ENCRYPT, |
| 244 | CBOR_TAG_MAC, |
| 245 | CBOR_TAG_SIGN, |
| 246 | CBOR_TAG_GEO_COORD, |
| 247 | CBOR_TAG_CBOR_MAGIC |
| 248 | }; |
| 249 | |
| 250 | // This is used in a bit of cleverness in GetNext_TaggedItem() to |
| 251 | // keep code size down and switch for the internal processing of |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 252 | // these types. This will break if the first six items in |
| 253 | // spBuiltInTagMap don't have values 0,1,2,3,4,5. That is the |
| 254 | // mapping is 0 to 0, 1 to 1, 2 to 2 and 3 to 3.... |
| 255 | #define QCBOR_TAGFLAG_DATE_STRING (0x01LL << CBOR_TAG_DATE_STRING) |
| 256 | #define QCBOR_TAGFLAG_DATE_EPOCH (0x01LL << CBOR_TAG_DATE_EPOCH) |
| 257 | #define QCBOR_TAGFLAG_POS_BIGNUM (0x01LL << CBOR_TAG_POS_BIGNUM) |
| 258 | #define QCBOR_TAGFLAG_NEG_BIGNUM (0x01LL << CBOR_TAG_NEG_BIGNUM) |
| 259 | #define QCBOR_TAGFLAG_DECIMAL_FRACTION (0x01LL << CBOR_TAG_DECIMAL_FRACTION) |
| 260 | #define QCBOR_TAGFLAG_BIGFLOAT (0x01LL << CBOR_TAG_BIGFLOAT) |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 261 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 262 | #define TAG_MAPPER_FIRST_SIX (QCBOR_TAGFLAG_DATE_STRING |\ |
| 263 | QCBOR_TAGFLAG_DATE_EPOCH |\ |
| 264 | QCBOR_TAGFLAG_POS_BIGNUM |\ |
| 265 | QCBOR_TAGFLAG_NEG_BIGNUM |\ |
| 266 | QCBOR_TAGFLAG_DECIMAL_FRACTION |\ |
| 267 | QCBOR_TAGFLAG_BIGFLOAT) |
| 268 | |
| 269 | #define TAG_MAPPER_FIRST_FOUR (QCBOR_TAGFLAG_DATE_STRING |\ |
| 270 | QCBOR_TAGFLAG_DATE_EPOCH |\ |
| 271 | QCBOR_TAGFLAG_POS_BIGNUM |\ |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 272 | QCBOR_TAGFLAG_NEG_BIGNUM) |
| 273 | |
| 274 | #define TAG_MAPPER_TOTAL_TAG_BITS 64 // Number of bits in a uint64_t |
| 275 | #define TAG_MAPPER_CUSTOM_TAGS_BASE_INDEX (TAG_MAPPER_TOTAL_TAG_BITS - QCBOR_MAX_CUSTOM_TAGS) // 48 |
| 276 | #define TAG_MAPPER_MAX_SIZE_BUILT_IN_TAGS (TAG_MAPPER_TOTAL_TAG_BITS - QCBOR_MAX_CUSTOM_TAGS ) // 48 |
| 277 | |
| 278 | static inline int TagMapper_LookupBuiltIn(uint64_t uTag) |
| 279 | { |
| 280 | if(sizeof(spBuiltInTagMap)/sizeof(uint16_t) > TAG_MAPPER_MAX_SIZE_BUILT_IN_TAGS) { |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 281 | /* |
| 282 | This is a cross-check to make sure the above array doesn't |
| 283 | accidentally get made too big. In normal conditions the above |
| 284 | test should optimize out as all the values are known at compile |
| 285 | time. |
| 286 | */ |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 287 | return -1; |
| 288 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 289 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 290 | if(uTag > UINT16_MAX) { |
| 291 | // This tag map works only on 16-bit tags |
| 292 | return -1; |
| 293 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 294 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 295 | for(int nTagBitIndex = 0; nTagBitIndex < (int)(sizeof(spBuiltInTagMap)/sizeof(uint16_t)); nTagBitIndex++) { |
| 296 | if(spBuiltInTagMap[nTagBitIndex] == uTag) { |
| 297 | return nTagBitIndex; |
| 298 | } |
| 299 | } |
| 300 | return -1; // Indicates no match |
| 301 | } |
| 302 | |
| 303 | static inline int TagMapper_LookupCallerConfigured(const QCBORTagListIn *pCallerConfiguredTagMap, uint64_t uTag) |
| 304 | { |
| 305 | for(int nTagBitIndex = 0; nTagBitIndex < pCallerConfiguredTagMap->uNumTags; nTagBitIndex++) { |
| 306 | if(pCallerConfiguredTagMap->puTags[nTagBitIndex] == uTag) { |
| 307 | return nTagBitIndex + TAG_MAPPER_CUSTOM_TAGS_BASE_INDEX; |
| 308 | } |
| 309 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 310 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 311 | return -1; // Indicates no match |
| 312 | } |
| 313 | |
| 314 | /* |
| 315 | Find the tag bit index for a given tag value, or error out |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 316 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 317 | This and the above functions could probably be optimized and made |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 318 | clearer and neater. |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 319 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 320 | static QCBORError |
| 321 | TagMapper_Lookup(const QCBORTagListIn *pCallerConfiguredTagMap, |
| 322 | uint64_t uTag, |
| 323 | uint8_t *puTagBitIndex) |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 324 | { |
| 325 | int nTagBitIndex = TagMapper_LookupBuiltIn(uTag); |
| 326 | if(nTagBitIndex >= 0) { |
| 327 | // Cast is safe because TagMapper_LookupBuiltIn never returns > 47 |
| 328 | *puTagBitIndex = (uint8_t)nTagBitIndex; |
| 329 | return QCBOR_SUCCESS; |
| 330 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 331 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 332 | if(pCallerConfiguredTagMap) { |
| 333 | if(pCallerConfiguredTagMap->uNumTags > QCBOR_MAX_CUSTOM_TAGS) { |
| 334 | return QCBOR_ERR_TOO_MANY_TAGS; |
| 335 | } |
| 336 | nTagBitIndex = TagMapper_LookupCallerConfigured(pCallerConfiguredTagMap, uTag); |
| 337 | if(nTagBitIndex >= 0) { |
| 338 | // Cast is safe because TagMapper_LookupBuiltIn never returns > 63 |
| 339 | |
| 340 | *puTagBitIndex = (uint8_t)nTagBitIndex; |
| 341 | return QCBOR_SUCCESS; |
| 342 | } |
| 343 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 344 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 345 | return QCBOR_ERR_BAD_OPT_TAG; |
| 346 | } |
| 347 | |
| 348 | |
| 349 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 350 | /*=========================================================================== |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 351 | QCBORStringAllocate -- STRING ALLOCATOR INVOCATION |
| 352 | |
| 353 | The following four functions are pretty wrappers for invocation of |
| 354 | the string allocator supplied by the caller. |
| 355 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 356 | ===========================================================================*/ |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 357 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 358 | static inline void |
| 359 | StringAllocator_Free(const QCORInternalAllocator *pMe, void *pMem) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 360 | { |
| 361 | (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, 0); |
| 362 | } |
| 363 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 364 | // StringAllocator_Reallocate called with pMem NULL is |
| 365 | // equal to StringAllocator_Allocate() |
| 366 | static inline UsefulBuf |
| 367 | StringAllocator_Reallocate(const QCORInternalAllocator *pMe, |
| 368 | void *pMem, |
| 369 | size_t uSize) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 370 | { |
| 371 | return (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, uSize); |
| 372 | } |
| 373 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 374 | static inline UsefulBuf |
| 375 | StringAllocator_Allocate(const QCORInternalAllocator *pMe, size_t uSize) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 376 | { |
| 377 | return (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, uSize); |
| 378 | } |
| 379 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 380 | static inline void |
| 381 | StringAllocator_Destruct(const QCORInternalAllocator *pMe) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 382 | { |
| 383 | if(pMe->pfAllocator) { |
| 384 | (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, 0); |
| 385 | } |
| 386 | } |
| 387 | |
| 388 | |
| 389 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 390 | /*=========================================================================== |
| 391 | QCBORDecode -- The main implementation of CBOR decoding |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 392 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 393 | See qcbor.h for definition of the object used here: QCBORDecodeContext |
| 394 | ===========================================================================*/ |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 395 | /* |
| 396 | Public function, see header file |
| 397 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 398 | void QCBORDecode_Init(QCBORDecodeContext *me, |
| 399 | UsefulBufC EncodedCBOR, |
| 400 | QCBORDecodeMode nDecodeMode) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 401 | { |
| 402 | memset(me, 0, sizeof(QCBORDecodeContext)); |
| 403 | UsefulInputBuf_Init(&(me->InBuf), EncodedCBOR); |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 404 | // Don't bother with error check on decode mode. If a bad value is |
| 405 | // passed it will just act as if the default normal mode of 0 was set. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 406 | me->uDecodeMode = nDecodeMode; |
| 407 | DecodeNesting_Init(&(me->nesting)); |
| 408 | } |
| 409 | |
| 410 | |
| 411 | /* |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 412 | Public function, see header file |
| 413 | */ |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 414 | void QCBORDecode_SetUpAllocator(QCBORDecodeContext *pMe, |
| 415 | QCBORStringAllocate pfAllocateFunction, |
| 416 | void *pAllocateContext, |
| 417 | bool bAllStrings) |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 418 | { |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 419 | pMe->StringAllocator.pfAllocator = pfAllocateFunction; |
| 420 | pMe->StringAllocator.pAllocateCxt = pAllocateContext; |
| 421 | pMe->bStringAllocateAll = bAllStrings; |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 422 | } |
| 423 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 424 | |
| 425 | /* |
| 426 | Public function, see header file |
| 427 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 428 | void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *me, |
| 429 | const QCBORTagListIn *pTagList) |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 430 | { |
| 431 | me->pCallerConfiguredTagList = pTagList; |
| 432 | } |
| 433 | |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 434 | |
| 435 | /* |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 436 | This decodes the fundamental part of a CBOR data item, the type and |
| 437 | number |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 438 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 439 | This is the Counterpart to InsertEncodedTypeAndNumber(). |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 440 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 441 | This does the network->host byte order conversion. The conversion |
| 442 | here also results in the conversion for floats in addition to that |
| 443 | for lengths, tags and integer values. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 444 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 445 | This returns: |
| 446 | pnMajorType -- the major type for the item |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 447 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 448 | puArgument -- the "number" which is used a the value for integers, |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 449 | tags and floats and length for strings and arrays |
| 450 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 451 | pnAdditionalInfo -- Pass this along to know what kind of float or |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 452 | if length is indefinite |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 453 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 454 | The int type is preferred to uint8_t for some variables as this |
| 455 | avoids integer promotions, can reduce code size and makes |
| 456 | static analyzers happier. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 457 | */ |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 458 | inline static QCBORError DecodeTypeAndNumber(UsefulInputBuf *pUInBuf, |
| 459 | int *pnMajorType, |
| 460 | uint64_t *puArgument, |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 461 | int *pnAdditionalInfo) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 462 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 463 | QCBORError nReturn; |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 464 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 465 | // Get the initial byte that every CBOR data item has |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 466 | const int nInitialByte = (int)UsefulInputBuf_GetByte(pUInBuf); |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 467 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 468 | // Break down the initial byte |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 469 | const int nTmpMajorType = nInitialByte >> 5; |
| 470 | const int nAdditionalInfo = nInitialByte & 0x1f; |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 471 | |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 472 | // Where the number or argument accumulates |
| 473 | uint64_t uArgument; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 474 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 475 | if(nAdditionalInfo >= LEN_IS_ONE_BYTE && nAdditionalInfo <= LEN_IS_EIGHT_BYTES) { |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 476 | // Need to get 1,2,4 or 8 additional argument bytes Map |
| 477 | // LEN_IS_ONE_BYTE.. LEN_IS_EIGHT_BYTES to actual length |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 478 | static const uint8_t aIterate[] = {1,2,4,8}; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 479 | |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 480 | // Loop getting all the bytes in the argument |
| 481 | uArgument = 0; |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 482 | for(int i = aIterate[nAdditionalInfo - LEN_IS_ONE_BYTE]; i; i--) { |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 483 | // This shift and add gives the endian conversion |
| 484 | uArgument = (uArgument << 8) + UsefulInputBuf_GetByte(pUInBuf); |
| 485 | } |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 486 | } else if(nAdditionalInfo >= ADDINFO_RESERVED1 && nAdditionalInfo <= ADDINFO_RESERVED3) { |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 487 | // The reserved and thus-far unused additional info values |
| 488 | nReturn = QCBOR_ERR_UNSUPPORTED; |
| 489 | goto Done; |
| 490 | } else { |
| 491 | // Less than 24, additional info is argument or 31, an indefinite length |
| 492 | // No more bytes to get |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 493 | uArgument = (uint64_t)nAdditionalInfo; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 494 | } |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 495 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 496 | if(UsefulInputBuf_GetError(pUInBuf)) { |
| 497 | nReturn = QCBOR_ERR_HIT_END; |
| 498 | goto Done; |
| 499 | } |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 500 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 501 | // All successful if we got here. |
| 502 | nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 503 | *pnMajorType = nTmpMajorType; |
Laurence Lundblade | 4c0cf84 | 2019-01-12 03:25:44 -0800 | [diff] [blame] | 504 | *puArgument = uArgument; |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 505 | *pnAdditionalInfo = nAdditionalInfo; |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 506 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 507 | Done: |
| 508 | return nReturn; |
| 509 | } |
| 510 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 511 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 512 | /* |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 513 | CBOR doesn't explicitly specify two's compliment for integers but all |
| 514 | CPUs use it these days and the test vectors in the RFC are so. All |
| 515 | integers in the CBOR structure are positive and the major type |
| 516 | indicates positive or negative. CBOR can express positive integers |
| 517 | up to 2^x - 1 where x is the number of bits and negative integers |
| 518 | down to 2^x. Note that negative numbers can be one more away from |
| 519 | zero than positive. Stdint, as far as I can tell, uses two's |
| 520 | compliment to represent negative integers. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 521 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 522 | See http://www.unix.org/whitepapers/64bit.html for reasons int isn't |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 523 | used carefully here, and in particular why it isn't used in the interface. |
| 524 | Also see |
| 525 | https://stackoverflow.com/questions/17489857/why-is-int-typically-32-bit-on-64-bit-compilers |
| 526 | |
| 527 | Int is used for values that need less than 16-bits and would be subject |
| 528 | to integer promotion and complaining by static analyzers. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 529 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 530 | inline static QCBORError |
| 531 | DecodeInteger(int nMajorType, uint64_t uNumber, QCBORItem *pDecodedItem) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 532 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 533 | QCBORError nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 534 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 535 | if(nMajorType == CBOR_MAJOR_TYPE_POSITIVE_INT) { |
| 536 | if (uNumber <= INT64_MAX) { |
| 537 | pDecodedItem->val.int64 = (int64_t)uNumber; |
| 538 | pDecodedItem->uDataType = QCBOR_TYPE_INT64; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 539 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 540 | } else { |
| 541 | pDecodedItem->val.uint64 = uNumber; |
| 542 | pDecodedItem->uDataType = QCBOR_TYPE_UINT64; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 543 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 544 | } |
| 545 | } else { |
| 546 | if(uNumber <= INT64_MAX) { |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 547 | // CBOR's representation of negative numbers lines up with the |
| 548 | // two-compliment representation. A negative integer has one |
| 549 | // more in range than a positive integer. INT64_MIN is |
| 550 | // equal to (-INT64_MAX) - 1. |
| 551 | pDecodedItem->val.int64 = (-(int64_t)uNumber) - 1; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 552 | pDecodedItem->uDataType = QCBOR_TYPE_INT64; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 553 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 554 | } else { |
| 555 | // C can't represent a negative integer in this range |
Laurence Lundblade | 21d1d81 | 2019-09-28 22:47:49 -1000 | [diff] [blame] | 556 | // so it is an error. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 557 | nReturn = QCBOR_ERR_INT_OVERFLOW; |
| 558 | } |
| 559 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 560 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 561 | return nReturn; |
| 562 | } |
| 563 | |
| 564 | // Make sure #define value line up as DecodeSimple counts on this. |
| 565 | #if QCBOR_TYPE_FALSE != CBOR_SIMPLEV_FALSE |
| 566 | #error QCBOR_TYPE_FALSE macro value wrong |
| 567 | #endif |
| 568 | |
| 569 | #if QCBOR_TYPE_TRUE != CBOR_SIMPLEV_TRUE |
| 570 | #error QCBOR_TYPE_TRUE macro value wrong |
| 571 | #endif |
| 572 | |
| 573 | #if QCBOR_TYPE_NULL != CBOR_SIMPLEV_NULL |
| 574 | #error QCBOR_TYPE_NULL macro value wrong |
| 575 | #endif |
| 576 | |
| 577 | #if QCBOR_TYPE_UNDEF != CBOR_SIMPLEV_UNDEF |
| 578 | #error QCBOR_TYPE_UNDEF macro value wrong |
| 579 | #endif |
| 580 | |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 581 | #if QCBOR_TYPE_BREAK != CBOR_SIMPLE_BREAK |
| 582 | #error QCBOR_TYPE_BREAK macro value wrong |
| 583 | #endif |
| 584 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 585 | #if QCBOR_TYPE_DOUBLE != DOUBLE_PREC_FLOAT |
| 586 | #error QCBOR_TYPE_DOUBLE macro value wrong |
| 587 | #endif |
| 588 | |
| 589 | #if QCBOR_TYPE_FLOAT != SINGLE_PREC_FLOAT |
| 590 | #error QCBOR_TYPE_FLOAT macro value wrong |
| 591 | #endif |
| 592 | |
| 593 | /* |
| 594 | Decode true, false, floats, break... |
| 595 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 596 | inline static QCBORError |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 597 | DecodeSimple(int nAdditionalInfo, uint64_t uNumber, QCBORItem *pDecodedItem) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 598 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 599 | QCBORError nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 600 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 601 | // uAdditionalInfo is 5 bits from the initial byte compile time checks |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 602 | // above make sure uAdditionalInfo values line up with uDataType values. |
| 603 | // DecodeTypeAndNumber never returns a major type > 1f so cast is safe |
| 604 | pDecodedItem->uDataType = (uint8_t)nAdditionalInfo; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 605 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 606 | switch(nAdditionalInfo) { |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 607 | // No check for ADDINFO_RESERVED1 - ADDINFO_RESERVED3 as they are |
| 608 | // caught before this is called. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 609 | |
Laurence Lundblade | cc2ed34 | 2018-09-22 17:29:55 -0700 | [diff] [blame] | 610 | case HALF_PREC_FLOAT: |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 611 | #ifndef QCBOR_CONFIG_DISABLE_ENCODE_IEEE754 |
| 612 | // The caast to uint16_t is safe because the encoded value |
| 613 | // was 16 bits. It was widened to 64 bits to be passed in here. |
Laurence Lundblade | 67bd551 | 2018-11-02 21:44:06 +0700 | [diff] [blame] | 614 | pDecodedItem->val.dfnum = IEEE754_HalfToDouble((uint16_t)uNumber); |
| 615 | pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE; |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 616 | #else |
| 617 | nReturn = QCBOR_ERR_UNSUPPORTED; |
| 618 | #endif |
Laurence Lundblade | 12d32c5 | 2018-09-19 11:25:27 -0700 | [diff] [blame] | 619 | break; |
Laurence Lundblade | cc2ed34 | 2018-09-22 17:29:55 -0700 | [diff] [blame] | 620 | case SINGLE_PREC_FLOAT: |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 621 | #ifndef QCBOR_CONFIG_DISABLE_ENCODE_IEEE754 |
| 622 | // The caast to uint32_t is safe because the encoded value |
| 623 | // was 16 bits. It was widened to 64 bits to be passed in here. |
| 624 | pDecodedItem->val.dfnum = IEEE754_FloatToDouble((uint32_t)uNumber); |
| 625 | #else |
| 626 | pDecodedItem->val.fnum = UsefulBufUtil_CopyUint32ToFloat((uint32_t)uNumber); |
| 627 | pDecodedItem->uDataType = QCBOR_TYPE_FLOAT; |
| 628 | #endif |
Laurence Lundblade | 12d32c5 | 2018-09-19 11:25:27 -0700 | [diff] [blame] | 629 | break; |
| 630 | case DOUBLE_PREC_FLOAT: |
| 631 | pDecodedItem->val.dfnum = UsefulBufUtil_CopyUint64ToDouble(uNumber); |
Laurence Lundblade | 67bd551 | 2018-11-02 21:44:06 +0700 | [diff] [blame] | 632 | pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE; |
Laurence Lundblade | 12d32c5 | 2018-09-19 11:25:27 -0700 | [diff] [blame] | 633 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 634 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 635 | case CBOR_SIMPLEV_FALSE: // 20 |
| 636 | case CBOR_SIMPLEV_TRUE: // 21 |
| 637 | case CBOR_SIMPLEV_NULL: // 22 |
| 638 | case CBOR_SIMPLEV_UNDEF: // 23 |
Laurence Lundblade | 0f99d69 | 2018-09-26 14:39:28 -0700 | [diff] [blame] | 639 | case CBOR_SIMPLE_BREAK: // 31 |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 640 | break; // nothing to do |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 641 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 642 | case CBOR_SIMPLEV_ONEBYTE: // 24 |
| 643 | if(uNumber <= CBOR_SIMPLE_BREAK) { |
| 644 | // This takes out f8 00 ... f8 1f which should be encoded as e0 … f7 |
Laurence Lundblade | 077475f | 2019-04-26 09:06:33 -0700 | [diff] [blame] | 645 | nReturn = QCBOR_ERR_BAD_TYPE_7; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 646 | goto Done; |
| 647 | } |
Laurence Lundblade | 5e39082 | 2019-01-06 12:35:01 -0800 | [diff] [blame] | 648 | /* FALLTHROUGH */ |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 649 | // fall through intentionally |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 650 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 651 | default: // 0-19 |
| 652 | pDecodedItem->uDataType = QCBOR_TYPE_UKNOWN_SIMPLE; |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 653 | /* |
| 654 | DecodeTypeAndNumber will make uNumber equal to |
| 655 | uAdditionalInfo when uAdditionalInfo is < 24 This cast is |
| 656 | safe because the 2, 4 and 8 byte lengths of uNumber are in |
| 657 | the double/float cases above |
| 658 | */ |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 659 | pDecodedItem->val.uSimple = (uint8_t)uNumber; |
| 660 | break; |
| 661 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 662 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 663 | Done: |
| 664 | return nReturn; |
| 665 | } |
| 666 | |
| 667 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 668 | /* |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 669 | Decode text and byte strings. Call the string allocator if asked to. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 670 | */ |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 671 | inline static QCBORError DecodeBytes(const QCORInternalAllocator *pAllocator, |
| 672 | int nMajorType, |
| 673 | uint64_t uStrLen, |
| 674 | UsefulInputBuf *pUInBuf, |
| 675 | QCBORItem *pDecodedItem) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 676 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 677 | QCBORError nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 678 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 679 | // CBOR lengths can be 64 bits, but size_t is not 64 bits on all CPUs. |
| 680 | // This check makes the casts to size_t below safe. |
| 681 | |
| 682 | // 4 bytes less than the largest sizeof() so this can be tested by |
| 683 | // putting a SIZE_MAX length in the CBOR test input (no one will |
| 684 | // care the limit on strings is 4 bytes shorter). |
| 685 | if(uStrLen > SIZE_MAX-4) { |
| 686 | nReturn = QCBOR_ERR_STRING_TOO_LONG; |
| 687 | goto Done; |
| 688 | } |
| 689 | |
| 690 | const UsefulBufC Bytes = UsefulInputBuf_GetUsefulBuf(pUInBuf, (size_t)uStrLen); |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 691 | if(UsefulBuf_IsNULLC(Bytes)) { |
| 692 | // Failed to get the bytes for this string item |
| 693 | nReturn = QCBOR_ERR_HIT_END; |
| 694 | goto Done; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 695 | } |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 696 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 697 | if(pAllocator) { |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 698 | // We are asked to use string allocator to make a copy |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 699 | UsefulBuf NewMem = StringAllocator_Allocate(pAllocator, (size_t)uStrLen); |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 700 | if(UsefulBuf_IsNULL(NewMem)) { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 701 | nReturn = QCBOR_ERR_STRING_ALLOCATE; |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 702 | goto Done; |
| 703 | } |
| 704 | pDecodedItem->val.string = UsefulBuf_Copy(NewMem, Bytes); |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 705 | pDecodedItem->uDataAlloc = 1; |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 706 | } else { |
| 707 | // Normal case with no string allocator |
| 708 | pDecodedItem->val.string = Bytes; |
| 709 | } |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 710 | const bool bIsBstr = (nMajorType == CBOR_MAJOR_TYPE_BYTE_STRING); |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 711 | // Cast because ternary operator causes promotion to integer |
| 712 | pDecodedItem->uDataType = (uint8_t)(bIsBstr ? QCBOR_TYPE_BYTE_STRING |
| 713 | : QCBOR_TYPE_TEXT_STRING); |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 714 | |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 715 | Done: |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 716 | return nReturn; |
| 717 | } |
| 718 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 719 | |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 720 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 721 | |
| 722 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 723 | |
| 724 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 725 | // Make sure the constants align as this is assumed by |
| 726 | // the GetAnItem() implementation |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 727 | #if QCBOR_TYPE_ARRAY != CBOR_MAJOR_TYPE_ARRAY |
| 728 | #error QCBOR_TYPE_ARRAY value not lined up with major type |
| 729 | #endif |
| 730 | #if QCBOR_TYPE_MAP != CBOR_MAJOR_TYPE_MAP |
| 731 | #error QCBOR_TYPE_MAP value not lined up with major type |
| 732 | #endif |
| 733 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 734 | /* |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 735 | This gets a single data item and decodes it including preceding |
| 736 | optional tagging. This does not deal with arrays and maps and nesting |
| 737 | except to decode the data item introducing them. Arrays and maps are |
| 738 | handled at the next level up in GetNext(). |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 739 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 740 | Errors detected here include: an array that is too long to decode, |
| 741 | hit end of buffer unexpectedly, a few forms of invalid encoded CBOR |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 742 | */ |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 743 | static QCBORError GetNext_Item(UsefulInputBuf *pUInBuf, |
| 744 | QCBORItem *pDecodedItem, |
| 745 | const QCORInternalAllocator *pAllocator) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 746 | { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 747 | QCBORError nReturn; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 748 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 749 | /* |
| 750 | Get the major type and the number. Number could be length of more |
| 751 | bytes or the value depending on the major type nAdditionalInfo is |
| 752 | an encoding of the length of the uNumber and is needed to decode |
| 753 | floats and doubles |
| 754 | */ |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 755 | int nMajorType; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 756 | uint64_t uNumber; |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 757 | int nAdditionalInfo; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 758 | |
Laurence Lundblade | 4b09f63 | 2019-10-09 14:34:59 -0700 | [diff] [blame] | 759 | memset(pDecodedItem, 0, sizeof(QCBORItem)); |
| 760 | |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 761 | nReturn = DecodeTypeAndNumber(pUInBuf, &nMajorType, &uNumber, &nAdditionalInfo); |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 762 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 763 | // Error out here if we got into trouble on the type and number. The |
| 764 | // code after this will not work if the type and number is not good. |
Laurence Lundblade | 3a6042e | 2019-06-28 19:58:04 -0700 | [diff] [blame] | 765 | if(nReturn) { |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 766 | goto Done; |
Laurence Lundblade | 3a6042e | 2019-06-28 19:58:04 -0700 | [diff] [blame] | 767 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 768 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 769 | // At this point the major type and the value are valid. We've got |
| 770 | // the type and the number that starts every CBOR data item. |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 771 | switch (nMajorType) { |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 772 | case CBOR_MAJOR_TYPE_POSITIVE_INT: // Major type 0 |
| 773 | case CBOR_MAJOR_TYPE_NEGATIVE_INT: // Major type 1 |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 774 | if(nAdditionalInfo == LEN_IS_INDEFINITE) { |
Laurence Lundblade | 3a6042e | 2019-06-28 19:58:04 -0700 | [diff] [blame] | 775 | nReturn = QCBOR_ERR_BAD_INT; |
| 776 | } else { |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 777 | nReturn = DecodeInteger(nMajorType, uNumber, pDecodedItem); |
Laurence Lundblade | 3a6042e | 2019-06-28 19:58:04 -0700 | [diff] [blame] | 778 | } |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 779 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 780 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 781 | case CBOR_MAJOR_TYPE_BYTE_STRING: // Major type 2 |
| 782 | case CBOR_MAJOR_TYPE_TEXT_STRING: // Major type 3 |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 783 | if(nAdditionalInfo == LEN_IS_INDEFINITE) { |
| 784 | const bool bIsBstr = (nMajorType == CBOR_MAJOR_TYPE_BYTE_STRING); |
| 785 | pDecodedItem->uDataType = (uint8_t)(bIsBstr ? QCBOR_TYPE_BYTE_STRING |
| 786 | : QCBOR_TYPE_TEXT_STRING); |
Laurence Lundblade | a44d506 | 2018-10-17 18:45:12 +0530 | [diff] [blame] | 787 | pDecodedItem->val.string = (UsefulBufC){NULL, SIZE_MAX}; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 788 | } else { |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 789 | nReturn = DecodeBytes(pAllocator, nMajorType, uNumber, pUInBuf, pDecodedItem); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 790 | } |
| 791 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 792 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 793 | case CBOR_MAJOR_TYPE_ARRAY: // Major type 4 |
| 794 | case CBOR_MAJOR_TYPE_MAP: // Major type 5 |
| 795 | // Record the number of items in the array or map |
| 796 | if(uNumber > QCBOR_MAX_ITEMS_IN_ARRAY) { |
| 797 | nReturn = QCBOR_ERR_ARRAY_TOO_LONG; |
| 798 | goto Done; |
| 799 | } |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 800 | if(nAdditionalInfo == LEN_IS_INDEFINITE) { |
Laurence Lundblade | a44d506 | 2018-10-17 18:45:12 +0530 | [diff] [blame] | 801 | pDecodedItem->val.uCount = UINT16_MAX; // Indicate indefinite length |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 802 | } else { |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 803 | // type conversion OK because of check above |
| 804 | pDecodedItem->val.uCount = (uint16_t)uNumber; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 805 | } |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 806 | // C preproc #if above makes sure constants for major types align |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 807 | // DecodeTypeAndNumber never returns a major type > 7 so cast is safe |
| 808 | pDecodedItem->uDataType = (uint8_t)nMajorType; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 809 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 810 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 811 | case CBOR_MAJOR_TYPE_OPTIONAL: // Major type 6, optional prepended tags |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 812 | if(nAdditionalInfo == LEN_IS_INDEFINITE) { |
Laurence Lundblade | bb1062e | 2019-08-12 23:28:54 -0700 | [diff] [blame] | 813 | nReturn = QCBOR_ERR_BAD_INT; |
| 814 | } else { |
| 815 | pDecodedItem->val.uTagV = uNumber; |
| 816 | pDecodedItem->uDataType = QCBOR_TYPE_OPTTAG; |
| 817 | } |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 818 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 819 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 820 | case CBOR_MAJOR_TYPE_SIMPLE: |
| 821 | // Major type 7, float, double, true, false, null... |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 822 | nReturn = DecodeSimple(nAdditionalInfo, uNumber, pDecodedItem); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 823 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 824 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 825 | default: |
| 826 | // Never happens because DecodeTypeAndNumber() should never return > 7 |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 827 | nReturn = QCBOR_ERR_UNSUPPORTED; |
| 828 | break; |
| 829 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 830 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 831 | Done: |
| 832 | return nReturn; |
| 833 | } |
| 834 | |
| 835 | |
| 836 | |
| 837 | /* |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 838 | This layer deals with indefinite length strings. It pulls all the |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 839 | individual chunk items together into one QCBORItem using the string |
| 840 | allocator. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 841 | |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 842 | Code Reviewers: THIS FUNCTION DOES A LITTLE POINTER MATH |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 843 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 844 | static inline QCBORError |
| 845 | GetNext_FullItem(QCBORDecodeContext *me, QCBORItem *pDecodedItem) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 846 | { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 847 | // Stack usage; int/ptr 2 UsefulBuf 2 QCBORItem -- 96 |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 848 | QCBORError nReturn; |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 849 | const QCORInternalAllocator *pAllocator = me->StringAllocator.pfAllocator ? |
| 850 | &(me->StringAllocator) : |
| 851 | NULL; |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 852 | UsefulBufC FullString = NULLUsefulBufC; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 853 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 854 | nReturn = GetNext_Item(&(me->InBuf), |
| 855 | pDecodedItem, |
| 856 | me->bStringAllocateAll ? pAllocator: NULL); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 857 | if(nReturn) { |
| 858 | goto Done; |
| 859 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 860 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 861 | // To reduce code size by removing support for indefinite length strings, the |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 862 | // code in this function from here down can be eliminated. Run tests, except |
| 863 | // indefinite length string tests, to be sure all is OK if this is removed. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 864 | |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 865 | // Only do indefinite length processing on strings |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 866 | if(pDecodedItem->uDataType != QCBOR_TYPE_BYTE_STRING && |
| 867 | pDecodedItem->uDataType != QCBOR_TYPE_TEXT_STRING) { |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 868 | goto Done; // no need to do any work here on non-string types |
| 869 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 870 | |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 871 | // Is this a string with an indefinite length? |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 872 | if(pDecodedItem->val.string.len != SIZE_MAX) { |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 873 | goto Done; // length is not indefinite, so no work to do here |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 874 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 875 | |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 876 | // Can't do indefinite length strings without a string allocator |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 877 | if(pAllocator == NULL) { |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 878 | nReturn = QCBOR_ERR_NO_STRING_ALLOCATOR; |
| 879 | goto Done; |
| 880 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 881 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 882 | // There is an indefinite length string to work on... |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 883 | // Track which type of string it is |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 884 | const uint8_t uStringType = pDecodedItem->uDataType; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 885 | |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 886 | // Loop getting chunk of indefinite string |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 887 | for(;;) { |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 888 | // Get item for next chunk |
| 889 | QCBORItem StringChunkItem; |
| 890 | // NULL passed to never string alloc chunk of indefinite length strings |
Laurence Lundblade | fae26bf | 2019-02-18 11:15:43 -0800 | [diff] [blame] | 891 | nReturn = GetNext_Item(&(me->InBuf), &StringChunkItem, NULL); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 892 | if(nReturn) { |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 893 | break; // Error getting the next chunk |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 894 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 895 | |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 896 | // See if it is a marker at end of indefinite length string |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 897 | if(StringChunkItem.uDataType == QCBOR_TYPE_BREAK) { |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 898 | // String is complete |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 899 | pDecodedItem->val.string = FullString; |
Laurence Lundblade | 57dd144 | 2018-10-15 20:26:28 +0530 | [diff] [blame] | 900 | pDecodedItem->uDataAlloc = 1; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 901 | break; |
| 902 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 903 | |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 904 | // Match data type of chunk to type at beginning. |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 905 | // Also catches error of other non-string types that don't belong. |
Laurence Lundblade | bb1062e | 2019-08-12 23:28:54 -0700 | [diff] [blame] | 906 | // Also catches indefinite length strings inside indefinite length strings |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 907 | if(StringChunkItem.uDataType != uStringType || |
| 908 | StringChunkItem.val.string.len == SIZE_MAX) { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 909 | nReturn = QCBOR_ERR_INDEFINITE_STRING_CHUNK; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 910 | break; |
| 911 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 912 | |
Laurence Lundblade | 471a3fd | 2018-10-18 21:27:45 +0530 | [diff] [blame] | 913 | // Alloc new buffer or expand previously allocated buffer so it can fit |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 914 | // The first time throurgh FullString.ptr is NULL and this is |
| 915 | // equivalent to StringAllocator_Allocate() |
| 916 | UsefulBuf NewMem = StringAllocator_Reallocate(pAllocator, |
| 917 | UNCONST_POINTER(FullString.ptr), |
| 918 | FullString.len + StringChunkItem.val.string.len); |
| 919 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 920 | if(UsefulBuf_IsNULL(NewMem)) { |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 921 | // Allocation of memory for the string failed |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 922 | nReturn = QCBOR_ERR_STRING_ALLOCATE; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 923 | break; |
| 924 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 925 | |
Laurence Lundblade | 2a6850e | 2018-10-28 20:13:44 +0700 | [diff] [blame] | 926 | // Copy new string chunk at the end of string so far. |
| 927 | FullString = UsefulBuf_CopyOffset(NewMem, FullString.len, StringChunkItem.val.string); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 928 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 929 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 930 | Done: |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 931 | if(nReturn != QCBOR_SUCCESS && !UsefulBuf_IsNULLC(FullString)) { |
| 932 | // Getting the item failed, clean up the allocated memory |
| 933 | StringAllocator_Free(pAllocator, UNCONST_POINTER(FullString.ptr)); |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 934 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 935 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 936 | return nReturn; |
| 937 | } |
| 938 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 939 | |
| 940 | /* |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 941 | Gets all optional tag data items preceding a data item that is not an |
| 942 | optional tag and records them as bits in the tag map. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 943 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 944 | static QCBORError |
| 945 | GetNext_TaggedItem(QCBORDecodeContext *me, |
| 946 | QCBORItem *pDecodedItem, |
| 947 | QCBORTagListOut *pTags) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 948 | { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 949 | // Stack usage: int/ptr: 3 -- 24 |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 950 | QCBORError nReturn; |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 951 | uint64_t uTagBits = 0; |
| 952 | if(pTags) { |
| 953 | pTags->uNumUsed = 0; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 954 | } |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 955 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 956 | // Loop fetching items until the item fetched is not a tag |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 957 | for(;;) { |
| 958 | nReturn = GetNext_FullItem(me, pDecodedItem); |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 959 | if(nReturn) { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 960 | goto Done; // Error out of the loop |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 961 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 962 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 963 | if(pDecodedItem->uDataType != QCBOR_TYPE_OPTTAG) { |
| 964 | // Successful exit from loop; maybe got some tags, maybe not |
| 965 | pDecodedItem->uTagBits = uTagBits; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 966 | break; |
| 967 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 968 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 969 | uint8_t uTagBitIndex; |
| 970 | // Tag was mapped, tag was not mapped, error with tag list |
| 971 | switch(TagMapper_Lookup(me->pCallerConfiguredTagList, pDecodedItem->val.uTagV, &uTagBitIndex)) { |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 972 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 973 | case QCBOR_SUCCESS: |
| 974 | // Successfully mapped the tag |
| 975 | uTagBits |= 0x01ULL << uTagBitIndex; |
| 976 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 977 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 978 | case QCBOR_ERR_BAD_OPT_TAG: |
| 979 | // Tag is not recognized. Do nothing |
| 980 | break; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 981 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 982 | default: |
| 983 | // Error Condition |
| 984 | goto Done; |
| 985 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 986 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 987 | if(pTags) { |
| 988 | // Caller wants all tags recorded in the provided buffer |
| 989 | if(pTags->uNumUsed >= pTags->uNumAllocated) { |
| 990 | nReturn = QCBOR_ERR_TOO_MANY_TAGS; |
| 991 | goto Done; |
| 992 | } |
| 993 | pTags->puTags[pTags->uNumUsed] = pDecodedItem->val.uTagV; |
| 994 | pTags->uNumUsed++; |
| 995 | } |
| 996 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 997 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 998 | Done: |
| 999 | return nReturn; |
| 1000 | } |
| 1001 | |
| 1002 | |
| 1003 | /* |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1004 | This layer takes care of map entries. It combines the label and data |
| 1005 | items into one QCBORItem. |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1006 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1007 | static inline QCBORError |
| 1008 | GetNext_MapEntry(QCBORDecodeContext *me, |
| 1009 | QCBORItem *pDecodedItem, |
| 1010 | QCBORTagListOut *pTags) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1011 | { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1012 | // Stack use: int/ptr 1, QCBORItem -- 56 |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1013 | QCBORError nReturn = GetNext_TaggedItem(me, pDecodedItem, pTags); |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1014 | if(nReturn) |
| 1015 | goto Done; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1016 | |
Laurence Lundblade | 742df4a | 2018-10-13 20:07:17 +0800 | [diff] [blame] | 1017 | if(pDecodedItem->uDataType == QCBOR_TYPE_BREAK) { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1018 | // Break can't be a map entry |
Laurence Lundblade | 742df4a | 2018-10-13 20:07:17 +0800 | [diff] [blame] | 1019 | goto Done; |
| 1020 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1021 | |
Laurence Lundblade | d61cbf3 | 2018-12-09 11:42:21 -0800 | [diff] [blame] | 1022 | if(me->uDecodeMode != QCBOR_DECODE_MODE_MAP_AS_ARRAY) { |
| 1023 | // In a map and caller wants maps decoded, not treated as arrays |
| 1024 | |
| 1025 | if(DecodeNesting_TypeIsMap(&(me->nesting))) { |
| 1026 | // If in a map and the right decoding mode, get the label |
| 1027 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1028 | // Save label in pDecodedItem and get the next which will |
| 1029 | // be the real data |
Laurence Lundblade | ccfb8cd | 2018-12-07 21:11:30 +0900 | [diff] [blame] | 1030 | QCBORItem LabelItem = *pDecodedItem; |
| 1031 | nReturn = GetNext_TaggedItem(me, pDecodedItem, pTags); |
| 1032 | if(nReturn) |
| 1033 | goto Done; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1034 | |
Laurence Lundblade | 57dd144 | 2018-10-15 20:26:28 +0530 | [diff] [blame] | 1035 | pDecodedItem->uLabelAlloc = LabelItem.uDataAlloc; |
Laurence Lundblade | ccfb8cd | 2018-12-07 21:11:30 +0900 | [diff] [blame] | 1036 | |
| 1037 | if(LabelItem.uDataType == QCBOR_TYPE_TEXT_STRING) { |
| 1038 | // strings are always good labels |
| 1039 | pDecodedItem->label.string = LabelItem.val.string; |
| 1040 | pDecodedItem->uLabelType = QCBOR_TYPE_TEXT_STRING; |
| 1041 | } else if (QCBOR_DECODE_MODE_MAP_STRINGS_ONLY == me->uDecodeMode) { |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1042 | // It's not a string and we only want strings |
Laurence Lundblade | ccfb8cd | 2018-12-07 21:11:30 +0900 | [diff] [blame] | 1043 | nReturn = QCBOR_ERR_MAP_LABEL_TYPE; |
| 1044 | goto Done; |
| 1045 | } else if(LabelItem.uDataType == QCBOR_TYPE_INT64) { |
| 1046 | pDecodedItem->label.int64 = LabelItem.val.int64; |
| 1047 | pDecodedItem->uLabelType = QCBOR_TYPE_INT64; |
| 1048 | } else if(LabelItem.uDataType == QCBOR_TYPE_UINT64) { |
| 1049 | pDecodedItem->label.uint64 = LabelItem.val.uint64; |
| 1050 | pDecodedItem->uLabelType = QCBOR_TYPE_UINT64; |
| 1051 | } else if(LabelItem.uDataType == QCBOR_TYPE_BYTE_STRING) { |
| 1052 | pDecodedItem->label.string = LabelItem.val.string; |
| 1053 | pDecodedItem->uLabelAlloc = LabelItem.uDataAlloc; |
| 1054 | pDecodedItem->uLabelType = QCBOR_TYPE_BYTE_STRING; |
| 1055 | } else { |
| 1056 | // label is not an int or a string. It is an arrray |
| 1057 | // or a float or such and this implementation doesn't handle that. |
| 1058 | // Also, tags on labels are ignored. |
| 1059 | nReturn = QCBOR_ERR_MAP_LABEL_TYPE; |
| 1060 | goto Done; |
| 1061 | } |
Laurence Lundblade | d61cbf3 | 2018-12-09 11:42:21 -0800 | [diff] [blame] | 1062 | } |
| 1063 | } else { |
| 1064 | if(pDecodedItem->uDataType == QCBOR_TYPE_MAP) { |
| 1065 | // Decoding a map as an array |
| 1066 | pDecodedItem->uDataType = QCBOR_TYPE_MAP_AS_ARRAY; |
| 1067 | pDecodedItem->val.uCount *= 2; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1068 | } |
| 1069 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1070 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1071 | Done: |
| 1072 | return nReturn; |
| 1073 | } |
| 1074 | |
| 1075 | |
| 1076 | /* |
| 1077 | Public function, see header qcbor.h file |
| 1078 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1079 | QCBORError QCBORDecode_GetNextMapOrArray(QCBORDecodeContext *me, |
| 1080 | QCBORItem *pDecodedItem, |
| 1081 | QCBORTagListOut *pTags) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1082 | { |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1083 | // Stack ptr/int: 2, QCBORItem : 64 |
| 1084 | |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 1085 | // The public entry point for fetching and parsing the next QCBORItem. |
| 1086 | // All the CBOR parsing work is here and in subordinate calls. |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1087 | QCBORError nReturn; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1088 | |
Laurence Lundblade | bb1062e | 2019-08-12 23:28:54 -0700 | [diff] [blame] | 1089 | // Check if there are an |
| 1090 | if(UsefulInputBuf_BytesUnconsumed(&(me->InBuf)) == 0 && !DecodeNesting_IsNested(&(me->nesting))) { |
| 1091 | nReturn = QCBOR_ERR_NO_MORE_ITEMS; |
| 1092 | goto Done; |
| 1093 | } |
| 1094 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1095 | nReturn = GetNext_MapEntry(me, pDecodedItem, pTags); |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 1096 | if(nReturn) { |
| 1097 | goto Done; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1098 | } |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 1099 | |
| 1100 | // Break ending arrays/maps are always processed at the end of this function. |
| 1101 | // They should never show up here. |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1102 | if(pDecodedItem->uDataType == QCBOR_TYPE_BREAK) { |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1103 | nReturn = QCBOR_ERR_BAD_BREAK; |
| 1104 | goto Done; |
Laurence Lundblade | 5b8c585 | 2018-10-14 21:11:42 +0530 | [diff] [blame] | 1105 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1106 | |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1107 | // Record the nesting level for this data item before processing any of |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 1108 | // decrementing and descending. |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1109 | pDecodedItem->uNestingLevel = DecodeNesting_GetLevel(&(me->nesting)); |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1110 | |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1111 | // Process the item just received for descent or decrement, and |
| 1112 | // ascent if decrements are enough to close out a definite length array/map |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 1113 | if(IsMapOrArray(pDecodedItem->uDataType)) { |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 1114 | // If the new item is array or map, the nesting level descends |
Laurence Lundblade | 3a760b0 | 2018-10-08 13:46:03 +0800 | [diff] [blame] | 1115 | nReturn = DecodeNesting_Descend(&(me->nesting), pDecodedItem); |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 1116 | // Maps and arrays do count in as items in the map/array that encloses |
| 1117 | // them so a decrement needs to be done for them too, but that is done |
| 1118 | // only when all the items in them have been processed, not when they |
Laurence Lundblade | 9916b1b | 2019-09-07 22:33:25 -0700 | [diff] [blame] | 1119 | // are opened with the exception of an empty map or array. |
| 1120 | if(pDecodedItem->val.uCount == 0) { |
| 1121 | DecodeNesting_DecrementCount(&(me->nesting)); |
| 1122 | } |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 1123 | } else { |
| 1124 | // Decrement the count of items in the enclosing map/array |
| 1125 | // If the count in the enclosing map/array goes to zero, that |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1126 | // triggers a decrement in the map/array above that and |
| 1127 | // an ascend in nesting level. |
Laurence Lundblade | 9e3651c | 2018-10-10 11:49:55 +0800 | [diff] [blame] | 1128 | DecodeNesting_DecrementCount(&(me->nesting)); |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1129 | } |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1130 | if(nReturn) { |
| 1131 | goto Done; |
| 1132 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1133 | |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1134 | // For indefinite length maps/arrays, looking at any and |
| 1135 | // all breaks that might terminate them. The equivalent |
| 1136 | // for definite length maps/arrays happens in |
| 1137 | // DecodeNesting_DecrementCount(). |
| 1138 | if(DecodeNesting_IsNested(&(me->nesting)) && DecodeNesting_IsIndefiniteLength(&(me->nesting))) { |
| 1139 | while(UsefulInputBuf_BytesUnconsumed(&(me->InBuf))) { |
| 1140 | // Peek forward one item to see if it is a break. |
| 1141 | QCBORItem Peek; |
| 1142 | size_t uPeek = UsefulInputBuf_Tell(&(me->InBuf)); |
| 1143 | nReturn = GetNext_Item(&(me->InBuf), &Peek, NULL); |
| 1144 | if(nReturn) { |
| 1145 | goto Done; |
| 1146 | } |
| 1147 | if(Peek.uDataType != QCBOR_TYPE_BREAK) { |
| 1148 | // It is not a break, rewind so it can be processed normally. |
| 1149 | UsefulInputBuf_Seek(&(me->InBuf), uPeek); |
| 1150 | break; |
| 1151 | } |
| 1152 | // It is a break. Ascend one nesting level. |
Laurence Lundblade | 7e0d13b | 2018-10-16 19:54:13 +0530 | [diff] [blame] | 1153 | // The break is consumed. |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1154 | nReturn = DecodeNesting_BreakAscend(&(me->nesting)); |
| 1155 | if(nReturn) { |
| 1156 | // break occured outside of an indefinite length array/map |
| 1157 | goto Done; |
| 1158 | } |
| 1159 | } |
| 1160 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1161 | |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1162 | // Tell the caller what level is next. This tells them what maps/arrays |
| 1163 | // were closed out and makes it possible for them to reconstruct |
| 1164 | // the tree with just the information returned by GetNext |
| 1165 | pDecodedItem->uNextNestLevel = DecodeNesting_GetLevel(&(me->nesting)); |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1166 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1167 | Done: |
Laurence Lundblade | e9482dd | 2019-10-11 12:58:46 -0700 | [diff] [blame] | 1168 | if(nReturn != QCBOR_SUCCESS) { |
| 1169 | // Make sure uDataType and uLabelType are QCBOR_TYPE_NONE |
| 1170 | memset(pDecodedItem, 0, sizeof(QCBORItem)); |
| 1171 | } |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1172 | return nReturn; |
| 1173 | } |
| 1174 | |
| 1175 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1176 | /* |
| 1177 | Mostly just assign the right data type for the date string. |
| 1178 | */ |
| 1179 | inline static QCBORError DecodeDateString(QCBORItem *pDecodedItem) |
| 1180 | { |
| 1181 | // Stack Use: UsefulBuf 1 16 |
| 1182 | if(pDecodedItem->uDataType != QCBOR_TYPE_TEXT_STRING) { |
| 1183 | return QCBOR_ERR_BAD_OPT_TAG; |
| 1184 | } |
| 1185 | |
| 1186 | const UsefulBufC Temp = pDecodedItem->val.string; |
| 1187 | pDecodedItem->val.dateString = Temp; |
| 1188 | pDecodedItem->uDataType = QCBOR_TYPE_DATE_STRING; |
| 1189 | return QCBOR_SUCCESS; |
| 1190 | } |
| 1191 | |
| 1192 | |
| 1193 | /* |
| 1194 | Mostly just assign the right data type for the bignum. |
| 1195 | */ |
| 1196 | inline static QCBORError DecodeBigNum(QCBORItem *pDecodedItem) |
| 1197 | { |
| 1198 | // Stack Use: UsefulBuf 1 -- 16 |
| 1199 | if(pDecodedItem->uDataType != QCBOR_TYPE_BYTE_STRING) { |
| 1200 | return QCBOR_ERR_BAD_OPT_TAG; |
| 1201 | } |
| 1202 | const UsefulBufC Temp = pDecodedItem->val.string; |
| 1203 | pDecodedItem->val.bigNum = Temp; |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1204 | const bool bIsPosBigNum = (bool)(pDecodedItem->uTagBits & QCBOR_TAGFLAG_POS_BIGNUM); |
Laurence Lundblade | c5fef68 | 2020-01-25 11:38:45 -0800 | [diff] [blame] | 1205 | pDecodedItem->uDataType = (uint8_t)(bIsPosBigNum ? QCBOR_TYPE_POSBIGNUM |
| 1206 | : QCBOR_TYPE_NEGBIGNUM); |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1207 | return QCBOR_SUCCESS; |
| 1208 | } |
| 1209 | |
| 1210 | |
| 1211 | /* |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1212 | The epoch formatted date. Turns lots of different forms of encoding |
| 1213 | date into uniform one |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1214 | */ |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 1215 | static QCBORError DecodeDateEpoch(QCBORItem *pDecodedItem) |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1216 | { |
| 1217 | // Stack usage: 1 |
| 1218 | QCBORError nReturn = QCBOR_SUCCESS; |
| 1219 | |
| 1220 | pDecodedItem->val.epochDate.fSecondsFraction = 0; |
| 1221 | |
| 1222 | switch (pDecodedItem->uDataType) { |
| 1223 | |
| 1224 | case QCBOR_TYPE_INT64: |
| 1225 | pDecodedItem->val.epochDate.nSeconds = pDecodedItem->val.int64; |
| 1226 | break; |
| 1227 | |
| 1228 | case QCBOR_TYPE_UINT64: |
| 1229 | if(pDecodedItem->val.uint64 > INT64_MAX) { |
| 1230 | nReturn = QCBOR_ERR_DATE_OVERFLOW; |
| 1231 | goto Done; |
| 1232 | } |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 1233 | pDecodedItem->val.epochDate.nSeconds = (int64_t)pDecodedItem->val.uint64; |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1234 | break; |
| 1235 | |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1236 | // TODO: test this with float and half input |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1237 | case QCBOR_TYPE_DOUBLE: |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1238 | case QCBOR_TYPE_FLOAT: |
| 1239 | #ifndef QCBOR_DISABLE_FLOAT_HW_USE |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1240 | { |
| 1241 | // This comparison needs to be done as a float before |
| 1242 | // conversion to an int64_t to be able to detect doubles |
| 1243 | // that are too large to fit into an int64_t. A double |
| 1244 | // has 52 bits of preceision. An int64_t has 63. Casting |
| 1245 | // INT64_MAX to a double actually causes a round up which |
| 1246 | // is bad and wrong for the comparison because it will |
| 1247 | // allow conversion of doubles that can't fit into a |
| 1248 | // uint64_t. To remedy this INT64_MAX - 0x7ff is used as |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1249 | // the cutoff point because if that value rounds up in conversion to |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1250 | // double it will still be less than INT64_MAX. 0x7ff is |
| 1251 | // picked because it has 11 bits set. |
| 1252 | // |
| 1253 | // INT64_MAX seconds is on the order of 10 billion years, |
| 1254 | // and the earth is less than 5 billion years old, so for |
| 1255 | // most uses this conversion error won't occur even though |
| 1256 | // doubles can go much larger. |
| 1257 | // |
| 1258 | // Without the 0x7ff there is a ~30 minute range of time |
| 1259 | // values 10 billion years in the past and in the future |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1260 | // where this this code would go wrong and some compilers |
| 1261 | // will generate warnings or errors. |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1262 | const double d = pDecodedItem->val.dfnum; |
| 1263 | if(d > (double)(INT64_MAX - 0x7ff)) { |
| 1264 | nReturn = QCBOR_ERR_DATE_OVERFLOW; |
| 1265 | goto Done; |
| 1266 | } |
| 1267 | pDecodedItem->val.epochDate.nSeconds = (int64_t)d; |
| 1268 | pDecodedItem->val.epochDate.fSecondsFraction = d - (double)pDecodedItem->val.epochDate.nSeconds; |
| 1269 | } |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1270 | #else |
| 1271 | /* Disabling float support causes a floating point |
| 1272 | data to error in the default below. The above code |
| 1273 | requires floating point conversion to integers and |
| 1274 | comparison which requires either floating point HW |
| 1275 | or a SW library. */ |
| 1276 | |
| 1277 | nReturn = QCBOR_ERR_FLOAT_DATE_UNSUPPORTED; |
| 1278 | #endif /* QCBOR_DISABLE_FLOAT_HW_USE */ |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1279 | break; |
| 1280 | |
Laurence Lundblade | 9682a53 | 2020-06-06 18:33:04 -0700 | [diff] [blame^] | 1281 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1282 | default: |
| 1283 | nReturn = QCBOR_ERR_BAD_OPT_TAG; |
| 1284 | goto Done; |
| 1285 | } |
| 1286 | pDecodedItem->uDataType = QCBOR_TYPE_DATE_EPOCH; |
| 1287 | |
| 1288 | Done: |
| 1289 | return nReturn; |
| 1290 | } |
| 1291 | |
| 1292 | |
| 1293 | #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA |
| 1294 | /* |
| 1295 | Decode decimal fractions and big floats. |
| 1296 | |
| 1297 | When called pDecodedItem must be the array that is tagged as a big |
| 1298 | float or decimal fraction, the array that has the two members, the |
| 1299 | exponent and mantissa. |
| 1300 | |
| 1301 | This will fetch and decode the exponent and mantissa and put the |
| 1302 | result back into pDecodedItem. |
| 1303 | */ |
| 1304 | inline static QCBORError |
| 1305 | QCBORDecode_MantissaAndExponent(QCBORDecodeContext *me, QCBORItem *pDecodedItem) |
| 1306 | { |
| 1307 | QCBORError nReturn; |
| 1308 | |
| 1309 | // --- Make sure it is an array; track nesting level of members --- |
| 1310 | if(pDecodedItem->uDataType != QCBOR_TYPE_ARRAY) { |
| 1311 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1312 | goto Done; |
| 1313 | } |
| 1314 | |
| 1315 | // A check for pDecodedItem->val.uCount == 2 would work for |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1316 | // definite length arrays, but not for indefnite. Instead remember |
| 1317 | // the nesting level the two integers must be at, which is one |
| 1318 | // deeper than that of the array. |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1319 | const int nNestLevel = pDecodedItem->uNestingLevel + 1; |
| 1320 | |
| 1321 | // --- Is it a decimal fraction or a bigfloat? --- |
| 1322 | const bool bIsTaggedDecimalFraction = QCBORDecode_IsTagged(me, pDecodedItem, CBOR_TAG_DECIMAL_FRACTION); |
| 1323 | pDecodedItem->uDataType = bIsTaggedDecimalFraction ? QCBOR_TYPE_DECIMAL_FRACTION : QCBOR_TYPE_BIGFLOAT; |
| 1324 | |
| 1325 | // --- Get the exponent --- |
| 1326 | QCBORItem exponentItem; |
| 1327 | nReturn = QCBORDecode_GetNextMapOrArray(me, &exponentItem, NULL); |
| 1328 | if(nReturn != QCBOR_SUCCESS) { |
| 1329 | goto Done; |
| 1330 | } |
| 1331 | if(exponentItem.uNestingLevel != nNestLevel) { |
| 1332 | // Array is empty or a map/array encountered when expecting an int |
| 1333 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1334 | goto Done; |
| 1335 | } |
| 1336 | if(exponentItem.uDataType == QCBOR_TYPE_INT64) { |
| 1337 | // Data arriving as an unsigned int < INT64_MAX has been converted |
| 1338 | // to QCBOR_TYPE_INT64 and thus handled here. This is also means |
| 1339 | // that the only data arriving here of type QCBOR_TYPE_UINT64 data |
| 1340 | // will be too large for this to handle and thus an error that will |
| 1341 | // get handled in the next else. |
| 1342 | pDecodedItem->val.expAndMantissa.nExponent = exponentItem.val.int64; |
| 1343 | } else { |
| 1344 | // Wrong type of exponent or a QCBOR_TYPE_UINT64 > INT64_MAX |
| 1345 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1346 | goto Done; |
| 1347 | } |
| 1348 | |
| 1349 | // --- Get the mantissa --- |
| 1350 | QCBORItem mantissaItem; |
| 1351 | nReturn = QCBORDecode_GetNextWithTags(me, &mantissaItem, NULL); |
| 1352 | if(nReturn != QCBOR_SUCCESS) { |
| 1353 | goto Done; |
| 1354 | } |
| 1355 | if(mantissaItem.uNestingLevel != nNestLevel) { |
| 1356 | // Mantissa missing or map/array encountered when expecting number |
| 1357 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1358 | goto Done; |
| 1359 | } |
| 1360 | if(mantissaItem.uDataType == QCBOR_TYPE_INT64) { |
| 1361 | // Data arriving as an unsigned int < INT64_MAX has been converted |
| 1362 | // to QCBOR_TYPE_INT64 and thus handled here. This is also means |
| 1363 | // that the only data arriving here of type QCBOR_TYPE_UINT64 data |
| 1364 | // will be too large for this to handle and thus an error that |
| 1365 | // will get handled in an else below. |
| 1366 | pDecodedItem->val.expAndMantissa.Mantissa.nInt = mantissaItem.val.int64; |
| 1367 | } else if(mantissaItem.uDataType == QCBOR_TYPE_POSBIGNUM || mantissaItem.uDataType == QCBOR_TYPE_NEGBIGNUM) { |
| 1368 | // Got a good big num mantissa |
| 1369 | pDecodedItem->val.expAndMantissa.Mantissa.bigNum = mantissaItem.val.bigNum; |
| 1370 | // Depends on numbering of QCBOR_TYPE_XXX |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 1371 | pDecodedItem->uDataType = (uint8_t)(pDecodedItem->uDataType + |
| 1372 | mantissaItem.uDataType - QCBOR_TYPE_POSBIGNUM + |
| 1373 | 1); |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1374 | } else { |
| 1375 | // Wrong type of mantissa or a QCBOR_TYPE_UINT64 > INT64_MAX |
| 1376 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1377 | goto Done; |
| 1378 | } |
| 1379 | |
| 1380 | // --- Check that array only has the two numbers --- |
| 1381 | if(mantissaItem.uNextNestLevel == nNestLevel) { |
| 1382 | // Extra items in the decimal fraction / big num |
| 1383 | nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA; |
| 1384 | goto Done; |
| 1385 | } |
| 1386 | |
| 1387 | Done: |
| 1388 | |
| 1389 | return nReturn; |
| 1390 | } |
| 1391 | #endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */ |
| 1392 | |
| 1393 | |
| 1394 | /* |
| 1395 | Public function, see header qcbor.h file |
| 1396 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1397 | QCBORError |
| 1398 | QCBORDecode_GetNextWithTags(QCBORDecodeContext *me, |
| 1399 | QCBORItem *pDecodedItem, |
| 1400 | QCBORTagListOut *pTags) |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1401 | { |
| 1402 | QCBORError nReturn; |
| 1403 | |
| 1404 | nReturn = QCBORDecode_GetNextMapOrArray(me, pDecodedItem, pTags); |
| 1405 | if(nReturn != QCBOR_SUCCESS) { |
| 1406 | goto Done; |
| 1407 | } |
| 1408 | |
| 1409 | #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA |
| 1410 | #define TAG_MAPPER_FIRST_XXX TAG_MAPPER_FIRST_SIX |
| 1411 | #else |
| 1412 | #define TAG_MAPPER_FIRST_XXX TAG_MAPPER_FIRST_FOUR |
| 1413 | #endif |
| 1414 | |
| 1415 | // Only pay attention to tags this code knows how to decode. |
| 1416 | switch(pDecodedItem->uTagBits & TAG_MAPPER_FIRST_XXX) { |
| 1417 | case 0: |
| 1418 | // No tags at all or none we know about. Nothing to do. |
| 1419 | // This is the pass-through path of this function |
| 1420 | // that will mostly be taken when decoding any item. |
| 1421 | break; |
| 1422 | |
| 1423 | case QCBOR_TAGFLAG_DATE_STRING: |
| 1424 | nReturn = DecodeDateString(pDecodedItem); |
| 1425 | break; |
| 1426 | |
| 1427 | case QCBOR_TAGFLAG_DATE_EPOCH: |
| 1428 | nReturn = DecodeDateEpoch(pDecodedItem); |
| 1429 | break; |
| 1430 | |
| 1431 | case QCBOR_TAGFLAG_POS_BIGNUM: |
| 1432 | case QCBOR_TAGFLAG_NEG_BIGNUM: |
| 1433 | nReturn = DecodeBigNum(pDecodedItem); |
| 1434 | break; |
| 1435 | |
| 1436 | #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA |
| 1437 | case QCBOR_TAGFLAG_DECIMAL_FRACTION: |
| 1438 | case QCBOR_TAGFLAG_BIGFLOAT: |
| 1439 | // For aggregate tagged types, what goes into pTags is only collected |
| 1440 | // from the surrounding data item, not the contents, so pTags is not |
| 1441 | // passed on here. |
| 1442 | |
| 1443 | nReturn = QCBORDecode_MantissaAndExponent(me, pDecodedItem); |
| 1444 | break; |
| 1445 | #endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */ |
| 1446 | |
| 1447 | default: |
| 1448 | // Encountering some mixed-up CBOR like something that |
| 1449 | // is tagged as both a string and integer date. |
| 1450 | nReturn = QCBOR_ERR_BAD_OPT_TAG; |
| 1451 | } |
| 1452 | |
| 1453 | Done: |
| 1454 | if(nReturn != QCBOR_SUCCESS) { |
| 1455 | pDecodedItem->uDataType = QCBOR_TYPE_NONE; |
| 1456 | pDecodedItem->uLabelType = QCBOR_TYPE_NONE; |
| 1457 | } |
| 1458 | return nReturn; |
| 1459 | } |
| 1460 | |
| 1461 | |
| 1462 | /* |
| 1463 | Public function, see header qcbor.h file |
| 1464 | */ |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1465 | QCBORError QCBORDecode_GetNext(QCBORDecodeContext *me, QCBORItem *pDecodedItem) |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1466 | { |
| 1467 | return QCBORDecode_GetNextWithTags(me, pDecodedItem, NULL); |
| 1468 | } |
| 1469 | |
| 1470 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1471 | /* |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1472 | Decoding items is done in 5 layered functions, one calling the |
Laurence Lundblade | 0fb2f64 | 2018-10-11 19:33:35 +0530 | [diff] [blame] | 1473 | next one down. If a layer has no work to do for a particular item |
| 1474 | it returns quickly. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1475 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1476 | - QCBORDecode_GetNext, GetNextWithTags -- The top layer processes |
| 1477 | tagged data items, turning them into the local C representation. |
| 1478 | For the most simple it is just associating a QCBOR_TYPE with the data. For |
| 1479 | the complex ones that an aggregate of data items, there is some further |
| 1480 | decoding and a little bit of recursion. |
| 1481 | |
| 1482 | - QCBORDecode_GetNextMapOrArray - This manages the beginnings and |
Laurence Lundblade | 0fb2f64 | 2018-10-11 19:33:35 +0530 | [diff] [blame] | 1483 | ends of maps and arrays. It tracks descending into and ascending |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1484 | out of maps/arrays. It processes all breaks that terminate |
| 1485 | maps and arrays. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1486 | |
Laurence Lundblade | 0fb2f64 | 2018-10-11 19:33:35 +0530 | [diff] [blame] | 1487 | - GetNext_MapEntry -- This handles the combining of two |
| 1488 | items, the label and the data, that make up a map entry. |
| 1489 | It only does work on maps. It combines the label and data |
| 1490 | items into one labeled item. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1491 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1492 | - GetNext_TaggedItem -- This decodes type 6 tagging. It turns the |
| 1493 | tags into bit flags associated with the data item. No actual decoding |
| 1494 | of the contents of the tagged item is performed here. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1495 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1496 | - GetNext_FullItem -- This assembles the sub-items that make up |
Laurence Lundblade | 0fb2f64 | 2018-10-11 19:33:35 +0530 | [diff] [blame] | 1497 | an indefinte length string into one string item. It uses the |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1498 | string allocater to create contiguous space for the item. It |
| 1499 | processes all breaks that are part of indefinite length strings. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1500 | |
Laurence Lundblade | 59289e5 | 2019-12-30 13:44:37 -0800 | [diff] [blame] | 1501 | - GetNext_Item -- This decodes the atomic data items in CBOR. Each |
| 1502 | atomic data item has a "major type", an integer "argument" and optionally |
| 1503 | some content. For text and byte strings, the content is the bytes |
| 1504 | that make up the string. These are the smallest data items that are |
| 1505 | considered to be well-formed. The content may also be other data items in |
| 1506 | the case of aggregate types. They are not handled in this layer. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1507 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1508 | Roughly this takes 300 bytes of stack for vars. Need to |
| 1509 | evaluate this more carefully and correctly. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1510 | |
Laurence Lundblade | 0fb2f64 | 2018-10-11 19:33:35 +0530 | [diff] [blame] | 1511 | */ |
| 1512 | |
| 1513 | |
| 1514 | /* |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1515 | Public function, see header qcbor.h file |
| 1516 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1517 | int QCBORDecode_IsTagged(QCBORDecodeContext *me, |
| 1518 | const QCBORItem *pItem, |
| 1519 | uint64_t uTag) |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1520 | { |
| 1521 | const QCBORTagListIn *pCallerConfiguredTagMap = me->pCallerConfiguredTagList; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1522 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1523 | uint8_t uTagBitIndex; |
| 1524 | // Do not care about errors in pCallerConfiguredTagMap here. They are |
| 1525 | // caught during GetNext() before this is called. |
| 1526 | if(TagMapper_Lookup(pCallerConfiguredTagMap, uTag, &uTagBitIndex)) { |
| 1527 | return 0; |
| 1528 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1529 | |
Laurence Lundblade | dbe6f21 | 2018-10-28 11:37:53 +0700 | [diff] [blame] | 1530 | const uint64_t uTagBit = 0x01ULL << uTagBitIndex; |
| 1531 | return (uTagBit & pItem->uTagBits) != 0; |
| 1532 | } |
| 1533 | |
| 1534 | |
| 1535 | /* |
| 1536 | Public function, see header qcbor.h file |
| 1537 | */ |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1538 | QCBORError QCBORDecode_Finish(QCBORDecodeContext *me) |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1539 | { |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 1540 | QCBORError nReturn = QCBOR_SUCCESS; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1541 | |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 1542 | // Error out if all the maps/arrays are not closed out |
| 1543 | if(DecodeNesting_IsNested(&(me->nesting))) { |
| 1544 | nReturn = QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN; |
| 1545 | goto Done; |
| 1546 | } |
| 1547 | |
| 1548 | // Error out if not all the bytes are consumed |
| 1549 | if(UsefulInputBuf_BytesUnconsumed(&(me->InBuf))) { |
| 1550 | nReturn = QCBOR_ERR_EXTRA_BYTES; |
| 1551 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1552 | |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 1553 | Done: |
Laurence Lundblade | 6de3706 | 2018-10-15 12:22:42 +0530 | [diff] [blame] | 1554 | // Call the destructor for the string allocator if there is one. |
Laurence Lundblade | 20b533d | 2018-10-08 20:44:53 +0800 | [diff] [blame] | 1555 | // Always called, even if there are errors; always have to clean up |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1556 | StringAllocator_Destruct(&(me->StringAllocator)); |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1557 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1558 | return nReturn; |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1559 | } |
| 1560 | |
| 1561 | |
| 1562 | |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1563 | /* |
| 1564 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1565 | Decoder errors handled in this file |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1566 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1567 | - Hit end of input before it was expected while decoding type and |
| 1568 | number QCBOR_ERR_HIT_END |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1569 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1570 | - negative integer that is too large for C QCBOR_ERR_INT_OVERFLOW |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1571 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1572 | - Hit end of input while decoding a text or byte string |
| 1573 | QCBOR_ERR_HIT_END |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1574 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1575 | - Encountered conflicting tags -- e.g., an item is tagged both a date |
| 1576 | string and an epoch date QCBOR_ERR_UNSUPPORTED |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1577 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1578 | - Encontered an array or mapp that has too many items |
| 1579 | QCBOR_ERR_ARRAY_TOO_LONG |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1580 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1581 | - Encountered array/map nesting that is too deep |
| 1582 | QCBOR_ERR_ARRAY_NESTING_TOO_DEEP |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1583 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1584 | - An epoch date > INT64_MAX or < INT64_MIN was encountered |
| 1585 | QCBOR_ERR_DATE_OVERFLOW |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1586 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1587 | - The type of a map label is not a string or int |
| 1588 | QCBOR_ERR_MAP_LABEL_TYPE |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1589 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1590 | - Hit end with arrays or maps still open -- QCBOR_ERR_EXTRA_BYTES |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1591 | |
Laurence Lundblade | b69cad7 | 2018-09-13 11:09:01 -0700 | [diff] [blame] | 1592 | */ |
| 1593 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1594 | |
| 1595 | |
Laurence Lundblade | f653166 | 2018-12-04 10:42:22 +0900 | [diff] [blame] | 1596 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1597 | /* =========================================================================== |
| 1598 | MemPool -- BUILT-IN SIMPLE STRING ALLOCATOR |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1599 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1600 | This implements a simple sting allocator for indefinite length |
| 1601 | strings that can be enabled by calling QCBORDecode_SetMemPool(). It |
| 1602 | implements the function type QCBORStringAllocate and allows easy |
| 1603 | use of it. |
Laurence Lundblade | f653166 | 2018-12-04 10:42:22 +0900 | [diff] [blame] | 1604 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1605 | This particular allocator is built-in for convenience. The caller |
| 1606 | can implement their own. All of this following code will get |
| 1607 | dead-stripped if QCBORDecode_SetMemPool() is not called. |
| 1608 | |
| 1609 | This is a very primitive memory allocator. It does not track |
| 1610 | individual allocations, only a high-water mark. A free or |
| 1611 | reallocation must be of the last chunk allocated. |
| 1612 | |
| 1613 | The size of the pool and offset to free memory are packed into the |
| 1614 | first 8 bytes of the memory pool so we don't have to keep them in |
| 1615 | the decode context. Since the address of the pool may not be |
| 1616 | aligned, they have to be packed and unpacked as if they were |
| 1617 | serialized data of the wire or such. |
| 1618 | |
| 1619 | The sizes packed in are uint32_t to be the same on all CPU types |
| 1620 | and simplify the code. |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1621 | ========================================================================== */ |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1622 | |
| 1623 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1624 | static inline int |
| 1625 | MemPool_Unpack(const void *pMem, uint32_t *puPoolSize, uint32_t *puFreeOffset) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1626 | { |
| 1627 | // Use of UsefulInputBuf is overkill, but it is convenient. |
| 1628 | UsefulInputBuf UIB; |
| 1629 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1630 | // Just assume the size here. It was checked during SetUp so |
| 1631 | // the assumption is safe. |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1632 | UsefulInputBuf_Init(&UIB, (UsefulBufC){pMem, QCBOR_DECODE_MIN_MEM_POOL_SIZE}); |
| 1633 | *puPoolSize = UsefulInputBuf_GetUint32(&UIB); |
| 1634 | *puFreeOffset = UsefulInputBuf_GetUint32(&UIB); |
| 1635 | return UsefulInputBuf_GetError(&UIB); |
| 1636 | } |
| 1637 | |
| 1638 | |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1639 | static inline int |
| 1640 | MemPool_Pack(UsefulBuf Pool, uint32_t uFreeOffset) |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1641 | { |
| 1642 | // Use of UsefulOutBuf is overkill, but convenient. The |
| 1643 | // length check performed here is useful. |
| 1644 | UsefulOutBuf UOB; |
| 1645 | |
| 1646 | UsefulOutBuf_Init(&UOB, Pool); |
| 1647 | UsefulOutBuf_AppendUint32(&UOB, (uint32_t)Pool.len); // size of pool |
| 1648 | UsefulOutBuf_AppendUint32(&UOB, uFreeOffset); // first free position |
| 1649 | return UsefulOutBuf_GetError(&UOB); |
| 1650 | } |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1651 | |
| 1652 | |
| 1653 | /* |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1654 | Internal function for an allocation, reallocation free and destuct. |
| 1655 | |
| 1656 | Having only one function rather than one each per mode saves space in |
| 1657 | QCBORDecodeContext. |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1658 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1659 | Code Reviewers: THIS FUNCTION DOES POINTER MATH |
| 1660 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1661 | static UsefulBuf |
| 1662 | MemPool_Function(void *pPool, void *pMem, size_t uNewSize) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1663 | { |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1664 | UsefulBuf ReturnValue = NULLUsefulBuf; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1665 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1666 | uint32_t uPoolSize; |
| 1667 | uint32_t uFreeOffset; |
| 1668 | |
| 1669 | if(uNewSize > UINT32_MAX) { |
| 1670 | // This allocator is only good up to 4GB. This check should |
| 1671 | // optimize out if sizeof(size_t) == sizeof(uint32_t) |
| 1672 | goto Done; |
| 1673 | } |
| 1674 | const uint32_t uNewSize32 = (uint32_t)uNewSize; |
| 1675 | |
| 1676 | if(MemPool_Unpack(pPool, &uPoolSize, &uFreeOffset)) { |
| 1677 | goto Done; |
| 1678 | } |
| 1679 | |
| 1680 | if(uNewSize) { |
| 1681 | if(pMem) { |
| 1682 | // REALLOCATION MODE |
| 1683 | // Calculate pointer to the end of the memory pool. It is |
| 1684 | // assumed that pPool + uPoolSize won't wrap around by |
| 1685 | // assuming the caller won't pass a pool buffer in that is |
| 1686 | // not in legitimate memory space. |
| 1687 | const void *pPoolEnd = (uint8_t *)pPool + uPoolSize; |
| 1688 | |
| 1689 | // Check that the pointer for reallocation is in the range of the |
| 1690 | // pool. This also makes sure that pointer math further down |
| 1691 | // doesn't wrap under or over. |
| 1692 | if(pMem >= pPool && pMem < pPoolEnd) { |
| 1693 | // Offset to start of chunk for reallocation. This won't |
| 1694 | // wrap under because of check that pMem >= pPool. Cast |
| 1695 | // is safe because the pool is always less than UINT32_MAX |
| 1696 | // because of check in QCBORDecode_SetMemPool(). |
| 1697 | const uint32_t uMemOffset = (uint32_t)((uint8_t *)pMem - (uint8_t *)pPool); |
| 1698 | |
| 1699 | // Check to see if the allocation will fit. uPoolSize - |
| 1700 | // uMemOffset will not wrap under because of check that |
| 1701 | // pMem is in the range of the uPoolSize by check above. |
| 1702 | if(uNewSize <= uPoolSize - uMemOffset) { |
| 1703 | ReturnValue.ptr = pMem; |
| 1704 | ReturnValue.len = uNewSize; |
| 1705 | |
| 1706 | // Addition won't wrap around over because uNewSize was |
| 1707 | // checked to be sure it is less than the pool size. |
| 1708 | uFreeOffset = uMemOffset + uNewSize32; |
| 1709 | } |
| 1710 | } |
| 1711 | } else { |
| 1712 | // ALLOCATION MODE |
| 1713 | // uPoolSize - uFreeOffset will not underflow because this |
| 1714 | // pool implementation makes sure uFreeOffset is always |
| 1715 | // smaller than uPoolSize through this check here and |
| 1716 | // reallocation case. |
| 1717 | if(uNewSize <= uPoolSize - uFreeOffset) { |
| 1718 | ReturnValue.len = uNewSize; |
| 1719 | ReturnValue.ptr = (uint8_t *)pPool + uFreeOffset; |
Laurence Lundblade | 06350ea | 2020-01-27 19:32:40 -0800 | [diff] [blame] | 1720 | uFreeOffset += (uint32_t)uNewSize; |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1721 | } |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1722 | } |
| 1723 | } else { |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1724 | if(pMem) { |
| 1725 | // FREE MODE |
| 1726 | // Cast is safe because of limit on pool size in |
| 1727 | // QCBORDecode_SetMemPool() |
| 1728 | uFreeOffset = (uint32_t)((uint8_t *)pMem - (uint8_t *)pPool); |
| 1729 | } else { |
| 1730 | // DESTRUCT MODE |
| 1731 | // Nothing to do for this allocator |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1732 | } |
| 1733 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1734 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1735 | UsefulBuf Pool = {pPool, uPoolSize}; |
| 1736 | MemPool_Pack(Pool, uFreeOffset); |
| 1737 | |
| 1738 | Done: |
| 1739 | return ReturnValue; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1740 | } |
| 1741 | |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1742 | |
Laurence Lundblade | f653166 | 2018-12-04 10:42:22 +0900 | [diff] [blame] | 1743 | /* |
| 1744 | Public function, see header qcbor.h file |
| 1745 | */ |
Laurence Lundblade | ee85174 | 2020-01-08 08:37:05 -0800 | [diff] [blame] | 1746 | QCBORError QCBORDecode_SetMemPool(QCBORDecodeContext *pMe, |
| 1747 | UsefulBuf Pool, |
| 1748 | bool bAllStrings) |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1749 | { |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1750 | // The pool size and free mem offset are packed into the beginning |
| 1751 | // of the pool memory. This compile time check make sure the |
| 1752 | // constant in the header is correct. This check should optimize |
| 1753 | // down to nothing. |
| 1754 | if(QCBOR_DECODE_MIN_MEM_POOL_SIZE < 2 * sizeof(uint32_t)) { |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1755 | return QCBOR_ERR_BUFFER_TOO_SMALL; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1756 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1757 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1758 | // The pool size and free offset packed in to the beginning of pool |
| 1759 | // memory are only 32-bits. This check will optimize out on 32-bit |
| 1760 | // machines. |
| 1761 | if(Pool.len > UINT32_MAX) { |
| 1762 | return QCBOR_ERR_BUFFER_TOO_LARGE; |
| 1763 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1764 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1765 | // This checks that the pool buffer given is big enough. |
| 1766 | if(MemPool_Pack(Pool, QCBOR_DECODE_MIN_MEM_POOL_SIZE)) { |
| 1767 | return QCBOR_ERR_BUFFER_TOO_SMALL; |
| 1768 | } |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1769 | |
Laurence Lundblade | 1d7eb63 | 2019-02-17 17:23:38 -0800 | [diff] [blame] | 1770 | pMe->StringAllocator.pfAllocator = MemPool_Function; |
| 1771 | pMe->StringAllocator.pAllocateCxt = Pool.ptr; |
| 1772 | pMe->bStringAllocateAll = bAllStrings; |
Laurence Lundblade | 3aee3a3 | 2018-12-17 16:17:45 -0800 | [diff] [blame] | 1773 | |
Laurence Lundblade | 30816f2 | 2018-11-10 13:40:22 +0700 | [diff] [blame] | 1774 | return QCBOR_SUCCESS; |
Laurence Lundblade | 041ffa5 | 2018-10-07 11:43:51 +0700 | [diff] [blame] | 1775 | } |