]> cvs.zerfleddert.de Git - proxmark3-svn/blame - client/tinycbor/cbor.h
projects / proxmark3-svn / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix some printf/scanf format strings
[proxmark3-svn] / client / tinycbor / cbor.h
CommitLineData
0bb51450
OM		 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
42extern "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
82typedef 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
100typedef uint64_t CborTag;
101typedef 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
152typedef 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
202CBOR_API const char *cbor_error_string(CborError error);
203
204/* Encoder API */
205struct 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};
215typedef struct CborEncoder CborEncoder;
216
217static const size_t CborIndefiniteLength = SIZE_MAX;
218
219CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags);
220CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value);
221CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value);
222CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value);
223CBOR_API CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value);
224CBOR_API CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag);
225CBOR_API CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length);
226CBOR_INLINE_API CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
227{ return cbor_encode_text_string(encoder, string, strlen(string)); }
228CBOR_API CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length);
229CBOR_API CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value);
230
231CBOR_INLINE_API CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
232{ return cbor_encode_simple_value(encoder, (int)value - 1 + (CborBooleanType & 0x1f)); }
233CBOR_INLINE_API CborError cbor_encode_null(CborEncoder *encoder)
234{ return cbor_encode_simple_value(encoder, CborNullType & 0x1f); }
235CBOR_INLINE_API CborError cbor_encode_undefined(CborEncoder *encoder)
236{ return cbor_encode_simple_value(encoder, CborUndefinedType & 0x1f); }
237
238CBOR_INLINE_API CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
239{ return cbor_encode_floating_point(encoder, CborHalfFloatType, value); }
240CBOR_INLINE_API CborError cbor_encode_float(CborEncoder *encoder, float value)
241{ return cbor_encode_floating_point(encoder, CborFloatType, &value); }
242CBOR_INLINE_API CborError cbor_encode_double(CborEncoder *encoder, double value)
243{ return cbor_encode_floating_point(encoder, CborDoubleType, &value); }
244
245CBOR_API CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length);
246CBOR_API CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length);
247CBOR_API CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder);
248CBOR_API CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder);
249
250CBOR_INLINE_API uint8_t *_cbor_encoder_get_buffer_pointer(const CborEncoder *encoder)
251{
252 return encoder->data.ptr;
253}
254
255CBOR_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
260CBOR_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
267enum CborParserIteratorFlags
268{
269 CborIteratorFlag_IntegerValueTooLarge = 0x01,
270 CborIteratorFlag_NegativeInteger = 0x02,
271 CborIteratorFlag_IteratingStringChunks = 0x02,
272 CborIteratorFlag_UnknownLength = 0x04,
273 CborIteratorFlag_ContainerIsMap = 0x20
274};
275
276struct CborParser
277{
278 const uint8_t *end;
279 uint32_t flags;
280};
281typedef struct CborParser CborParser;
282
283struct 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};
292typedef struct CborValue CborValue;
293
294CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, uint32_t flags, CborParser *parser, CborValue *it);
295
296CBOR_API CborError cbor_value_validate_basic(const CborValue *it);
297
298CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it)
299{ return it->remaining == 0; }
300CBOR_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it)
301{ return it->ptr; }
302CBOR_API CborError cbor_value_advance_fixed(CborValue *it);
303CBOR_API CborError cbor_value_advance(CborValue *it);
304CBOR_INLINE_API bool cbor_value_is_container(const CborValue *it)
305{ return it->type == CborArrayType || it->type == CborMapType; }
306CBOR_API CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed);
307CBOR_API CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed);
308
309CBOR_PRIVATE_API uint64_t _cbor_value_decode_int64_internal(const CborValue *value);
310CBOR_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
316CBOR_INLINE_API bool cbor_value_is_valid(const CborValue *value)
317{ return value && value->type != CborInvalidType; }
318CBOR_INLINE_API CborType cbor_value_get_type(const CborValue *value)
319{ return (CborType)value->type; }
320
321/* Null & undefined type */
322CBOR_INLINE_API bool cbor_value_is_null(const CborValue *value)
323{ return value->type == CborNullType; }
324CBOR_INLINE_API bool cbor_value_is_undefined(const CborValue *value)
325{ return value->type == CborUndefinedType; }
326
327/* Booleans */
328CBOR_INLINE_API bool cbor_value_is_boolean(const CborValue *value)
329{ return value->type == CborBooleanType; }
330CBOR_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 */
338CBOR_INLINE_API bool cbor_value_is_simple_type(const CborValue *value)
339{ return value->type == CborSimpleType; }
340CBOR_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 */
348CBOR_INLINE_API bool cbor_value_is_integer(const CborValue *value)
349{ return value->type == CborIntegerType; }
350CBOR_INLINE_API bool cbor_value_is_unsigned_integer(const CborValue *value)
351{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger) == 0; }
352CBOR_INLINE_API bool cbor_value_is_negative_integer(const CborValue *value)
353{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger); }
354
355CBOR_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
362CBOR_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
369CBOR_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
378CBOR_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
387CBOR_API CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result);
388CBOR_API CborError cbor_value_get_int_checked(const CborValue *value, int *result);
389
390CBOR_INLINE_API bool cbor_value_is_length_known(const CborValue *value)
391{ return (value->flags & CborIteratorFlag_UnknownLength) == 0; }
392
393/* Tags */
394CBOR_INLINE_API bool cbor_value_is_tag(const CborValue *value)
395{ return value->type == CborTagType; }
396CBOR_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}
402CBOR_API CborError cbor_value_skip_tag(CborValue *it);
403
404/* Strings */
405CBOR_INLINE_API bool cbor_value_is_byte_string(const CborValue *value)
406{ return value->type == CborByteStringType; }
407CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value)
408{ return value->type == CborTextStringType; }
409
410CBOR_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
423CBOR_PRIVATE_API CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
424 size_t *buflen, CborValue *next);
425CBOR_PRIVATE_API CborError _cbor_value_dup_string(const CborValue *value, void **buffer,
426 size_t *buflen, CborValue *next);
427
428CBOR_API CborError cbor_value_calculate_string_length(const CborValue *value, size_t *length);
429
430CBOR_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}
436CBOR_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
443CBOR_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}
449CBOR_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
456CBOR_API CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result);
457
458/* Maps and arrays */
459CBOR_INLINE_API bool cbor_value_is_array(const CborValue *value)
460{ return value->type == CborArrayType; }
461CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value)
462{ return value->type == CborMapType; }
463
464CBOR_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
477CBOR_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
490CBOR_API CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element);
491
492/* Floating point */
493CBOR_INLINE_API bool cbor_value_is_half_float(const CborValue *value)
494{ return value->type == CborHalfFloatType; }
495CBOR_API CborError cbor_value_get_half_float(const CborValue *value, void *result);
496
497CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value)
498{ return value->type == CborFloatType; }
499CBOR_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
509CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value)
510{ return value->type == CborDoubleType; }
511CBOR_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
523enum 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
564CBOR_API CborError cbor_value_validate(const CborValue *it, uint32_t flags);
565
566/* Human-readable (dump) API */
567
568enum 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
582typedef CborError (*CborStreamFunction)(void *token, const char *fmt, ...)
583#ifdef __GNUC__
584 __attribute__((__format__(printf, 2, 3)))
585#endif
586;
587
588CBOR_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
592CBOR_API CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags);
593CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
594CBOR_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
Proxmark3 GIT tracking
Impressum, Datenschutz