git.zerfleddert.de Git - proxmark3-svn/blob - client/tinycbor/cborpretty.c

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2018 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 #define _BSD_SOURCE 1
  26 #define _DEFAULT_SOURCE 1
  27 #ifndef __STDC_LIMIT_MACROS
  28 #  define __STDC_LIMIT_MACROS 1
  29 #endif
  30
  31 #include "cbor.h"
  32 #include "cborinternal_p.h"
  33 #include "compilersupport_p.h"
  34 #include "utf8_p.h"
  35
  36 #include <inttypes.h>
  37 #include <string.h>
  38
  39 /**
  40  * \defgroup CborPretty Converting CBOR to text
  41  * \brief Group of functions used to convert CBOR to text form.
  42  *
  43  * This group contains two functions that can be used to convert a \ref
  44  * CborValue object to a text representation. This module attempts to follow
  45  * the recommendations from RFC 7049 section 6 "Diagnostic Notation", though it
  46  * has a few differences. They are noted below.
  47  *
  48  * TinyCBOR does not provide a way to convert from the text representation back
  49  * to encoded form. To produce a text form meant to be parsed, CborToJson is
  50  * recommended instead.
  51  *
  52  * Either of the functions in this section will attempt to convert exactly one
  53  * CborValue object to text. Those functions may return any error documented
  54  * for the functions for CborParsing. In addition, if the C standard library
  55  * stream functions return with error, the text conversion will return with
  56  * error CborErrorIO.
  57  *
  58  * These functions also perform UTF-8 validation in CBOR text strings. If they
  59  * encounter a sequence of bytes that is not permitted in UTF-8, they will return
  60  * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
  61  * in UTF-8.
  62  *
  63  * \warning The output type produced by these functions is not guaranteed to
  64  * remain stable. A future update of TinyCBOR may produce different output for
  65  * the same input and parsers may be unable to handle it.
  66  *
  67  * \sa CborParsing, CborToJson, cbor_parser_init()
  68  */
  69
  70 /**
  71  * \addtogroup CborPretty
  72  * @{
  73  * <h2 class="groupheader">Text format</h2>
  74  *
  75  * As described in RFC 7049 section 6 "Diagnostic Notation", the format is
  76  * largely borrowed from JSON, but modified to suit CBOR's different data
  77  * types. TinyCBOR makes further modifications to distinguish different, but
  78  * similar values.
  79  *
  80  * CBOR values are currently encoded as follows:
  81  * \par Integrals (unsigned and negative)
  82  *      Base-10 (decimal) text representation of the value
  83  * \par Byte strings:
  84  *      <tt>"h'"</tt> followed by the Base16 (hex) representation of the binary data, followed by an ending quote (')
  85  * \par Text strings:
  86  *      C-style escaped string in quotes, with C11/C++11 escaping of Unicode codepoints above U+007F.
  87  * \par Tags:
  88  *      Tag value, with the tagged value in parentheses. No special encoding of the tagged value is performed.
  89  * \par Simple types:
  90  *      <tt>"simple(nn)"</tt> where \c nn is the simple value
  91  * \par Null:
  92  *      \c null
  93  * \par Undefined:
  94  *      \c undefined
  95  * \par Booleans:
  96  *      \c true or \c false
  97  * \par Floating point:
  98  *      If NaN or infinite, the actual words \c NaN or \c infinite.
  99  *      Otherwise, the decimal representation with as many digits as necessary to ensure no loss of information.
 100  *      By default, float values are suffixed by "f" and half-float values suffixed by "f16" (doubles have no suffix).
 101  *      If the CborPrettyNumericEncodingIndicators flag is active, the values instead are encoded following the
 102  *      Section 6 recommended encoding indicators: float values are suffixed with "_2" and half-float with "_1".
 103  *      A decimal point is always present.
 104  * \par Arrays:
 105  *      Comma-separated list of elements, enclosed in square brackets ("[" and "]").
 106  * \par Maps:
 107  *      Comma-separated list of key-value pairs, with the key and value separated
 108  *      by a colon (":"), enclosed in curly braces ("{" and "}").
 109  *
 110  * The CborPrettyFlags enumerator contains flags to control some aspects of the
 111  * encoding:
 112  * \par String fragmentation
 113  *      When the CborPrettyShowStringFragments option is active, text and byte
 114  *      strings that are transmitted in fragments are shown instead inside
 115  *      parentheses ("(" and ")") with no preceding number and each fragment is
 116  *      displayed individually. If a tag precedes the string, then the output
 117  *      will contain a double set of parentheses. If the option is not active,
 118  *      the fragments are merged together and the display will not show any
 119  *      difference from a string transmitted with determinate length.
 120  * \par Encoding indicators
 121  *      Numbers and lengths in CBOR can be encoded in multiple representations.
 122  *      If the CborPrettyIndicateOverlongNumbers option is active, numbers
 123  *      and lengths that are transmitted in a longer encoding than necessary
 124  *      will be indicated, by appending an underscore ("_") to either the
 125  *      number or the opening bracket or brace, followed by a number
 126  *      indicating the CBOR additional information: 0 for 1 byte, 1 for 2
 127  *      bytes, 2 for 4 bytes and 3 for 8 bytes.
 128  *      If the CborPrettyIndicateIndeterminateLength option is active, maps,
 129  *      arrays and strings encoded with indeterminate length will be marked by
 130  *      an underscore after the opening bracket or brace or the string (if not
 131  *      showing fragments), without a number after it.
 132  */
 133
 134 /**
 135  * \enum CborPrettyFlags
 136  * The CborPrettyFlags enum contains flags that control the conversion of CBOR to text format.
 137  *
 138  * \value CborPrettyNumericEncodingIndicators   Use numeric encoding indicators instead of textual for float and half-float.
 139  * \value CborPrettyTextualEncodingIndicators   Use textual encoding indicators for float ("f") and half-float ("f16").
 140  * \value CborPrettyIndicateIndeterminateLength (default) Indicate when a map or array has indeterminate length.
 141  * \value CborPrettyIndicateOverlongNumbers     Indicate when a number or length was encoded with more bytes than needed.
 142  * \value CborPrettyShowStringFragments         If the byte or text string is transmitted in chunks, show each individually.
 143  * \value CborPrettyMergeStringFragment         Merge all chunked byte or text strings and display them in a single entry.
 144  * \value CborPrettyDefaultFlags                Default conversion flags.
 145  */
 146
 147 #ifndef CBOR_NO_FLOATING_POINT
 148 static inline bool convertToUint64(double v, uint64_t *absolute)
 149 {
 150     double supremum;
 151     v = fabs(v);
 152
 153     /* C11 standard section 6.3.1.4 "Real floating and integer" says:
 154      *
 155      *  1 When a finite value of real floating type is converted to an integer
 156      *    type other than _Bool, the fractional part is discarded (i.e., the
 157      *    value is truncated toward zero). If the value of the integral part
 158      *    cannot be represented by the integer type, the behavior is undefined.
 159      *
 160      * So we must perform a range check that v <= UINT64_MAX, but we can't use
 161      * UINT64_MAX + 1.0 because the standard continues:
 162      *
 163      *  2 When a value of integer type is converted to a real floating type, if
 164      *    the value being converted can be represented exactly in the new type,
 165      *    it is unchanged. If the value being converted is in the range of
 166      *    values that can be represented but cannot be represented exactly, the
 167      *    result is either the nearest higher or nearest lower representable
 168      *    value, chosen in an implementation-defined manner.
 169      */
 170     supremum = -2.0 * INT64_MIN;     /* -2 * (- 2^63) == 2^64 */
 171     if (v >= supremum)
 172         return false;
 173
 174     /* Now we can convert, these two conversions cannot be UB */
 175     *absolute = v;
 176     return *absolute == v;
 177 }
 178 #endif
 179
 180 static void printRecursionLimit(CborStreamFunction stream, void *out)
 181 {
 182     stream(out, "<nesting too deep, recursion stopped>");
 183 }
 184
 185 static CborError hexDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
 186 {
 187     const uint8_t *buffer = (const uint8_t *)ptr;
 188     CborError err = CborNoError;
 189     while (n-- && !err)
 190         err = stream(out, "%02" PRIx8, *buffer++);
 191
 192     return err;
 193 }
 194
 195 /* This function decodes buffer as UTF-8 and prints as escaped UTF-16.
 196  * On UTF-8 decoding error, it returns CborErrorInvalidUtf8TextString */
 197 static CborError utf8EscapedDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
 198 {
 199     const uint8_t *buffer = (const uint8_t *)ptr;
 200     const uint8_t * const end = buffer + n;
 201     CborError err = CborNoError;
 202
 203     while (buffer < end && !err) {
 204         uint32_t uc = get_utf8(&buffer, end);
 205         if (uc == ~0U)
 206             return CborErrorInvalidUtf8TextString;
 207
 208         if (uc < 0x80) {
 209             /* single-byte UTF-8 */
 210             unsigned char escaped = (unsigned char)uc;
 211             if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
 212                 err = stream(out, "%c", (char)uc);
 213                 continue;
 214             }
 215
 216             /* print as an escape sequence */
 217             switch (uc) {
 218             case '"':
 219             case '\\':
 220                 break;
 221             case '\b':
 222                 escaped = 'b';
 223                 break;
 224             case '\f':
 225                 escaped = 'f';
 226                 break;
 227             case '\n':
 228                 escaped = 'n';
 229                 break;
 230             case '\r':
 231                 escaped = 'r';
 232                 break;
 233             case '\t':
 234                 escaped = 't';
 235                 break;
 236             default:
 237                 goto print_utf16;
 238             }
 239             err = stream(out, "\\%c", escaped);
 240             continue;
 241         }
 242
 243         /* now print the sequence */
 244         if (uc > 0xffffU) {
 245             /* needs surrogate pairs */
 246             err = stream(out, "\\u%04" PRIX32 "\\u%04" PRIX32,
 247                          (uc >> 10) + 0xd7c0,    /* high surrogate */
 248                          (uc % 0x0400) + 0xdc00);
 249         } else {
 250 print_utf16:
 251             /* no surrogate pair needed */
 252             err = stream(out, "\\u%04" PRIX32, uc);
 253         }
 254     }
 255     return err;
 256 }
 257
 258 static const char *resolve_indicator(const uint8_t *ptr, const uint8_t *end, int flags)
 259 {
 260     static const char indicators[8][3] = {
 261         "_0", "_1", "_2", "_3",
 262         "", "", "",             /* these are not possible */
 263         "_"
 264     };
 265     const char *no_indicator = indicators[5];   /* empty string */
 266     uint8_t additional_information;
 267     uint8_t expected_information;
 268     uint64_t value;
 269     CborError err;
 270
 271     if (ptr == end)
 272         return NULL;    /* CborErrorUnexpectedEOF */
 273
 274     additional_information = (*ptr & SmallValueMask);
 275     if (additional_information < Value8Bit)
 276         return no_indicator;
 277
 278     /* determine whether to show anything */
 279     if ((flags & CborPrettyIndicateIndeterminateLength) &&
 280             additional_information == IndefiniteLength)
 281         return indicators[IndefiniteLength - Value8Bit];
 282     if ((flags & CborPrettyIndicateOverlongNumbers) == 0)
 283         return no_indicator;
 284
 285     err = _cbor_value_extract_number(&ptr, end, &value);
 286     if (err)
 287         return NULL;    /* CborErrorUnexpectedEOF */
 288
 289     expected_information = Value8Bit - 1;
 290     if (value >= Value8Bit)
 291         ++expected_information;
 292     if (value > 0xffU)
 293         ++expected_information;
 294     if (value > 0xffffU)
 295         ++expected_information;
 296     if (value > 0xffffffffU)
 297         ++expected_information;
 298     return expected_information == additional_information ?
 299                 no_indicator :
 300                 indicators[additional_information - Value8Bit];
 301 }
 302
 303 static const char *get_indicator(const CborValue *it, int flags)
 304 {
 305     return resolve_indicator(it->ptr, it->parser->end, flags);
 306 }
 307
 308 static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft);
 309 static CborError container_to_pretty(CborStreamFunction stream, void *out, CborValue *it, CborType containerType,
 310                                      int flags, int recursionsLeft)
 311 {
 312     const char *comma = "";
 313     CborError err = CborNoError;
 314
 315     if (!recursionsLeft) {
 316         printRecursionLimit(stream, out);
 317         return err;     /* do allow the dumping to continue */
 318     }
 319
 320     while (!cbor_value_at_end(it) && !err) {
 321         err = stream(out, "%s", comma);
 322         comma = ", ";
 323
 324         if (!err)
 325             err = value_to_pretty(stream, out, it, flags, recursionsLeft);
 326
 327         if (containerType == CborArrayType)
 328             continue;
 329
 330         /* map: that was the key, so get the value */
 331         if (!err)
 332             err = stream(out, ": ");
 333         if (!err)
 334             err = value_to_pretty(stream, out, it, flags, recursionsLeft);
 335     }
 336     return err;
 337 }
 338
 339 static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft)
 340 {
 341     CborError err = CborNoError;
 342     CborType type = cbor_value_get_type(it);
 343     switch (type) {
 344     case CborArrayType:
 345     case CborMapType: {
 346         /* recursive type */
 347         CborValue recursed;
 348         const char *indicator = get_indicator(it, flags);
 349         const char *space = *indicator ? " " : indicator;
 350
 351         err = stream(out, "%c%s%s", type == CborArrayType ? '[' : '{', indicator, space);
 352         if (err)
 353             return err;
 354
 355         err = cbor_value_enter_container(it, &recursed);
 356         if (err) {
 357             it->ptr = recursed.ptr;
 358             return err;       /* parse error */
 359         }
 360         err = container_to_pretty(stream, out, &recursed, type, flags, recursionsLeft - 1);
 361         if (err) {
 362             it->ptr = recursed.ptr;
 363             return err;       /* parse error */
 364         }
 365         err = cbor_value_leave_container(it, &recursed);
 366         if (err)
 367             return err;       /* parse error */
 368
 369         return stream(out, type == CborArrayType ? "]" : "}");
 370     }
 371
 372     case CborIntegerType: {
 373         uint64_t val;
 374         cbor_value_get_raw_integer(it, &val);    /* can't fail */
 375
 376         if (cbor_value_is_unsigned_integer(it)) {
 377             err = stream(out, "%" PRIu64, val);
 378         } else {
 379             /* CBOR stores the negative number X as -1 - X
 380              * (that is, -1 is stored as 0, -2 as 1 and so forth) */
 381             if (++val) {                /* unsigned overflow may happen */
 382                 err = stream(out, "-%" PRIu64, val);
 383             } else {
 384                 /* overflown
 385                  *   0xffff`ffff`ffff`ffff + 1 =
 386                  * 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64) */
 387                 err = stream(out, "-18446744073709551616");
 388             }
 389         }
 390         if (!err)
 391             err = stream(out, "%s", get_indicator(it, flags));
 392         break;
 393     }
 394
 395     case CborByteStringType:
 396     case CborTextStringType: {
 397         size_t n = 0;
 398         const void *ptr;
 399         bool showingFragments = (flags & CborPrettyShowStringFragments) && !cbor_value_is_length_known(it);
 400         const char *separator = "";
 401         char close = '\'';
 402         char open[3] = "h'";
 403         const char *indicator = NULL;
 404
 405         if (type == CborTextStringType) {
 406             close = open[0] = '"';
 407             open[1] = '\0';
 408         }
 409
 410         if (showingFragments) {
 411             err = stream(out, "(_ ");
 412             if (!err)
 413                 err = _cbor_value_prepare_string_iteration(it);
 414         } else {
 415             err = stream(out, "%s", open);
 416         }
 417
 418         while (!err) {
 419             if (showingFragments || indicator == NULL) {
 420                 /* any iteration, except the second for a non-chunked string */
 421                 indicator = resolve_indicator(it->ptr, it->parser->end, flags);
 422             }
 423
 424             err = _cbor_value_get_string_chunk(it, &ptr, &n, it);
 425             if (!ptr)
 426                 break;
 427
 428             if (!err && showingFragments)
 429                 err = stream(out, "%s%s", separator, open);
 430             if (!err)
 431                 err = (type == CborByteStringType ?
 432                            hexDump(stream, out, ptr, n) :
 433                            utf8EscapedDump(stream, out, ptr, n));
 434             if (!err && showingFragments) {
 435                 err = stream(out, "%c%s", close, indicator);
 436                 separator = ", ";
 437             }
 438         }
 439
 440         if (!err) {
 441             if (showingFragments)
 442                 err = stream(out, ")");
 443             else
 444                 err = stream(out, "%c%s", close, indicator);
 445         }
 446         return err;
 447     }
 448
 449     case CborTagType: {
 450         CborTag tag;
 451         cbor_value_get_tag(it, &tag);       /* can't fail */
 452         err = stream(out, "%" PRIu64 "%s(", tag, get_indicator(it, flags));
 453         if (!err)
 454             err = cbor_value_advance_fixed(it);
 455         if (!err && recursionsLeft)
 456             err = value_to_pretty(stream, out, it, flags, recursionsLeft - 1);
 457         else if (!err)
 458             printRecursionLimit(stream, out);
 459         if (!err)
 460             err = stream(out, ")");
 461         return err;
 462     }
 463
 464     case CborSimpleType: {
 465         /* simple types can't fail and can't have overlong encoding */
 466         uint8_t simple_type;
 467         cbor_value_get_simple_type(it, &simple_type);
 468         err = stream(out, "simple(%" PRIu8 ")", simple_type);
 469         break;
 470     }
 471
 472     case CborNullType:
 473         err = stream(out, "null");
 474         break;
 475
 476     case CborUndefinedType:
 477         err = stream(out, "undefined");
 478         break;
 479
 480     case CborBooleanType: {
 481         bool val;
 482         cbor_value_get_boolean(it, &val);       /* can't fail */
 483         err = stream(out, val ? "true" : "false");
 484         break;
 485     }
 486
 487 #ifndef CBOR_NO_FLOATING_POINT
 488     case CborDoubleType: {
 489         const char *suffix;
 490         double val;
 491         int r;
 492         uint64_t ival;
 493
 494         if (false) {
 495             float f;
 496     case CborFloatType:
 497             cbor_value_get_float(it, &f);
 498             val = f;
 499             suffix = flags & CborPrettyNumericEncodingIndicators ? "_2" : "f";
 500         } else if (false) {
 501             uint16_t f16;
 502     case CborHalfFloatType:
 503 #ifndef CBOR_NO_HALF_FLOAT_TYPE
 504             cbor_value_get_half_float(it, &f16);
 505             val = decode_half(f16);
 506             suffix = flags & CborPrettyNumericEncodingIndicators ? "_1" : "f16";
 507 #else
 508             (void)f16;
 509             err = CborErrorUnsupportedType;
 510             break;
 511 #endif
 512         } else {
 513             cbor_value_get_double(it, &val);
 514             suffix = "";
 515         }
 516
 517         if ((flags & CborPrettyNumericEncodingIndicators) == 0) {
 518             r = fpclassify(val);
 519             if (r == FP_NAN || r == FP_INFINITE)
 520                 suffix = "";
 521         }
 522
 523         if (convertToUint64(val, &ival)) {
 524             /* this double value fits in a 64-bit integer, so show it as such
 525              * (followed by a floating point suffix, to disambiguate) */
 526             err = stream(out, "%s%" PRIu64 ".%s", val < 0 ? "-" : "", ival, suffix);
 527         } else {
 528             /* this number is definitely not a 64-bit integer */
 529             err = stream(out, "%." DBL_DECIMAL_DIG_STR "g%s", val, suffix);
 530         }
 531         break;
 532     }
 533 #else
 534     case CborDoubleType:
 535     case CborFloatType:
 536     case CborHalfFloatType:
 537         err = CborErrorUnsupportedType;
 538         break;
 539 #endif /* !CBOR_NO_FLOATING_POINT */
 540
 541     case CborInvalidType:
 542         err = stream(out, "invalid");
 543         if (err)
 544             return err;
 545         return CborErrorUnknownType;
 546     }
 547
 548     if (!err)
 549         err = cbor_value_advance_fixed(it);
 550     return err;
 551 }
 552
 553 /**
 554  * Converts the current CBOR type pointed by \a value to its textual
 555  * representation and writes it to the stream by calling the \a streamFunction.
 556  * If an error occurs, this function returns an error code similar to
 557  * \ref CborParsing.
 558  *
 559  * The textual representation can be controlled by the \a flags parameter (see
 560  * \ref CborPrettyFlags for more information).
 561  *
 562  * If no error ocurred, this function advances \a value to the next element.
 563  * Often, concatenating the text representation of multiple elements can be
 564  * done by appending a comma to the output stream in between calls to this
 565  * function.
 566  *
 567  * The \a streamFunction function will be called with the \a token value as the
 568  * first parameter and a printf-style format string as the second, with a variable
 569  * number of further parameters.
 570  *
 571  * \sa cbor_value_to_pretty(), cbor_value_to_json_advance()
 572  */
 573 CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags)
 574 {
 575     return value_to_pretty(streamFunction, token, value, flags, CBOR_PARSER_MAX_RECURSIONS);
 576 }
 577
 578 /** @} */