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         #if defined(__MINGW32__) || defined(__MINGW64__)
 585                 __attribute__((__format__(__MINGW_PRINTF_FORMAT, 2, 3)))
 586         #else
 587                 __attribute__((__format__(printf, 2, 3)))
 588         #endif
 589 #endif
 590 ;
 591
 592 CBOR_API CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags);
 593
 594 /* The following API requires a hosted C implementation (uses FILE*) */
 595 #if !defined(__STDC_HOSTED__) || __STDC_HOSTED__-0 == 1
 596 CBOR_API CborError cbor_value_to_pretty_advance_flags(FILE *out, CborValue *value, int flags);
 597 CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
 598 CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
 599 {
 600     CborValue copy = *value;
 601     return cbor_value_to_pretty_advance_flags(out, &copy, CborPrettyDefaultFlags);
 602 }
 603 #endif /* __STDC_HOSTED__ check */
 604
 605 #ifdef __cplusplus
 606 }
 607 #endif
 608
 609 #endif /* CBOR_H */
 610