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

1 /****************************************************************************

2 **

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 ****************************************************************************/

25 #define _BSD_SOURCE 1

26 #define _DEFAULT_SOURCE 1

27 #ifndef __STDC_LIMIT_MACROS

28 # define __STDC_LIMIT_MACROS 1

29 #endif

31 #include "cbor.h"

32 #include "cborinternal_p.h"

33 #include "compilersupport_p.h"

34 #include "utf8_p.h"

36 #include <inttypes.h>

37 #include <string.h>

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 */

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

 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 */

     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

 static void printRecursionLimit(CborStreamFunction stream, void *out)

181 {

     stream(out, "<nesting too deep, recursion stopped>");

183 }

184

 static CborError hexDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)

186 {

     const uint8_t *buffer = (const uint8_t *)ptr;

188 CborError err = CborNoError;

189 while (n-- && !err)

         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 */

 static CborError utf8EscapedDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)

198 {

     const uint8_t *buffer = (const uint8_t *)ptr;

     const uint8_t * const end = buffer + n;

201 CborError err = CborNoError;

202

     while (buffer < end && !err) {

         uint32_t uc = get_utf8(&buffer, end);

         if (uc == ~0U)

206 return CborErrorInvalidUtf8TextString;

207

         if (uc < 0x80) {

209 /* single-byte UTF-8 */

             unsigned char escaped = (unsigned char)uc;

             if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {

                 err = stream(out, "%c", (char)uc);

213 continue;

214 }

215

216 /* print as an escape sequence */

217 switch (uc) {

218 case '"':

             case '\\':

220 break;

             case '\b':

222 escaped = 'b';

223 break;

             case '\f':

225 escaped = 'f';

226 break;

             case '\n':

228 escaped = 'n';

229 break;

             case '\r':

231 escaped = 'r';

232 break;

             case '\t':

234 escaped = 't';

235 break;

236 default:

237 goto print_utf16;

238 }

             err = stream(out, "\\%c", escaped);

240 continue;

241 }

242

243 /* now print the sequence */

         if (uc > 0xffffU) {

245 /* needs surrogate pairs */

             err = stream(out, "\\u%04" PRIX32 "\\u%04" PRIX32,

                          (uc >> 10) + 0xd7c0,    /* high surrogate */

                          (uc % 0x0400) + 0xdc00);

249 } else {

250 print_utf16:

251 /* no surrogate pair needed */

             err = stream(out, "\\u%04" PRIX32, uc);

253 }

254 }

255 return err;

256 }

257

 static const char *resolve_indicator(const uint8_t *ptr, const uint8_t *end, int flags)

259 {

     static const char indicators[8][3] = {

         "_0", "_1", "_2", "_3",

         "", "", "",             /* these are not possible */

263 "_"

264 };

     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];

     if ((flags & CborPrettyIndicateOverlongNumbers) == 0)

283 return no_indicator;

284

     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;

     if (value > 0xffU)

293 ++expected_information;

     if (value > 0xffffU)

295 ++expected_information;

     if (value > 0xffffffffU)

297 ++expected_information;

298 return expected_information == additional_information ?

299 no_indicator :

300 indicators[additional_information - Value8Bit];

301 }

302

 static const char *get_indicator(const CborValue *it, int flags)

304 {

     return resolve_indicator(it->ptr, it->parser->end, flags);

306 }

307

 static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft);

 static CborError container_to_pretty(CborStreamFunction stream, void *out, CborValue *it, CborType containerType,

310 int flags, int recursionsLeft)

311 {

     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

     while (!cbor_value_at_end(it) && !err) {

         err = stream(out, "%s", comma);

322 comma = ", ";

323

324 if (!err)

             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)

             err = stream(out, ": ");

333 if (!err)

             err = value_to_pretty(stream, out, it, flags, recursionsLeft);

335 }

336 return err;

337 }

338

 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;

         const char *indicator = get_indicator(it, flags);

         const char *space = *indicator ? " " : indicator;

350

         err = stream(out, "%c%s%s", type == CborArrayType ? '[' : '{', indicator, space);

352 if (err)

353 return err;

354

         err = cbor_value_enter_container(it, &recursed);

356 if (err) {

357 it->ptr = recursed.ptr;

358 return err; /* parse error */

359 }

         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 }

         err = cbor_value_leave_container(it, &recursed);

366 if (err)

367 return err; /* parse error */

368

         return stream(out, type == CborArrayType ? "]" : "}");

370 }

371

372 case CborIntegerType: {

373 uint64_t val;

         cbor_value_get_raw_integer(it, &val);    /* can't fail */

375

         if (cbor_value_is_unsigned_integer(it)) {

             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 */

                 err = stream(out, "-%" PRIu64, val);

383 } else {

384 /* overflown

385 * 0xffff`ffff`ffff`ffff + 1 =

386 * 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64) */

                 err = stream(out, "-18446744073709551616");

388 }

389 }

390 if (!err)

             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;

         bool showingFragments = (flags & CborPrettyShowStringFragments) && !cbor_value_is_length_known(it);

         const char *separator = "";

         char close = '\'';

         char open[3] = "h'";

403 const char *indicator = NULL;

404

405 if (type == CborTextStringType) {

             close = open[0] = '"';

             open[1] = '\0';

408 }

409

410 if (showingFragments) {

             err = stream(out, "(_ ");

412 if (!err)

413 err = _cbor_value_prepare_string_iteration(it);

414 } else {

             err = stream(out, "%s", open);

416 }

417

418 while (!err) {

             if (showingFragments || indicator == NULL) {

420 /* any iteration, except the second for a non-chunked string */

                 indicator = resolve_indicator(it->ptr, it->parser->end, flags);

422 }

423

             err = _cbor_value_get_string_chunk(it, &ptr, &n, it);

425 if (!ptr)

426 break;

427

428 if (!err && showingFragments)

                 err = stream(out, "%s%s", separator, open);

430 if (!err)

431 err = (type == CborByteStringType ?

                            hexDump(stream, out, ptr, n) :

                            utf8EscapedDump(stream, out, ptr, n));

434 if (!err && showingFragments) {

                 err = stream(out, "%c%s", close, indicator);

436 separator = ", ";

437 }

438 }

439

440 if (!err) {

441 if (showingFragments)

                 err = stream(out, ")");

443 else

                 err = stream(out, "%c%s", close, indicator);

445 }

446 return err;

447 }

448

449 case CborTagType: {

450 CborTag tag;

         cbor_value_get_tag(it, &tag);       /* can't fail */

         err = stream(out, "%" PRIu64 "%s(", tag, get_indicator(it, flags));

453 if (!err)

454 err = cbor_value_advance_fixed(it);

455 if (!err && recursionsLeft)

             err = value_to_pretty(stream, out, it, flags, recursionsLeft - 1);

457 else if (!err)

458 printRecursionLimit(stream, out);

459 if (!err)

             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);

         err = stream(out, "simple(%" PRIu8 ")", simple_type);

469 break;

470 }

471

472 case CborNullType:

         err = stream(out, "null");

474 break;

475

476 case CborUndefinedType:

         err = stream(out, "undefined");

478 break;

479

480 case CborBooleanType: {

481 bool val;

         cbor_value_get_boolean(it, &val);       /* can't fail */

         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;

             suffix = flags & CborPrettyNumericEncodingIndicators ? "_2" : "f";

         } 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);

             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

         if ((flags & CborPrettyNumericEncodingIndicators) == 0) {

518 r = fpclassify(val);

             if (r == FP_NAN || r == FP_INFINITE)

520 suffix = "";

521 }

522

         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) */

             err = stream(out, "%s%" PRIu64 ".%s", val < 0 ? "-" : "", ival, suffix);

527 } else {

528 /* this number is definitely not a 64-bit integer */

             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:

         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 */

 CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags)

574 {

     return value_to_pretty(streamFunction, token, value, flags, CBOR_PARSER_MAX_RECURSIONS);

576 }

577

578 /** @} */