Fido2 (#727)
[proxmark3-svn] / client / tinycbor / cbor.h
1 /****************************************************************************
2 **
3 ** Copyright (C) 2017 Intel Corporation
4 **
5 ** Permission is hereby granted, free of charge, to any person obtaining a copy
6 ** of this software and associated documentation files (the "Software"), to deal
7 ** in the Software without restriction, including without limitation the rights
8 ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 ** copies of the Software, and to permit persons to whom the Software is
10 ** furnished to do so, subject to the following conditions:
11 **
12 ** The above copyright notice and this permission notice shall be included in
13 ** all copies or substantial portions of the Software.
14 **
15 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 ** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 ** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 ** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 ** THE SOFTWARE.
22 **
23 ****************************************************************************/
24
25 #ifndef CBOR_H
26 #define CBOR_H
27
28 #ifndef assert
29 #include <assert.h>
30 #endif
31 #include <limits.h>
32 #include <stddef.h>
33 #include <stdint.h>
34 #include <string.h>
35 #include <stdio.h>
36
37 #include "tinycbor-version.h"
38
39 #define TINYCBOR_VERSION ((TINYCBOR_VERSION_MAJOR << 16) | (TINYCBOR_VERSION_MINOR << 8) | TINYCBOR_VERSION_PATCH)
40
41 #ifdef __cplusplus
42 extern "C" {
43 #else
44 #include <stdbool.h>
45 #endif
46
47 #ifndef SIZE_MAX
48 /* Some systems fail to define SIZE_MAX in <stdint.h>, even though C99 requires it...
49 * Conversion from signed to unsigned is defined in 6.3.1.3 (Signed and unsigned integers) p2,
50 * which says: "the value is converted by repeatedly adding or subtracting one more than the
51 * maximum value that can be represented in the new type until the value is in the range of the
52 * new type."
53 * So -1 gets converted to size_t by adding SIZE_MAX + 1, which results in SIZE_MAX.
54 */
55 # define SIZE_MAX ((size_t)-1)
56 #endif
57
58 #ifndef CBOR_API
59 # define CBOR_API
60 #endif
61 #ifndef CBOR_PRIVATE_API
62 # define CBOR_PRIVATE_API
63 #endif
64 #ifndef CBOR_INLINE_API
65 # if defined(__cplusplus)
66 # define CBOR_INLINE inline
67 # define CBOR_INLINE_API inline
68 # else
69 # define CBOR_INLINE_API static CBOR_INLINE
70 # if defined(_MSC_VER)
71 # define CBOR_INLINE __inline
72 # elif defined(__GNUC__)
73 # define CBOR_INLINE __inline__
74 # elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
75 # define CBOR_INLINE inline
76 # else
77 # define CBOR_INLINE
78 # endif
79 # endif
80 #endif
81
82 typedef enum CborType {
83 CborIntegerType = 0x00,
84 CborByteStringType = 0x40,
85 CborTextStringType = 0x60,
86 CborArrayType = 0x80,
87 CborMapType = 0xa0,
88 CborTagType = 0xc0,
89 CborSimpleType = 0xe0,
90 CborBooleanType = 0xf5,
91 CborNullType = 0xf6,
92 CborUndefinedType = 0xf7,
93 CborHalfFloatType = 0xf9,
94 CborFloatType = 0xfa,
95 CborDoubleType = 0xfb,
96
97 CborInvalidType = 0xff /* equivalent to the break byte, so it will never be used */
98 } CborType;
99
100 typedef uint64_t CborTag;
101 typedef enum CborKnownTags {
102 CborDateTimeStringTag = 0,
103 CborUnixTime_tTag = 1,
104 CborPositiveBignumTag = 2,
105 CborNegativeBignumTag = 3,
106 CborDecimalTag = 4,
107 CborBigfloatTag = 5,
108 CborCOSE_Encrypt0Tag = 16,
109 CborCOSE_Mac0Tag = 17,
110 CborCOSE_Sign1Tag = 18,
111 CborExpectedBase64urlTag = 21,
112 CborExpectedBase64Tag = 22,
113 CborExpectedBase16Tag = 23,
114 CborEncodedCborTag = 24,
115 CborUrlTag = 32,
116 CborBase64urlTag = 33,
117 CborBase64Tag = 34,
118 CborRegularExpressionTag = 35,
119 CborMimeMessageTag = 36,
120 CborCOSE_EncryptTag = 96,
121 CborCOSE_MacTag = 97,
122 CborCOSE_SignTag = 98,
123 CborSignatureTag = 55799
124 } CborKnownTags;
125
126 /* #define the constants so we can check with #ifdef */
127 #define CborDateTimeStringTag CborDateTimeStringTag
128 #define CborUnixTime_tTag CborUnixTime_tTag
129 #define CborPositiveBignumTag CborPositiveBignumTag
130 #define CborNegativeBignumTag CborNegativeBignumTag
131 #define CborDecimalTag CborDecimalTag
132 #define CborBigfloatTag CborBigfloatTag
133 #define CborCOSE_Encrypt0Tag CborCOSE_Encrypt0Tag
134 #define CborCOSE_Mac0Tag CborCOSE_Mac0Tag
135 #define CborCOSE_Sign1Tag CborCOSE_Sign1Tag
136 #define CborExpectedBase64urlTag CborExpectedBase64urlTag
137 #define CborExpectedBase64Tag CborExpectedBase64Tag
138 #define CborExpectedBase16Tag CborExpectedBase16Tag
139 #define CborEncodedCborTag CborEncodedCborTag
140 #define CborUrlTag CborUrlTag
141 #define CborBase64urlTag CborBase64urlTag
142 #define CborBase64Tag CborBase64Tag
143 #define CborRegularExpressionTag CborRegularExpressionTag
144 #define CborMimeMessageTag CborMimeMessageTag
145 #define CborCOSE_EncryptTag CborCOSE_EncryptTag
146 #define CborCOSE_MacTag CborCOSE_MacTag
147 #define CborCOSE_SignTag CborCOSE_SignTag
148 #define CborSignatureTag CborSignatureTag
149
150 /* Error API */
151
152 typedef enum CborError {
153 CborNoError = 0,
154
155 /* errors in all modes */
156 CborUnknownError,
157 CborErrorUnknownLength, /* request for length in array, map, or string with indeterminate length */
158 CborErrorAdvancePastEOF,
159 CborErrorIO,
160
161 /* parser errors streaming errors */
162 CborErrorGarbageAtEnd = 256,
163 CborErrorUnexpectedEOF,
164 CborErrorUnexpectedBreak,
165 CborErrorUnknownType, /* can only happen in major type 7 */
166 CborErrorIllegalType, /* type not allowed here */
167 CborErrorIllegalNumber,
168 CborErrorIllegalSimpleType, /* types of value less than 32 encoded in two bytes */
169
170 /* parser errors in strict mode parsing only */
171 CborErrorUnknownSimpleType = 512,
172 CborErrorUnknownTag,
173 CborErrorInappropriateTagForType,
174 CborErrorDuplicateObjectKeys,
175 CborErrorInvalidUtf8TextString,
176 CborErrorExcludedType,
177 CborErrorExcludedValue,
178 CborErrorImproperValue,
179 CborErrorOverlongEncoding,
180 CborErrorMapKeyNotString,
181 CborErrorMapNotSorted,
182 CborErrorMapKeysNotUnique,
183
184 /* encoder errors */
185 CborErrorTooManyItems = 768,
186 CborErrorTooFewItems,
187
188 /* internal implementation errors */
189 CborErrorDataTooLarge = 1024,
190 CborErrorNestingTooDeep,
191 CborErrorUnsupportedType,
192
193 /* errors in converting to JSON */
194 CborErrorJsonObjectKeyIsAggregate = 1280,
195 CborErrorJsonObjectKeyNotString,
196 CborErrorJsonNotImplemented,
197
198 CborErrorOutOfMemory = (int) (~0U / 2 + 1),
199 CborErrorInternalError = (int) (~0U / 2) /* INT_MAX on two's complement machines */
200 } CborError;
201
202 CBOR_API const char *cbor_error_string(CborError error);
203
204 /* Encoder API */
205 struct CborEncoder
206 {
207 union {
208 uint8_t *ptr;
209 ptrdiff_t bytes_needed;
210 } data;
211 const uint8_t *end;
212 size_t remaining;
213 int flags;
214 };
215 typedef struct CborEncoder CborEncoder;
216
217 static const size_t CborIndefiniteLength = SIZE_MAX;
218
219 CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags);
220 CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value);
221 CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value);
222 CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value);
223 CBOR_API CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value);
224 CBOR_API CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag);
225 CBOR_API CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length);
226 CBOR_INLINE_API CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
227 { return cbor_encode_text_string(encoder, string, strlen(string)); }
228 CBOR_API CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length);
229 CBOR_API CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value);
230
231 CBOR_INLINE_API CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
232 { return cbor_encode_simple_value(encoder, (int)value - 1 + (CborBooleanType & 0x1f)); }
233 CBOR_INLINE_API CborError cbor_encode_null(CborEncoder *encoder)
234 { return cbor_encode_simple_value(encoder, CborNullType & 0x1f); }
235 CBOR_INLINE_API CborError cbor_encode_undefined(CborEncoder *encoder)
236 { return cbor_encode_simple_value(encoder, CborUndefinedType & 0x1f); }
237
238 CBOR_INLINE_API CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
239 { return cbor_encode_floating_point(encoder, CborHalfFloatType, value); }
240 CBOR_INLINE_API CborError cbor_encode_float(CborEncoder *encoder, float value)
241 { return cbor_encode_floating_point(encoder, CborFloatType, &value); }
242 CBOR_INLINE_API CborError cbor_encode_double(CborEncoder *encoder, double value)
243 { return cbor_encode_floating_point(encoder, CborDoubleType, &value); }
244
245 CBOR_API CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length);
246 CBOR_API CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length);
247 CBOR_API CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder);
248 CBOR_API CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder);
249
250 CBOR_INLINE_API uint8_t *_cbor_encoder_get_buffer_pointer(const CborEncoder *encoder)
251 {
252 return encoder->data.ptr;
253 }
254
255 CBOR_INLINE_API size_t cbor_encoder_get_buffer_size(const CborEncoder *encoder, const uint8_t *buffer)
256 {
257 return (size_t)(encoder->data.ptr - buffer);
258 }
259
260 CBOR_INLINE_API size_t cbor_encoder_get_extra_bytes_needed(const CborEncoder *encoder)
261 {
262 return encoder->end ? 0 : (size_t)encoder->data.bytes_needed;
263 }
264
265 /* Parser API */
266
267 enum CborParserIteratorFlags
268 {
269 CborIteratorFlag_IntegerValueTooLarge = 0x01,
270 CborIteratorFlag_NegativeInteger = 0x02,
271 CborIteratorFlag_IteratingStringChunks = 0x02,
272 CborIteratorFlag_UnknownLength = 0x04,
273 CborIteratorFlag_ContainerIsMap = 0x20
274 };
275
276 struct CborParser
277 {
278 const uint8_t *end;
279 uint32_t flags;
280 };
281 typedef struct CborParser CborParser;
282
283 struct CborValue
284 {
285 const CborParser *parser;
286 const uint8_t *ptr;
287 uint32_t remaining;
288 uint16_t extra;
289 uint8_t type;
290 uint8_t flags;
291 };
292 typedef struct CborValue CborValue;
293
294 CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, uint32_t flags, CborParser *parser, CborValue *it);
295
296 CBOR_API CborError cbor_value_validate_basic(const CborValue *it);
297
298 CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it)
299 { return it->remaining == 0; }
300 CBOR_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it)
301 { return it->ptr; }
302 CBOR_API CborError cbor_value_advance_fixed(CborValue *it);
303 CBOR_API CborError cbor_value_advance(CborValue *it);
304 CBOR_INLINE_API bool cbor_value_is_container(const CborValue *it)
305 { return it->type == CborArrayType || it->type == CborMapType; }
306 CBOR_API CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed);
307 CBOR_API CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed);
308
309 CBOR_PRIVATE_API uint64_t _cbor_value_decode_int64_internal(const CborValue *value);
310 CBOR_INLINE_API uint64_t _cbor_value_extract_int64_helper(const CborValue *value)
311 {
312 return value->flags & CborIteratorFlag_IntegerValueTooLarge ?
313 _cbor_value_decode_int64_internal(value) : value->extra;
314 }
315
316 CBOR_INLINE_API bool cbor_value_is_valid(const CborValue *value)
317 { return value && value->type != CborInvalidType; }
318 CBOR_INLINE_API CborType cbor_value_get_type(const CborValue *value)
319 { return (CborType)value->type; }
320
321 /* Null & undefined type */
322 CBOR_INLINE_API bool cbor_value_is_null(const CborValue *value)
323 { return value->type == CborNullType; }
324 CBOR_INLINE_API bool cbor_value_is_undefined(const CborValue *value)
325 { return value->type == CborUndefinedType; }
326
327 /* Booleans */
328 CBOR_INLINE_API bool cbor_value_is_boolean(const CborValue *value)
329 { return value->type == CborBooleanType; }
330 CBOR_INLINE_API CborError cbor_value_get_boolean(const CborValue *value, bool *result)
331 {
332 assert(cbor_value_is_boolean(value));
333 *result = !!value->extra;
334 return CborNoError;
335 }
336
337 /* Simple types */
338 CBOR_INLINE_API bool cbor_value_is_simple_type(const CborValue *value)
339 { return value->type == CborSimpleType; }
340 CBOR_INLINE_API CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result)
341 {
342 assert(cbor_value_is_simple_type(value));
343 *result = (uint8_t)value->extra;
344 return CborNoError;
345 }
346
347 /* Integers */
348 CBOR_INLINE_API bool cbor_value_is_integer(const CborValue *value)
349 { return value->type == CborIntegerType; }
350 CBOR_INLINE_API bool cbor_value_is_unsigned_integer(const CborValue *value)
351 { return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger) == 0; }
352 CBOR_INLINE_API bool cbor_value_is_negative_integer(const CborValue *value)
353 { return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger); }
354
355 CBOR_INLINE_API CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result)
356 {
357 assert(cbor_value_is_integer(value));
358 *result = _cbor_value_extract_int64_helper(value);
359 return CborNoError;
360 }
361
362 CBOR_INLINE_API CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result)
363 {
364 assert(cbor_value_is_unsigned_integer(value));
365 *result = _cbor_value_extract_int64_helper(value);
366 return CborNoError;
367 }
368
369 CBOR_INLINE_API CborError cbor_value_get_int64(const CborValue *value, int64_t *result)
370 {
371 assert(cbor_value_is_integer(value));
372 *result = (int64_t) _cbor_value_extract_int64_helper(value);
373 if (value->flags & CborIteratorFlag_NegativeInteger)
374 *result = -*result - 1;
375 return CborNoError;
376 }
377
378 CBOR_INLINE_API CborError cbor_value_get_int(const CborValue *value, int *result)
379 {
380 assert(cbor_value_is_integer(value));
381 *result = (int) _cbor_value_extract_int64_helper(value);
382 if (value->flags & CborIteratorFlag_NegativeInteger)
383 *result = -*result - 1;
384 return CborNoError;
385 }
386
387 CBOR_API CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result);
388 CBOR_API CborError cbor_value_get_int_checked(const CborValue *value, int *result);
389
390 CBOR_INLINE_API bool cbor_value_is_length_known(const CborValue *value)
391 { return (value->flags & CborIteratorFlag_UnknownLength) == 0; }
392
393 /* Tags */
394 CBOR_INLINE_API bool cbor_value_is_tag(const CborValue *value)
395 { return value->type == CborTagType; }
396 CBOR_INLINE_API CborError cbor_value_get_tag(const CborValue *value, CborTag *result)
397 {
398 assert(cbor_value_is_tag(value));
399 *result = _cbor_value_extract_int64_helper(value);
400 return CborNoError;
401 }
402 CBOR_API CborError cbor_value_skip_tag(CborValue *it);
403
404 /* Strings */
405 CBOR_INLINE_API bool cbor_value_is_byte_string(const CborValue *value)
406 { return value->type == CborByteStringType; }
407 CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value)
408 { return value->type == CborTextStringType; }
409
410 CBOR_INLINE_API CborError cbor_value_get_string_length(const CborValue *value, size_t *length)
411 {
412 uint64_t v;
413 assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
414 if (!cbor_value_is_length_known(value))
415 return CborErrorUnknownLength;
416 v = _cbor_value_extract_int64_helper(value);
417 *length = (size_t)v;
418 if (*length != v)
419 return CborErrorDataTooLarge;
420 return CborNoError;
421 }
422
423 CBOR_PRIVATE_API CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
424 size_t *buflen, CborValue *next);
425 CBOR_PRIVATE_API CborError _cbor_value_dup_string(const CborValue *value, void **buffer,
426 size_t *buflen, CborValue *next);
427
428 CBOR_API CborError cbor_value_calculate_string_length(const CborValue *value, size_t *length);
429
430 CBOR_INLINE_API CborError cbor_value_copy_text_string(const CborValue *value, char *buffer,
431 size_t *buflen, CborValue *next)
432 {
433 assert(cbor_value_is_text_string(value));
434 return _cbor_value_copy_string(value, buffer, buflen, next);
435 }
436 CBOR_INLINE_API CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer,
437 size_t *buflen, CborValue *next)
438 {
439 assert(cbor_value_is_byte_string(value));
440 return _cbor_value_copy_string(value, buffer, buflen, next);
441 }
442
443 CBOR_INLINE_API CborError cbor_value_dup_text_string(const CborValue *value, char **buffer,
444 size_t *buflen, CborValue *next)
445 {
446 assert(cbor_value_is_text_string(value));
447 return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
448 }
449 CBOR_INLINE_API CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer,
450 size_t *buflen, CborValue *next)
451 {
452 assert(cbor_value_is_byte_string(value));
453 return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
454 }
455
456 CBOR_API CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result);
457
458 /* Maps and arrays */
459 CBOR_INLINE_API bool cbor_value_is_array(const CborValue *value)
460 { return value->type == CborArrayType; }
461 CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value)
462 { return value->type == CborMapType; }
463
464 CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, size_t *length)
465 {
466 uint64_t v;
467 assert(cbor_value_is_array(value));
468 if (!cbor_value_is_length_known(value))
469 return CborErrorUnknownLength;
470 v = _cbor_value_extract_int64_helper(value);
471 *length = (size_t)v;
472 if (*length != v)
473 return CborErrorDataTooLarge;
474 return CborNoError;
475 }
476
477 CBOR_INLINE_API CborError cbor_value_get_map_length(const CborValue *value, size_t *length)
478 {
479 uint64_t v;
480 assert(cbor_value_is_map(value));
481 if (!cbor_value_is_length_known(value))
482 return CborErrorUnknownLength;
483 v = _cbor_value_extract_int64_helper(value);
484 *length = (size_t)v;
485 if (*length != v)
486 return CborErrorDataTooLarge;
487 return CborNoError;
488 }
489
490 CBOR_API CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element);
491
492 /* Floating point */
493 CBOR_INLINE_API bool cbor_value_is_half_float(const CborValue *value)
494 { return value->type == CborHalfFloatType; }
495 CBOR_API CborError cbor_value_get_half_float(const CborValue *value, void *result);
496
497 CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value)
498 { return value->type == CborFloatType; }
499 CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result)
500 {
501 uint32_t data;
502 assert(cbor_value_is_float(value));
503 assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
504 data = (uint32_t)_cbor_value_decode_int64_internal(value);
505 memcpy(result, &data, sizeof(*result));
506 return CborNoError;
507 }
508
509 CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value)
510 { return value->type == CborDoubleType; }
511 CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result)
512 {
513 uint64_t data;
514 assert(cbor_value_is_double(value));
515 assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
516 data = _cbor_value_decode_int64_internal(value);
517 memcpy(result, &data, sizeof(*result));
518 return CborNoError;
519 }
520
521 /* Validation API */
522
523 enum CborValidationFlags {
524 /* Bit mapping:
525 * bits 0-7 (8 bits): canonical format
526 * bits 8-11 (4 bits): canonical format & strict mode
527 * bits 12-20 (8 bits): strict mode
528 * bits 21-31 (10 bits): other
529 */
530
531 CborValidateShortestIntegrals = 0x0001,
532 CborValidateShortestFloatingPoint = 0x0002,
533 CborValidateShortestNumbers = CborValidateShortestIntegrals | CborValidateShortestFloatingPoint,
534 CborValidateNoIndeterminateLength = 0x0100,
535 CborValidateMapIsSorted = 0x0200 | CborValidateNoIndeterminateLength,
536
537 CborValidateCanonicalFormat = 0x0fff,
538
539 CborValidateMapKeysAreUnique = 0x1000 | CborValidateMapIsSorted,
540 CborValidateTagUse = 0x2000,
541 CborValidateUtf8 = 0x4000,
542
543 CborValidateStrictMode = 0xfff00,
544
545 CborValidateMapKeysAreString = 0x100000,
546 CborValidateNoUndefined = 0x200000,
547 CborValidateNoTags = 0x400000,
548 CborValidateFiniteFloatingPoint = 0x800000,
549 /* unused = 0x1000000, */
550 /* unused = 0x2000000, */
551
552 CborValidateNoUnknownSimpleTypesSA = 0x4000000,
553 CborValidateNoUnknownSimpleTypes = 0x8000000 | CborValidateNoUnknownSimpleTypesSA,
554 CborValidateNoUnknownTagsSA = 0x10000000,
555 CborValidateNoUnknownTagsSR = 0x20000000 | CborValidateNoUnknownTagsSA,
556 CborValidateNoUnknownTags = 0x40000000 | CborValidateNoUnknownTagsSR,
557
558 CborValidateCompleteData = (int)0x80000000,
559
560 CborValidateStrictest = (int)~0U,
561 CborValidateBasic = 0
562 };
563
564 CBOR_API CborError cbor_value_validate(const CborValue *it, uint32_t flags);
565
566 /* Human-readable (dump) API */
567
568 enum CborPrettyFlags {
569 CborPrettyNumericEncodingIndicators = 0x01,
570 CborPrettyTextualEncodingIndicators = 0,
571
572 CborPrettyIndicateIndeterminateLength = 0x02,
573 CborPrettyIndicateIndetermineLength = CborPrettyIndicateIndeterminateLength, /* deprecated */
574 CborPrettyIndicateOverlongNumbers = 0x04,
575
576 CborPrettyShowStringFragments = 0x100,
577 CborPrettyMergeStringFragments = 0,
578
579 CborPrettyDefaultFlags = CborPrettyIndicateIndeterminateLength
580 };
581
582 typedef CborError (*CborStreamFunction)(void *token, const char *fmt, ...)
583 #ifdef __GNUC__
584 __attribute__((__format__(printf, 2, 3)))
585 #endif
586 ;
587
588 CBOR_API CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags);
589
590 /* The following API requires a hosted C implementation (uses FILE*) */
591 #if !defined(__STDC_HOSTED__) || __STDC_HOSTED__-0 == 1
592 CBOR_API CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags);
593 CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
594 CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
595 {
596 CborValue copy = *value;
597 return cbor_value_to_pretty_advance_flags(out, &copy, CborPrettyDefaultFlags);
598 }
599 #endif /* __STDC_HOSTED__ check */
600
601 #ifdef __cplusplus
602 }
603 #endif
604
605 #endif /* CBOR_H */
606
Impressum, Datenschutz