--- /dev/null
+.tag export-subst
+.gitignore export-ignore
+.gitattributes export-ignore
--- /dev/null
+# Frequent generated files
+callgrind.out.*
+pcviewer.cfg
+*~
+*.a
+*.la
+*.core
+*.d
+*.dylib
+*.moc
+*.o
+*.obj
+*.orig
+*.swp
+*.rej
+*.so
+*.so.*
+*.pbxuser
+*.mode1
+*.mode1v3
+*_pch.h.cpp
+*_resource.rc
+.#*
+*.*#
+core
+.qmake.cache
+.qmake.vars
+.device.vars
+tags
+.DS_Store
+*.debug
+Makefile*
+*.prl
+*.app
+*.pro.user*
+*.qmlproject.user*
+*.gcov
+*.gcda
+*.gcno
+*.flc
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+*.exe.embed.manifest
+*.exe_manifest.rc
+*.exe_manifest.res
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# INTEGRITY generated files
+*.gpj
+*.int
+*.ael
+*.dla
+*.dnm
+*.dep
+*.map
+
+bin
+lib
+src/cjson
+!Makefile
+.config
--- /dev/null
+$Format:%H$
--- /dev/null
+language: cpp
+os:
+ - linux
+ - osx
+env:
+ - CFLAGS="-O0 -g" QMAKEFLAGS="-config debug" PATH=/opt/qt56/bin:/usr/local/opt/qt5/bin:$PATH
+install:
+ - if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
+ sudo apt-add-repository -y ppa:beineri/opt-qt56;
+ sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test;
+ sudo apt-get update -qq;
+ sudo apt-get install -y qt56base valgrind g++-5;
+ else
+ brew install qt5;
+ fi
+script:
+ - if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
+ sudo ln -sf g++-5 /usr/bin/g++;
+ fi
+ - make -s -f Makefile.configure configure | tee .config
+ - make
+ CFLAGS="$CFLAGS"
+ all tests/Makefile
+ - cd tests && make check -k
+ TESTRUNNER=`which valgrind 2>/dev/null`
--- /dev/null
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- /dev/null
+# Variables:
+prefix = /usr/local
+exec_prefix = $(prefix)
+bindir = $(exec_prefix)/bin
+libdir = $(exec_prefix)/lib
+includedir = $(prefix)/include
+pkgconfigdir = $(libdir)/pkgconfig
+
+CFLAGS = -Wall -Wextra
+LDFLAGS_GCSECTIONS = -Wl,--gc-sections
+LDFLAGS = $(if $(gc_sections-pass),$(LDFLAGS_GCSECTIONS))
+
+GIT_ARCHIVE = git archive --prefix="$(PACKAGE)/" -9
+INSTALL = install
+INSTALL_DATA = $(INSTALL) -m 644
+INSTALL_PROGRAM = $(INSTALL) -m 755
+QMAKE = qmake
+MKDIR = mkdir -p
+RMDIR = rmdir
+SED = sed
+
+# Our sources
+TINYCBOR_HEADERS = src/cbor.h src/cborjson.h
+TINYCBOR_SOURCES = \
+ src/cborerrorstrings.c \
+ src/cborencoder.c \
+ src/cborencoder_close_container_checked.c \
+ src/cborparser.c \
+ src/cborpretty.c \
+ src/cbortojson.c \
+ $(if $(open_memstream-pass),,src/open_memstream.c) \
+#
+CBORDUMP_SOURCES = tools/cbordump/cbordump.c
+
+INSTALL_TARGETS += $(bindir)/cbordump
+INSTALL_TARGETS += $(libdir)/libtinycbor.a
+INSTALL_TARGETS += $(pkgconfigdir)/tinycbor.pc
+INSTALL_TARGETS += $(TINYCBOR_HEADERS:src/%=$(includedir)/tinycbor/%)
+
+# setup VPATH
+MAKEFILE := $(lastword $(MAKEFILE_LIST))
+SRCDIR := $(dir $(MAKEFILE))
+VPATH = $(SRCDIR):$(SRCDIR)/src
+
+# Our version
+GIT_DIR := $(strip $(shell git -C $(SRCDIR). rev-parse --git-dir 2> /dev/null))
+ifeq ($(GIT_DIR),)
+ VERSION = $(shell cat $(SRCDIR)VERSION)
+ DIRTYSRC :=
+else
+ VERSION := $(shell git -C $(SRCDIR). describe --tags | cut -c2-)
+ DIRTYSRC := $(shell \
+ test -n "`git -C $(SRCDIR). diff --name-only HEAD`" && \
+ echo +)
+endif
+PACKAGE = tinycbor-$(VERSION)
+
+# Check that QMAKE is Qt 5
+ifeq ($(origin QMAKE),file)
+ check_qmake = $(strip $(shell $(1) -query QT_VERSION 2>/dev/null | cut -b1))
+ ifneq ($(call check_qmake,$(QMAKE)),5)
+ QMAKE := qmake -qt5
+ ifneq ($(call check_qmake,$(QMAKE)),5)
+ QMAKE := qmake-qt5
+ ifneq ($(call check_qmake,$(QMAKE)),5)
+ QMAKE := @echo >&2 $(MAKEFILE): Cannot find a Qt 5 qmake; false
+ endif
+ endif
+ endif
+endif
+
+-include .config
+
+# json2cbor depends on an external library (cJSON)
+ifneq ($(cjson-pass)$(system-cjson-pass),)
+ JSON2CBOR_SOURCES = tools/json2cbor/json2cbor.c
+ INSTALL_TARGETS += $(bindir)/json2cbor
+ ifeq ($(system-cjson-pass),1)
+ LDFLAGS_CJSON = -lcJSON
+ else
+ JSON2CBOR_SOURCES += src/cjson/cJSON.c
+ json2cbor_CCFLAGS = -I$(SRCDIR)src/cjson
+ endif
+endif
+
+# Rules
+all: .config lib/libtinycbor.a bin/cbordump tinycbor.pc
+all: $(if $(JSON2CBOR_SOURCES),bin/json2cbor)
+check: tests/Makefile | lib/libtinycbor.a
+ $(MAKE) -C tests check
+silentcheck: | lib/libtinycbor.a
+ TESTARGS=-silent $(MAKE) -f $(MAKEFILE) -s check
+configure: .config
+.config: Makefile.configure
+ $(MAKE) -f $(SRCDIR)Makefile.configure OUT='>&10' configure 10> $@
+
+lib bin:
+ $(MKDIR) $@
+
+lib/libtinycbor.a: $(TINYCBOR_SOURCES:.c=.o) | lib
+ $(AR) cqs $@ $^
+
+bin/cbordump: $(CBORDUMP_SOURCES:.c=.o) lib/libtinycbor.a | bin
+ $(CC) -o $@ $(LDFLAGS) $^ $(LDLIBS) -lm
+
+bin/json2cbor: $(JSON2CBOR_SOURCES:.c=.o) lib/libtinycbor.a | bin
+ $(CC) -o $@ $(LDFLAGS) $(LDFLAGS_CJSON) $^ $(LDLIBS) -lm
+
+tinycbor.pc: tinycbor.pc.in
+ $(SED) > $@ < $< \
+ -e 's,@prefix@,$(prefix),' \
+ -e 's,@exec_prefix@,$(exec_prefix),' \
+ -e 's,@libdir@,$(libdir),' \
+ -e 's,@includedir@,$(includedir),' \
+ -e 's,@version@,$(VERSION),'
+
+tests/Makefile: tests/tests.pro
+ $(QMAKE) $(QMAKEFLAGS) -o $@ $<
+
+$(PACKAGE).tar.gz: | .git
+ GIT_DIR=$(SRCDIR).git $(GIT_ARCHIVE) --format=tar.gz -o "$(PACKAGE).tar.gz" HEAD
+$(PACKAGE).zip: | .git
+ GIT_DIR=$(SRCDIR).git $(GIT_ARCHIVE) --format=zip -o "$(PACKAGE).zip" HEAD
+
+$(DESTDIR)%/:
+ $(INSTALL) -d $@
+$(DESTDIR)$(libdir)/%: lib/% | $(DESTDIR)$(libdir)/
+ $(INSTALL_DATA) $< $@
+$(DESTDIR)$(bindir)/%: bin/% | $(DESTDIR)$(bindir)/
+ $(INSTALL_PROGRAM) $< $@
+$(DESTDIR)$(pkgconfigdir)/%: % | $(DESTDIR)$(pkgconfigdir)/
+ $(INSTALL_DATA) $< $@
+$(DESTDIR)$(includedir)/tinycbor/%: src/% | $(DESTDIR)$(includedir)/tinycbor/
+ $(INSTALL_DATA) $< $@
+
+install-strip:
+ $(MAKE) -f $(MAKEFILE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' install
+
+install: $(INSTALL_TARGETS:%=$(DESTDIR)%)
+uninstall:
+ $(RM) $(INSTALL_TARGETS:%=$(DESTDIR)%)
+
+mostlyclean:
+ $(RM) $(TINYCBOR_SOURCES:.c=.o)
+ $(RM) $(CBORDUMP_SOURCES:.c=.o)
+
+clean: mostlyclean
+ $(RM) bin/cbordump
+ $(RM) bin/json2cbor
+ $(RM) lib/libtinycbor.a
+ $(RM) tinycbor.pc
+ test -e tests/Makefile && $(MAKE) -C tests clean || :
+
+distclean: clean
+ test -e tests/Makefile && $(MAKE) -C tests distclean || :
+
+dist: $(PACKAGE).tar.gz $(PACKAGE).zip
+distcheck: .git
+ -$(RM) -r $$TMPDIR/tinycbor-distcheck
+ GIT_DIR=$(SRCDIR).git git archive --prefix=tinycbor-distcheck/ --format=tar HEAD | tar -xf - -C $$TMPDIR
+ cd $$TMPDIR/tinycbor-distcheck && $(MAKE) silentcheck
+ $(RM) -r $$TMPDIR/tinycbor-distcheck
+
+release: .git
+ $(MAKE) -f $(MAKEFILE) distcheck
+ git -C $(SRCDIR). show HEAD:VERSION | \
+ perl -l -n -e '@_ = split /\./; print "$$_[0]." . ($$_[1] + 1)' > $(SRCDIR)VERSION
+ git -C $(SRCDIR). commit -s -m "Update version number" VERSION
+ { echo "TinyCBOR release `cat $(SRCDIR)VERSION`"; \
+ echo; \
+ echo '# Write something nice about this release here'; \
+ tmpl=`git -C $(SRCDIR). config --get commit.template` && \
+ cat "$$tmpl"; \
+ echo '# Commit log:'; \
+ git -C $(SRCDIR). shortlog -e --no-merges HEAD --not `git -C $(SRCDIR). tag` | sed 's,^,# ,'; \
+ echo '# Header diff:'; \
+ git -C $(SRCDIR). diff HEAD --not `git -C $(SRCDIR). tag` -- 'src/*.h' ':!*_p.h' | sed 's,^,# ,'; \
+ } > $(SRCDIR).git/TAG_EDITMSG
+ @`git -C $(SRCDIR). var GIT_EDITOR` $(SRCDIR).git/TAG_EDITMSG
+ git -C $(SRCDIR). tag -a -F $(SRCDIR).git/TAG_EDITMSG $(GITTAGFLAGS) v`cat $(SRCDIR)VERSION`
+ $(MAKE) -f $(MAKEFILE) dist
+
+.PHONY: all check silentcheck configure install uninstall
+.PHONY: mostlyclean clean distclean
+.PHONY: dist distcheck release
+.SECONDARY:
+
+cflags := $(CPPFLAGS) -I$(SRCDIR)src
+cflags += -DTINYCBOR_VERSION=\"$(VERSION)$(DIRTYSRC)\"
+cflags += -std=c99 $(CFLAGS)
+%.o: %.c
+ @test -d $(@D) || $(MKDIR) $(@D)
+ $(CC) $(cflags) $($(basename $(notdir $@))_CCFLAGS) -c -o $@ $<
+
--- /dev/null
+ALLTESTS = open_memstream funopen gc_sections \
+ system-cjson cjson
+MAKEFILE := $(lastword $(MAKEFILE_LIST))
+OUT :=
+
+PROGRAM-open_memstream = extern int open_memstream(); int main() { return open_memstream(); }
+PROGRAM-funopen = extern int funopen(); int main() { return funopen(); }
+PROGRAM-gc_sections = int main() {}
+CCFLAGS-gc_sections = -Wl,--gc-sections
+
+PROGRAM-cjson = \#include <stdlib.h>\n
+PROGRAM-cjson += \#include <cJSON.h>\n
+PROGRAM-cjson += int main() { return cJSON_False; }
+CCFLAGS-cjson = -I$(dir $(MAKEFILE))src/cjson
+PROGRAM-system-cjson = $(PROGRAM-cjson)
+CCLFAGS-system-cjson = -lcJSON
+
+sink:
+ @echo >&2 Please run from the top-level Makefile.
+
+configure: $(foreach it,$(ALLTESTS),check-$(it))
+
+check-%:
+ @echo $(subst check-,,$@)-tested := 1 $(OUT)
+ $(if $(V),,@)if echo -e "$($(subst check-,PROGRAM-,$@))" | \
+ $(CC) -xc $($(subst check-,CCFLAGS-,$@)) -o /dev/null - $(if $(V),,>/dev/null 2>&1); \
+ then \
+ echo $(subst check-,,$@)-pass := 1 $(OUT); \
+ fi
--- /dev/null
+CFLAGS = -W3
+
+TINYCBOR_HEADERS = src\cbor.h src\cborjson.h
+TINYCBOR_SOURCES = \
+ src\cborerrorstrings.c \
+ src\cborencoder.c \
+ src\cborencoder_close_container_checked.c \
+ src\cborparser.c \
+ src\cborpretty.c
+TINYCBOR_OBJS = \
+ src\cborerrorstrings.obj \
+ src\cborencoder.obj \
+ src\cborencoder_close_container_checked.obj \
+ src\cborparser.obj \
+ src\cborpretty.obj
+
+all: lib\tinycbor.lib
+check: tests\Makefile lib\tinycbor.lib
+ cd tests & $(MAKE) check
+silentcheck:
+ cd tests & set TESTARGS=-silent & $(MAKE) -s check
+tests\Makefile: tests\tests.pro
+ qmake -o $@ $**
+
+lib\tinycbor.lib: $(TINYCBOR_OBJS)
+ -if not exist lib\NUL md lib
+ lib -nologo /out:$@ $**
+
+mostlyclean:
+ -del $(TINYCBOR_OBJS)
+clean: mostlyclean
+ -del lib\tinycbor.lib
+ if exist tests\Makefile (cd tests & $(MAKE) clean)
+distclean: clean
+ if exist tests\Makefile (cd tests & $(MAKE) distclean)
+
+{src\}.c{src\}.obj:
+ $(CC) -nologo $(CFLAGS) -Isrc -DTINYCBOR_VERSION="" -c -Fo$@ $<
+
--- /dev/null
+==== To Do list for libcbor ====
+=== General ===
+* API review
+* Benchmark
+* Write examples
+** Simple decoder
+** Decoder to JSON
+** Windowed encoding/decoding (limited memory)
+
+=== Encoder ===
+* Write API docs
+* Add API for creating indeterminate-length arrays and maps
+* Add API for creating indeterminate-length strings
+* Add API for relaxing doubles to floats and to integers
+* Add length-checking of the sub-containers (#ifndef CBOR_ENCODER_NO_USER_CHECK)
+* Decide how to indicate number of bytes needed
+** Suggestion: return negative number from the functions
+
+=== Decoder ===
+* Write functions not yet implemented
+* Add API for stream-decoding strings
+* Add API for checking known tags and simple types
+* (unlikely) Add API for checking the pairing of a tag and the tagged type
+* Write tests for error conditions
+* Fuzzy-test the decoder
--- /dev/null
+TEMPLATE = subdirs
+SUBDIRS = simplereader.pro
--- /dev/null
+#include "../src/cbor.h"
+
+#include <sys/stat.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static uint8_t *readfile(const char *fname, size_t *size)
+{
+ struct stat st;
+ FILE *f = fopen(fname, "rb");
+ if (!f)
+ return NULL;
+ if (fstat(fileno(f), &st) == -1)
+ return NULL;
+ uint8_t *buf = malloc(st.st_size);
+ *size = fread(buf, st.st_size, 1, f);
+ fclose(f);
+ return buf;
+}
+
+static void indent(int nestingLevel)
+{
+ while (nestingLevel--)
+ puts(" ");
+}
+
+static void dumpbytes(const uint8_t *buf, size_t len)
+{
+ while (len--)
+ printf("%02X ", *buf++);
+}
+
+static bool dumprecursive(CborValue *it, int nestingLevel)
+{
+ while (!cbor_value_at_end(it)) {
+ CborError err;
+ CborType type = cbor_value_get_type(it);
+
+ indent(nestingLevel);
+ switch (type) {
+ case CborArrayType:
+ case CborMapType: {
+ // recursive type
+ CborValue recursed;
+ assert(cbor_value_is_container(it));
+ puts(type == CborArrayType ? "Array[" : "Map[");
+ err = cbor_value_enter_container(it, &recursed);
+ if (err)
+ return err; // parse error
+ err = dumprecursive(&recursed, nestingLevel + 1);
+ if (err)
+ return err; // parse error
+ err = cbor_value_leave_container(it, &recursed);
+ if (err)
+ return err; // parse error
+ indent(nestingLevel);
+ puts("]");
+ continue;
+ }
+
+ case CborIntegerType: {
+ int64_t val;
+ cbor_value_get_int64(it, &val); // can't fail
+ printf("%lld\n", (long long)val);
+ break;
+ }
+
+ case CborByteStringType: {
+ uint8_t *buf;
+ size_t n;
+ err = cbor_value_dup_byte_string(it, &buf, &n, it);
+ if (err)
+ return err; // parse error
+ dumpbytes(buf, n);
+ puts("");
+ free(buf);
+ continue;
+ }
+
+ case CborTextStringType: {
+ char *buf;
+ size_t n;
+ err = cbor_value_dup_text_string(it, &buf, &n, it);
+ if (err)
+ return err; // parse error
+ puts(buf);
+ free(buf);
+ continue;
+ }
+
+ case CborTagType: {
+ CborTag tag;
+ cbor_value_get_tag(it, &tag); // can't fail
+ printf("Tag(%lld)\n", (long long)tag);
+ break;
+ }
+
+ case CborSimpleType: {
+ uint8_t type;
+ cbor_value_get_simple_type(it, &type); // can't fail
+ printf("simple(%u)\n", type);
+ break;
+ }
+
+ case CborNullType:
+ puts("null");
+ break;
+
+ case CborUndefinedType:
+ puts("undefined");
+ break;
+
+ case CborBooleanType: {
+ bool val;
+ cbor_value_get_boolean(it, &val); // can't fail
+ puts(val ? "true" : "false");
+ break;
+ }
+
+ case CborDoubleType: {
+ double val;
+ if (false) {
+ float f;
+ case CborFloatType:
+ cbor_value_get_float(it, &f);
+ val = f;
+ } else {
+ cbor_value_get_double(it, &val);
+ }
+ printf("%g\n", val);
+ break;
+ }
+ case CborHalfFloatType: {
+ uint16_t val;
+ cbor_value_get_half_float(it, &val);
+ printf("__f16(%04x)\n", val);
+ break;
+ }
+
+ case CborInvalidType:
+ assert(false); // can't happen
+ break;
+ }
+
+ err = cbor_value_advance_fixed(it);
+ if (err)
+ return err;
+ }
+ return CborNoError;
+}
+
+int main(int argc, char **argv)
+{
+ if (argc == 1) {
+ puts("simplereader <filename>");
+ return 0;
+ }
+
+ size_t length;
+ uint8_t *buf = readfile(argv[1], &length);
+ if (!buf) {
+ perror("readfile");
+ return 1;
+ }
+
+ CborParser parser;
+ CborValue it;
+ CborError err = cbor_parser_init(buf, length, 0, &parser, &it);
+ if (!err)
+ err = dumprecursive(&it, 0);
+ free(buf);
+
+ if (err) {
+ fprintf(stderr, "CBOR parsing failure at offset %ld: %s\n",
+ it.ptr - buf, cbor_error_string(err));
+ return 1;
+ }
+ return 0;
+}
--- /dev/null
+CONFIG -= qt
+SOURCES = simplereader.c
+include(../src/src.pri)
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include <assert.h>
+#ifdef NDEBUG
+# undef assert
+# define assert(cond) do { if (!(cond)) unreachable(); } while (0)
+#endif
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBOR_H
+#define CBOR_H
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+#ifndef SIZE_MAX
+/* Some systems fail to define SIZE_MAX in <stdint.h>, even though C99 requires it...
+ * Conversion from signed to unsigned is defined in 6.3.1.3 (Signed and unsigned integers) p2,
+ * which says: "the value is converted by repeatedly adding or subtracting one more than the
+ * maximum value that can be represented in the new type until the value is in the range of the
+ * new type."
+ * So -1 gets converted to size_t by adding SIZE_MAX + 1, which results in SIZE_MAX.
+ */
+# define SIZE_MAX ((size_t)-1)
+#endif
+
+#ifndef CBOR_API
+# define CBOR_API
+#endif
+#ifndef CBOR_PRIVATE_API
+# define CBOR_PRIVATE_API
+#endif
+#ifndef CBOR_INLINE_API
+# if defined(__cplusplus)
+# define CBOR_INLINE inline
+# define CBOR_INLINE_API inline
+# else
+# define CBOR_INLINE_API static CBOR_INLINE
+# if defined(_MSC_VER)
+# define CBOR_INLINE __inline
+# elif defined(__GNUC__)
+# define CBOR_INLINE __inline__
+# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+# define CBOR_INLINE inline
+# else
+# define CBOR_INLINE
+# endif
+# endif
+#endif
+
+typedef enum CborType {
+ CborIntegerType = 0x00,
+ CborByteStringType = 0x40,
+ CborTextStringType = 0x60,
+ CborArrayType = 0x80,
+ CborMapType = 0xa0,
+ CborTagType = 0xc0,
+ CborSimpleType = 0xe0,
+ CborBooleanType = 0xf5,
+ CborNullType = 0xf6,
+ CborUndefinedType = 0xf7,
+ CborHalfFloatType = 0xf9,
+ CborFloatType = 0xfa,
+ CborDoubleType = 0xfb,
+
+ CborInvalidType = 0xff /* equivalent to the break byte, so it will never be used */
+} CborType;
+
+typedef uint64_t CborTag;
+typedef enum CborKnownTags {
+ CborDateTimeStringTag = 0, /* RFC 3339 format: YYYY-MM-DD hh:mm:ss+zzzz */
+ CborUnixTime_tTag = 1,
+ CborPositiveBignumTag = 2,
+ CborNegativeBignumTag = 3,
+ CborDecimalTag = 4,
+ CborBigfloatTag = 5,
+ CborExpectedBase64urlTag = 21,
+ CborExpectedBase64Tag = 22,
+ CborExpectedBase16Tag = 23,
+ CborUriTag = 32,
+ CborBase64urlTag = 33,
+ CborBase64Tag = 34,
+ CborRegularExpressionTag = 35,
+ CborMimeMessageTag = 36, /* RFC 2045-2047 */
+ CborSignatureTag = 55799
+} CborKnownTags;
+
+/* Error API */
+
+typedef enum CborError {
+ CborNoError = 0,
+
+ /* errors in all modes */
+ CborUnknownError,
+ CborErrorUnknownLength, /* request for length in array, map, or string with indeterminate length */
+ CborErrorAdvancePastEOF,
+ CborErrorIO,
+
+ /* parser errors streaming errors */
+ CborErrorGarbageAtEnd = 256,
+ CborErrorUnexpectedEOF,
+ CborErrorUnexpectedBreak,
+ CborErrorUnknownType, /* can only heppen in major type 7 */
+ CborErrorIllegalType, /* type not allowed here */
+ CborErrorIllegalNumber,
+ CborErrorIllegalSimpleType, /* types of value less than 32 encoded in two bytes */
+
+ /* parser errors in strict mode parsing only */
+ CborErrorUnknownSimpleType = 512,
+ CborErrorUnknownTag,
+ CborErrorInappropriateTagForType,
+ CborErrorDuplicateObjectKeys,
+ CborErrorInvalidUtf8TextString,
+
+ /* encoder errors */
+ CborErrorTooManyItems = 768,
+ CborErrorTooFewItems,
+
+ /* internal implementation errors */
+ CborErrorDataTooLarge = 1024,
+ CborErrorNestingTooDeep,
+ CborErrorUnsupportedType,
+
+ /* errors in converting to JSON */
+ CborErrorJsonObjectKeyIsAggregate,
+ CborErrorJsonObjectKeyNotString,
+
+ CborErrorOutOfMemory = ~0U / 2 + 1,
+ CborErrorInternalError = ~0U
+} CborError;
+
+CBOR_API const char *cbor_error_string(CborError error);
+
+/* Encoder API */
+struct CborEncoder
+{
+ union {
+ uint8_t *ptr;
+ ptrdiff_t bytes_needed;
+ };
+ const uint8_t *end;
+ size_t added;
+ int flags;
+};
+typedef struct CborEncoder CborEncoder;
+
+static const size_t CborIndefiniteLength = SIZE_MAX;
+
+CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags);
+CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value);
+CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value);
+CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value);
+CBOR_API CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value);
+CBOR_API CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag);
+CBOR_API CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length);
+CBOR_INLINE_API CborError cbor_encode_text_stringz(CborEncoder *encoder, const char *string)
+{ return cbor_encode_text_string(encoder, string, strlen(string)); }
+CBOR_API CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length);
+CBOR_API CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value);
+
+CBOR_INLINE_API CborError cbor_encode_boolean(CborEncoder *encoder, bool value)
+{ return cbor_encode_simple_value(encoder, (int)value - 1 + (CborBooleanType & 0x1f)); }
+CBOR_INLINE_API CborError cbor_encode_null(CborEncoder *encoder)
+{ return cbor_encode_simple_value(encoder, CborNullType & 0x1f); }
+CBOR_INLINE_API CborError cbor_encode_undefined(CborEncoder *encoder)
+{ return cbor_encode_simple_value(encoder, CborUndefinedType & 0x1f); }
+
+CBOR_INLINE_API CborError cbor_encode_half_float(CborEncoder *encoder, const void *value)
+{ return cbor_encode_floating_point(encoder, CborHalfFloatType, value); }
+CBOR_INLINE_API CborError cbor_encode_float(CborEncoder *encoder, float value)
+{ return cbor_encode_floating_point(encoder, CborFloatType, &value); }
+CBOR_INLINE_API CborError cbor_encode_double(CborEncoder *encoder, double value)
+{ return cbor_encode_floating_point(encoder, CborDoubleType, &value); }
+
+CBOR_API CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length);
+CBOR_API CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length);
+CBOR_API CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder);
+CBOR_API CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder);
+
+/* Parser API */
+
+enum CborParserIteratorFlags
+{
+ CborIteratorFlag_IntegerValueTooLarge = 0x01,
+ CborIteratorFlag_NegativeInteger = 0x02,
+ CborIteratorFlag_UnknownLength = 0x04,
+ CborIteratorFlag_ContainerIsMap = 0x20
+};
+
+struct CborParser
+{
+ const uint8_t *end;
+ int flags;
+};
+typedef struct CborParser CborParser;
+
+struct CborValue
+{
+ const CborParser *parser;
+ const uint8_t *ptr;
+ uint32_t remaining;
+ uint16_t extra;
+ uint8_t type;
+ uint8_t flags;
+};
+typedef struct CborValue CborValue;
+
+CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, int flags, CborParser *parser, CborValue *it);
+
+CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it)
+{ return it->remaining == 0; }
+CBOR_API CborError cbor_value_advance_fixed(CborValue *it);
+CBOR_API CborError cbor_value_advance(CborValue *it);
+CBOR_INLINE_API bool cbor_value_is_container(const CborValue *it)
+{ return it->type == CborArrayType || it->type == CborMapType; }
+CBOR_API CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed);
+CBOR_API CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed);
+
+CBOR_PRIVATE_API uint64_t _cbor_value_decode_int64_internal(const CborValue *value);
+CBOR_INLINE_API uint64_t _cbor_value_extract_int64_helper(const CborValue *value)
+{
+ return value->flags & CborIteratorFlag_IntegerValueTooLarge ?
+ _cbor_value_decode_int64_internal(value) : value->extra;
+}
+
+CBOR_INLINE_API bool cbor_value_is_valid(const CborValue *value)
+{ return value && value->type != CborInvalidType; }
+CBOR_INLINE_API CborType cbor_value_get_type(const CborValue *value)
+{ return (CborType)value->type; }
+
+/* Null & undefined type */
+CBOR_INLINE_API bool cbor_type_is_null(const CborValue *value)
+{ return value->type == CborNullType; }
+CBOR_INLINE_API bool cbor_type_is_undefined(const CborValue *value)
+{ return value->type == CborUndefinedType; }
+
+/* Booleans */
+CBOR_INLINE_API bool cbor_value_is_boolean(const CborValue *value)
+{ return value->type == CborBooleanType; }
+CBOR_INLINE_API CborError cbor_value_get_boolean(const CborValue *value, bool *result)
+{
+ assert(cbor_value_is_boolean(value));
+ *result = !!value->extra;
+ return CborNoError;
+}
+
+/* Simple types */
+CBOR_INLINE_API bool cbor_value_is_simple_type(const CborValue *value)
+{ return value->type == CborSimpleType; }
+CBOR_INLINE_API CborError cbor_value_get_simple_type(const CborValue *value, uint8_t *result)
+{
+ assert(cbor_value_is_simple_type(value));
+ *result = (uint8_t)value->extra;
+ return CborNoError;
+}
+
+/* Integers */
+CBOR_INLINE_API bool cbor_value_is_integer(const CborValue *value)
+{ return value->type == CborIntegerType; }
+CBOR_INLINE_API bool cbor_value_is_unsigned_integer(const CborValue *value)
+{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger) == 0; }
+CBOR_INLINE_API bool cbor_value_is_negative_integer(const CborValue *value)
+{ return cbor_value_is_integer(value) && (value->flags & CborIteratorFlag_NegativeInteger); }
+
+CBOR_INLINE_API CborError cbor_value_get_raw_integer(const CborValue *value, uint64_t *result)
+{
+ assert(cbor_value_is_integer(value));
+ *result = _cbor_value_extract_int64_helper(value);
+ return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_uint64(const CborValue *value, uint64_t *result)
+{
+ assert(cbor_value_is_unsigned_integer(value));
+ *result = _cbor_value_extract_int64_helper(value);
+ return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_int64(const CborValue *value, int64_t *result)
+{
+ assert(cbor_value_is_integer(value));
+ *result = (int64_t) _cbor_value_extract_int64_helper(value);
+ if (value->flags & CborIteratorFlag_NegativeInteger)
+ *result = -*result - 1;
+ return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_int(const CborValue *value, int *result)
+{
+ assert(cbor_value_is_integer(value));
+ *result = (int) _cbor_value_extract_int64_helper(value);
+ if (value->flags & CborIteratorFlag_NegativeInteger)
+ *result = -*result - 1;
+ return CborNoError;
+}
+
+CBOR_API CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result);
+CBOR_API CborError cbor_value_get_int_checked(const CborValue *value, int *result);
+
+CBOR_INLINE_API bool cbor_value_is_length_known(const CborValue *value)
+{ return (value->flags & CborIteratorFlag_UnknownLength) == 0; }
+
+/* Tags */
+CBOR_INLINE_API bool cbor_value_is_tag(const CborValue *value)
+{ return value->type == CborTagType; }
+CBOR_INLINE_API CborError cbor_value_get_tag(const CborValue *value, CborTag *result)
+{
+ assert(cbor_value_is_tag(value));
+ *result = _cbor_value_extract_int64_helper(value);
+ return CborNoError;
+}
+CBOR_API CborError cbor_value_skip_tag(CborValue *it);
+
+/* Strings */
+CBOR_INLINE_API bool cbor_value_is_byte_string(const CborValue *value)
+{ return value->type == CborByteStringType; }
+CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value)
+{ return value->type == CborTextStringType; }
+
+CBOR_INLINE_API CborError cbor_value_get_string_length(const CborValue *value, size_t *length)
+{
+ assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
+ if (!cbor_value_is_length_known(value))
+ return CborErrorUnknownLength;
+ uint64_t v = _cbor_value_extract_int64_helper(value);
+ *length = v;
+ if (*length != v)
+ return CborErrorDataTooLarge;
+ return CborNoError;
+}
+
+CBOR_PRIVATE_API CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
+ size_t *buflen, CborValue *next);
+CBOR_PRIVATE_API CborError _cbor_value_dup_string(const CborValue *value, void **buffer,
+ size_t *buflen, CborValue *next);
+
+CBOR_API CborError cbor_value_calculate_string_length(const CborValue *value, size_t *length);
+
+CBOR_INLINE_API CborError cbor_value_copy_text_string(const CborValue *value, char *buffer,
+ size_t *buflen, CborValue *next)
+{
+ assert(cbor_value_is_text_string(value));
+ return _cbor_value_copy_string(value, buffer, buflen, next);
+}
+CBOR_INLINE_API CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer,
+ size_t *buflen, CborValue *next)
+{
+ assert(cbor_value_is_byte_string(value));
+ return _cbor_value_copy_string(value, buffer, buflen, next);
+}
+
+CBOR_INLINE_API CborError cbor_value_dup_text_string(const CborValue *value, char **buffer,
+ size_t *buflen, CborValue *next)
+{
+ assert(cbor_value_is_text_string(value));
+ return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
+}
+CBOR_INLINE_API CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer,
+ size_t *buflen, CborValue *next)
+{
+ assert(cbor_value_is_byte_string(value));
+ return _cbor_value_dup_string(value, (void **)buffer, buflen, next);
+}
+
+/* ### TBD: partial reading API */
+
+CBOR_API CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result);
+
+/* Maps and arrays */
+CBOR_INLINE_API bool cbor_value_is_array(const CborValue *value)
+{ return value->type == CborArrayType; }
+CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value)
+{ return value->type == CborMapType; }
+
+CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, size_t *length)
+{
+ assert(cbor_value_is_array(value));
+ if (!cbor_value_is_length_known(value))
+ return CborErrorUnknownLength;
+ uint64_t v = _cbor_value_extract_int64_helper(value);
+ *length = v;
+ if (*length != v)
+ return CborErrorDataTooLarge;
+ return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_map_length(const CborValue *value, size_t *length)
+{
+ assert(cbor_value_is_map(value));
+ if (!cbor_value_is_length_known(value))
+ return CborErrorUnknownLength;
+ uint64_t v = _cbor_value_extract_int64_helper(value);
+ *length = v;
+ if (*length != v)
+ return CborErrorDataTooLarge;
+ return CborNoError;
+}
+
+CBOR_API CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element);
+
+/* Floating point */
+CBOR_API CborError cbor_value_get_half_float(const CborValue *value, void *result);
+CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result)
+{
+ assert(value->type == CborFloatType);
+ assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
+ uint32_t data = (uint32_t)_cbor_value_decode_int64_internal(value);
+ memcpy(result, &data, sizeof(*result));
+ return CborNoError;
+}
+
+CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result)
+{
+ assert(value->type == CborDoubleType);
+ assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
+ uint64_t data = _cbor_value_decode_int64_internal(value);
+ memcpy(result, &data, sizeof(*result));
+ return CborNoError;
+}
+
+/* Human-readable (dump) API */
+CBOR_API CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value);
+CBOR_INLINE_API CborError cbor_value_to_pretty(FILE *out, const CborValue *value)
+{
+ CborValue copy = *value;
+ return cbor_value_to_pretty_advance(out, ©);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CBOR_H
+
--- /dev/null
+#ifndef CBORCONSTANTS_P_H
+#define CBORCONSTANTS_P_H
+
+/*
+ * CBOR Major types
+ * Encoded in the high 3 bits of the descriptor byte
+ * See http://tools.ietf.org/html/rfc7049#section-2.1
+ */
+typedef enum CborMajorTypes {
+ UnsignedIntegerType = 0U,
+ NegativeIntegerType = 1U,
+ ByteStringType = 2U,
+ TextStringType = 3U,
+ ArrayType = 4U,
+ MapType = 5U, /* a.k.a. object */
+ TagType = 6U,
+ SimpleTypesType = 7U
+} CborMajorTypes;
+
+/*
+ * CBOR simple and floating point types
+ * Encoded in the low 8 bits of the descriptor byte when the
+ * Major Type is 7.
+ */
+typedef enum CborSimpleTypes {
+ FalseValue = 20,
+ TrueValue = 21,
+ NullValue = 22,
+ UndefinedValue = 23,
+ SimpleTypeInNextByte = 24, /* not really a simple type */
+ HalfPrecisionFloat = 25, /* ditto */
+ SinglePrecisionFloat = 26, /* ditto */
+ DoublePrecisionFloat = 27, /* ditto */
+ Break = 31
+} CborSimpleTypes;
+
+enum {
+ SmallValueBitLength = 5U,
+ SmallValueMask = (1U << SmallValueBitLength) - 1, // 31
+ Value8Bit = 24U,
+ Value16Bit = 25U,
+ Value32Bit = 26U,
+ Value64Bit = 27U,
+ IndefiniteLength = 31U,
+
+ MajorTypeShift = SmallValueBitLength,
+ MajorTypeMask = ~0U << MajorTypeShift,
+
+ BreakByte = (unsigned)Break | (SimpleTypesType << MajorTypeShift)
+};
+
+#endif // CBORCONSTANTS_P_H
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "assert_p.h" /* Always include last */
+
+void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags)
+{
+ encoder->ptr = buffer;
+ encoder->end = buffer + size;
+ encoder->added = 0;
+ encoder->flags = flags;
+}
+
+static inline void put16(void *where, uint16_t v)
+{
+ v = cbor_htons(v);
+ memcpy(where, &v, sizeof(v));
+}
+
+// Note: Since this is currently only used in situations where OOM is the only
+// valid error, we KNOW this to be true. Thus, this function now returns just 'true',
+// but if in the future, any function starts returning a non-OOM error, this will need
+// to be changed to the test. At the moment, this is done to prevent more branches
+// being created in the tinycbor output
+static inline bool isOomError(CborError err)
+{
+ (void) err;
+ return true;
+}
+
+static inline void put32(void *where, uint32_t v)
+{
+ v = cbor_htonl(v);
+ memcpy(where, &v, sizeof(v));
+}
+
+static inline void put64(void *where, uint64_t v)
+{
+ v = cbor_htonll(v);
+ memcpy(where, &v, sizeof(v));
+}
+
+static inline bool would_overflow(CborEncoder *encoder, size_t len)
+{
+ ptrdiff_t remaining = (ptrdiff_t)encoder->end;
+ remaining -= remaining ? (ptrdiff_t)encoder->ptr : encoder->bytes_needed;
+ remaining -= (ptrdiff_t)len;
+ return unlikely(remaining < 0);
+}
+
+static inline void advance_ptr(CborEncoder *encoder, size_t n)
+{
+ if (encoder->end)
+ encoder->ptr += n;
+ else
+ encoder->bytes_needed += n;
+}
+
+static inline CborError append_to_buffer(CborEncoder *encoder, const void *data, size_t len)
+{
+ if (would_overflow(encoder, len)) {
+ if (encoder->end != NULL) {
+ len -= encoder->end - encoder->ptr;
+ encoder->end = NULL;
+ encoder->bytes_needed = 0;
+ }
+
+ advance_ptr(encoder, len);
+ return CborErrorOutOfMemory;
+ }
+
+ memcpy(encoder->ptr, data, len);
+ encoder->ptr += len;
+ return CborNoError;
+}
+
+static inline CborError append_byte_to_buffer(CborEncoder *encoder, uint8_t byte)
+{
+ return append_to_buffer(encoder, &byte, 1);
+}
+
+static inline CborError encode_number_no_update(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType)
+{
+ /* Little-endian would have been so much more convenient here:
+ * We could just write at the beginning of buf but append_to_buffer
+ * only the necessary bytes.
+ * Since it has to be big endian, do it the other way around:
+ * write from the end. */
+ uint64_t buf[2];
+ uint8_t *const bufend = (uint8_t *)buf + sizeof(buf);
+ uint8_t *bufstart = bufend - 1;
+ put64(buf + 1, ui); // we probably have a bunch of zeros in the beginning
+
+ if (ui < Value8Bit) {
+ *bufstart += shiftedMajorType;
+ } else {
+ unsigned more = 0;
+ if (ui > 0xffU)
+ ++more;
+ if (ui > 0xffffU)
+ ++more;
+ if (ui > 0xffffffffU)
+ ++more;
+ bufstart -= (size_t)1 << more;
+ *bufstart = shiftedMajorType + Value8Bit + more;
+ }
+
+ return append_to_buffer(encoder, bufstart, bufend - bufstart);
+}
+
+static inline CborError encode_number(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType)
+{
+ ++encoder->added;
+ return encode_number_no_update(encoder, ui, shiftedMajorType);
+}
+
+
+CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value)
+{
+ return encode_number(encoder, value, UnsignedIntegerType << MajorTypeShift);
+}
+
+CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value)
+{
+ return encode_number(encoder, absolute_value, NegativeIntegerType << MajorTypeShift);
+}
+
+CborError cbor_encode_int(CborEncoder *encoder, int64_t value)
+{
+ // adapted from code in RFC 7049 appendix C (pseudocode)
+ uint64_t ui = value >> 63; // extend sign to whole length
+ uint8_t majorType = ui & 0x20; // extract major type
+ ui ^= value; // complement negatives
+ return encode_number(encoder, ui, majorType);
+}
+
+CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value)
+{
+#ifndef CBOR_ENCODER_NO_CHECK_USER
+ // check if this is a valid simple type
+ if (value >= HalfPrecisionFloat && value <= Break)
+ return CborErrorIllegalSimpleType;
+#endif
+ return encode_number(encoder, value, SimpleTypesType << MajorTypeShift);
+}
+
+CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value)
+{
+ uint8_t buf[1 + sizeof(uint64_t)];
+ assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType);
+ buf[0] = fpType;
+
+ unsigned size = 2U << (fpType - CborHalfFloatType);
+ if (size == 8)
+ put64(buf + 1, *(const uint64_t*)value);
+ else if (size == 4)
+ put32(buf + 1, *(const uint32_t*)value);
+ else
+ put16(buf + 1, *(const uint16_t*)value);
+ ++encoder->added;
+ return append_to_buffer(encoder, buf, size + 1);
+}
+
+CborError cbor_encode_tag(CborEncoder *encoder, CborTag tag)
+{
+ // tags don't count towards the number of elements in an array or map
+ return encode_number_no_update(encoder, tag, TagType << MajorTypeShift);
+}
+
+static CborError encode_string(CborEncoder *encoder, size_t length, uint8_t shiftedMajorType, const void *string)
+{
+ CborError err = encode_number(encoder, length, shiftedMajorType);
+ if (err && !isOomError(err))
+ return err;
+ return append_to_buffer(encoder, string, length);
+}
+
+CborError cbor_encode_byte_string(CborEncoder *encoder, const uint8_t *string, size_t length)
+{
+ return encode_string(encoder, length, ByteStringType << MajorTypeShift, string);
+}
+
+CborError cbor_encode_text_string(CborEncoder *encoder, const char *string, size_t length)
+{
+ return encode_string(encoder, length, TextStringType << MajorTypeShift, string);
+}
+
+#ifdef __GNUC__
+__attribute__((noinline))
+#endif
+static CborError create_container(CborEncoder *encoder, CborEncoder *container, size_t length, uint8_t shiftedMajorType)
+{
+ CborError err;
+ container->ptr = encoder->ptr;
+ container->end = encoder->end;
+ ++encoder->added;
+ container->added = 0;
+
+ cbor_static_assert(((MapType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == CborIteratorFlag_ContainerIsMap);
+ cbor_static_assert(((ArrayType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == 0);
+ container->flags = shiftedMajorType & CborIteratorFlag_ContainerIsMap;
+
+ if (length == CborIndefiniteLength) {
+ container->flags |= CborIteratorFlag_UnknownLength;
+ err = append_byte_to_buffer(container, shiftedMajorType + IndefiniteLength);
+ } else {
+ err = encode_number_no_update(container, length, shiftedMajorType);
+ }
+ if (err && !isOomError(err))
+ return err;
+
+ return CborNoError;
+}
+
+CborError cbor_encoder_create_array(CborEncoder *encoder, CborEncoder *arrayEncoder, size_t length)
+{
+ return create_container(encoder, arrayEncoder, length, ArrayType << MajorTypeShift);
+}
+
+CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder, size_t length)
+{
+ if (length != CborIndefiniteLength && length > SIZE_MAX / 2)
+ return CborErrorDataTooLarge;
+ return create_container(encoder, mapEncoder, length, MapType << MajorTypeShift);
+}
+
+CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder)
+{
+ if (encoder->end)
+ encoder->ptr = containerEncoder->ptr;
+ else
+ encoder->bytes_needed = containerEncoder->bytes_needed;
+ encoder->end = containerEncoder->end;
+ if (containerEncoder->flags & CborIteratorFlag_UnknownLength)
+ return append_byte_to_buffer(encoder, BreakByte);
+ return CborNoError;
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include "extract_number_p.h"
+
+#include <assert.h>
+
+#include "assert_p.h" /* Always include last */
+
+CborError cbor_encoder_close_container_checked(CborEncoder *encoder, const CborEncoder *containerEncoder)
+{
+ const uint8_t *ptr = encoder->ptr;
+ CborError err = cbor_encoder_close_container(encoder, containerEncoder);
+ if (containerEncoder->flags & CborIteratorFlag_UnknownLength || encoder->end == NULL)
+ return err;
+
+ // check what the original length was
+ uint64_t actually_added;
+ err = extract_number(&ptr, encoder->ptr, &actually_added);
+ if (err)
+ return err;
+
+ if (containerEncoder->flags & CborIteratorFlag_ContainerIsMap) {
+ if (actually_added > SIZE_MAX / 2)
+ return CborErrorDataTooLarge;
+ actually_added *= 2;
+ }
+ return actually_added == containerEncoder->added ? CborNoError :
+ actually_added < containerEncoder->added ? CborErrorTooManyItems : CborErrorTooFewItems;
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include "cbor.h"
+
+#ifndef _
+# define _(msg) msg
+#endif
+
+const char *cbor_error_string(CborError error)
+{
+ switch (error) {
+ case CborNoError:
+ return "";
+
+ case CborUnknownError:
+ return _("unknown error");
+
+ case CborErrorOutOfMemory:
+ return _("out of memory/need more memory");
+
+ case CborErrorUnknownLength:
+ return _("unknown length (attempted to get the length of a map/array/string of indeterminate length");
+
+ case CborErrorAdvancePastEOF:
+ return _("attempted to advance past EOF");
+
+ case CborErrorIO:
+ return _("I/O error");
+
+ case CborErrorGarbageAtEnd:
+ return _("garbage after the end of the content");
+
+ case CborErrorUnexpectedEOF:
+ return _("unexpected end of data");
+
+ case CborErrorUnexpectedBreak:
+ return _("unexpected 'break' byte");
+
+ case CborErrorUnknownType:
+ return _("illegal byte (encodes future extension type)");
+
+ case CborErrorIllegalType:
+ return _("mismatched string type in chunked string");
+
+ case CborErrorIllegalNumber:
+ return _("illegal initial byte (encodes unspecified additional information)");
+
+ case CborErrorIllegalSimpleType:
+ return _("illegal encoding of simple type smaller than 32");
+
+ case CborErrorUnknownSimpleType:
+ return _("unknown simple type");
+
+ case CborErrorUnknownTag:
+ return _("unknown tag");
+
+ case CborErrorInappropriateTagForType:
+ return _("inappropriate tag for type");
+
+ case CborErrorDuplicateObjectKeys:
+ return _("duplicate keys in object");
+
+ case CborErrorInvalidUtf8TextString:
+ return _("invalid UTF-8 content in string");
+
+ case CborErrorTooManyItems:
+ return _("too many items added to encoder");
+
+ case CborErrorTooFewItems:
+ return _("too few items added to encoder");
+
+ case CborErrorDataTooLarge:
+ return _("internal error: data too large");
+
+ case CborErrorNestingTooDeep:
+ return _("internal error: too many nested containers found in recursive function");
+
+ case CborErrorUnsupportedType:
+ return _("unsupported type");
+
+ case CborErrorJsonObjectKeyIsAggregate:
+ return _("conversion to JSON failed: key in object is an array or map");
+
+ case CborErrorJsonObjectKeyNotString:
+ return _("conversion to JSON failed: key in object is not a string");
+
+
+ case CborErrorInternalError:
+ return _("internal error");
+ }
+ return cbor_error_string(CborUnknownError);
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef CBORJSON_H
+#define CBORJSON_H
+
+#include "cbor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Conversion to JSON */
+enum CborToJsonFlags
+{
+ CborConvertAddMetadata = 1,
+ CborConvertTagsToObjects = 2,
+ CborConvertIgnoreTags = 0,
+
+ CborConvertObeyByteStringTags = 0,
+ CborConvertByteStringsToBase64Url = 4,
+
+ CborConvertRequireMapStringKeys = 0,
+ CborConvertStringifyMapKeys = 8,
+
+ CborConvertDefaultFlags = 0
+};
+
+CBOR_API CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags);
+CBOR_INLINE_API CborError cbor_value_to_json(FILE *out, const CborValue *value, int flags)
+{
+ CborValue copy = *value;
+ return cbor_value_to_json_advance(out, ©, flags);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CBORJSON_H
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include "extract_number_p.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "assert_p.h" /* Always include last */
+
+#ifndef CBOR_PARSER_MAX_RECURSIONS
+# define CBOR_PARSER_MAX_RECURSIONS 1024
+#endif
+
+/**
+ * \typedef CborValue
+ * This type contains one value parsed from the CBOR stream.
+ *
+ * To get the actual type, use cbor_value_get_type(). Then extract the value
+ * using one of the corresponding functions: cbor_value_get_boolean(), cbor_value_get_int64(),
+ * cbor_value_get_int(), cbor_value_copy_string(), cbor_value_get_array(), cbor_value_get_map(),
+ * cbor_value_get_double(), cbor_value_get_float().
+ *
+ * In C++ and C11 modes, you can additionally use the cbor_value_get_integer()
+ * and cbor_value_get_floating_point() generic functions.
+ *
+ * \omit
+ * Implementation details: the CborValue contains these fields:
+ * \list
+ * \li ptr: pointer to the actual data
+ * \li flags: flags from the decoder
+ * \li extra: partially decoded integer value (0, 1 or 2 bytes)
+ * \li remaining: remaining items in this collection after this item or UINT32_MAX if length is unknown
+ * \endlist
+ * \endomit
+ */
+
+static CborError extract_length(const CborParser *parser, const uint8_t **ptr, size_t *len)
+{
+ uint64_t v;
+ CborError err = extract_number(ptr, parser->end, &v);
+ if (err) {
+ *len = 0;
+ return err;
+ }
+
+ *len = v;
+ if (v != *len)
+ return CborErrorDataTooLarge;
+ return CborNoError;
+}
+
+static bool is_fixed_type(uint8_t type)
+{
+ return type != CborTextStringType && type != CborByteStringType && type != CborArrayType &&
+ type != CborMapType;
+}
+
+static CborError preparse_value(CborValue *it)
+{
+ const CborParser *parser = it->parser;
+ it->type = CborInvalidType;
+
+ // are we at the end?
+ if (it->ptr == parser->end)
+ return CborErrorUnexpectedEOF;
+
+ uint8_t descriptor = *it->ptr;
+ uint8_t type = descriptor & MajorTypeMask;
+ it->type = type;
+ it->flags = 0;
+ it->extra = (descriptor &= SmallValueMask);
+
+ if (descriptor > Value64Bit) {
+ if (unlikely(descriptor != IndefiniteLength))
+ return type == CborSimpleType ? CborErrorUnknownType : CborErrorIllegalNumber;
+ if (likely(!is_fixed_type(type))) {
+ // special case
+ it->flags |= CborIteratorFlag_UnknownLength;
+ it->type = type;
+ return CborNoError;
+ }
+ return type == CborSimpleType ? CborErrorUnexpectedBreak : CborErrorIllegalNumber;
+ }
+
+ size_t bytesNeeded = descriptor < Value8Bit ? 0 : (1 << (descriptor - Value8Bit));
+ if (bytesNeeded + 1 > (size_t)(parser->end - it->ptr))
+ return CborErrorUnexpectedEOF;
+
+ uint8_t majortype = type >> MajorTypeShift;
+ if (majortype == NegativeIntegerType) {
+ it->flags |= CborIteratorFlag_NegativeInteger;
+ it->type = CborIntegerType;
+ } else if (majortype == SimpleTypesType) {
+ switch (descriptor) {
+ case FalseValue:
+ it->extra = false;
+ it->type = CborBooleanType;
+ break;
+
+ case SinglePrecisionFloat:
+ case DoublePrecisionFloat:
+ it->flags |= CborIteratorFlag_IntegerValueTooLarge;
+ // fall through
+ case TrueValue:
+ case NullValue:
+ case UndefinedValue:
+ case HalfPrecisionFloat:
+ it->type = *it->ptr;
+ break;
+
+ case SimpleTypeInNextByte:
+ it->extra = (uint8_t)it->ptr[1];
+#ifndef CBOR_PARSER_NO_STRICT_CHECKS
+ if (unlikely(it->extra < 32)) {
+ it->type = CborInvalidType;
+ return CborErrorIllegalSimpleType;
+ }
+#endif
+ break;
+
+ case 28:
+ case 29:
+ case 30:
+ case Break:
+ assert(false); // these conditions can't be reached
+ return CborErrorUnexpectedBreak;
+ }
+ return CborNoError;
+ }
+
+ // try to decode up to 16 bits
+ if (descriptor < Value8Bit)
+ return CborNoError;
+
+ if (descriptor == Value8Bit)
+ it->extra = (uint8_t)it->ptr[1];
+ else if (descriptor == Value16Bit)
+ it->extra = get16(it->ptr + 1);
+ else
+ it->flags |= CborIteratorFlag_IntegerValueTooLarge; // Value32Bit or Value64Bit
+ return CborNoError;
+}
+
+static CborError preparse_next_value(CborValue *it)
+{
+ if (it->remaining != UINT32_MAX) {
+ // don't decrement the item count if the current item is tag: they don't count
+ if (it->type != CborTagType && !--it->remaining) {
+ it->type = CborInvalidType;
+ return CborNoError;
+ }
+ } else if (it->remaining == UINT32_MAX && it->ptr != it->parser->end && *it->ptr == (uint8_t)BreakByte) {
+ // end of map or array
+ ++it->ptr;
+ it->type = CborInvalidType;
+ it->remaining = 0;
+ return CborNoError;
+ }
+
+ return preparse_value(it);
+}
+
+static CborError advance_internal(CborValue *it)
+{
+ uint64_t length;
+ CborError err = extract_number(&it->ptr, it->parser->end, &length);
+ assert(err == CborNoError);
+
+ if (it->type == CborByteStringType || it->type == CborTextStringType) {
+ assert(length == (size_t)length);
+ assert((it->flags & CborIteratorFlag_UnknownLength) == 0);
+ it->ptr += length;
+ }
+
+ return preparse_next_value(it);
+}
+
+/** \internal
+ *
+ * Decodes the CBOR integer value when it is larger than the 16 bits available
+ * in value->extra. This function requires that value->flags have the
+ * CborIteratorFlag_IntegerValueTooLarge flag set.
+ *
+ * This function is also used to extract single- and double-precision floating
+ * point values (SinglePrecisionFloat == Value32Bit and DoublePrecisionFloat ==
+ * Value64Bit).
+ */
+uint64_t _cbor_value_decode_int64_internal(const CborValue *value)
+{
+ assert(value->flags & CborIteratorFlag_IntegerValueTooLarge ||
+ value->type == CborFloatType || value->type == CborDoubleType);
+
+ // since the additional information can only be Value32Bit or Value64Bit,
+ // we just need to test for the one bit those two options differ
+ assert((*value->ptr & SmallValueMask) == Value32Bit || (*value->ptr & SmallValueMask) == Value64Bit);
+ if ((*value->ptr & 1) == (Value32Bit & 1))
+ return get32(value->ptr + 1);
+
+ assert((*value->ptr & SmallValueMask) == Value64Bit);
+ return get64(value->ptr + 1);
+}
+
+/**
+ * Initializes the CBOR parser for parsing \a size bytes beginning at \a
+ * buffer. Parsing will use flags set in \a flags. The iterator to the first
+ * element is returned in \a it.
+ *
+ * The \a parser structure needs to remain valid throughout the decoding
+ * process. It is not thread-safe to share one CborParser among multiple
+ * threads iterating at the same time, but the object can be copied so multiple
+ * threads can iterate.
+ *
+ * ### Write how to determine the end pointer
+ * ### Write how to do limited-buffer windowed decoding
+ */
+CborError cbor_parser_init(const uint8_t *buffer, size_t size, int flags, CborParser *parser, CborValue *it)
+{
+ memset(parser, 0, sizeof(*parser));
+ parser->end = buffer + size;
+ parser->flags = flags;
+ it->parser = parser;
+ it->ptr = buffer;
+ it->remaining = 1; // there's one type altogether, usually an array or map
+ return preparse_value(it);
+}
+
+/**
+ * Advances the CBOR value \a it by one fixed-size position. Fixed-size types
+ * are: integers, tags, simple types (including boolean, null and undefined
+ * values) and floating point types.
+ *
+ * \sa cbor_value_at_end(), cbor_value_advance(), cbor_value_begin_recurse(), cbor_value_end_recurse()
+ */
+CborError cbor_value_advance_fixed(CborValue *it)
+{
+ assert(it->type != CborInvalidType);
+ assert(is_fixed_type(it->type));
+ if (!it->remaining)
+ return CborErrorAdvancePastEOF;
+ return advance_internal(it);
+}
+
+static CborError advance_recursive(CborValue *it, int nestingLevel)
+{
+ if (is_fixed_type(it->type))
+ return advance_internal(it);
+
+ if (!cbor_value_is_container(it)) {
+ size_t len = SIZE_MAX;
+ return _cbor_value_copy_string(it, NULL, &len, it);
+ }
+
+ // map or array
+ if (nestingLevel == CBOR_PARSER_MAX_RECURSIONS)
+ return CborErrorNestingTooDeep;
+
+ CborError err;
+ CborValue recursed;
+ err = cbor_value_enter_container(it, &recursed);
+ if (err)
+ return err;
+ while (!cbor_value_at_end(&recursed)) {
+ err = advance_recursive(&recursed, nestingLevel + 1);
+ if (err)
+ return err;
+ }
+ return cbor_value_leave_container(it, &recursed);
+}
+
+
+/**
+ * Advances the CBOR value \a it by one element, skipping over containers.
+ * Unlike cbor_value_advance_fixed(), this function can be called on a CBOR
+ * value of any type. However, if the type is a container (map or array) or a
+ * string with a chunked payload, this function will not run in constant time
+ * and will recurse into itself (it will run on O(n) time for the number of
+ * elements or chunks and will use O(n) memory for the number of nested
+ * containers).
+ *
+ * \sa cbor_value_at_end(), cbor_value_advance_fixed(), cbor_value_begin_recurse(), cbor_value_end_recurse()
+ */
+CborError cbor_value_advance(CborValue *it)
+{
+ assert(it->type != CborInvalidType);
+ if (!it->remaining)
+ return CborErrorAdvancePastEOF;
+ return advance_recursive(it, 0);
+}
+
+/**
+ * Advances the CBOR value \a it until it no longer points to a tag. If \a it is
+ * already not pointing to a tag, then this function returns it unchanged.
+ *
+ * \sa cbor_value_advance_fixed(), cbor_value_advance()
+ */
+CborError cbor_value_skip_tag(CborValue *it)
+{
+ while (cbor_value_is_tag(it)) {
+ CborError err = cbor_value_advance_fixed(it);
+ if (err)
+ return err;
+ }
+ return CborNoError;
+}
+
+/**
+ * \fn bool cbor_value_is_container(const CborValue *it)
+ *
+ * Returns true if the \a it value is a container and requires recursion in
+ * order to decode (maps and arrays), false otherwise.
+ */
+
+/**
+ * Creates a CborValue iterator pointing to the first element of the container
+ * represented by \a it and saves it in \a recursed. The \a it container object
+ * needs to be kept and passed again to cbor_value_leave_container() in order
+ * to continue iterating past this container.
+ *
+ * \sa cbor_value_is_container(), cbor_value_leave_container(), cbor_value_advance()
+ */
+CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed)
+{
+ CborError err;
+ assert(cbor_value_is_container(it));
+ *recursed = *it;
+
+ if (it->flags & CborIteratorFlag_UnknownLength) {
+ recursed->remaining = UINT32_MAX;
+ ++recursed->ptr;
+ err = preparse_value(recursed);
+ if (err != CborErrorUnexpectedBreak)
+ return err;
+ // actually, break was expected here
+ // it's just an empty container
+ ++recursed->ptr;
+ } else {
+ uint64_t len;
+ err = extract_number(&recursed->ptr, recursed->parser->end, &len);
+ assert(err == CborNoError);
+
+ recursed->remaining = (uint32_t)len;
+ if (recursed->remaining != len || len == UINT32_MAX) {
+ // back track the pointer to indicate where the error occurred
+ recursed->ptr = it->ptr;
+ return CborErrorDataTooLarge;
+ }
+ if (recursed->type == CborMapType) {
+ // maps have keys and values, so we need to multiply by 2
+ if (recursed->remaining > UINT32_MAX / 2) {
+ // back track the pointer to indicate where the error occurred
+ recursed->ptr = it->ptr;
+ return CborErrorDataTooLarge;
+ }
+ recursed->remaining *= 2;
+ }
+ if (len != 0)
+ return preparse_value(recursed);
+ }
+
+ // the case of the empty container
+ recursed->type = CborInvalidType;
+ recursed->remaining = 0;
+ return CborNoError;
+}
+
+/**
+ * Updates \a it to point to the next element after the container. The \a
+ * recursed object needs to point to the element obtained either by advancing
+ * the last element of the container (via cbor_value_advance(),
+ * cbor_value_advance_fixed(), a nested cbor_value_leave_container(), or the \c
+ * next pointer from cbor_value_copy_string() or cbor_value_dup_string()).
+ *
+ * \sa cbor_value_enter_container(), cbor_value_at_end()
+ */
+CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed)
+{
+ assert(cbor_value_is_container(it));
+ assert(recursed->type == CborInvalidType);
+ it->ptr = recursed->ptr;
+ return preparse_next_value(it);
+}
+
+/**
+ * Calculates the length of the string in \a value and stores the result in \a
+ * len. This function is different from cbor_value_get_string_length() in that
+ * it calculates the length even for strings sent in chunks. For that reason,
+ * this function may not run in constant time (it will run in O(n) time on the
+ * number of chunks).
+ *
+ * \note On 32-bit platforms, this function will return error condition of \ref
+ * CborErrorDataTooLarge if the stream indicates a length that is too big to
+ * fit in 32-bit.
+ *
+ * \sa cbor_value_get_string_length(), cbor_value_copy_string(), cbor_value_is_length_known()
+ */
+CborError cbor_value_calculate_string_length(const CborValue *value, size_t *len)
+{
+ *len = SIZE_MAX;
+ return _cbor_value_copy_string(value, NULL, len, NULL);
+}
+
+/**
+ * \fn CborError cbor_value_dup_text_string(const CborValue *value, char **buffer, size_t *buflen, CborValue *next)
+ *
+ * Allocates memory for the string pointed by \a value and copies it into this
+ * buffer. The pointer to the buffer is stored in \a buffer and the number of
+ * bytes copied is stored in \a len (those variables must not be NULL).
+ *
+ * If \c malloc returns a NULL pointer, this function will return error
+ * condition \ref CborErrorOutOfMemory.
+ *
+ * On success, \c{*buffer} will contain a valid pointer that must be freed by
+ * calling \c{free()}. This is the case even for zero-length strings.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * \note This function does not perform UTF-8 validation on the incoming text
+ * string.
+ *
+ * \sa cbor_value_copy_text_string(), cbor_value_dup_byte_string()
+ */
+
+/**
+ * \fn CborError cbor_value_dup_byte_string(const CborValue *value, uint8_t **buffer, size_t *buflen, CborValue *next)
+ *
+ * Allocates memory for the string pointed by \a value and copies it into this
+ * buffer. The pointer to the buffer is stored in \a buffer and the number of
+ * bytes copied is stored in \a len (those variables must not be NULL).
+ *
+ * If \c malloc returns a NULL pointer, this function will return error
+ * condition \ref CborErrorOutOfMemory.
+ *
+ * On success, \c{*buffer} will contain a valid pointer that must be freed by
+ * calling \c{free()}. This is the case even for zero-length strings.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * \sa cbor_value_copy_byte_string(), cbor_value_dup_text_string()
+ */
+CborError _cbor_value_dup_string(const CborValue *value, void **buffer, size_t *buflen, CborValue *next)
+{
+ assert(buffer);
+ assert(buflen);
+ *buflen = SIZE_MAX;
+ CborError err = _cbor_value_copy_string(value, NULL, buflen, NULL);
+ if (err)
+ return err;
+
+ ++*buflen;
+ *buffer = malloc(*buflen);
+ if (!*buffer) {
+ // out of memory
+ return CborErrorOutOfMemory;
+ }
+ err = _cbor_value_copy_string(value, *buffer, buflen, next);
+ if (err) {
+ free(*buffer);
+ return err;
+ }
+ return CborNoError;
+}
+
+// We return uintptr_t so that we can pass memcpy directly as the iteration
+// function. The choice is to optimize for memcpy, which is used in the base
+// parser API (cbor_value_copy_string), while memcmp is used in convenience API
+// only.
+typedef uintptr_t (*IterateFunction)(char *, const uint8_t *, size_t);
+
+static uintptr_t iterate_noop(char *dest, const uint8_t *src, size_t len)
+{
+ (void)dest;
+ (void)src;
+ (void)len;
+ return true;
+}
+
+static uintptr_t iterate_memcmp(char *s1, const uint8_t *s2, size_t len)
+{
+ return memcmp(s1, (const char *)s2, len) == 0;
+}
+
+static CborError iterate_string_chunks(const CborValue *value, char *buffer, size_t *buflen,
+ bool *result, CborValue *next, IterateFunction func)
+{
+ assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
+
+ size_t total;
+ CborError err;
+ const uint8_t *ptr = value->ptr;
+ if (cbor_value_is_length_known(value)) {
+ // easy case: fixed length
+ err = extract_length(value->parser, &ptr, &total);
+ if (err)
+ return err;
+ if (total > (size_t)(value->parser->end - ptr))
+ return CborErrorUnexpectedEOF;
+ if (total <= *buflen)
+ *result = !!func(buffer, ptr, total);
+ else
+ *result = false;
+ ptr += total;
+ } else {
+ // chunked
+ ++ptr;
+ total = 0;
+ *result = true;
+ while (true) {
+ size_t chunkLen;
+ size_t newTotal;
+
+ if (ptr == value->parser->end)
+ return CborErrorUnexpectedEOF;
+
+ if (*ptr == (uint8_t)BreakByte) {
+ ++ptr;
+ break;
+ }
+
+ // is this the right type?
+ if ((*ptr & MajorTypeMask) != value->type)
+ return CborErrorIllegalType;
+
+ err = extract_length(value->parser, &ptr, &chunkLen);
+ if (err)
+ return err;
+
+ if (unlikely(add_check_overflow(total, chunkLen, &newTotal)))
+ return CborErrorDataTooLarge;
+
+ if (chunkLen > (size_t)(value->parser->end - ptr))
+ return CborErrorUnexpectedEOF;
+
+ if (*result && *buflen >= newTotal)
+ *result = !!func(buffer + total, ptr, chunkLen);
+ else
+ *result = false;
+
+ ptr += chunkLen;
+ total = newTotal;
+ }
+ }
+
+ // is there enough room for the ending NUL byte?
+ if (*result && *buflen > total)
+ *result = !!func(buffer + total, (const uint8_t *)"", 1);
+ *buflen = total;
+
+ if (next) {
+ *next = *value;
+ next->ptr = ptr;
+ return preparse_next_value(next);
+ }
+ return CborNoError;
+}
+
+/**
+ * \fn CborError cbor_value_copy_text_string(const CborValue *value, char *buffer, size_t *buflen, CborValue *next)
+ *
+ * Copies the string pointed by \a value into the buffer provided at \a buffer
+ * of \a buflen bytes. If \a buffer is a NULL pointer, this function will not
+ * copy anything and will only update the \a next value.
+ *
+ * If the provided buffer length was too small, this function returns an error
+ * condition of \ref CborErrorOutOfMemory. If you need to calculate the length
+ * of the string in order to preallocate a buffer, use
+ * cbor_value_calculate_string_length().
+ *
+ * On success, this function sets the number of bytes copied to \c{*buflen}. If
+ * the buffer is large enough, this function will insert a null byte after the
+ * last copied byte, to facilitate manipulation of text strings. That byte is
+ * not included in the returned value of \c{*buflen}.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * \note This function does not perform UTF-8 validation on the incoming text
+ * string.
+ *
+ * \sa cbor_value_dup_text_string(), cbor_value_copy_byte_string(), cbor_value_get_string_length(), cbor_value_calculate_string_length()
+ */
+
+/**
+ * \fn CborError cbor_value_copy_byte_string(const CborValue *value, uint8_t *buffer, size_t *buflen, CborValue *next)
+ *
+ * Copies the string pointed by \a value into the buffer provided at \a buffer
+ * of \a buflen bytes. If \a buffer is a NULL pointer, this function will not
+ * copy anything and will only update the \a next value.
+ *
+ * If the provided buffer length was too small, this function returns an error
+ * condition of \ref CborErrorOutOfMemory. If you need to calculate the length
+ * of the string in order to preallocate a buffer, use
+ * cbor_value_calculate_string_length().
+ *
+ * On success, this function sets the number of bytes copied to \c{*buflen}. If
+ * the buffer is large enough, this function will insert a null byte after the
+ * last copied byte, to facilitate manipulation of null-terminated strings.
+ * That byte is not included in the returned value of \c{*buflen}.
+ *
+ * The \a next pointer, if not null, will be updated to point to the next item
+ * after this string. If \a value points to the last item, then \a next will be
+ * invalid.
+ *
+ * \sa cbor_value_dup_text_string(), cbor_value_copy_text_string(), cbor_value_get_string_length(), cbor_value_calculate_string_length()
+ */
+
+CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
+ size_t *buflen, CborValue *next)
+{
+ bool copied_all;
+ CborError err = iterate_string_chunks(value, (char*)buffer, buflen, &copied_all, next,
+ buffer ? (IterateFunction)memcpy : iterate_noop);
+ return err ? err :
+ copied_all ? CborNoError : CborErrorOutOfMemory;
+}
+
+/**
+ * Compares the entry \a value with the string \a string and store the result
+ * in \a result. If the value is different from \a string or if it is not a
+ * text string, \a result will contain \c false.
+ *
+ * The entry at \a value may be a tagged string. If \a is not a string or a
+ * tagged string, the comparison result will be false.
+ */
+CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result)
+{
+ CborValue copy = *value;
+ CborError err = cbor_value_skip_tag(©);
+ if (err)
+ return err;
+ if (!cbor_value_is_text_string(©)) {
+ *result = false;
+ return CborNoError;
+ }
+
+ size_t len = strlen(string);
+ return iterate_string_chunks(©, CONST_CAST(char *, string), &len, result, NULL, iterate_memcmp);
+}
+
+/**
+ * Attempts to find the value in map \a map that corresponds to the text string
+ * entry \a string. If the item is found, it is stored in \a result. If no item
+ * is found matching the key, then \a result will contain an element of type
+ * \ref CborInvalidType.
+ *
+ * \note This function may be expensive to execute.
+ */
+CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element)
+{
+ assert(cbor_value_is_map(map));
+ size_t len = strlen(string);
+ CborError err = cbor_value_enter_container(map, element);
+ if (err)
+ goto error;
+
+ while (!cbor_value_at_end(element)) {
+ // find the non-tag so we can compare
+ err = cbor_value_skip_tag(element);
+ if (err)
+ goto error;
+ if (cbor_value_is_text_string(element)) {
+ bool equals;
+ size_t dummyLen = len;
+ err = iterate_string_chunks(element, CONST_CAST(char *, string), &dummyLen,
+ &equals, element, iterate_memcmp);
+ if (err)
+ goto error;
+ if (equals)
+ return preparse_value(element);
+ } else {
+ // skip this key
+ err = cbor_value_advance(element);
+ if (err)
+ goto error;
+ }
+
+ // skip this value
+ err = cbor_value_skip_tag(element);
+ if (err)
+ goto error;
+ err = cbor_value_advance(element);
+ if (err)
+ goto error;
+ }
+
+ // not found
+ element->type = CborInvalidType;
+ return CborNoError;
+
+error:
+ element->type = CborInvalidType;
+ return err;
+}
+
+/**
+ * Extracts a half-precision floating point from \a value and stores it in \a
+ * result.
+ */
+CborError cbor_value_get_half_float(const CborValue *value, void *result)
+{
+ assert(value->type == CborHalfFloatType);
+
+ // size has been computed already
+ uint16_t v = get16(value->ptr + 1);
+ memcpy(result, &v, sizeof(v));
+ return CborNoError;
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#include "cbor.h"
+#include "compilersupport_p.h"
+#include "math_support_p.h"
+
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int hexDump(FILE *out, const uint8_t *buffer, size_t n)
+{
+ while (n--) {
+ int r = fprintf(out, "%02" PRIx8, *buffer++);
+ if (r < 0)
+ return r;
+ }
+ return 0; // should be n * 2, but we don't have the original n anymore
+}
+
+/* This function decodes buffer as UTF-8 and prints as escaped UTF-16.
+ * On UTF-8 decoding error, it returns CborErrorInvalidUtf8TextString */
+static int utf8EscapedDump(FILE *out, const char *buffer, size_t n)
+{
+ uint32_t uc;
+ while (n--) {
+ uc = (uint8_t)*buffer++;
+ if (uc < 0x80) {
+ // single-byte UTF-8
+ if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
+ if (fprintf(out, "%c", (char)uc) < 0)
+ return CborErrorIO;
+ continue;
+ }
+
+ // print as an escape sequence
+ char escaped = (char)uc;
+ switch (uc) {
+ case '"':
+ case '\\':
+ break;
+ case '\b':
+ escaped = 'b';
+ break;
+ case '\f':
+ escaped = 'f';
+ break;
+ case '\n':
+ escaped = 'n';
+ break;
+ case '\r':
+ escaped = 'r';
+ break;
+ case '\t':
+ escaped = 't';
+ break;
+ default:
+ goto print_utf16;
+ }
+ if (fprintf(out, "\\%c", escaped) < 0)
+ return CborErrorIO;
+ continue;
+ }
+
+ // multi-byte UTF-8, decode it
+ unsigned charsNeeded;
+ uint32_t min_uc;
+ if (unlikely(uc <= 0xC1))
+ return CborErrorInvalidUtf8TextString;
+ if (uc < 0xE0) {
+ /* two-byte UTF-8 */
+ charsNeeded = 2;
+ min_uc = 0x80;
+ uc &= 0x1f;
+ } else if (uc < 0xF0) {
+ /* three-byte UTF-8 */
+ charsNeeded = 3;
+ min_uc = 0x800;
+ uc &= 0x0f;
+ } else if (uc < 0xF5) {
+ /* four-byte UTF-8 */
+ charsNeeded = 4;
+ min_uc = 0x10000;
+ uc &= 0x07;
+ } else {
+ return CborErrorInvalidUtf8TextString;
+ }
+
+ if (n < charsNeeded - 1)
+ return CborErrorInvalidUtf8TextString;
+
+ // first continuation character
+ uint8_t b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+
+ if (charsNeeded > 2) {
+ // second continuation character
+ b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+
+ if (charsNeeded > 3) {
+ // third continuation character
+ b = (uint8_t)*buffer++;
+ if ((b & 0xc0) != 0x80)
+ return CborErrorInvalidUtf8TextString;
+ uc <<= 6;
+ uc |= b & 0x3f;
+ }
+ }
+
+ // overlong sequence? surrogate pair? out or range?
+ if (uc < min_uc || uc - 0xd800U < 2048U || uc > 0x10ffff)
+ return CborErrorInvalidUtf8TextString;
+
+ // now print the sequence
+ if (charsNeeded > 3) {
+ // needs surrogate pairs
+ if (fprintf(out, "\\u%04" PRIX32 "\\u%04" PRIX32,
+ (uc >> 10) + 0xd7c0, // high surrogate
+ (uc % 0x0400) + 0xdc00) < 0)
+ return CborErrorIO;
+ } else {
+print_utf16:
+ // no surrogate pair needed
+ if (fprintf(out, "\\u%04" PRIX32, uc) < 0)
+ return CborErrorIO;
+ }
+ }
+ return CborNoError;
+}
+
+static CborError value_to_pretty(FILE *out, CborValue *it);
+static CborError container_to_pretty(FILE *out, CborValue *it, CborType containerType)
+{
+ const char *comma = "";
+ while (!cbor_value_at_end(it)) {
+ if (fprintf(out, "%s", comma) < 0)
+ return CborErrorIO;
+ comma = ", ";
+
+ CborError err = value_to_pretty(out, it);
+ if (err)
+ return err;
+
+ if (containerType == CborArrayType)
+ continue;
+
+ // map: that was the key, so get the value
+ if (fprintf(out, ": ") < 0)
+ return CborErrorIO;
+ err = value_to_pretty(out, it);
+ if (err)
+ return err;
+ }
+ return CborNoError;
+}
+
+static CborError value_to_pretty(FILE *out, CborValue *it)
+{
+ CborError err;
+ CborType type = cbor_value_get_type(it);
+ switch (type) {
+ case CborArrayType:
+ case CborMapType: {
+ // recursive type
+ CborValue recursed;
+
+ if (fprintf(out, type == CborArrayType ? "[" : "{") < 0)
+ return CborErrorIO;
+ if (!cbor_value_is_length_known(it)) {
+ if (fprintf(out, "_ ") < 0)
+ return CborErrorIO;
+ }
+
+ err = cbor_value_enter_container(it, &recursed);
+ if (err) {
+ it->ptr = recursed.ptr;
+ return err; // parse error
+ }
+ err = container_to_pretty(out, &recursed, type);
+ if (err) {
+ it->ptr = recursed.ptr;
+ return err; // parse error
+ }
+ err = cbor_value_leave_container(it, &recursed);
+ if (err)
+ return err; // parse error
+
+ if (fprintf(out, type == CborArrayType ? "]" : "}") < 0)
+ return CborErrorIO;
+ return CborNoError;
+ }
+
+ case CborIntegerType: {
+ uint64_t val;
+ cbor_value_get_raw_integer(it, &val); // can't fail
+
+ if (cbor_value_is_unsigned_integer(it)) {
+ if (fprintf(out, "%" PRIu64, val) < 0)
+ return CborErrorIO;
+ } else {
+ // CBOR stores the negative number X as -1 - X
+ // (that is, -1 is stored as 0, -2 as 1 and so forth)
+ if (++val) { // unsigned overflow may happen
+ if (fprintf(out, "-%" PRIu64, val) < 0)
+ return CborErrorIO;
+ } else {
+ // overflown
+ // 0xffff`ffff`ffff`ffff + 1 =
+ // 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64)
+ if (fprintf(out, "-18446744073709551616") < 0)
+ return CborErrorIO;
+ }
+ }
+ break;
+ }
+
+ case CborByteStringType:{
+ size_t n = 0;
+ uint8_t *buffer;
+ err = cbor_value_dup_byte_string(it, &buffer, &n, it);
+ if (err)
+ return err;
+
+ bool failed = fprintf(out, "h'") < 0 || hexDump(out, buffer, n) < 0 || fprintf(out, "'") < 0;
+ free(buffer);
+ return failed ? CborErrorIO : CborNoError;
+ }
+
+ case CborTextStringType: {
+ size_t n = 0;
+ char *buffer;
+ err = cbor_value_dup_text_string(it, &buffer, &n, it);
+ if (err)
+ return err;
+
+ err = CborNoError;
+ bool failed = fprintf(out, "\"") < 0
+ || (err = utf8EscapedDump(out, buffer, n)) != CborNoError
+ || fprintf(out, "\"") < 0;
+ free(buffer);
+ return err != CborNoError ? err :
+ failed ? CborErrorIO : CborNoError;
+ }
+
+ case CborTagType: {
+ CborTag tag;
+ cbor_value_get_tag(it, &tag); // can't fail
+ if (fprintf(out, "%" PRIu64 "(", tag) < 0)
+ return CborErrorIO;
+ err = cbor_value_advance_fixed(it);
+ if (err)
+ return err;
+ err = value_to_pretty(out, it);
+ if (err)
+ return err;
+ if (fprintf(out, ")") < 0)
+ return CborErrorIO;
+ return CborNoError;
+ }
+
+ case CborSimpleType: {
+ uint8_t simple_type;
+ cbor_value_get_simple_type(it, &simple_type); // can't fail
+ if (fprintf(out, "simple(%" PRIu8 ")", simple_type) < 0)
+ return CborErrorIO;
+ break;
+ }
+
+ case CborNullType:
+ if (fprintf(out, "null") < 0)
+ return CborErrorIO;
+ break;
+
+ case CborUndefinedType:
+ if (fprintf(out, "undefined") < 0)
+ return CborErrorIO;
+ break;
+
+ case CborBooleanType: {
+ bool val;
+ cbor_value_get_boolean(it, &val); // can't fail
+ if (fprintf(out, val ? "true" : "false") < 0)
+ return CborErrorIO;
+ break;
+ }
+
+ case CborDoubleType: {
+ const char *suffix;
+ double val;
+ if (false) {
+ float f;
+ case CborFloatType:
+ cbor_value_get_float(it, &f);
+ val = f;
+ suffix = "f";
+ } else if (false) {
+ uint16_t f16;
+ case CborHalfFloatType:
+ cbor_value_get_half_float(it, &f16);
+ val = decode_half(f16);
+ suffix = "f16";
+ } else {
+ cbor_value_get_double(it, &val);
+ suffix = "";
+ }
+
+ int r = fpclassify(val);
+ if (r == FP_NAN || r == FP_INFINITE)
+ suffix = "";
+
+ uint64_t ival = (uint64_t)fabs(val);
+ if (ival == fabs(val)) {
+ // this double value fits in a 64-bit integer, so show it as such
+ // (followed by a floating point suffix, to disambiguate)
+ r = fprintf(out, "%s%" PRIu64 ".%s", val < 0 ? "-" : "", ival, suffix);
+ } else {
+ // this number is definitely not a 64-bit integer
+ r = fprintf(out, "%." DBL_DECIMAL_DIG_STR "g%s", val, suffix);
+ }
+ if (r < 0)
+ return CborErrorIO;
+ break;
+ }
+
+ case CborInvalidType:
+ if (fprintf(out, "invalid") < 0)
+ return CborErrorIO;
+ return CborErrorUnknownType;
+ }
+
+ err = cbor_value_advance_fixed(it);
+ return err;
+}
+
+CborError cbor_value_to_pretty_advance(FILE *out, CborValue *value)
+{
+ return value_to_pretty(out, value);
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _GNU_SOURCE 1
+#define _POSIX_C_SOURCE 200809L
+#include "cbor.h"
+#include "cborjson.h"
+#include "compilersupport_p.h"
+#include "math_support_p.h"
+
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern FILE *open_memstream(char **bufptr, size_t *sizeptr);
+
+enum ConversionStatusFlags {
+ TypeWasNotNative = 0x100, // anything but strings, boolean, null, arrays and maps
+ TypeWasTagged = 0x200,
+ NumberPrecisionWasLost = 0x400,
+ NumberWasNaN = 0x800,
+ NumberWasInfinite = 0x1000,
+ NumberWasNegative = 0x2000, // always used with NumberWasInifite or NumberWasTooBig
+
+ FinalTypeMask = 0xff
+};
+
+typedef struct ConversionStatus {
+ CborTag lastTag;
+ uint64_t originalNumber;
+ int flags;
+} ConversionStatus;
+
+static CborError value_to_json(FILE *out, CborValue *it, int flags, CborType type, ConversionStatus *status);
+
+static CborError dump_bytestring_base16(char **result, CborValue *it)
+{
+ static const char characters[] = "0123456789abcdef";
+ size_t i;
+ size_t n = 0;
+ uint8_t *buffer;
+ CborError err = cbor_value_calculate_string_length(it, &n);
+ if (err)
+ return err;
+
+ // a Base16 (hex) output is twice as big as our buffer
+ buffer = (uint8_t *)malloc(n * 2 + 1);
+ *result = (char *)buffer;
+
+ // let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL
+ ++n;
+ err = cbor_value_copy_byte_string(it, buffer + n - 1, &n, it);
+ assert(err == CborNoError);
+
+ for (i = 0; i < n; ++i) {
+ uint8_t byte = buffer[n + i];
+ buffer[2*i] = characters[byte >> 4];
+ buffer[2*i + 1] = characters[byte & 0xf];
+ }
+ return CborNoError;
+}
+
+static CborError generic_dump_base64(char **result, CborValue *it, const char alphabet[65])
+{
+ size_t n = 0, i;
+ uint8_t *buffer, *out, *in;
+ CborError err = cbor_value_calculate_string_length(it, &n);
+ if (err)
+ return err;
+
+ // a Base64 output (untruncated) has 4 bytes for every 3 in the input
+ size_t len = (n + 5) / 3 * 4;
+ out = buffer = (uint8_t *)malloc(len + 1);
+ *result = (char *)buffer;
+
+ // we read our byte string at the tail end of the buffer
+ // so we can do an in-place conversion while iterating forwards
+ in = buffer + len - n;
+
+ // let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL
+ ++n;
+ err = cbor_value_copy_byte_string(it, in, &n, it);
+ assert(err == CborNoError);
+
+ uint_least32_t val = 0;
+ for (i = 0; n - i >= 3; i += 3) {
+ // read 3 bytes x 8 bits = 24 bits
+ if (false) {
+#ifdef __GNUC__
+ } else if (i) {
+ __builtin_memcpy(&val, in + i - 1, sizeof(val));
+ val = cbor_ntohl(val);
+#endif
+ } else {
+ val = (in[i] << 16) | (in[i + 1] << 8) | in[i + 2];
+ }
+
+ // write 4 chars x 6 bits = 24 bits
+ *out++ = alphabet[(val >> 18) & 0x3f];
+ *out++ = alphabet[(val >> 12) & 0x3f];
+ *out++ = alphabet[(val >> 6) & 0x3f];
+ *out++ = alphabet[val & 0x3f];
+ }
+
+ // maybe 1 or 2 bytes left
+ if (n - i) {
+ // we can read in[i + 1] even if it's past the end of the string because
+ // we know (by construction) that it's a NUL byte
+#ifdef __GNUC__
+ uint16_t val16;
+ __builtin_memcpy(&val16, in + i, sizeof(val16));
+ val = cbor_ntohs(val16);
+#else
+ val = (in[i] << 8) | in[i + 1];
+#endif
+ val <<= 8;
+
+ // the 65th character in the alphabet is our filler: either '=' or '\0'
+ out[4] = '\0';
+ out[3] = alphabet[64];
+ if (n - i == 2) {
+ // write the third char in 3 chars x 6 bits = 18 bits
+ out[2] = alphabet[(val >> 6) & 0x3f];
+ } else {
+ out[2] = alphabet[64]; // filler
+ }
+ out[1] = alphabet[(val >> 12) & 0x3f];
+ out[0] = alphabet[(val >> 18) & 0x3f];
+ } else {
+ out[0] = '\0';
+ }
+
+ return CborNoError;
+}
+
+static CborError dump_bytestring_base64(char **result, CborValue *it)
+{
+ static const char alphabet[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
+ "ghijklmn" "opqrstuv" "wxyz0123" "456789+/" "=";
+ return generic_dump_base64(result, it, alphabet);
+}
+
+static CborError dump_bytestring_base64url(char **result, CborValue *it)
+{
+ static const char alphabet[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
+ "ghijklmn" "opqrstuv" "wxyz0123" "456789-_";
+ return generic_dump_base64(result, it, alphabet);
+}
+
+static CborError add_value_metadata(FILE *out, CborType type, const ConversionStatus *status)
+{
+ int flags = status->flags;
+ if (flags & TypeWasTagged) {
+ // extract the tagged type, which may be JSON native
+ type = flags & FinalTypeMask;
+ flags &= ~(FinalTypeMask | TypeWasTagged);
+
+ if (fprintf(out, "\"tag\":\"%" PRIu64 "\"%s", status->lastTag,
+ flags & ~TypeWasTagged ? "," : "") < 0)
+ return CborErrorIO;
+ }
+
+ if (!flags)
+ return CborNoError;
+
+ // print at least the type
+ if (fprintf(out, "\"t\":%d", type) < 0)
+ return CborErrorIO;
+
+ if (flags & NumberWasNaN)
+ if (fprintf(out, ",\"v\":\"nan\"") < 0)
+ return CborErrorIO;
+ if (flags & NumberWasInfinite)
+ if (fprintf(out, ",\"v\":\"%sinf\"", flags & NumberWasNegative ? "-" : "") < 0)
+ return CborErrorIO;
+ if (flags & NumberPrecisionWasLost)
+ if (fprintf(out, ",\"v\":\"%c%" PRIx64 "\"", flags & NumberWasNegative ? '-' : '+',
+ status->originalNumber) < 0)
+ return CborErrorIO;
+ if (type == CborSimpleType)
+ if (fprintf(out, ",\"v\":%d", (int)status->originalNumber) < 0)
+ return CborErrorIO;
+ return CborNoError;
+}
+
+static CborError find_tagged_type(CborValue *it, CborTag *tag, CborType *type)
+{
+ CborError err = CborNoError;
+ *type = cbor_value_get_type(it);
+ while (*type == CborTagType) {
+ cbor_value_get_tag(it, tag); // can't fail
+ err = cbor_value_advance_fixed(it);
+ if (err)
+ return err;
+
+ *type = cbor_value_get_type(it);
+ }
+ return err;
+}
+
+static CborError tagged_value_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+ CborTag tag;
+ CborError err;
+
+ if (flags & CborConvertTagsToObjects) {
+ cbor_value_get_tag(it, &tag); // can't fail
+ err = cbor_value_advance_fixed(it);
+ if (err)
+ return err;
+
+ if (fprintf(out, "{\"tag%" PRIu64 "\":", tag) < 0)
+ return CborErrorIO;
+
+ CborType type = cbor_value_get_type(it);
+ err = value_to_json(out, it, flags, type, status);
+ if (err)
+ return err;
+ if (flags & CborConvertAddMetadata && status->flags) {
+ if (fprintf(out, ",\"tag%" PRIu64 "$cbor\":{", tag) < 0 ||
+ add_value_metadata(out, type, status) != CborNoError ||
+ fputc('}', out) < 0)
+ return CborErrorIO;
+ }
+ if (fputc('}', out) < 0)
+ return CborErrorIO;
+ status->flags = TypeWasNotNative | CborTagType;
+ return CborNoError;
+ }
+
+ CborType type;
+ err = find_tagged_type(it, &status->lastTag, &type);
+ if (err)
+ return err;
+ tag = status->lastTag;
+
+ // special handling of byte strings?
+ if (type == CborByteStringType && (flags & CborConvertByteStringsToBase64Url) == 0 &&
+ (tag == CborNegativeBignumTag || tag == CborExpectedBase16Tag || tag == CborExpectedBase64Tag)) {
+ char *str;
+ char *pre = "";
+
+ if (tag == CborNegativeBignumTag) {
+ pre = "~";
+ err = dump_bytestring_base64url(&str, it);
+ } else if (tag == CborExpectedBase64Tag) {
+ err = dump_bytestring_base64(&str, it);
+ } else { // tag == CborExpectedBase16Tag
+ err = dump_bytestring_base16(&str, it);
+ }
+ if (err)
+ return err;
+ err = fprintf(out, "\"%s%s\"", pre, str) < 0 ? CborErrorIO : CborNoError;
+ free(str);
+ status->flags = TypeWasNotNative | TypeWasTagged | CborByteStringType;
+ return err;
+ }
+
+ // no special handling
+ err = value_to_json(out, it, flags, type, status);
+ status->flags |= TypeWasTagged | type;
+ return err;
+}
+
+static CborError stringify_map_key(char **key, CborValue *it, int flags, CborType type)
+{
+ (void)flags; // unused
+ (void)type; // unused
+ size_t size;
+
+ FILE *memstream = open_memstream(key, &size);
+ if (memstream == NULL)
+ return CborErrorOutOfMemory; // could also be EMFILE, but it's unlikely
+ CborError err = cbor_value_to_pretty_advance(memstream, it);
+
+ if (unlikely(fclose(memstream) < 0 || *key == NULL))
+ return CborErrorInternalError;
+ return err;
+}
+
+static CborError array_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+ const char *comma = "";
+ while (!cbor_value_at_end(it)) {
+ if (fprintf(out, "%s", comma) < 0)
+ return CborErrorIO;
+ comma = ",";
+
+ CborError err = value_to_json(out, it, flags, cbor_value_get_type(it), status);
+ if (err)
+ return err;
+ }
+ return CborNoError;
+}
+
+static CborError map_to_json(FILE *out, CborValue *it, int flags, ConversionStatus *status)
+{
+ const char *comma = "";
+ CborError err;
+ while (!cbor_value_at_end(it)) {
+ char *key;
+ if (fprintf(out, "%s", comma) < 0)
+ return CborErrorIO;
+ comma = ",";
+
+ CborType keyType = cbor_value_get_type(it);
+ if (likely(keyType == CborTextStringType)) {
+ size_t n = 0;
+ err = cbor_value_dup_text_string(it, &key, &n, it);
+ } else if (flags & CborConvertStringifyMapKeys) {
+ err = stringify_map_key(&key, it, flags, keyType);
+ } else {
+ return CborErrorJsonObjectKeyNotString;
+ }
+ if (err)
+ return err;
+
+ // first, print the key
+ if (fprintf(out, "\"%s\":", key) < 0)
+ return CborErrorIO;
+
+ // then, print the value
+ CborType valueType = cbor_value_get_type(it);
+ err = value_to_json(out, it, flags, valueType, status);
+
+ // finally, print any metadata we may have
+ if (flags & CborConvertAddMetadata) {
+ if (!err && keyType != CborTextStringType) {
+ if (fprintf(out, ",\"%s$keycbordump\":true", key) < 0)
+ err = CborErrorIO;
+ }
+ if (!err && status->flags) {
+ if (fprintf(out, ",\"%s$cbor\":{", key) < 0 ||
+ add_value_metadata(out, valueType, status) != CborNoError ||
+ fputc('}', out) < 0)
+ err = CborErrorIO;
+ }
+ }
+
+ free(key);
+ if (err)
+ return err;
+ }
+ return CborNoError;
+}
+
+static CborError value_to_json(FILE *out, CborValue *it, int flags, CborType type, ConversionStatus *status)
+{
+ CborError err;
+ status->flags = 0;
+
+ switch (type) {
+ case CborArrayType:
+ case CborMapType: {
+ // recursive type
+ CborValue recursed;
+ err = cbor_value_enter_container(it, &recursed);
+ if (err) {
+ it->ptr = recursed.ptr;
+ return err; // parse error
+ }
+ if (fputc(type == CborArrayType ? '[' : '{', out) < 0)
+ return CborErrorIO;
+
+ err = (type == CborArrayType) ?
+ array_to_json(out, &recursed, flags, status) :
+ map_to_json(out, &recursed, flags, status);
+ if (err) {
+ it->ptr = recursed.ptr;
+ return err; // parse error
+ }
+
+ if (fputc(type == CborArrayType ? ']' : '}', out) < 0)
+ return CborErrorIO;
+ err = cbor_value_leave_container(it, &recursed);
+ if (err)
+ return err; // parse error
+
+ status->flags = 0; // reset, there are never conversion errors for us
+ return CborNoError;
+ }
+
+ case CborIntegerType: {
+ double num; // JS numbers are IEEE double precision
+ uint64_t val;
+ cbor_value_get_raw_integer(it, &val); // can't fail
+ num = (double)val;
+
+ if (cbor_value_is_negative_integer(it)) {
+ num = -num - 1; // convert to negative
+ if ((uint64_t)(-num - 1) != val) {
+ status->flags = NumberPrecisionWasLost | NumberWasNegative;
+ status->originalNumber = val;
+ }
+ } else {
+ if ((uint64_t)num != val) {
+ status->flags = NumberPrecisionWasLost;
+ status->originalNumber = val;
+ }
+ }
+ if (fprintf(out, "%.0f", num) < 0) // this number has no fraction, so no decimal points please
+ return CborErrorIO;
+ break;
+ }
+
+ case CborByteStringType:
+ case CborTextStringType: {
+ char *str;
+ if (type == CborByteStringType) {
+ err = dump_bytestring_base64url(&str, it);
+ status->flags = TypeWasNotNative;
+ } else {
+ size_t n = 0;
+ err = cbor_value_dup_text_string(it, &str, &n, it);
+ }
+ if (err)
+ return err;
+ err = (fprintf(out, "\"%s\"", str) < 0) ? CborErrorIO : CborNoError;
+ free(str);
+ return err;
+ }
+
+ case CborTagType:
+ return tagged_value_to_json(out, it, flags, status);
+
+ case CborSimpleType: {
+ uint8_t simple_type;
+ cbor_value_get_simple_type(it, &simple_type); // can't fail
+ status->flags = TypeWasNotNative;
+ status->originalNumber = simple_type;
+ if (fprintf(out, "\"simple(%" PRIu8 ")\"", simple_type) < 0)
+ return CborErrorIO;
+ break;
+ }
+
+ case CborNullType:
+ if (fprintf(out, "null") < 0)
+ return CborErrorIO;
+ break;
+
+ case CborUndefinedType:
+ status->flags = TypeWasNotNative;
+ if (fprintf(out, "\"undefined\"") < 0)
+ return CborErrorIO;
+ break;
+
+ case CborBooleanType: {
+ bool val;
+ cbor_value_get_boolean(it, &val); // can't fail
+ if (fprintf(out, val ? "true" : "false") < 0)
+ return CborErrorIO;
+ break;
+ }
+
+ case CborDoubleType: {
+ double val;
+ if (false) {
+ float f;
+ case CborFloatType:
+ status->flags = TypeWasNotNative;
+ cbor_value_get_float(it, &f);
+ val = f;
+ } else if (false) {
+ uint16_t f16;
+ case CborHalfFloatType:
+ status->flags = TypeWasNotNative;
+ cbor_value_get_half_float(it, &f16);
+ val = decode_half(f16);
+ } else {
+ cbor_value_get_double(it, &val);
+ }
+
+ int r = fpclassify(val);
+ if (r == FP_NAN || r == FP_INFINITE) {
+ if (fprintf(out, "null") < 0)
+ return CborErrorIO;
+ status->flags |= r == FP_NAN ? NumberWasNaN :
+ NumberWasInfinite | (val < 0 ? NumberWasNegative : 0);
+ } else {
+ uint64_t ival = (uint64_t)fabs(val);
+ if ((double)ival == fabs(val)) {
+ // print as integer so we get the full precision
+ r = fprintf(out, "%s%" PRIu64, val < 0 ? "-" : "", ival);
+ status->flags |= TypeWasNotNative; // mark this integer number as a double
+ } else {
+ // this number is definitely not a 64-bit integer
+ r = fprintf(out, "%." DBL_DECIMAL_DIG_STR "g", val);
+ }
+ if (r < 0)
+ return CborErrorIO;
+ }
+ break;
+ }
+
+ case CborInvalidType:
+ return CborErrorUnknownType;
+ }
+
+ return cbor_value_advance_fixed(it);
+}
+
+CborError cbor_value_to_json_advance(FILE *out, CborValue *value, int flags)
+{
+ ConversionStatus status;
+ return value_to_json(out, value, flags, cbor_value_get_type(value), &status);
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef COMPILERSUPPORT_H
+#define COMPILERSUPPORT_H
+
+#include "cbor.h"
+
+#ifndef _BSD_SOURCE
+# define _BSD_SOURCE
+#endif
+#include <assert.h>
+#include <float.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef __cplusplus
+# include <stdbool.h>
+#endif
+
+#ifdef __F16C__
+# include <immintrin.h>
+#endif
+
+#if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L || __cpp_static_assert >= 200410
+# define cbor_static_assert(x) static_assert(x, #x)
+#elif !defined(__cplusplus) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)
+# define cbor_static_assert(x) _Static_assert(x, #x)
+#else
+# define cbor_static_assert(x) ((void)sizeof(char[2*!!(x) - 1]))
+#endif
+#if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
+/* inline is a keyword */
+#else
+/* use the definition from cbor.h */
+# define inline CBOR_INLINE
+#endif
+
+#define STRINGIFY(x) STRINGIFY2(x)
+#define STRINGIFY2(x) #x
+
+#ifndef UINT32_MAX
+/* C99 requires it in stdint.h, but some systems lack it */
+# define UINT32_MAX (0xffffffffU)
+#endif
+#ifndef DBL_DECIMAL_DIG
+// DBL_DECIMAL_DIG is C11
+# define DBL_DECIMAL_DIG 17
+#endif
+#define DBL_DECIMAL_DIG_STR STRINGIFY(DBL_DECIMAL_DIG)
+
+#ifndef __has_builtin
+# define __has_builtin(x) 0
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || \
+ (__has_builtin(__builtin_bswap64) && __has_builtin(__builtin_bswap32))
+# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define cbor_ntohll __builtin_bswap64
+# define cbor_htonll __builtin_bswap64
+# define cbor_ntohl __builtin_bswap32
+# define cbor_htonl __builtin_bswap32
+# ifdef __INTEL_COMPILER
+# define cbor_ntohs _bswap16
+# define cbor_htons _bswap16
+# elif (__GNUC__ * 100 + __GNUC_MINOR__ >= 608) || __has_builtin(__builtin_bswap16)
+# define cbor_ntohs __builtin_bswap16
+# define cbor_htons __builtin_bswap16
+# else
+# define cbor_ntohs(x) (((uint16_t)x >> 8) | ((uint16_t)x << 8))
+# define cbor_htons cbor_ntohs
+# endif
+# else
+# define cbor_ntohll
+# define cbor_htonll
+# define cbor_ntohl
+# define cbor_htonl
+# define cbor_ntohs
+# define cbor_htons
+# endif
+#elif defined(__sun)
+# include <sys/byteorder.h>
+#elif defined(_MSC_VER)
+/* MSVC, which implies Windows, which implies little-endian and sizeof(long) == 4 */
+# define cbor_ntohll _byteswap_uint64
+# define cbor_htonll _byteswap_uint64
+# define cbor_ntohl _byteswap_ulong
+# define cbor_htonl _byteswap_ulong
+# define cbor_ntohs _byteswap_ushort
+# define cbor_htons _byteswap_ushort
+#endif
+#ifndef cbor_ntohs
+# include <arpa/inet.h>
+# define cbor_ntohs ntohs
+# define cbor_htons htons
+#endif
+#ifndef cbor_ntohl
+# include <arpa/inet.h>
+# define cbor_ntohl ntohl
+# define cbor_htonl htonl
+#endif
+#ifndef cbor_ntohll
+# define cbor_ntohll ntohll
+# define cbor_htonll htonll
+/* ntohll isn't usually defined */
+# ifndef ntohll
+# if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+# define ntohll
+# define htonll
+# elif defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define ntohll(x) ((ntohl((uint32_t)(x)) * UINT64_C(0x100000000)) + (ntohl((x) >> 32)))
+# define htonll ntohll
+# else
+# error "Unable to determine byte order!"
+# endif
+# endif
+#endif
+
+
+#ifdef __cplusplus
+# define CONST_CAST(t, v) const_cast<t>(v)
+#else
+// C-style const_cast without triggering a warning with -Wcast-qual
+# define CONST_CAST(t, v) (t)(uintptr_t)(v)
+#endif
+
+#ifdef __GNUC__
+# define likely(x) __builtin_expect(!!(x), 1)
+# define unlikely(x) __builtin_expect(!!(x), 0)
+# define unreachable() __builtin_unreachable()
+#elif defined(_MSC_VER)
+# define likely(x) (x)
+# define unlikely(x) (x)
+# define unreachable() __assume(0)
+#else
+# define likely(x) (x)
+# define unlikely(x) (x)
+# define unreachable() do {} while (0)
+#endif
+
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__) && \
+ (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)
+# pragma GCC optimize("-ffunction-sections")
+#endif
+
+static inline bool add_check_overflow(size_t v1, size_t v2, size_t *r)
+{
+#if ((defined(__GNUC__) && (__GNUC__ >= 5)) && !defined(__INTEL_COMPILER)) || __has_builtin(__builtin_add_overflow)
+ return __builtin_add_overflow(v1, v2, r);
+#else
+ // unsigned additions are well-defined
+ *r = v1 + v2;
+ return v1 > v1 + v2;
+#endif
+}
+
+static inline unsigned short encode_half(double val)
+{
+#ifdef __F16C__
+ return _cvtss_sh(val, 3);
+#else
+ uint64_t v;
+ memcpy(&v, &val, sizeof(v));
+ int sign = v >> 63 << 15;
+ int exp = (v >> 52) & 0x7ff;
+ int mant = v << 12 >> 12 >> (53-11); // keep only the 11 most significant bits of the mantissa
+ exp -= 1023;
+ if (exp == 1024) {
+ // infinity or NaN
+ exp = 16;
+ mant >>= 1;
+ } else if (exp >= 16) {
+ // overflow, as largest number
+ exp = 15;
+ mant = 1023;
+ } else if (exp >= -14) {
+ // regular normal
+ } else if (exp >= -24) {
+ // subnormal
+ mant |= 1024;
+ mant >>= -(exp + 14);
+ exp = -15;
+ } else {
+ // underflow, make zero
+ return 0;
+ }
+ return sign | ((exp + 15) << 10) | mant;
+#endif
+}
+
+#endif // COMPILERSUPPORT_H
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#include "cbor.h"
+#include "cborconstants_p.h"
+#include "compilersupport_p.h"
+#include <stdlib.h>
+
+static inline uint16_t get16(const uint8_t *ptr)
+{
+ uint16_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohs(result);
+}
+
+static inline uint32_t get32(const uint8_t *ptr)
+{
+ uint32_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohl(result);
+}
+
+static inline uint64_t get64(const uint8_t *ptr)
+{
+ uint64_t result;
+ memcpy(&result, ptr, sizeof(result));
+ return cbor_ntohll(result);
+}
+
+static CborError extract_number(const uint8_t **ptr, const uint8_t *end, uint64_t *len)
+{
+ uint8_t additional_information = **ptr & SmallValueMask;
+ ++*ptr;
+ if (additional_information < Value8Bit) {
+ *len = additional_information;
+ return CborNoError;
+ }
+ if (unlikely(additional_information > Value64Bit))
+ return CborErrorIllegalNumber;
+
+ size_t bytesNeeded = (size_t)(1 << (additional_information - Value8Bit));
+ if (unlikely(bytesNeeded > (size_t)(end - *ptr))) {
+ return CborErrorUnexpectedEOF;
+ } else if (bytesNeeded == 1) {
+ *len = (uint8_t)(*ptr)[0];
+ } else if (bytesNeeded == 2) {
+ *len = get16(*ptr);
+ } else if (bytesNeeded == 4) {
+ *len = get32(*ptr);
+ } else {
+ *len = get64(*ptr);
+ }
+ *ptr += bytesNeeded;
+ return CborNoError;
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#ifndef MATH_SUPPORT_H
+#define MATH_SUPPORT_H
+
+#include <math.h>
+
+// this function was copied & adapted from RFC 7049 Appendix D
+static inline double decode_half(unsigned short half)
+{
+#ifdef __F16C__
+ return _cvtsh_ss(half);
+#else
+ int exp = (half >> 10) & 0x1f;
+ int mant = half & 0x3ff;
+ double val;
+ if (exp == 0) val = ldexp(mant, -24);
+ else if (exp != 31) val = ldexp(mant + 1024, exp - 25);
+ else val = mant == 0 ? INFINITY : NAN;
+ return half & 0x8000 ? -val : val;
+#endif
+}
+
+#endif // MATH_SUPPORT_H
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _BSD_SOURCE 1
+#define _GNU_SOURCE 1
+
+#include <sys/types.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__unix__) || defined(__APPLE__)
+# include <unistd.h>
+#endif
+#ifdef __APPLE__
+typedef int RetType;
+typedef int LenType;
+#elif __GLIBC__
+typedef ssize_t RetType;
+typedef size_t LenType;
+#else
+# error "Cannot implement open_memstream!"
+#endif
+
+#include "compilersupport_p.h"
+
+struct Buffer
+{
+ char **ptr;
+ size_t *len;
+ size_t alloc;
+};
+
+static RetType write_to_buffer(void *cookie, const char *data, LenType len)
+{
+ struct Buffer *b = (struct Buffer *)cookie;
+ char *ptr = *b->ptr;
+ size_t newsize;
+
+ errno = EFBIG;
+ if (unlikely(add_check_overflow(*b->len, len, &newsize)))
+ return -1;
+
+ if (newsize > b->alloc) {
+ // make room
+ size_t newalloc = newsize + newsize / 2 + 1; // give 50% more room
+ ptr = realloc(ptr, newalloc);
+ if (ptr == NULL)
+ return -1;
+ b->alloc = newalloc;
+ *b->ptr = ptr;
+ }
+
+ memcpy(ptr + *b->len, data, len);
+ *b->len = newsize;
+ return len;
+}
+
+static int close_buffer(void *cookie)
+{
+ struct Buffer *b = (struct Buffer *)cookie;
+ if (*b->ptr)
+ (*b->ptr)[*b->len] = '\0';
+ free(b);
+ return 0;
+}
+
+FILE *open_memstream(char **bufptr, size_t *lenptr)
+{
+ struct Buffer *b = (struct Buffer *)malloc(sizeof(struct Buffer));
+ if (b == NULL)
+ return NULL;
+ b->alloc = 0;
+ b->len = lenptr;
+ b->ptr = bufptr;
+ *bufptr = NULL;
+ *lenptr = 0;
+
+#ifdef __APPLE__
+ return funopen(b, NULL, write_to_buffer, NULL, close_buffer);
+#elif __GLIBC__
+ static const cookie_io_functions_t vtable = {
+ NULL,
+ write_to_buffer,
+ NULL,
+ close_buffer
+ };
+ return fopencookie(b, "w", vtable);
+#endif
+}
+
--- /dev/null
+SOURCES += \
+ $$PWD/cborencoder.c \
+ $$PWD/cborencoder_close_container_checked.c \
+ $$PWD/cborerrorstrings.c \
+ $$PWD/cborparser.c \
+ $$PWD/cborpretty.c \
+ $$PWD/cbortojson.c \
+
+QMAKE_CFLAGS *= $$QMAKE_CFLAGS_SPLIT_SECTIONS
+QMAKE_LFLAGS *= $$QMAKE_LFLAGS_GCSECTIONS
+INCLUDEPATH += $$PWD
--- /dev/null
+TEMPLATE = lib
+CONFIG += static
+DESTDIR = ../lib
+
+include(src.pri)
--- /dev/null
+Makefile
+debug
+release
+target_wrapper.*
--- /dev/null
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+
+SOURCES = tst_cpp.cpp
+INCLUDEPATH += ../../src
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include "../../src/cborencoder.c"
+#include "../../src/cborparser.c"
+#include "../../src/cborerrorstrings.c"
+
+#include <QtTest>
+
+// This is a compilation-only test.
+// All it does is verify that the three source files above
+// compile as C++ without errors.
+class tst_Cpp : public QObject
+{
+ Q_OBJECT
+};
+
+QTEST_MAIN(tst_Cpp)
+#include "tst_cpp.moc"
--- /dev/null
+SOURCES += tst_encoder.cpp
+
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+
+INCLUDEPATH += ../../src
+msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
+else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include <QtTest>
+#include "cbor.h"
+
+Q_DECLARE_METATYPE(CborError)
+
+class tst_Encoder : public QObject
+{
+ Q_OBJECT
+private slots:
+ void fixed_data();
+ void fixed();
+ void strings_data();
+ void strings() { fixed(); }
+ void arraysAndMaps_data();
+ void arraysAndMaps() { fixed(); }
+ void tags_data();
+ void tags();
+ void arrays_data() { tags_data(); }
+ void arrays();
+ void maps_data() { tags_data(); }
+ void maps();
+
+ void shortBuffer_data() { tags_data(); }
+ void shortBuffer();
+ void tooShortArrays_data() { tags_data(); }
+ void tooShortArrays();
+ void tooShortMaps_data() { tags_data(); }
+ void tooShortMaps();
+ void tooBigArrays_data() { tags_data(); }
+ void tooBigArrays();
+ void tooBigMaps_data() { tags_data(); }
+ void tooBigMaps();
+ void illegalSimpleType_data();
+ void illegalSimpleType();
+};
+
+#include "tst_encoder.moc"
+
+template <size_t N> QByteArray raw(const char (&data)[N])
+{
+ return QByteArray::fromRawData(data, N - 1);
+}
+
+struct SimpleType { uint8_t type; };
+Q_DECLARE_METATYPE(SimpleType)
+
+struct Float16Standin { uint16_t val; };
+Q_DECLARE_METATYPE(Float16Standin)
+
+struct Tag { CborTag tag; QVariant tagged; };
+Q_DECLARE_METATYPE(Tag)
+
+template <typename... Args>
+QVariant make_list(const Args &... args)
+{
+ return QVariantList{args...};
+}
+
+typedef QVector<QPair<QVariant, QVariant>> Map;
+Q_DECLARE_METATYPE(Map)
+QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list)
+{
+ return QVariant::fromValue(Map(list));
+}
+
+struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; };
+struct IndeterminateLengthMap : Map { using Map::Map; };
+Q_DECLARE_METATYPE(IndeterminateLengthArray)
+Q_DECLARE_METATYPE(IndeterminateLengthMap)
+
+QVariant make_ilarray(const std::initializer_list<QVariant> &list)
+{
+ return QVariant::fromValue(IndeterminateLengthArray(list));
+}
+
+QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list)
+{
+ return QVariant::fromValue(IndeterminateLengthMap(list));
+}
+
+static inline bool isOomError(CborError err)
+{
+ return err == CborErrorOutOfMemory;
+}
+
+CborError encodeVariant(CborEncoder *encoder, const QVariant &v)
+{
+ int type = v.userType();
+ switch (type) {
+ case QVariant::Int:
+ case QVariant::LongLong:
+ return cbor_encode_int(encoder, v.toLongLong());
+
+ case QVariant::UInt:
+ case QVariant::ULongLong:
+ return cbor_encode_uint(encoder, v.toULongLong());
+
+ case QVariant::Bool:
+ return cbor_encode_boolean(encoder, v.toBool());
+
+ case QVariant::Invalid:
+ return cbor_encode_undefined(encoder);
+
+ case QMetaType::VoidStar:
+ return cbor_encode_null(encoder);
+
+ case QVariant::Double:
+ return cbor_encode_double(encoder, v.toDouble());
+
+ case QMetaType::Float:
+ return cbor_encode_float(encoder, v.toFloat());
+
+ case QVariant::String: {
+ QByteArray string = v.toString().toUtf8();
+ return cbor_encode_text_string(encoder, string.constData(), string.length());
+ }
+
+ case QVariant::ByteArray: {
+ QByteArray string = v.toByteArray();
+ return cbor_encode_byte_string(encoder, reinterpret_cast<const quint8 *>(string.constData()), string.length());
+ }
+
+ default:
+ if (type == qMetaTypeId<SimpleType>())
+ return cbor_encode_simple_value(encoder, v.value<SimpleType>().type);
+ if (type == qMetaTypeId<Float16Standin>())
+ return cbor_encode_half_float(encoder, v.constData());
+ if (type == qMetaTypeId<Tag>()) {
+ CborError err = cbor_encode_tag(encoder, v.value<Tag>().tag);
+ if (err && !isOomError(err))
+ return err;
+ return static_cast<CborError>(err | encodeVariant(encoder, v.value<Tag>().tagged));
+ }
+ if (type == QVariant::List || type == qMetaTypeId<IndeterminateLengthArray>()) {
+ CborEncoder sub;
+ QVariantList list = v.toList();
+ size_t len = list.length();
+ if (type == qMetaTypeId<IndeterminateLengthArray>()) {
+ len = CborIndefiniteLength;
+ list = v.value<IndeterminateLengthArray>();
+ }
+ CborError err = cbor_encoder_create_array(encoder, &sub, len);
+ if (err && !isOomError(err))
+ return err;
+ foreach (const QVariant &v2, list) {
+ err = static_cast<CborError>(err | encodeVariant(&sub, v2));
+ if (err && !isOomError(err))
+ return err;
+ }
+ return static_cast<CborError>(err | cbor_encoder_close_container_checked(encoder, &sub));
+ }
+ if (type == qMetaTypeId<Map>() || type == qMetaTypeId<IndeterminateLengthMap>()) {
+ CborEncoder sub;
+ Map map = v.value<Map>();
+ size_t len = map.length();
+ if (type == qMetaTypeId<IndeterminateLengthMap>()) {
+ len = CborIndefiniteLength;
+ map = v.value<IndeterminateLengthMap>();
+ }
+ CborError err = cbor_encoder_create_map(encoder, &sub, len);
+ if (err && !isOomError(err))
+ return err;
+ for (auto pair : map) {
+ err = static_cast<CborError>(err | encodeVariant(&sub, pair.first));
+ if (err && !isOomError(err))
+ return err;
+ err = static_cast<CborError>(err | encodeVariant(&sub, pair.second));
+ if (err && !isOomError(err))
+ return err;
+ }
+ return (CborError)(err | cbor_encoder_close_container_checked(encoder, &sub));
+ }
+ }
+ return CborErrorUnknownType;
+}
+
+bool compareFailed;
+void compare(const QVariant &input, const QByteArray &output)
+{
+ QByteArray buffer(output.length(), Qt::Uninitialized);
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(int(encodeVariant(&encoder, input)), int(CborNoError));
+ buffer.resize(encoder.ptr - reinterpret_cast<const quint8 *>(buffer.constData()));
+ QCOMPARE(buffer, output);
+ QCOMPARE(encoder.added, size_t(1));
+}
+
+void addColumns()
+{
+ QTest::addColumn<QByteArray>("output");
+ QTest::addColumn<QVariant>("input");
+}
+
+void addFixedData()
+{
+ // unsigned integers
+ QTest::newRow("0U") << raw("\x00") << QVariant(0U);
+ QTest::newRow("1U") << raw("\x01") << QVariant(1U);
+ QTest::newRow("10U") << raw("\x0a") << QVariant(10U);
+ QTest::newRow("23U") << raw("\x17") << QVariant(23U);
+ QTest::newRow("24U") << raw("\x18\x18") << QVariant(24U);
+ QTest::newRow("255U") << raw("\x18\xff") << QVariant(255U);
+ QTest::newRow("256U") << raw("\x19\x01\x00") << QVariant(256U);
+ QTest::newRow("65535U") << raw("\x19\xff\xff") << QVariant(65535U);
+ QTest::newRow("65536U") << raw("\x1a\0\1\x00\x00") << QVariant(65536U);
+ QTest::newRow("4294967295U") << raw("\x1a\xff\xff\xff\xff") << QVariant(4294967295U);
+ QTest::newRow("4294967296U") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296));
+ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << QVariant(std::numeric_limits<quint64>::max());
+
+ // signed integers containing positive numbers
+ QTest::newRow("0") << raw("\x00") << QVariant(0);
+ QTest::newRow("1") << raw("\x01") << QVariant(1);
+ QTest::newRow("10") << raw("\x0a") << QVariant(10);
+ QTest::newRow("23") << raw("\x17") << QVariant(23);
+ QTest::newRow("24") << raw("\x18\x18") << QVariant(24);
+ QTest::newRow("255") << raw("\x18\xff") << QVariant(255);
+ QTest::newRow("256") << raw("\x19\x01\x00") << QVariant(256);
+ QTest::newRow("65535") << raw("\x19\xff\xff") << QVariant(65535);
+ QTest::newRow("65536") << raw("\x1a\0\1\x00\x00") << QVariant(65536);
+ QTest::newRow("4294967295") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
+ QTest::newRow("4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
+
+ // negative integers
+ QTest::newRow("-1") << raw("\x20") << QVariant(-1);
+ QTest::newRow("-2") << raw("\x21") << QVariant(-2);
+ QTest::newRow("-24") << raw("\x37") << QVariant(-24);
+ QTest::newRow("-25") << raw("\x38\x18") << QVariant(-25);
+ QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(-256);
+ QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(-257);
+ QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(-65536);
+ QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(-65537);
+ QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296));
+ QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297));
+// QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+// << QVariant::fromValue(BigNegative{std::numeric_limits<quint64>::max()});
+
+ QTest::newRow("simple0") << raw("\xe0") << QVariant::fromValue(SimpleType{0});
+ QTest::newRow("simple19") << raw("\xf3") << QVariant::fromValue(SimpleType{19});
+ QTest::newRow("false") << raw("\xf4") << QVariant(false);
+ QTest::newRow("true") << raw("\xf5") << QVariant(true);
+ QTest::newRow("null") << raw("\xf6") << QVariant::fromValue<void *>(nullptr);
+ QTest::newRow("undefined") << raw("\xf7") << QVariant();
+ QTest::newRow("simple32") << raw("\xf8\x20") << QVariant::fromValue(SimpleType{32});
+ QTest::newRow("simple255") << raw("\xf8\xff") << QVariant::fromValue(SimpleType{255});
+
+ // floating point
+ QTest::newRow("0f16") << raw("\xf9\0\0") << QVariant::fromValue(Float16Standin{0x0000});
+
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << QVariant::fromValue(0.f);
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << QVariant(0.);
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << QVariant::fromValue(-1.f);
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.);
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(16777215.f);
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(16777215.);
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f);
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(-16777215.);
+
+#ifdef Q_CC_MSVC
+ // MSVC NaNs have the sign bit unset
+ QTest::newRow("qnan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(qQNaN());
+ QTest::newRow("qnan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(qQNaN());
+ QTest::newRow("snan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(qSNaN());
+ QTest::newRow("snan") << raw("\xfb\x7f\xf0\0\0\0\0\0\1") << QVariant(qSNaN());
+#else
+ // GCC NaNs have the sign bit set
+ QTest::newRow("qnan_f") << raw("\xfa\xff\xc0\0\0") << QVariant::fromValue<float>(qQNaN());
+ QTest::newRow("qnan") << raw("\xfb\xff\xf8\0\0\0\0\0\0") << QVariant(qQNaN());
+ QTest::newRow("snan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(qSNaN());
+ QTest::newRow("snan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(qSNaN());
+#endif
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(-qInf());
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(-qInf());
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(qInf());
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(qInf());
+}
+
+void addStringsData()
+{
+ // byte strings
+ QTest::newRow("emptybytestring") << raw("\x40") << QVariant(QByteArray(""));
+ QTest::newRow("bytestring1") << raw("\x41 ") << QVariant(QByteArray(" "));
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << QVariant(QByteArray("", 1));
+ QTest::newRow("bytestring5") << raw("\x45Hello") << QVariant(QByteArray("Hello"));
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << QVariant(QByteArray("123456789012345678901234"));
+ QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
+ << QVariant(QByteArray(256, '3'));
+
+ // text strings
+ QTest::newRow("emptytextstring") << raw("\x60") << QVariant("");
+ QTest::newRow("textstring1") << raw("\x61 ") << QVariant(" ");
+ QTest::newRow("textstring1-nul") << raw("\x61\0") << QVariant(QString::fromLatin1("", 1));
+ QTest::newRow("textstring5") << raw("\x65Hello") << QVariant("Hello");
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
+ << QVariant("123456789012345678901234");
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
+ << QVariant(QString(256, '3'));
+}
+
+void addArraysAndMaps()
+{
+ QTest::newRow("emptyarray") << raw("\x80") << make_list();
+ QTest::newRow("emptymap") << raw("\xa0") << make_map({});
+
+ QTest::newRow("array-0") << raw("\x81\0") << make_list(0);
+ QTest::newRow("array-{0-0}") << raw("\x82\0\0") << make_list(0, 0);
+ QTest::newRow("array-Hello") << raw("\x81\x65Hello") << make_list("Hello");
+ QTest::newRow("array-array-0") << raw("\x81\x81\0") << make_list(make_list(0));
+ QTest::newRow("array-array-{0-0}") << raw("\x81\x82\0\0") << make_list(make_list(0, 0));
+ QTest::newRow("array-array-0-0") << raw("\x82\x81\0\0") << make_list(make_list(0),0);
+ QTest::newRow("array-array-Hello") << raw("\x81\x81\x65Hello") << make_list(make_list("Hello"));
+
+ QTest::newRow("map-0:0") << raw("\xa1\0\0") << make_map({{0,0}});
+ QTest::newRow("map-0:0-1:1") << raw("\xa2\0\0\1\1") << make_map({{0,0}, {1,1}});
+ QTest::newRow("map-0:{map-0:0-1:1}") << raw("\xa1\0\xa2\0\0\1\1") << make_map({{0, make_map({{0,0}, {1,1}})}});
+
+ QTest::newRow("array-map1") << raw("\x81\xa1\0\0") << make_list(make_map({{0,0}}));
+ QTest::newRow("array-map2") << raw("\x82\xa1\0\0\xa1\1\1") << make_list(make_map({{0,0}}), make_map({{1,1}}));
+
+ QTest::newRow("map-array1") << raw("\xa1\x62oc\x81\0") << make_map({{"oc", make_list(0)}});
+ QTest::newRow("map-array2") << raw("\xa1\x62oc\x84\0\1\2\3") << make_map({{"oc", make_list(0, 1, 2, 3)}});
+ QTest::newRow("map-array3") << raw("\xa2\x62oc\x82\0\1\2\3") << make_map({{"oc", make_list(0, 1)}, {2, 3}});
+
+ // indeterminate length
+ QTest::newRow("_emptyarray") << raw("\x9f\xff") << QVariant::fromValue(IndeterminateLengthArray{});
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << make_ilmap({});
+
+ QTest::newRow("_array-0") << raw("\x9f\0\xff") << make_ilarray({0});
+ QTest::newRow("_array-{0-0}") << raw("\x9f\0\0\xff") << make_ilarray({0, 0});
+ QTest::newRow("_array-Hello") << raw("\x9f\x65Hello\xff") << make_ilarray({"Hello"});
+ QTest::newRow("_array-array-0") << raw("\x9f\x81\0\xff") << make_ilarray({make_list(0)});
+ QTest::newRow("_array-_array-0") << raw("\x9f\x9f\0\xff\xff") << make_ilarray({make_ilarray({0})});
+ QTest::newRow("_array-_array-{0-0}") << raw("\x9f\x9f\0\0\xff\xff") << make_ilarray({make_ilarray({0, 0})});
+ QTest::newRow("_array-_array-0-0") << raw("\x9f\x9f\0\xff\0\xff") << make_ilarray({make_ilarray({0}),0});
+ QTest::newRow("_array-_array-Hello") << raw("\x9f\x9f\x65Hello\xff\xff") << make_ilarray({make_ilarray({"Hello"})});
+
+ QTest::newRow("_map-0:0") << raw("\xbf\0\0\xff") << make_ilmap({{0,0}});
+ QTest::newRow("_map-0:0-1:1") << raw("\xbf\0\0\1\1\xff") << make_ilmap({{0,0}, {1,1}});
+ QTest::newRow("_map-0:{map-0:0-1:1}") << raw("\xbf\0\xa2\0\0\1\1\xff") << make_ilmap({{0, make_map({{0,0}, {1,1}})}});
+ QTest::newRow("_map-0:{_map-0:0-1:1}") << raw("\xbf\0\xbf\0\0\1\1\xff\xff") << make_ilmap({{0, make_ilmap({{0,0}, {1,1}})}});
+
+ QTest::newRow("_array-map1") << raw("\x9f\xa1\0\0\xff") << make_ilarray({make_map({{0,0}})});
+ QTest::newRow("_array-_map1") << raw("\x9f\xbf\0\0\xff\xff") << make_ilarray({make_ilmap({{0,0}})});
+ QTest::newRow("_array-map2") << raw("\x9f\xa1\0\0\xa1\1\1\xff") << make_ilarray({make_map({{0,0}}), make_map({{1,1}})});
+ QTest::newRow("_array-_map2") << raw("\x9f\xbf\0\0\xff\xbf\1\1\xff\xff") << make_ilarray({make_ilmap({{0,0}}), make_ilmap({{1,1}})});
+
+ QTest::newRow("_map-array1") << raw("\xbf\x62oc\x81\0\xff") << make_ilmap({{"oc", make_list(0)}});
+ QTest::newRow("_map-_array1") << raw("\xbf\x62oc\x9f\0\xff\xff") << make_ilmap({{"oc", make_ilarray({0})}});
+ QTest::newRow("_map-array2") << raw("\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1, 2, 3)}});
+ QTest::newRow("_map-_array2") << raw("\xbf\x62oc\x9f\0\1\2\3\xff\xff") << make_ilmap({{"oc", make_ilarray({0, 1, 2, 3})}});
+ QTest::newRow("_map-array3") << raw("\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1)}, {2, 3}});
+ QTest::newRow("_map-_array3") << raw("\xbf\x62oc\x9f\0\1\xff\2\3\xff") << make_ilmap({{"oc", make_ilarray({0, 1})}, {2, 3}});
+
+ // tagged
+ QTest::newRow("array-1(0)") << raw("\x81\xc1\0") << make_list(QVariant::fromValue(Tag{1, 0}));
+ QTest::newRow("array-1(map)") << raw("\x81\xc1\xa0") << make_list(QVariant::fromValue(Tag{1, make_map({})}));
+ QTest::newRow("map-1(2):3(4)") << raw("\xa1\xc1\2\xc3\4") << make_map({{QVariant::fromValue(Tag{1, 2}), QVariant::fromValue(Tag{3, 4})}});
+}
+
+void tst_Encoder::fixed_data()
+{
+ addColumns();
+ addFixedData();
+}
+
+void tst_Encoder::fixed()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ compare(input, output);
+}
+
+void tst_Encoder::strings_data()
+{
+ addColumns();
+ addStringsData();
+}
+
+void tst_Encoder::arraysAndMaps_data()
+{
+ addColumns();
+ addArraysAndMaps();
+}
+
+void tst_Encoder::tags_data()
+{
+ addColumns();
+ addFixedData();
+ addStringsData();
+ addArraysAndMaps();
+}
+
+void tst_Encoder::tags()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+
+ compare(QVariant::fromValue(Tag{1, input}), "\xc1" + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{24, input}), "\xd8\x18" + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{255, input}), "\xd8\xff" + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{256, input}), raw("\xd9\1\0") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{CborSignatureTag, input}), raw("\xd9\xd9\xf7") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{65535, input}), raw("\xd9\xff\xff") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{65536, input}), raw("\xda\0\1\0\0") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{UINT32_MAX, input}), raw("\xda\xff\xff\xff\xff") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{UINT32_MAX + Q_UINT64_C(1), input}), raw("\xdb\0\0\0\1\0\0\0\0") + output);
+ if (compareFailed) return;
+
+ compare(QVariant::fromValue(Tag{UINT64_MAX, input}), raw("\xdb\xff\xff\xff\xff\xff\xff\xff\xff") + output);
+ if (compareFailed) return;
+
+ // nested tags
+ compare(QVariant::fromValue(Tag{1, QVariant::fromValue(Tag{1, input})}), "\xc1\xc1" + output);
+}
+
+void tst_Encoder::arrays()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+
+ compare(make_list(input), "\x81" + output);
+ if (compareFailed) return;
+
+ compare(make_list(input, input), "\x82" + output + output);
+ if (compareFailed) return;
+
+ {
+ QVariantList list{input};
+ QByteArray longoutput = output;
+
+ // make a list with 32 elements (1 << 5)
+ for (int i = 0; i < 5; ++i) {
+ list += list;
+ longoutput += longoutput;
+ }
+ compare(list, "\x98\x20" + longoutput);
+ if (compareFailed) return;
+
+ // now 256 elements (32 << 3)
+ for (int i = 0; i < 3; ++i) {
+ list += list;
+ longoutput += longoutput;
+ }
+ compare(list, raw("\x99\1\0") + longoutput);
+ if (compareFailed) return;
+ }
+
+ // nested lists
+ compare(make_list(make_list(input)), "\x81\x81" + output);
+ if (compareFailed) return;
+
+ compare(make_list(make_list(input, input)), "\x81\x82" + output + output);
+ if (compareFailed) return;
+
+ compare(make_list(make_list(input), input), "\x82\x81" + output + output);
+ if (compareFailed) return;
+
+ compare(make_list(make_list(input), make_list(input)), "\x82\x81" + output + "\x81" + output);
+}
+
+void tst_Encoder::maps()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+
+ compare(make_map({{1, input}}), "\xa1\1" + output);
+ if (compareFailed) return;
+
+ compare(make_map({{1, input}, {input, 24}}), "\xa2\1" + output + output + "\x18\x18");
+ if (compareFailed) return;
+
+ compare(make_map({{input, input}}), "\xa1" + output + output);
+ if (compareFailed) return;
+
+ {
+ Map map{{1, input}};
+ QByteArray longoutput = "\1" + output;
+
+ // make a map with 32 elements (1 << 5)
+ for (int i = 0; i < 5; ++i) {
+ map += map;
+ longoutput += longoutput;
+ }
+ compare(QVariant::fromValue(map), "\xb8\x20" + longoutput);
+ if (compareFailed) return;
+
+ // now 256 elements (32 << 3)
+ for (int i = 0; i < 3; ++i) {
+ map += map;
+ longoutput += longoutput;
+ }
+ compare(QVariant::fromValue(map), raw("\xb9\1\0") + longoutput);
+ if (compareFailed) return;
+ }
+
+ // nested lists
+ compare(make_map({{1, make_map({{2, input}})}}), "\xa1\1\xa1\2" + output);
+ if (compareFailed) return;
+
+ compare(make_map({{1, make_map({{2, input}, {input, false}})}}), "\xa1\1\xa2\2" + output + output + "\xf4");
+ if (compareFailed) return;
+
+ compare(make_map({{1, make_map({{2, input}})}, {input, false}}), "\xa2\1\xa1\2" + output + output + "\xf4");
+ if (compareFailed) return;
+}
+
+void tst_Encoder::shortBuffer()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length(), Qt::Uninitialized);
+
+ for (int len = 0; len < output.length() - 1; ++len) {
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), len, 0);
+ QCOMPARE(int(encodeVariant(&encoder, input)), int(CborErrorOutOfMemory));
+ QCOMPARE(len + int(encoder.ptr - encoder.end), output.length());
+ }
+}
+
+void tst_Encoder::tooShortArrays()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_array(&encoder, &container, 2), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(1));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooFewItems));
+}
+
+void tst_Encoder::tooShortMaps()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_map(&encoder, &container, 2), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(1));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooFewItems));
+}
+
+void tst_Encoder::tooBigArrays()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() * 2 + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_array(&encoder, &container, 1), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(2));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooManyItems));
+}
+
+void tst_Encoder::tooBigMaps()
+{
+ QFETCH(QVariant, input);
+ QFETCH(QByteArray, output);
+ QByteArray buffer(output.length() * 3 + 1, Qt::Uninitialized);
+
+ CborEncoder encoder, container;
+ cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+ QCOMPARE(cbor_encoder_create_map(&encoder, &container, 1), CborNoError);
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(int(encodeVariant(&container, input)), int(CborNoError));
+ QCOMPARE(container.added, size_t(3));
+ QCOMPARE(int(cbor_encoder_close_container_checked(&encoder, &container)), int(CborErrorTooManyItems));
+}
+
+void tst_Encoder::illegalSimpleType_data()
+{
+ QTest::addColumn<int>("type");
+ QTest::newRow("half-float") << 25;
+ QTest::newRow("float") << 26;
+ QTest::newRow("double") << 27;
+ QTest::newRow("28") << 28;
+ QTest::newRow("29") << 29;
+ QTest::newRow("30") << 30;
+ QTest::newRow("31") << 31;
+}
+
+void tst_Encoder::illegalSimpleType()
+{
+ QFETCH(int, type);
+
+ quint8 buf[2];
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+ QCOMPARE(int(cbor_encode_simple_value(&encoder, type)), int(CborErrorIllegalSimpleType));
+}
+
+QTEST_MAIN(tst_Encoder)
--- /dev/null
+SOURCES += tst_parser.cpp ../../src/cborparser.c
+
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+DEFINES += CBOR_PARSER_MAX_RECURSIONS=16
+
+INCLUDEPATH += ../../src
+msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
+else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _XOPEN_SOURCE 700
+#include <QtTest>
+#include "cbor.h"
+#include <locale.h>
+#include <stdio.h>
+
+#ifndef Q_CC_MSVC
+extern "C" FILE *open_memstream(char **bufptr, size_t *sizeptr);
+#endif
+
+Q_DECLARE_METATYPE(CborError)
+
+class tst_Parser : public QObject
+{
+ Q_OBJECT
+private slots:
+ void initParserEmpty();
+
+ // parsing API
+ void fixed_data();
+ void fixed();
+ void strings_data();
+ void strings() { fixed(); }
+ void tags_data();
+ void tags() { fixed(); }
+ void tagTags_data() { tags_data(); }
+ void tagTags();
+ void emptyContainers_data();
+ void emptyContainers();
+ void arrays_data();
+ void arrays();
+ void undefLengthArrays_data() { arrays_data(); }
+ void undefLengthArrays();
+ void nestedArrays_data() { arrays_data(); }
+ void nestedArrays();
+ void maps_data();
+ void maps();
+ void undefLengthMaps_data() { maps_data(); }
+ void undefLengthMaps();
+ void nestedMaps_data() { maps_data(); }
+ void nestedMaps();
+ void mapMixed_data();
+ void mapMixed() { arrays(); }
+ void mapsAndArrays_data() { arrays_data(); }
+ void mapsAndArrays();
+
+ // convenience API
+ void stringLength_data();
+ void stringLength();
+ void stringCompare_data();
+ void stringCompare();
+ void mapFind_data();
+ void mapFind();
+
+ // validation & errors
+ void validation_data();
+ void validation();
+ void resumeParsing_data();
+ void resumeParsing();
+ void endPointer_data();
+ void endPointer();
+ void recursionLimit_data();
+ void recursionLimit();
+};
+
+CborError parseOne(CborValue *it, QString *parsed)
+{
+ CborError err;
+ char *buffer;
+ size_t size;
+
+ setlocale(LC_ALL, "C");
+#ifdef Q_CC_MSVC
+ // no open_memstream, so use a temporary file
+ QTemporaryFile tmp("./output.XXXXXX.txt");
+ tmp.open();
+
+ FILE *f = fopen(QFile::encodeName(tmp.fileName()), "w+");
+ if (!f)
+ return CborErrorIO;
+ err = cbor_value_to_pretty_advance(f, it);
+ size = ftell(f);
+ rewind(f);
+
+ buffer = static_cast<char *>(malloc(size));
+ size = fread(buffer, 1, size, f);
+ fclose(f);
+#else
+ FILE *f = open_memstream(&buffer, &size);
+ err = cbor_value_to_pretty_advance(f, it);
+ fclose(f);
+#endif
+
+ *parsed = QString::fromLatin1(buffer, int(size));
+ free(buffer);
+ return err;
+}
+
+template <size_t N> QByteArray raw(const char (&data)[N])
+{
+ return QByteArray::fromRawData(data, N - 1);
+}
+
+void tst_Parser::initParserEmpty()
+{
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init((const quint8 *)"", 0, 0, &parser, &first);
+ QCOMPARE(err, CborErrorUnexpectedEOF);
+}
+
+void addColumns()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("expected");
+ QTest::addColumn<int>("n"); // some aux integer, not added in all columns
+}
+
+bool compareFailed = true;
+void compareOne_real(const QByteArray &data, const QString &expected, int line, int n = -1)
+{
+ compareFailed = true;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+
+ if (cbor_value_get_type(&first) == CborArrayType) {
+ size_t len;
+ if (n >= 0) {
+ QCOMPARE(cbor_value_get_array_length(&first, &len), CborNoError);
+ QCOMPARE(len, size_t(len));
+ } else {
+ QCOMPARE(cbor_value_get_array_length(&first, &len), CborErrorUnknownLength);
+ }
+ } else if (cbor_value_get_type(&first) == CborMapType) {
+ size_t len;
+ if (n >= 0) {
+ QCOMPARE(cbor_value_get_map_length(&first, &len), CborNoError);
+ QCOMPARE(len, size_t(len));
+ } else {
+ QCOMPARE(cbor_value_get_map_length(&first, &len), CborErrorUnknownLength);
+ }
+ }
+
+ QString decoded;
+ err = parseOne(&first, &decoded);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) +
+ "\"; decoded stream:\n" + decoded.toLatin1());
+ QCOMPARE(decoded, expected);
+
+ // check that we consumed everything
+ QCOMPARE((void*)first.ptr, (void*)data.constEnd());
+
+ compareFailed = false;
+}
+#define compareOne(data, expected) compareOne_real(data, expected, __LINE__)
+#define compareOneSize(n, data, expected) compareOne_real(data, expected, __LINE__, n)
+
+void addFixedData()
+{
+ // unsigned integers
+ QTest::newRow("0") << raw("\x00") << "0";
+ QTest::newRow("1") << raw("\x01") << "1";
+ QTest::newRow("10") << raw("\x0a") << "10";
+ QTest::newRow("23") << raw("\x17") << "23";
+ QTest::newRow("24") << raw("\x18\x18") << "24";
+ QTest::newRow("UINT8_MAX") << raw("\x18\xff") << "255";
+ QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << "256";
+ QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << "65535";
+ QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << "65536";
+ QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295";
+ QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296";
+ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << QString::number(std::numeric_limits<uint64_t>::max());
+
+ // negative integers
+ QTest::newRow("-1") << raw("\x20") << "-1";
+ QTest::newRow("-2") << raw("\x21") << "-2";
+ QTest::newRow("-24") << raw("\x37") << "-24";
+ QTest::newRow("-25") << raw("\x38\x18") << "-25";
+ QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << "-256";
+ QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << "-257";
+ QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << "-65536";
+ QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << "-65537";
+ QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296";
+ QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297";
+ QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
+ << QString::number(std::numeric_limits<int64_t>::min() + 1);
+ QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff")
+ << QString::number(std::numeric_limits<int64_t>::min());
+ QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << "-9223372036854775809";
+ QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
+ << '-' + QString::number(std::numeric_limits<uint64_t>::max());
+ QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << "-18446744073709551616";
+
+ // overlongs
+ QTest::newRow("0*1") << raw("\x18\x00") << "0";
+ QTest::newRow("0*2") << raw("\x19\x00\x00") << "0";
+ QTest::newRow("0*4") << raw("\x1a\0\0\0\0") << "0";
+ QTest::newRow("0*8") << raw("\x1b\0\0\0\0\0\0\0\0") << "0";
+ QTest::newRow("-1*1") << raw("\x38\x00") << "-1";
+ QTest::newRow("-1*2") << raw("\x39\x00\x00") << "-1";
+ QTest::newRow("-1*4") << raw("\x3a\0\0\0\0") << "-1";
+ QTest::newRow("-1*8") << raw("\x3b\0\0\0\0\0\0\0\0") << "-1";
+
+ QTest::newRow("simple0") << raw("\xe0") << "simple(0)";
+ QTest::newRow("simple19") << raw("\xf3") << "simple(19)";
+ QTest::newRow("false") << raw("\xf4") << "false";
+ QTest::newRow("true") << raw("\xf5") << "true";
+ QTest::newRow("null") << raw("\xf6") << "null";
+ QTest::newRow("undefined") << raw("\xf7") << "undefined";
+ QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)";
+ QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)";
+
+ // floating point
+
+ QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16";
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f";
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0.";
+ QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16";
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f";
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1.";
+ QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16";
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215.";
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f";
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215.";
+
+ QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16";
+ QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f";
+ QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
+ QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16";
+ QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991.";
+ QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f";
+ QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568.";
+ QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f";
+ QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
+
+ QTest::newRow("nan_f16") << raw("\xf9\x7e\x00")
+#ifdef Q_CC_MSVC
+ << "-nan(ind)"
+#else
+ << "nan"
+#endif
+ ;
+ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan";
+ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan";
+ QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf";
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf";
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf";
+ QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf";
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf";
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf";
+
+}
+
+void tst_Parser::fixed_data()
+{
+ addColumns();
+ addFixedData();
+}
+
+void tst_Parser::fixed()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne(data, expected);
+}
+
+void addStringsData()
+{
+ // byte strings
+ QTest::newRow("emptybytestring") << raw("\x40") << "h''";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'";
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'";
+ QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'";
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << "h'313233343536373839303132333435363738393031323334'";
+ QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
+ << "h'" + QString(256 * 2, '3') + '\'';
+
+ // text strings
+ QTest::newRow("emptytextstring") << raw("\x60") << "\"\"";
+ QTest::newRow("textstring1") << raw("\x61 ") << "\" \"";
+ QTest::newRow("textstring1-nul") << raw("\x61\0") << "\"\\u0000\"";
+ QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\"";
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
+ << "\"123456789012345678901234\"";
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
+ << '"' + QString(256, '3') + '"';
+
+ // strings with overlong length
+ QTest::newRow("emptybytestring*1") << raw("\x58\x00") << "h''";
+ QTest::newRow("emptytextstring*1") << raw("\x78\x00") << "\"\"";
+ QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << "h''";
+ QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << "\"\"";
+ QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << "h''";
+ QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << "\"\"";
+ QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << "h''";
+ QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << "\"\"";
+ QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << "\"Hello\"";
+ QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << "h'48656c6c6f'";
+ QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << "\"Hello\"";
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "h''";
+ QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"";
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "h''";
+ QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"";
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "h''";
+ QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"";
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << "\"Hello\"";
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "\"Hello\"";
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "h'48656c6c6f'";
+ QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "\"Hello\"";
+}
+
+void tst_Parser::strings_data()
+{
+ addColumns();
+ addStringsData();
+}
+
+void addTagsData()
+{
+ // since parseOne() works recursively for tags, we can't test lone tags
+ QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)";
+ QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)";
+ QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)";
+ QTest::newRow("tag255") << raw("\xd8\xff\x00") << "255(0)";
+ QTest::newRow("tag256") << raw("\xd9\1\0\x00") << "256(0)";
+ QTest::newRow("tag65535") << raw("\xd9\xff\xff\x00") << "65535(0)";
+ QTest::newRow("tag65536") << raw("\xda\0\1\0\0\x00") << "65536(0)";
+ QTest::newRow("tagUINT32_MAX-1") << raw("\xda\xff\xff\xff\xff\x00") << "4294967295(0)";
+ QTest::newRow("tagUINT32_MAX") << raw("\xdb\0\0\0\1\0\0\0\0\x00") << "4294967296(0)";
+ QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00")
+ << QString::number(std::numeric_limits<uint64_t>::max()) + "(0)";
+
+ // overlong tags
+ QTest::newRow("tag0*1") << raw("\xd8\0\x00") << "0(0)";
+ QTest::newRow("tag0*2") << raw("\xd9\0\0\x00") << "0(0)";
+ QTest::newRow("tag0*4") << raw("\xda\0\0\0\0\x00") << "0(0)";
+ QTest::newRow("tag0*8") << raw("\xdb\0\0\0\0\0\0\0\0\x00") << "0(0)";
+
+ // tag other things
+ QTest::newRow("unixtime") << raw("\xc1\x1a\x55\x4b\xbf\xd3") << "1(1431027667)";
+ QTest::newRow("rfc3339date") << raw("\xc0\x78\x19" "2015-05-07 12:41:07-07:00")
+ << "0(\"2015-05-07 12:41:07-07:00\")";
+ QTest::newRow("tag6+false") << raw("\xc6\xf4") << "6(false)";
+ QTest::newRow("tag25+true") << raw("\xd8\x19\xf5") << "25(true)";
+ QTest::newRow("tag256+null") << raw("\xd9\1\0\xf6") << "256(null)";
+ QTest::newRow("tag65536+simple32") << raw("\xda\0\1\0\0\xf8\x20") << "65536(simple(32))";
+ QTest::newRow("float+unixtime") << raw("\xc1\xfa\x4e\xaa\x97\x80") << "1(1431027712.f)";
+ QTest::newRow("double+unixtime") << raw("\xc1\xfb" "\x41\xd5\x52\xef" "\xf4\xc7\xce\xfe")
+ << "1(1431027667.1220088)";
+}
+
+void tst_Parser::tags_data()
+{
+ addColumns();
+ addTagsData();
+}
+
+void tst_Parser::tagTags()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\xd9\xd9\xf7" + data, "55799(" + expected + ')');
+ if (!compareFailed)
+ compareOne("\xd9\xd9\xf7" "\xd9\xd9\xf7" + data, "55799(55799(" + expected + "))");
+}
+
+void addEmptyContainersData()
+{
+ QTest::newRow("emptyarray") << raw("\x80") << "[]" << 0;
+ QTest::newRow("emptymap") << raw("\xa0") << "{}" << 0;
+ QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]" << -1;
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }" << -1;
+}
+
+void tst_Parser::emptyContainers_data()
+{
+ addColumns();
+ addEmptyContainersData();
+}
+
+void tst_Parser::emptyContainers()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+ QFETCH(int, n);
+
+ compareOneSize(n, data, expected);
+}
+
+void tst_Parser::arrays_data()
+{
+ addColumns();
+ addFixedData();
+ addStringsData();
+ addTagsData();
+}
+
+void tst_Parser::arrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOneSize(1, "\x81" + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82" + data + data, '[' + expected + ", " + expected + ']');
+ if (compareFailed) return;
+
+ // overlong length
+ compareOneSize(1, "\x98\1" + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x99\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x9a\0\0\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+ compareOneSize(1, raw("\x9b\0\0\0\0\0\0\0\1") + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ // medium-sized array: 32 elements (1 << 5)
+ expected += ", ";
+ for (int i = 0; i < 5; ++i) {
+ data += data;
+ expected += expected;
+ }
+ expected.chop(2); // remove the last ", "
+ compareOneSize(32, "\x98\x20" + data, '[' + expected + ']');
+ if (compareFailed) return;
+
+ // large array: 256 elements (32 << 3)
+ expected += ", ";
+ for (int i = 0; i < 3; ++i) {
+ data += data;
+ expected += expected;
+ }
+ expected.chop(2); // remove the last ", "
+ compareOneSize(256, raw("\x99\1\0") + data, '[' + expected + ']');
+ if (compareFailed) return;
+}
+
+void tst_Parser::undefLengthArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\x9f" + data + "\xff", "[_ " + expected + ']');
+ if (compareFailed) return;
+
+ compareOne("\x9f" + data + data + "\xff", "[_ " + expected + ", " + expected + ']');
+}
+
+void tst_Parser::nestedArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOneSize(1, "\x81\x81" + data, "[[" + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\x81\x81" + data, "[[[" + expected + "]]]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\x82" + data + data, "[[" + expected + ", " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\x81" + data + data, "[[" + expected + "], " + expected + "]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\x81" + data + '\x81' + data, "[[" + expected + "], [" + expected + "]]");
+ if (compareFailed) return;
+
+ // undefined length
+ compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\xff", "[_ [_ " + expected + ", " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x9f" + data + "\xff\x9f" + data + "\xff\xff", "[_ [_ " + expected + "], [_ " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x9f" + data + data + "\xff\x9f" + data + "\xff\xff",
+ "[_ [_ " + expected + ", " + expected + "], [_ " + expected + "]]");
+ if (compareFailed) return;
+
+ // mix them
+ compareOneSize(1, "\x81\x9f" + data + "\xff", "[[_ " + expected + "]]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\x81" + data + "\xff", "[_ [" + expected + "]]");
+}
+
+void tst_Parser::maps_data()
+{
+ arrays_data();
+}
+
+void tst_Parser::maps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // integer key
+ compareOneSize(1, "\xa1\1" + data, "{1: " + expected + '}');
+ if (compareFailed) return;
+
+ // string key
+ compareOneSize(1, "\xa1\x65" "Hello" + data, "{\"Hello\": " + expected + '}');
+ if (compareFailed) return;
+
+ // map to self
+ compareOneSize(1, "\xa1" + data + data, '{' + expected + ": " + expected + '}');
+ if (compareFailed) return;
+
+ // two integer keys
+ compareOneSize(2, "\xa2\1" + data + "\2" + data, "{1: " + expected + ", 2: " + expected + '}');
+ if (compareFailed) return;
+
+ // OneSize integer and OneSize string key
+ compareOneSize(2, "\xa2\1" + data + "\x65" "Hello" + data, "{1: " + expected + ", \"Hello\": " + expected + '}');
+ if (compareFailed) return;
+}
+
+void tst_Parser::undefLengthMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // integer key
+ compareOne("\xbf\1" + data + '\xff', "{_ 1: " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\1" + data + '\2' + data + '\xff', "{_ 1: " + expected + ", 2: " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\1" + data + "\x65Hello" + data + '\xff', "{_ 1: " + expected + ", \"Hello\": " + expected + '}');
+ if (compareFailed) return;
+
+ compareOne("\xbf\x65Hello" + data + '\1' + data + '\xff', "{_ \"Hello\": " + expected + ", 1: " + expected + '}');
+}
+
+void tst_Parser::nestedMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // nested maps as values
+ compareOneSize(1, "\xa1\1\xa1\2" + data, "{1: {2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\x65Hello\xa1\2" + data, "{\"Hello\": {2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\xa2\2" + data + '\x20' + data, "{1: {2: " + expected + ", -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\xa2\1\xa1\2" + data + "\2\xa1\x20" + data, "{1: {2: " + expected + "}, 2: {-1: " + expected + "}}");
+ if (compareFailed) return;
+
+ // nested maps as keys
+ compareOneSize(1, "\xa1\xa1\xf4" + data + "\xf5", "{{false: " + expected + "}: true}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\xa1" + data + data + "\xa1" + data + data,
+ "{{" + expected + ": " + expected + "}: {" + expected + ": " + expected + "}}");
+ if (compareFailed) return;
+
+ // undefined length
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\xff", "{_ 1: {_ 2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + '\x20' + data + "\xff\xff", "{_ 1: {_ 2: " + expected + ", -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xbf\2" + data + "\xff\2\xbf\x20" + data + "\xff\xff",
+ "{_ 1: {_ 2: " + expected + "}, 2: {_ -1: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\xbf" + data + data + "\xff\xbf" + data + data + "\xff\xff",
+ "{_ {_ " + expected + ": " + expected + "}: {_ " + expected + ": " + expected + "}}");
+ if (compareFailed) return;
+
+ // mix them
+ compareOneSize(1, "\xa1\1\xbf\2" + data + "\xff", "{1: {_ 2: " + expected + "}}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\xa1\2" + data + "\xff", "{_ 1: {2: " + expected + "}}");
+ if (compareFailed) return;
+}
+
+void addMapMixedData()
+{
+ QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*1-24") << raw("\xa1\x18\0\x18\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*1-24*2") << raw("\xa1\x18\0\x19\0\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-0*4-24*2") << raw("\xa1\x1a\0\0\0\0\x19\0\x18") << "{0: 24}" << 1;
+ QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1;
+ QTest::newRow("map-24-0*1") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1;
+ QTest::newRow("map-255-65535") << raw("\xa1\x18\xff\x19\xff\xff") << "{255: 65535}" << 1;
+
+ QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*1-24") << raw("\xbf\x18\0\x18\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*1-24*2") << raw("\xbf\x18\0\x19\0\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-0*4-24*2") << raw("\xbf\x1a\0\0\0\0\x19\0\x18\xff") << "{_ 0: 24}" << 1;
+ QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1;
+ QTest::newRow("_map-24-0*1") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1;
+ QTest::newRow("_map-255-65535") << raw("\xbf\x18\xff\x19\xff\xff\xff") << "{_ 255: 65535}" << 1;
+}
+
+void tst_Parser::mapMixed_data()
+{
+ addColumns();
+ addMapMixedData();
+}
+
+void tst_Parser::mapsAndArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // arrays of maps
+ compareOneSize(1, "\x81\xa1\1" + data, "[{1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\x82\xa1\1" + data + "\xa1\2" + data, "[{1: " + expected + "}, {2: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\xa2\1" + data + "\2" + data, "[{1: " + expected + ", 2: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\xa1\1" + data + "\xff", "[_ {1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\x81\xbf\1" + data + "\xff", "[{_ 1: " + expected + "}]");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\x9f\xbf\1" + data + "\xff\xff", "[_ {_ 1: " + expected + "}]");
+ if (compareFailed) return;
+
+ // maps of arrays
+ compareOneSize(1, "\xa1\1\x81" + data, "{1: [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x82" + data + data, "{1: [" + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(2, "\xa2\1\x81" + data + "\x65Hello\x81" + data, "{1: [" + expected + "], \"Hello\": [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x9f" + data + "\xff", "{1: [_ " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(1, "\xa1\1\x9f" + data + data + "\xff", "{1: [_ " + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x81" + data + "\xff", "{_ 1: [" + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\xff", "{_ 1: [_ " + expected + "]}");
+ if (compareFailed) return;
+
+ compareOneSize(-1, "\xbf\1\x9f" + data + data + "\xff\xff", "{_ 1: [_ " + expected + ", " + expected + "]}");
+ if (compareFailed) return;
+
+ // mixed with indeterminate length strings
+ compareOneSize(-1, "\xbf\1\x9f" + data + "\xff\x65Hello\xbf" + data + "\x7f\xff\xff\xff",
+ "{_ 1: [_ " + expected + "], \"Hello\": {_ " + expected + ": \"\"}}");
+}
+
+void tst_Parser::stringLength_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("expected");
+
+ QTest::newRow("emptybytestring") << raw("\x40") << 0;
+ QTest::newRow("bytestring1") << raw("\x41 ") << 1;
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << 1;
+ QTest::newRow("bytestring5") << raw("\x45Hello") << 5;
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234") << 24;
+ QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3') << 256;
+
+ // text strings
+ QTest::newRow("emptytextstring") << raw("\x60") << 0;
+ QTest::newRow("textstring1") << raw("\x61 ") << 1;
+ QTest::newRow("textstring1-nul") << raw("\x61\0") << 1;
+ QTest::newRow("textstring5") << raw("\x65Hello") << 5;
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234") << 24;
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3') << 256;
+
+ // strings with overlong length
+ QTest::newRow("emptybytestring*1") << raw("\x58\x00") << 0;
+ QTest::newRow("emptytextstring*1") << raw("\x78\x00") << 0;
+ QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << 0;
+ QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << 0;
+ QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << 0;
+ QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << 0;
+ QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << 0;
+ QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << 0;
+ QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << 5;
+ QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << 5;
+ QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << 5;
+ QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << 5;
+ QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << 5;
+ QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << 5;
+ QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << 5;
+ QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << 5;
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << 0;
+ QTest::newRow("_emptytextstring") << raw("\x7f\xff") << 0;
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << 0;
+ QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << 0;
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << 0;
+ QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << 0;
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << 5;
+ QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << 5;
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << 5;
+ QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << 5;
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << 5;
+ QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << 5;
+}
+
+void tst_Parser::stringLength()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, expected);
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ size_t result;
+ err = cbor_value_calculate_string_length(&value, &result);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(result, size_t(expected));
+}
+
+void tst_Parser::stringCompare_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("string");
+ QTest::addColumn<bool>("expected");
+
+ // compare empty to empty
+ QTest::newRow("empty-empty") << raw("\x60") << QString() << true;
+ QTest::newRow("_empty-empty") << raw("\x7f\xff") << QString() << true;
+ QTest::newRow("_empty*1-empty") << raw("\x7f\x60\xff") << QString() << true;
+ QTest::newRow("_empty*2-empty") << raw("\x7f\x60\x60\xff") << QString() << true;
+
+ // compare empty to non-empty
+ QTest::newRow("empty-nonempty") << raw("\x60") << "Hello" << false;
+ QTest::newRow("_empty-nonempty") << raw("\x7f\xff") << "Hello" << false;
+ QTest::newRow("_empty*1-nonempty") << raw("\x7f\x60\xff") << "Hello" << false;
+ QTest::newRow("_empty*2-nonempty") << raw("\x7f\x60\x60\xff") << "Hello" << false;
+
+ // compare same strings
+ QTest::newRow("same-short-short") << raw("\x65Hello") << "Hello" << true;
+ QTest::newRow("same-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello" << true;
+ QTest::newRow("same-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello" << true;
+ QTest::newRow("same-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello" << true;
+ QTest::newRow("same-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello" << true;
+ QTest::newRow("same-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight" << true;
+ QTest::newRow("same-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight" << true;
+ QTest::newRow("same-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight" << true;
+
+ // compare different strings (same length)
+ QTest::newRow("diff-same-length-short-short") << raw("\x65Hello") << "World" << false;
+ QTest::newRow("diff-same-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "World" << false;
+ QTest::newRow("diff-same-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "World" << false;
+ QTest::newRow("diff-same-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight, world" << false;
+ QTest::newRow("diff-same-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight, world" << false;
+ QTest::newRow("diff-same-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight, world" << false;
+
+ // compare different strings (different length)
+ QTest::newRow("diff-diff-length-short-short") << raw("\x65Hello") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*1-short") << raw("\x7f\x65Hello\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*2-short") << raw("\x7f\x63Hel\x62lo\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*5-short") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-_short*8-short") << raw("\x7f\x61H\x60\x61""e\x60\x61l\x61l\x60\x61o\xff") << "Hello World" << false;
+ QTest::newRow("diff-diff-length-long-long") << raw("\x78\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight World" << false;
+ QTest::newRow("diff-diff-length-_long*1-long") << raw("\x7f\x78\x2aGood morning, good afternoon and goodnight\xff")
+ << "Good morning, good afternoon and goodnight World" << false;
+ QTest::newRow("diff-diff-length-_long*2-long") << raw("\x7f\x78\x1cGood morning, good afternoon\x6e and goodnight\xff")
+ << "Good morning, good afternoon and goodnight World" << false;
+
+ // compare against non-strings
+ QTest::newRow("unsigned") << raw("\0") << "0" << false;
+ QTest::newRow("negative") << raw("\x20") << "-1" << false;
+ QTest::newRow("emptybytestring") << raw("\x40") << "" << false;
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "" << false;
+ QTest::newRow("shortbytestring") << raw("\x45Hello") << "Hello" << false;
+ QTest::newRow("longbytestring") << raw("\x58\x2aGood morning, good afternoon and goodnight")
+ << "Good morning, good afternoon and goodnight" << false;
+ QTest::newRow("emptyarray") << raw("\x80") << "" << false;
+ QTest::newRow("emptymap") << raw("\xa0") << "" << false;
+ QTest::newRow("array") << raw("\x81\x65Hello") << "Hello" << false;
+ QTest::newRow("map") << raw("\xa1\x65Hello\x65World") << "Hello World" << false;
+ QTest::newRow("false") << raw("\xf4") << "false" << false;
+ QTest::newRow("true") << raw("\xf5") << "true" << false;
+ QTest::newRow("null") << raw("\xf6") << "null" << false;
+}
+
+void compareOneString(const QByteArray &data, const QString &string, bool expected, int line)
+{
+ compareFailed = true;
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+
+ bool result;
+ err = cbor_value_text_string_equals(&value, string.toUtf8().constData(), &result);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+ QCOMPARE(result, expected);
+
+ compareFailed = false;
+}
+#define compareOneString(data, string, expected) compareOneString(data, string, expected, __LINE__)
+
+void tst_Parser::stringCompare()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, string);
+ QFETCH(bool, expected);
+
+ compareOneString(data, string, expected);
+ if (compareFailed) return;
+
+ // tag it
+ compareOneString("\xc1" + data, string, expected);
+ if (compareFailed) return;
+
+ compareOneString("\xc1\xc2" + data, string, expected);
+}
+
+void tst_Parser::mapFind_data()
+{
+ // Rules:
+ // we are searching for string "needle"
+ // if present, the value should be the string "haystack" (with tag 42)
+
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<bool>("expected");
+
+ QTest::newRow("emptymap") << raw("\xa0") << false;
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << false;
+
+ // maps not containing our items
+ QTest::newRow("absent-unsigned-unsigned") << raw("\xa1\0\0") << false;
+ QTest::newRow("absent-taggedunsigned-unsigned") << raw("\xa1\xc0\0\0") << false;
+ QTest::newRow("absent-unsigned-taggedunsigned") << raw("\xa1\0\xc0\0") << false;
+ QTest::newRow("absent-taggedunsigned-taggedunsigned") << raw("\xa1\xc0\0\xc0\0") << false;
+ QTest::newRow("absent-string-unsigned") << raw("\xa1\x68haystack\0") << false;
+ QTest::newRow("absent-taggedstring-unsigned") << raw("\xa1\xc0\x68haystack\0") << false;
+ QTest::newRow("absent-string-taggedunsigned") << raw("\xa1\x68haystack\xc0\0") << false;
+ QTest::newRow("absent-taggedstring-taggedunsigned") << raw("\xa1\xc0\x68haystack\xc0\0") << false;
+ QTest::newRow("absent-string-string") << raw("\xa1\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-taggedstring") << raw("\xa1\x68haystack\xc0\x66needle") << false;
+ QTest::newRow("absent-taggedstring-string") << raw("\xa1\xc0\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-taggedstring") << raw("\xa1\xc0\x68haystack\xc0\x66needle") << false;
+
+ QTest::newRow("absent-string-emptyarray") << raw("\xa1\x68haystack\x80") << false;
+ QTest::newRow("absent-string-_emptyarray") << raw("\xa1\x68haystack\x9f\xff") << false;
+ QTest::newRow("absent-string-array1") << raw("\xa1\x68haystack\x81\0") << false;
+ QTest::newRow("absent-string-array2") << raw("\xa1\x68haystack\x85\0\1\2\3\4") << false;
+ QTest::newRow("absent-string-array3") << raw("\xa1\x68haystack\x85\x63one\x63two\x65three\x64""four\x64""five") << false;
+
+ QTest::newRow("absent-string-emptymap") << raw("\xa1\x68haystack\xa0") << false;
+ QTest::newRow("absent-string-_emptymap") << raw("\xa1\x68haystack\xbf\xff") << false;
+ QTest::newRow("absent-string-map") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle") << false;
+ QTest::newRow("absent-string-map2") << raw("\xa1\x68haystack\xa1\x68haystack\x66needle\61z\62yx") << false;
+
+ // maps containing our items
+ QTest::newRow("alone") << raw("\xa1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("tagged") << raw("\xa1\xc1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("doubletagged") << raw("\xa1\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked") << raw("\xa1\x7f\x66needle\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*2") << raw("\xa1\x7f\x60\x66needle\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*2bis") << raw("\xa1\x7f\x66needle\x60\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*3") << raw("\xa1\x7f\x62ne\x62""ed\x62le\xff\xd8\x2a\x68haystack") << true;
+ QTest::newRow("chunked*8") << raw("\xa1\x7f\x61n\x61""e\x60\x61""e\x61""d\x60\x62le\x60\xff\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("1before") << raw("\xa2\x68haystack\x66needle\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("tagged-1before") << raw("\xa2\xc1\x68haystack\x66needle\xc1\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("doubletagged-1before2") << raw("\xa2\xc1\xc2\x68haystack\x66needle\xc1\xc2\x66needle\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("arraybefore") << raw("\xa2\x61z\x80\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("nestedarraybefore") << raw("\xa2\x61z\x81\x81\0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("arrayarraybefore") << raw("\xa2\x82\1\2\x80\x66needle\xd8\x2a\x68haystack") << true;
+
+ QTest::newRow("mapbefore") << raw("\xa2\x61z\xa0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("nestedmapbefore") << raw("\xa2\x61z\xa1\0\x81\0\x66needle\xd8\x2a\x68haystack") << true;
+ QTest::newRow("mapmapbefore") << raw("\xa2\xa1\1\2\xa0\x66needle\xd8\x2a\x68haystack") << true;
+}
+
+void tst_Parser::mapFind()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(bool, expected);
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ CborValue element;
+ err = cbor_value_map_find_value(&value, "needle", &element);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ if (expected) {
+ QCOMPARE(int(element.type), int(CborTagType));
+
+ CborTag tag;
+ err = cbor_value_get_tag(&element, &tag);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(int(tag), 42);
+
+ bool equals;
+ err = cbor_value_text_string_equals(&element, "haystack", &equals);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QVERIFY(equals);
+ } else {
+ QCOMPARE(int(element.type), int(CborInvalidType));
+ }
+}
+
+void tst_Parser::validation_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("flags"); // future
+ QTest::addColumn<CborError>("expectedError");
+ QTest::addColumn<int>("offset");
+
+ // illegal numbers are future extension points
+ QTest::newRow("illegal-number-in-unsigned-1") << raw("\x81\x1c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-2") << raw("\x81\x1d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-3") << raw("\x81\x1e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-unsigned-4") << raw("\x81\x1f") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-1") << raw("\x81\x3c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-2") << raw("\x81\x3d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-3") << raw("\x81\x3e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-negative-4") << raw("\x81\x3f") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-1") << raw("\x81\x5c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-2") << raw("\x81\x5d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-bytearray-length-3") << raw("\x81\x5e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-1") << raw("\x81\x7c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-2") << raw("\x81\x7d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-string-length-3") << raw("\x81\x7e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-1") << raw("\x81\x9c") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-2") << raw("\x81\x9d") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-array-length-3") << raw("\x81\x9e") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-1") << raw("\x81\xbc") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-2") << raw("\x81\xbd") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("illegal-number-in-map-length-3") << raw("\x81\xbe") << 0 << CborErrorIllegalNumber << 1;
+
+ QTest::newRow("number-too-short-1-0") << raw("\x81\x18") << 0 << CborErrorUnexpectedEOF << 1; // requires 1 byte, 0 given
+ QTest::newRow("number-too-short-2-0") << raw("\x81\x19") << 0 << CborErrorUnexpectedEOF << 1; // requires 2 bytes, 0 given
+ QTest::newRow("number-too-short-2-1") << raw("\x81\x19\x01") << 0 << CborErrorUnexpectedEOF << 1; // etc
+ QTest::newRow("number-too-short-4-0") << raw("\x81\x1a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-4-3") << raw("\x81\x1a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-8-0") << raw("\x81\x1b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("number-too-short-8-7") << raw("\x81\x1b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-1-0") << raw("\x81\x38") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-2-0") << raw("\x81\x39") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-2-1") << raw("\x81\x39\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-4-0") << raw("\x81\x3a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-4-3") << raw("\x81\x3a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-8-0") << raw("\x81\x3b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-length-too-short-8-7") << raw("\x81\x3b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-1-0") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-2-0") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-2-1") << raw("\x81\x59\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-4-0") << raw("\x81\x5a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-4-3") << raw("\x81\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-8-0") << raw("\x81\x5b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-length-too-short-8-7") << raw("\x81\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-1-0") << raw("\x81\x98") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-2-0") << raw("\x81\x99") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-2-1") << raw("\x81\x99\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-4-0") << raw("\x81\x9a") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-4-3") << raw("\x81\x9a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-8-0") << raw("\x81\x9b") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("array-length-too-short-8-7") << raw("\x81\x9b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-1-0") << raw("\x81\xb8") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-2-0") << raw("\x81\xb9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-2-1") << raw("\x81\xb9\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-4-0") << raw("\x81\xba") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-4-3") << raw("\x81\xba\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-8-0") << raw("\x81\xbb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("map-length-too-short-8-7") << raw("\x81\xbb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-1-0") << raw("\x81\xd8") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-2-0") << raw("\x81\xd9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-2-1") << raw("\x81\xd9\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-4-0") << raw("\x81\xda") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-4-3") << raw("\x81\xda\x01\x02\x03") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-8-0") << raw("\x81\xdb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("tag-too-short-8-7") << raw("\x81\xdb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF << 1;
+
+ QTest::newRow("bytearray-too-short1") << raw("\x81\x41") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short2") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short3") << raw("\x81\x58\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short4") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short5") << raw("\x81\x5a\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("bytearray-too-short6") << raw("\x81\x5b\0\0\0\0\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short1") << raw("\x81\x61") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short2") << raw("\x81\x78") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short3") << raw("\x81\x78\x01") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short4") << raw("\x81\x79") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short5") << raw("\x81\x7a\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-too-short6") << raw("\x81\x7b\0\0\0\0\0\0\0\1") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("fp16-too-short1") << raw("\x81\xf9") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("fp16-too-short2") << raw("\x81\xf9\x00") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("float-too-short1") << raw("\x81\xfa") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("float-too-short2") << raw("\x81\xfa\0\0\0") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("double-too-short1") << raw("\x81\xfb") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("double-too-short2") << raw("\x81\xfb\0\0\0\0\0\0\0") << 0 << CborErrorUnexpectedEOF << 1;
+
+ // check for pointer additions wrapping over the limit of the address space
+ CborError tooLargeOn32bit = (sizeof(void *) == 4) ? CborErrorDataTooLarge : CborErrorUnexpectedEOF;
+ // on 32-bit systems, this is a -1
+ QTest::newRow("bytearray-wraparound1") << raw("\x81\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-wraparound1") << raw("\x81\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ // on 32-bit systems, a 4GB addition could be dropped
+ QTest::newRow("bytearray-wraparound2") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-wraparound2") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ // on 64-bit systems, this could be a -1
+ QTest::newRow("bytearray-wraparound3") << raw("\x81\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-wraparound3") << raw("\x81\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+
+ // ditto on chunks
+ QTest::newRow("bytearray-chunk-wraparound1") << raw("\x81\x5f\x5a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("string-chunk-wraparound1") << raw("\x81\x7f\x7a\xff\xff\xff\xff") << 0 << CborErrorUnexpectedEOF << 1;
+ // on 32-bit systems, a 4GB addition could be dropped
+ QTest::newRow("bytearray-chunk-wraparound2") << raw("\x81\x5f\x5b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-chunk-wraparound2") << raw("\x81\x7f\x7b\0\0\0\1\0\0\0\0") << 0 << tooLargeOn32bit << 1;
+ // on 64-bit systems, this could be a -1
+ QTest::newRow("bytearray-chunk-wraparound3") << raw("\x81\x5f\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+ QTest::newRow("string-chunk-wraparound3") << raw("\x81\x7f\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0 << tooLargeOn32bit << 1;
+
+ QTest::newRow("eof-after-array") << raw("\x81") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("eof-after-array2") << raw("\x81\x78\x20") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("eof-after-array-element") << raw("\x81\x82\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object") << raw("\x81\xa1") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("eof-after-object2") << raw("\x81\xb8\x20") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object-key") << raw("\x81\xa1\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("eof-after-object-value") << raw("\x81\xa2\x01\x01") << 0 << CborErrorUnexpectedEOF << 4;
+ QTest::newRow("eof-after-tag") << raw("\x81\xc0") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("eof-after-tag2") << raw("\x81\xd8\x20") << 0 << CborErrorUnexpectedEOF << 3;
+
+ // major type 7 has future types
+ QTest::newRow("future-type-28") << raw("\x81\xfc") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("future-type-29") << raw("\x81\xfd") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("future-type-30") << raw("\x81\xfe") << 0 << CborErrorUnknownType << 1;
+ QTest::newRow("unexpected-break") << raw("\x81\xff") << 0 << CborErrorUnexpectedBreak << 1;
+ QTest::newRow("illegal-simple-0") << raw("\x81\xf8\0") << 0 << CborErrorIllegalSimpleType << 1;
+ QTest::newRow("illegal-simple-31") << raw("\x81\xf8\x1f") << 0 << CborErrorIllegalSimpleType << 1;
+
+ // not only too big (UINT_MAX or UINT_MAX+1 in size), but also incomplete
+ if (sizeof(size_t) < sizeof(uint64_t)) {
+ QTest::newRow("bytearray-too-big1") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("string-too-big1") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ }
+ QTest::newRow("array-too-big1") << raw("\x81\x9a\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("array-too-big2") << raw("\x81\x9b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("object-too-big1") << raw("\x81\xba\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+ QTest::newRow("object-too-big2") << raw("\x81\xbb\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge << 1;
+
+ QTest::newRow("no-break-for-array0") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF << 2;
+ QTest::newRow("no-break-for-array1") << raw("\x81\x9f\x01") << 0 << CborErrorUnexpectedEOF << 3;
+ QTest::newRow("no-break-string0") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF << 1;
+ QTest::newRow("no-break-string1") << raw("\x81\x7f\x61Z") << 0 << CborErrorUnexpectedEOF << 1;
+
+ QTest::newRow("nested-indefinite-length-bytearrays") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber << 1;
+ QTest::newRow("nested-indefinite-length-strings") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber << 1;
+
+ QTest::newRow("string-chunk-unsigned") << raw("\x81\x7f\0\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("string-chunk-bytearray") << raw("\x81\x7f\x40\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("string-chunk-array") << raw("\x81\x7f\x80\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-unsigned") << raw("\x81\x5f\0\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-string") << raw("\x81\x5f\x60\xff") << 0 << CborErrorIllegalType << 1;
+ QTest::newRow("bytearray-chunk-array") << raw("\x81\x5f\x80\xff") << 0 << CborErrorIllegalType << 1;
+}
+
+void tst_Parser::validation()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, flags);
+ QFETCH(CborError, expectedError);
+ QFETCH(int, offset);
+
+ QString decoded;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), flags, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ err = parseOne(&first, &decoded);
+ QCOMPARE(int(err), int(expectedError));
+ QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
+}
+
+void tst_Parser::resumeParsing_data()
+{
+ addColumns();
+ addFixedData();
+ addStringsData();
+ addTagsData();
+ addMapMixedData();
+}
+
+void tst_Parser::resumeParsing()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ for (int len = 0; len < data.length() - 1; ++len) {
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), len, 0, &parser, &first);
+ if (!err) {
+ QString decoded;
+ err = parseOne(&first, &decoded);
+ }
+ if (err != CborErrorUnexpectedEOF)
+ qDebug() << "Length is" << len;
+ QCOMPARE(int(err), int(CborErrorUnexpectedEOF));
+ }
+}
+
+void tst_Parser::endPointer_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<int>("offset");
+
+ QTest::newRow("number1") << raw("\x81\x01\x01") << 2;
+ QTest::newRow("number24") << raw("\x81\x18\x18\x01") << 3;
+ QTest::newRow("string") << raw("\x81\x61Z\x01") << 3;
+ QTest::newRow("indefinite-string") << raw("\x81\x7f\x61Z\xff\x01") << 5;
+ QTest::newRow("array") << raw("\x81\x02\x01") << 2;
+ QTest::newRow("indefinite-array") << raw("\x81\x9f\x02\xff\x01") << 4;
+ QTest::newRow("object") << raw("\x81\xa1\x03\x02\x01") << 4;
+ QTest::newRow("indefinite-object") << raw("\x81\xbf\x03\x02\xff\x01") << 5;
+}
+
+void tst_Parser::endPointer()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(int, offset);
+
+ QString decoded;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ err = parseOne(&first, &decoded);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
+}
+
+void tst_Parser::recursionLimit_data()
+{
+ static const int recursions = CBOR_PARSER_MAX_RECURSIONS + 2;
+ QTest::addColumn<QByteArray>("data");
+
+ QTest::newRow("array") << QByteArray(recursions, '\x81') + '\x20';
+ QTest::newRow("_array") << QByteArray(recursions, '\x9f') + '\x20' + QByteArray(recursions, '\xff');
+
+ QByteArray data;
+ for (int i = 0; i < recursions; ++i)
+ data += "\xa1\x65Hello";
+ data += '\2';
+ QTest::newRow("map-recursive-values") << data;
+
+ data.clear();
+ for (int i = 0; i < recursions; ++i)
+ data += "\xbf\x65World";
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\xff";
+ QTest::newRow("_map-recursive-values") << data;
+
+ data = QByteArray(recursions, '\xa1');
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\x7f\x64quux\xff";
+ QTest::newRow("map-recursive-keys") << data;
+
+ data = QByteArray(recursions, '\xbf');
+ data += '\2';
+ for (int i = 0; i < recursions; ++i)
+ data += "\1\xff";
+ QTest::newRow("_map-recursive-keys") << data;
+
+ data.clear();
+ for (int i = 0; i < recursions / 2; ++i)
+ data += "\x81\xa1\1";
+ data += '\2';
+ QTest::newRow("mixed") << data;
+}
+
+void tst_Parser::recursionLimit()
+{
+ QFETCH(QByteArray, data);
+
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+
+ // check that it is valid:
+ CborValue it = first;
+ {
+ QString dummy;
+ err = parseOne(&it, &dummy);
+ QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
+ }
+
+ it = first;
+ err = cbor_value_advance(&it);
+ QCOMPARE(int(err), int(CborErrorNestingTooDeep));
+
+ it = first;
+ if (cbor_value_is_map(&it)) {
+ CborValue dummy;
+ err = cbor_value_map_find_value(&it, "foo", &dummy);
+ QCOMPARE(int(err), int(CborErrorNestingTooDeep));
+ }
+}
+
+QTEST_MAIN(tst_Parser)
+#include "tst_parser.moc"
--- /dev/null
+TEMPLATE = subdirs
+SUBDIRS = parser encoder cpp tojson
+msvc: SUBDIRS -= tojson
--- /dev/null
+CONFIG += testcase parallel_test c++11
+QT = core testlib
+
+SOURCES += tst_tojson.cpp
+INCLUDEPATH += ../../src
+msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
+else: POST_TARGETDEPS += ../../lib/libtinycbor.a
+LIBS += $$POST_TARGETDEPS
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include <QtTest>
+#include "cbor.h"
+#include "cborjson.h"
+#include <locale.h>
+
+extern "C" FILE *open_memstream(char **bufptr, size_t *sizeptr);
+
+class tst_ToJson : public QObject
+{
+ Q_OBJECT
+private slots:
+ void initTestCase();
+
+ void fixed_data();
+ void fixed();
+ void textstrings_data();
+ void textstrings() { fixed(); }
+ void nonjson_data();
+ void nonjson() { fixed(); }
+ void bytestrings_data();
+ void bytestrings() { fixed(); }
+ void emptyContainers_data();
+ void emptyContainers() { fixed(); }
+ void arrays_data();
+ void arrays();
+ void nestedArrays_data() { arrays_data(); }
+ void nestedArrays();
+ void maps_data() { arrays_data(); }
+ void maps();
+ void nestedMaps_data() { maps_data(); }
+ void nestedMaps();
+ void nonStringKeyMaps_data();
+ void nonStringKeyMaps();
+
+ void tagsToObjects_data();
+ void tagsToObjects();
+ void taggedByteStringsToBase16_data();
+ void taggedByteStringsToBase16();
+ void taggedByteStringsToBase64_data() { taggedByteStringsToBase16_data(); }
+ void taggedByteStringsToBase64();
+ void taggedByteStringsToBigNum_data() { taggedByteStringsToBase16_data(); }
+ void taggedByteStringsToBigNum();
+ void otherTags_data();
+ void otherTags();
+
+ void metaData_data();
+ void metaData();
+ void metaDataAndTagsToObjects_data() { tagsToObjects_data(); }
+ void metaDataAndTagsToObjects();
+ void metaDataForKeys_data();
+ void metaDataForKeys();
+};
+#include "tst_tojson.moc"
+
+template <size_t N> QByteArray raw(const char (&data)[N])
+{
+ return QByteArray::fromRawData(data, N - 1);
+}
+
+void addColumns()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("expected");
+}
+
+void addFixedData()
+{
+ // unsigned integers
+ QTest::newRow("0") << raw("\x00") << "0";
+ QTest::newRow("1") << raw("\x01") << "1";
+ QTest::newRow("2^53-1") << raw("\x1b\0\x1f\xff\xff""\xff\xff\xff\xff") << "9007199254740991";
+ QTest::newRow("2^64-epsilon") << raw("\x1b\xff\xff\xff\xff""\xff\xff\xf8\x00") << "18446744073709549568";
+
+ // negative integers
+ QTest::newRow("-1") << raw("\x20") << "-1";
+ QTest::newRow("-2") << raw("\x21") << "-2";
+ QTest::newRow("-2^53+1") << raw("\x3b\0\x1f\xff\xff""\xff\xff\xff\xfe") << "-9007199254740991";
+ QTest::newRow("-2^64+epsilon") << raw("\x3b\xff\xff\xff\xff""\xff\xff\xf8\x00") << "-18446744073709549568";
+
+ QTest::newRow("false") << raw("\xf4") << "false";
+ QTest::newRow("true") << raw("\xf5") << "true";
+ QTest::newRow("null") << raw("\xf6") << "null";
+
+ QTest::newRow("0.f16") << raw("\xf9\0\0") << "0";
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0";
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0";
+ QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1";
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1";
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1";
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215";
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215";
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215";
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215";
+
+ QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5";
+ QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5";
+ QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
+ QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215";
+ QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991";
+ QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840";
+ QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568";
+ QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19";
+ QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
+
+ // infinities and NaN are not supported in JSON, they convert to null
+ QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "null";
+ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "null";
+ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "null";
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "null";
+ QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "null";
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "null";
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "null";
+ QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "null";
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "null";
+}
+
+void addTextStringsData()
+{
+ QTest::newRow("emptytextstring") << raw("\x60") << "\"\"";
+ QTest::newRow("textstring1") << raw("\x61 ") << "\" \"";
+ QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\"";
+ QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
+ << "\"123456789012345678901234\"";
+ QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
+ << '"' + QString(256, '3') + '"';
+
+ // strings with undefined length
+ QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"";
+ QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"";
+ QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"";
+ QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << "\"Hello\"";
+ QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "\"Hello\"";
+ QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "\"Hello\"";
+}
+
+void addNonJsonData()
+{
+ QTest::newRow("undefined") << raw("\xf7") << "\"undefined\"";
+ QTest::newRow("simple0") << raw("\xe0") << "\"simple(0)\"";
+ QTest::newRow("simple19") << raw("\xf3") << "\"simple(19)\"";
+ QTest::newRow("simple32") << raw("\xf8\x20") << "\"simple(32)\"";
+ QTest::newRow("simple255") << raw("\xf8\xff") << "\"simple(255)\"";
+}
+
+void addByteStringsData()
+{
+ QTest::newRow("emptybytestring") << raw("\x40") << "\"\"";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "\"IA\"";
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << "\"AA\"";
+ QTest::newRow("bytestring2") << raw("\x42Hi") << "\"SGk\"";
+ QTest::newRow("bytestring3") << raw("\x43Hey") << "\"SGV5\"";
+ QTest::newRow("bytestring4") << raw("\x44Hola") << "\"SG9sYQ\"";
+ QTest::newRow("bytestring5") << raw("\x45Hello") << "\"SGVsbG8\"";
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << "\"MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0\"";
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "\"\"";
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "\"\"";
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "\"\"";
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "\"SGVsbG8\"";
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "\"SGVsbG8\"";
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "\"SGVsbG8\"";
+}
+
+void addEmptyContainersData()
+{
+ QTest::newRow("emptyarray") << raw("\x80") << "[]";
+ QTest::newRow("emptymap") << raw("\xa0") << "{}";
+ QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[]";
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << "{}";
+}
+
+CborError parseOne(CborValue *it, QString *parsed, int flags)
+{
+ char *buffer;
+ size_t size;
+
+ FILE *f = open_memstream(&buffer, &size);
+ CborError err = cbor_value_to_json_advance(f, it, flags);
+ fclose(f);
+
+ *parsed = QString::fromLatin1(buffer);
+ free(buffer);
+ return err;
+}
+
+bool compareFailed = true;
+void compareOne_real(const QByteArray &data, const QString &expected, int flags, int line)
+{
+ compareFailed = true;
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
+
+ QString decoded;
+ err = parseOne(&first, &decoded, flags);
+ QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) +
+ "\"; decoded stream:\n" + decoded.toLatin1());
+ QCOMPARE(decoded, expected);
+
+ // check that we consumed everything
+ QCOMPARE((void*)first.ptr, (void*)data.constEnd());
+
+ compareFailed = false;
+}
+#define compareOne(data, expected, flags) \
+ compareOne_real(data, expected, flags, __LINE__); \
+ if (compareFailed) return
+
+void tst_ToJson::initTestCase()
+{
+ setlocale(LC_ALL, "C");
+}
+
+void tst_ToJson::fixed_data()
+{
+ addColumns();
+ addFixedData();
+}
+
+void tst_ToJson::fixed()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne(data, expected, 0);
+}
+
+void tst_ToJson::textstrings_data()
+{
+ addColumns();
+ addTextStringsData();
+}
+
+void tst_ToJson::nonjson_data()
+{
+ addColumns();
+ addNonJsonData();
+}
+
+void tst_ToJson::bytestrings_data()
+{
+ addColumns();
+ addByteStringsData();
+}
+
+void tst_ToJson::emptyContainers_data()
+{
+ addColumns();
+ addEmptyContainersData();
+}
+
+void tst_ToJson::arrays_data()
+{
+ addColumns();
+ addFixedData();
+ addTextStringsData();
+ addNonJsonData();
+ addByteStringsData();
+}
+
+void tst_ToJson::arrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\x81" + data, '[' + expected + ']', 0);
+ compareOne("\x82" + data + data, '[' + expected + ',' + expected + ']', 0);
+}
+
+void tst_ToJson::nestedArrays()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\x81\x81" + data, "[[" + expected + "]]", 0);
+ compareOne("\x81\x81\x81" + data, "[[[" + expected + "]]]", 0);
+ compareOne("\x81\x82" + data + data, "[[" + expected + ',' + expected + "]]", 0);
+ compareOne("\x82\x81" + data + data, "[[" + expected + "]," + expected + "]", 0);
+ compareOne("\x82\x81" + data + '\x81' + data, "[[" + expected + "],[" + expected + "]]", 0);
+}
+
+void tst_ToJson::maps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\xa1\x65" "Hello" + data, "{\"Hello\":" + expected + '}', 0);
+}
+
+void tst_ToJson::nestedMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne("\xa1\x65Hello\xa1\x65World" + data, "{\"Hello\":{\"World\":" + expected + "}}", 0);
+// compareOne("\xa1\x63""foo\xa1\63""bar" + data + "\63""baz\xa1\x64quux" + data,
+// "{\"foo\":{\"bar\":" + expected + "},\"baz\":{\"quux\":" + expected + "}", 0);
+}
+
+void tst_ToJson::nonStringKeyMaps_data()
+{
+ addColumns();
+
+ QTest::newRow("0") << raw("\x00") << "0";
+ QTest::newRow("1") << raw("\x01") << "1";
+ QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295";
+ QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296";
+ QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << QString::number(std::numeric_limits<uint64_t>::max());
+
+ QTest::newRow("-1") << raw("\x20") << "-1";
+ QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296";
+ QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297";
+ QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
+ << '-' + QString::number(std::numeric_limits<uint64_t>::max());
+ QTest::newRow("-UINT64_MAX-1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
+ << "-18446744073709551616";
+
+ QTest::newRow("simple0") << raw("\xe0") << "simple(0)";
+ QTest::newRow("simple19") << raw("\xf3") << "simple(19)";
+ QTest::newRow("false") << raw("\xf4") << "false";
+ QTest::newRow("true") << raw("\xf5") << "true";
+ QTest::newRow("null") << raw("\xf6") << "null";
+ QTest::newRow("undefined") << raw("\xf7") << "undefined";
+ QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)";
+ QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)";
+
+ QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16";
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f";
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0.";
+ QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16";
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f";
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1.";
+ QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16";
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215.";
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f";
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215.";
+
+ QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16";
+ QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f";
+ QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
+ QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16";
+ QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
+ QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991.";
+ QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f";
+ QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568.";
+ QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f";
+ QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
+
+ QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "nan";
+ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan";
+ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan";
+ QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf";
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf";
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf";
+ QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf";
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf";
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf";
+
+ QTest::newRow("emptybytestring") << raw("\x40") << "h''";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'";
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'";
+ QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'";
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << "h'313233343536373839303132333435363738393031323334'";
+
+ QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)";
+ QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)";
+ QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)";
+ QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00")
+ << QString::number(std::numeric_limits<uint64_t>::max()) + "(0)";
+
+ QTest::newRow("emptyarray") << raw("\x80") << "[]";
+ QTest::newRow("emptymap") << raw("\xa0") << "{}";
+ QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]";
+ QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }";
+
+ QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}";
+ QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}";
+ QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}";
+ QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}";
+}
+
+void tst_ToJson::nonStringKeyMaps()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ data = "\xa1" + data + "\1";
+ compareOne(data, "{\"" + expected + "\":1}", CborConvertStringifyMapKeys);
+
+ // and verify that they fail if we use CborConvertRequireMapStringKeys
+ CborParser parser;
+ CborValue first;
+ QString decoded;
+ cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ CborError err = parseOne(&first, &decoded, CborConvertRequireMapStringKeys);
+ QCOMPARE(err, CborErrorJsonObjectKeyNotString);
+}
+
+void tst_ToJson::tagsToObjects_data()
+{
+ addColumns();
+ QTest::newRow("0(0)") << raw("\xc0\0") << "{\"tag0\":0}";
+ QTest::newRow("0(-1)") << raw("\xc0\x20") << "{\"tag0\":-1}";
+ QTest::newRow("0(\"hello\")") << raw("\xc0\x65hello") << "{\"tag0\":\"hello\"}";
+ QTest::newRow("22(h'48656c6c6f')") << raw("\xd6\x45Hello") << "{\"tag22\":\"SGVsbG8\"}";
+ QTest::newRow("0([1,2,3])") << raw("\xc0\x83\1\2\3") << "{\"tag0\":[1,2,3]}";
+ QTest::newRow("0({\"z\":true,\"y\":1})") << raw("\xc0\xa2\x61z\xf5\x61y\1") << "{\"tag0\":{\"z\":true,\"y\":1}}";
+
+ // large tags
+ QTest::newRow("55799(0)") << raw("\xd9\xd9\xf7\0") << "{\"tag55799\":0}";
+ QTest::newRow("4294967295") << raw("\xda\xff\xff\xff\xff\0") << "{\"tag4294967295\":0}";
+ QTest::newRow("18446744073709551615(0)") << raw("\xdb\xff\xff\xff\xff""\xff\xff\xff\xff\0")
+ << "{\"tag18446744073709551615\":0}";
+
+ // nested tags
+ QTest::newRow("0(1(2))") << raw("\xc0\xc1\2") << "{\"tag0\":{\"tag1\":2}}";
+ QTest::newRow("0({\"z\":1(2)})") << raw("\xc0\xa1\x61z\xc1\2") << "{\"tag0\":{\"z\":{\"tag1\":2}}}";
+}
+
+void tst_ToJson::tagsToObjects()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ compareOne(data, expected, CborConvertTagsToObjects);
+}
+
+void tst_ToJson::taggedByteStringsToBase16_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<QString>("base64url");
+ QTest::addColumn<QString>("base64");
+ QTest::addColumn<QString>("base16");
+
+ QTest::newRow("emptybytestring") << raw("\x40") << "" << "" << "";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "IA" << "IA==" << "20";
+ QTest::newRow("bytestring1-nul") << raw("\x41\0") << "AA" << "AA==" << "00";
+ QTest::newRow("bytestring1-ff") << raw("\x41\xff") << "_w" << "/w==" << "ff";
+ QTest::newRow("bytestring2") << raw("\x42Hi") << "SGk" << "SGk=" << "4869";
+ QTest::newRow("bytestring3") << raw("\x43Hey") << "SGV5" << "SGV5" << "486579";
+ QTest::newRow("bytestring4") << raw("\x44Hola") << "SG9sYQ" << "SG9sYQ==" << "486f6c61";
+ QTest::newRow("bytestring5") << raw("\x45Hello") << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
+ QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
+ << "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0"
+ << "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0"
+ << "313233343536373839303132333435363738393031323334";
+
+ // strings with undefined length
+ QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "" << "" << "";
+ QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "" << "" << "";
+ QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "" << "" << "";
+ QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
+ QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff")
+ << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
+ QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff")
+ << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
+}
+
+void tst_ToJson::taggedByteStringsToBase16()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, base16);
+
+ compareOne('\xd7' + data, '"' + base16 + '"', 0);
+}
+
+void tst_ToJson::taggedByteStringsToBase64()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, base64);
+
+ compareOne('\xd6' + data, '"' + base64 + '"', 0);
+}
+
+void tst_ToJson::taggedByteStringsToBigNum()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, base64url);
+
+ compareOne('\xc3' + data, "\"~" + base64url + '"', 0);
+}
+
+void tst_ToJson::otherTags_data()
+{
+ addColumns();
+ addFixedData();
+ addTextStringsData();
+ addNonJsonData();
+ addByteStringsData();
+ addEmptyContainersData();
+}
+
+void tst_ToJson::otherTags()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+
+ // other tags produce no change in output
+ compareOne("\xc0" + data, expected, 0);
+ compareOne("\xc1" + data, expected, 0);
+ compareOne("\xc2" + data, expected, 0);
+ compareOne("\xc4" + data, expected, 0);
+ compareOne("\xc5" + data, expected, 0);
+ compareOne("\xd8\x20" + data, expected, 0);
+ compareOne("\xd8\x21" + data, expected, 0);
+ compareOne("\xd8\x22" + data, expected, 0);
+ compareOne("\xd8\x23" + data, expected, 0);
+ compareOne("\xd8\x24" + data, expected, 0);
+ compareOne("\xd9\xd9\xf7" + data, expected, 0);
+}
+
+void tst_ToJson::metaData_data()
+{
+ addColumns();
+
+ // booleans, null, strings, double precision numbers, regular maps, arrays and integers that
+ // didn't get rounded don't have metadata
+ QTest::newRow("0") << raw("\x00") << QString();
+ QTest::newRow("1") << raw("\x01") << QString();
+ QTest::newRow("2^53-1") << raw("\x1b\0\x1f\xff\xff""\xff\xff\xff\xff") << QString();
+ QTest::newRow("2^64-epsilon") << raw("\x1b\xff\xff\xff\xff""\xff\xff\xf8\x00") << QString();
+ QTest::newRow("-1") << raw("\x20") << QString();
+ QTest::newRow("-2") << raw("\x21") << QString();
+ QTest::newRow("-2^53+1") << raw("\x3b\0\x1f\xff\xff""\xff\xff\xff\xfe") << QString();
+ QTest::newRow("-2^64+epsilon") << raw("\x3b\xff\xff\xff\xff""\xff\xff\xf8\x00") << QString();
+ QTest::newRow("emptytextstring") << raw("\x60") << QString();
+ QTest::newRow("textstring1") << raw("\x61 ") << QString();
+ QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << QString();
+ QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << QString();
+ QTest::newRow("false") << raw("\xf4") << QString();
+ QTest::newRow("true") << raw("\xf5") << QString();
+ QTest::newRow("null") << raw("\xf6") << QString();
+ QTest::newRow("emptyarray") << raw("\x80") << QString();
+ QTest::newRow("emptymap") << raw("\xa0") << QString();
+ QTest::newRow("array*1") << raw("\x81\xf6") << QString();
+ QTest::newRow("map*1") << raw("\xa1\x61z\xf4") << QString();
+
+ // ---- everything from here on has at least the type ----
+ QTest::newRow("emptybytestring") << raw("\x40") << "\"t\":64";
+ QTest::newRow("bytestring1") << raw("\x41 ") << "\"t\":64";
+ QTest::newRow("undefined") << raw("\xf7") << "\"t\":247";
+ QTest::newRow("0.f16") << raw("\xf9\0\0") << "\"t\":249";
+ QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "\"t\":249";
+ QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "\"t\":250";
+ QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "\"t\":250";
+ QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "\"t\":250";
+ QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "\"t\":250";
+ QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "\"t\":251";
+ QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "\"t\":251";
+ QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "\"t\":251";
+ QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "\"t\":251";
+ QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "\"t\":251";
+ QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "\"t\":251";
+
+ // integers that are too precise for double
+ QTest::newRow("2^53+1") << raw("\x1b\0\x20\0\0""\0\0\0\1")
+ << "\"t\":0,\"v\":\"+20000000000001\"";
+ QTest::newRow("INT64_MAX-1") << raw("\x1b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
+ << "\"t\":0,\"v\":\"+7ffffffffffffffe\"";
+ QTest::newRow("INT64_MAX+1") << raw("\x1b\x80\0\0\0""\0\0\0\1")
+ << "\"t\":0,\"v\":\"+8000000000000001\"";
+ QTest::newRow("-2^53-1") << raw("\x3b\0\x20\0\0""\0\0\0\0")
+ << "\"t\":0,\"v\":\"-20000000000000\"";
+
+ // simple values
+ QTest::newRow("simple0") << raw("\xe0") << "\"t\":224,\"v\":0";
+ QTest::newRow("simple19") << raw("\xf3") << "\"t\":224,\"v\":19";
+ QTest::newRow("simple32") << raw("\xf8\x20") << "\"t\":224,\"v\":32";
+ QTest::newRow("simple255") << raw("\xf8\xff") << "\"t\":224,\"v\":255";
+
+ // infinities and NaN are not supported in JSON, they convert to null
+ QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "\"t\":249,\"v\":\"nan\"";
+ QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "\"t\":250,\"v\":\"nan\"";
+ QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "\"t\":251,\"v\":\"nan\"";
+ QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "\"t\":249,\"v\":\"-inf\"";
+ QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "\"t\":250,\"v\":\"-inf\"";
+ QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "\"t\":251,\"v\":\"-inf\"";
+ QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "\"t\":249,\"v\":\"inf\"";
+ QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "\"t\":250,\"v\":\"inf\"";
+ QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "\"t\":251,\"v\":\"inf\"";
+
+ // tags on native types
+ QTest::newRow("tag+0") << raw("\xc0\x00") << "\"tag\":\"0\"";
+ QTest::newRow("tag+-2") << raw("\xc0\x21") << "\"tag\":\"0\"";
+ QTest::newRow("tag+0.5") << raw("\xc0\xfb\x3f\xe0\0\0\0\0\0\0") << "\"tag\":\"0\"";
+ QTest::newRow("tag+emptytextstring") << raw("\xc0\x60") << "\"tag\":\"0\"";
+ QTest::newRow("tag+textstring1") << raw("\xc0\x61 ") << "\"tag\":\"0\"";
+ QTest::newRow("tag+false") << raw("\xc0\xf4") << "\"tag\":\"0\"";
+ QTest::newRow("tag+true") << raw("\xc0\xf5") << "\"tag\":\"0\"";
+ QTest::newRow("tag+null") << raw("\xc0\xf6") << "\"tag\":\"0\"";
+ QTest::newRow("tag+emptyarray") << raw("\xc0\x80") << "\"tag\":\"0\"";
+ QTest::newRow("tag+emptymap") << raw("\xc0\xa0") << "\"tag\":\"0\"";
+ QTest::newRow("tag+array*1") << raw("\xc0\x81\xf6") << "\"tag\":\"0\"";
+ QTest::newRow("tag+map*1") << raw("\xc0\xa1\x61z\xf4") << "\"tag\":\"0\"";
+
+ // tags on non-native types
+ QTest::newRow("tag+emptybytestring") << raw("\xc0\x40") << "\"tag\":\"0\",\"t\":64";
+ QTest::newRow("tag+bytestring1") << raw("\xc0\x41 ") << "\"tag\":\"0\",\"t\":64";
+ QTest::newRow("tag+undefined") << raw("\xc0\xf7") << "\"tag\":\"0\",\"t\":247";
+ QTest::newRow("tag+0.f") << raw("\xc0\xfa\0\0\0\0") << "\"tag\":\"0\",\"t\":250";
+ QTest::newRow("tag+-1.f") << raw("\xc0\xfa\xbf\x80\0\0") << "\"tag\":\"0\",\"t\":250";
+ QTest::newRow("tag+16777215.f") << raw("\xc0\xfa\x4b\x7f\xff\xff") << "\"tag\":\"0\",\"t\":250";
+ QTest::newRow("tag+-16777215.f") << raw("\xc0\xfa\xcb\x7f\xff\xff") << "\"tag\":\"0\",\"t\":250";
+ QTest::newRow("tag+0.") << raw("\xc0\xfb\0\0\0\0\0\0\0\0") << "\"tag\":\"0\",\"t\":251";
+ QTest::newRow("tag+-1.") << raw("\xc0\xfb\xbf\xf0\0\0\0\0\0\0") << "\"tag\":\"0\",\"t\":251";
+ QTest::newRow("tag+16777215.") << raw("\xc0\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "\"tag\":\"0\",\"t\":251";
+ QTest::newRow("tag+-16777215.") << raw("\xc0\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "\"tag\":\"0\",\"t\":251";
+
+ // big tags (don't fit in JS numbers)
+ QTest::newRow("bigtag1") << raw("\xdb\0\x20\0\0""\0\0\0\1\x60") << "\"tag\":\"9007199254740993\"";
+ QTest::newRow("bigtag2") << raw("\xdb\xff\xff\xff\xff""\xff\xff\xff\xfe\x60")
+ << "\"tag\":\"18446744073709551614\"";
+
+ // specially-handled tags
+ QTest::newRow("negativebignum") << raw("\xc3\x41 ") << "\"tag\":\"3\",\"t\":64";
+ QTest::newRow("base64") << raw("\xd6\x41 ") << "\"tag\":\"22\",\"t\":64";
+ QTest::newRow("base16") << raw("\xd7\x41 ") << "\"tag\":\"23\",\"t\":64";
+}
+
+void compareMetaData(QByteArray data, const QString &expected, int otherFlags = 0)
+{
+ QString decoded;
+
+ // needs to be in in one map, with the entry called "v"
+ data = "\xa1\x61v" + data;
+
+ {
+ CborParser parser;
+ CborValue first;
+ CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
+ QVERIFY2(!err, QByteArrayLiteral(": Got error \"") + cbor_error_string(err) + "\"");
+
+ err = parseOne(&first, &decoded, CborConvertAddMetadata | otherFlags);
+ QVERIFY2(!err, QByteArrayLiteral(": Got error \"") + cbor_error_string(err) +
+ "\"; decoded stream:\n" + decoded.toLatin1());
+
+ // check that we consumed everything
+ QCOMPARE((void*)first.ptr, (void*)data.constEnd());
+ }
+
+ QVERIFY(decoded.startsWith("{\"v\":"));
+ QVERIFY(decoded.endsWith('}'));
+// qDebug() << "was" << decoded;
+
+ // extract just the metadata
+ static const char needle[] = "\"v$cbor\":{";
+ int pos = decoded.indexOf(needle);
+ QCOMPARE(pos == -1, expected.isEmpty());
+ if (pos != -1) {
+ decoded.chop(2);
+ decoded = std::move(decoded).mid(pos + strlen(needle));
+ QCOMPARE(decoded, expected);
+ }
+}
+
+void tst_ToJson::metaData()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+ compareMetaData(data, expected);
+}
+
+void tst_ToJson::metaDataAndTagsToObjects()
+{
+ QFETCH(QByteArray, data);
+
+ // when a tag is converted to an object, the object gets metadata indicating it was a tag
+ compareMetaData(data, "\"t\":192", CborConvertTagsToObjects);
+}
+
+void tst_ToJson::metaDataForKeys_data()
+{
+ nonStringKeyMaps_data();
+
+ // string keys generate no metadata
+ QTest::newRow("string") << raw("\x60") << QString();
+}
+
+void tst_ToJson::metaDataForKeys()
+{
+ QFETCH(QByteArray, data);
+ QFETCH(QString, expected);
+ if (expected.isEmpty())
+ expected = "{\"\":false}";
+ else
+ expected = "{\"" + expected + "\":false,\"" + expected + "$keycbordump\":true}";
+ compareOne('\xa1' + data + '\xf4', expected,
+ CborConvertAddMetadata | CborConvertStringifyMapKeys);
+}
+
+QTEST_MAIN(tst_ToJson)
--- /dev/null
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: TinyCBOR
+Description: A tiny CBOR encoder and decoder library
+Version: @version@
+Libs: -L${libdir} -ltinycbor
+Libs.private: -lm
+Cflags: -I${includedir}/tinycbor
--- /dev/null
+CFLAGS = -O2 -g
+CPPFLAGS = -I../src
+VPATH = cbordump:../src
+
+all: ../bin ../bin/cbordump
+../bin:
+ @-mkdir ../bin
+
+../bin/cbordump: cbordump.o cborparser.o cborerrorstrings.o cborpretty.o
+ $(CC) -o $@ $^
+ $(RM) $^
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _POSIX_C_SOURCE 200809L
+#include "cbor.h"
+#include "cborjson.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+enum Mode {
+ PrintCborDump = 0,
+ PrintJson = 0x80000000
+};
+
+void *xrealloc(void *old, size_t size, const char *fname)
+{
+ old = realloc(old, size);
+ if (old == NULL) {
+ fprintf(stderr, "%s: %s\n", fname, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ return old;
+}
+
+void printerror(CborError err, const char *fname)
+{
+ fprintf(stderr, "%s: %s\n", fname, cbor_error_string(err));
+ exit(EXIT_FAILURE);
+}
+
+void dumpFile(FILE *in, const char *fname, int mode)
+{
+ static const size_t chunklen = 16 * 1024;
+ static size_t bufsize = 0;
+ static uint8_t *buffer = NULL;
+
+ size_t buflen = 0;
+ do {
+ if (bufsize == buflen)
+ buffer = xrealloc(buffer, bufsize += chunklen, fname);
+
+ size_t n = fread(buffer + buflen, 1, bufsize - buflen, in);
+ buflen += n;
+ if (n == 0) {
+ if (!ferror(in))
+ continue;
+ fprintf(stderr, "%s: %s\n", fname, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ } while (!feof(in));
+
+ CborParser parser;
+ CborValue value;
+ CborError err = cbor_parser_init(buffer, buflen, 0, &parser, &value);
+ if (!err) {
+ if (mode)
+ err = cbor_value_to_json_advance(stdout, &value, mode & ~PrintJson);
+ else
+ err = cbor_value_to_pretty_advance(stdout, &value);
+ if (!err)
+ puts("");
+ }
+ if (!err && value.ptr != buffer + buflen)
+ err = CborErrorGarbageAtEnd;
+ if (err)
+ printerror(err, fname);
+}
+
+int main(int argc, char **argv)
+{
+ int mode = PrintCborDump;
+ int c;
+ while ((c = getopt(argc, argv, "MOSUcjh")) != -1) {
+ switch (c) {
+ case 'c':
+ mode = PrintCborDump;
+ break;
+ case 'j':
+ mode &= ~PrintCborDump;
+ mode |= PrintJson;
+ break;
+
+ case 'M':
+ mode |= CborConvertAddMetadata;
+ break;
+ case 'O':
+ mode |= CborConvertTagsToObjects;
+ break;
+ case 'S':
+ mode |= CborConvertStringifyMapKeys;
+ break;
+ case 'U':
+ mode |= CborConvertByteStringsToBase64Url;
+ break;
+
+ case '?':
+ fprintf(stderr, "Unknown option -%c.\n", optopt);
+ // fall through
+ case 'h':
+ puts("Usage: cbordump [OPTION]... [FILE]...\n"
+ "Interprets FILEs as CBOR binary data and dumps the content to stdout.\n"
+ "\n"
+ "Options:\n"
+ " -c Print a CBOR dump (see RFC 7049) (default)\n"
+ " -j Print a JSON equivalent version\n"
+ " -h Print this help output and exit\n"
+ "When JSON output is active, the following options are recognized:\n"
+ " -M Add metadata so converting back to CBOR is possible\n"
+ " -O Convert CBOR tags to JSON objects\n"
+ " -S Stringify non-text string map keys\n"
+ " -U Convert all CBOR byte strings to Base64url regardless of tags"
+ "");
+ return c == '?' ? EXIT_FAILURE : EXIT_SUCCESS;
+ }
+ }
+
+ char **fname = argv + optind;
+ if (!*fname) {
+ dumpFile(stdin, "-", mode);
+ } else {
+ for ( ; *fname; ++fname) {
+ FILE *in = fopen(*fname, "rb");
+ if (!in) {
+ perror("open");
+ return EXIT_FAILURE;
+ }
+
+ dumpFile(in, *fname, mode);
+ fclose(in);
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
--- /dev/null
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG -= qt
+DESTDIR = ../../bin
+
+CBORDIR = $$PWD/../../src
+INCLUDEPATH += $$CBORDIR
+SOURCES += cbordump.c
+LIBS += ../../lib/libtinycbor.a
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2015 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#define _POSIX_C_SOURCE 200809L
+#define _GNU_SOURCE
+#include "cbor.h"
+#include "compilersupport_p.h"
+
+#include <cJSON.h>
+
+#include <errno.h>
+#include <math.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static const char meta_data_marker[] = "$cbor";
+uint8_t *buffer;
+size_t buffersize;
+bool usingMetaData = false;
+
+struct MetaData {
+ CborTag tag;
+ union {
+ const char *v;
+ uint8_t simpleType;
+ };
+ CborType t;
+ bool tagged;
+};
+
+uint8_t *decode_base64_generic(const char *string, size_t *len, const int8_t reverse_alphabet[256])
+{
+ *len = ((strlen(string) + 3) & ~3) * 3 / 4;
+ uint8_t *buffer = malloc(*len);
+ if (buffer == NULL)
+ return NULL;
+
+ uint8_t *out = buffer;
+ const uint8_t *in = (const uint8_t *)string;
+ bool done = false;
+ while (!done) {
+ if (reverse_alphabet[in[0]] < 0 || reverse_alphabet[in[1]] < 0) {
+ if (in[0] == '\0')
+ done = true;
+ break;
+ }
+
+ uint32_t val = reverse_alphabet[in[0]] << 18;
+ val |= reverse_alphabet[in[1]] << 12;
+ if (in[2] == '=' || in[2] == '\0') {
+ if (in[2] == '=' && (in[3] != '=' || in[4] != '\0'))
+ break;
+ val >>= 12;
+ done = true;
+ } else if (in[3] == '=' || in[3] == '\0') {
+ if (in[3] == '=' && in[4] != '\0')
+ break;
+ val >>= 6;
+ val |= reverse_alphabet[in[2]];
+ done = true;
+ } else {
+ val |= reverse_alphabet[in[2]] << 6;
+ val |= reverse_alphabet[in[3]];
+ }
+
+ *out++ = val >> 16;
+ *out++ = val >> 8;
+ *out++ = val;
+ in += 4;
+ }
+
+ if (!done) {
+ free(buffer);
+ return NULL;
+ }
+ *len = out - buffer;
+ return buffer;
+}
+
+uint8_t *decode_base64(const char *string, size_t *len)
+{
+ static const int8_t reverse_alphabet[256] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+ };
+ return decode_base64_generic(string, len, reverse_alphabet);
+}
+
+uint8_t *decode_base64url(const char *string, size_t *len)
+{
+ static const int8_t reverse_alphabet[256] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+ };
+ return decode_base64_generic(string, len, reverse_alphabet);
+}
+
+uint8_t *decode_base16(const char *string, size_t *len)
+{
+ *len = strlen(string) / 2;
+ uint8_t *buffer = malloc(*len);
+ if (buffer == NULL)
+ return NULL;
+
+ for (size_t i = 0; i < *len; ++i) {
+ char c = string[i * 2];
+ if (c >= '0' && c <= '9') {
+ buffer[i] = (c - '0') << 4;
+ } else if ((c | 0x20) >= 'a' && (c | 0x20) <= 'f') {
+ buffer[i] = ((c | 0x20) - 'a' + 10) << 4;
+ } else {
+ free(buffer);
+ return NULL;
+ }
+
+ c = string[i * 2 + 1];
+ if (c >= '0' && c <= '9') {
+ buffer[i] |= (c - '0');
+ } else if ((c | 0x20) >= 'a' && (c | 0x20) <= 'f') {
+ buffer[i] |= ((c | 0x20) - 'a' + 10);
+ } else {
+ free(buffer);
+ return NULL;
+ }
+ }
+
+ return buffer;
+}
+
+size_t get_cjson_size_limited(cJSON *container)
+{
+ // cJSON_GetArraySize is O(n), so don't go too far
+ unsigned s = 0;
+ cJSON *item;
+ for (item = container->child; item; item = item->next) {
+ if (++s > 255)
+ return CborIndefiniteLength;
+ }
+ return s;
+}
+
+cJSON *get_meta_data(cJSON *object, cJSON *item)
+{
+ cJSON *meta;
+ char *metadatakey;
+
+ if (asprintf(&metadatakey, "%s%s", item->string, meta_data_marker) < 0 || metadatakey == NULL)
+ return NULL;
+ meta = cJSON_GetObjectItem(object, metadatakey);
+ free(metadatakey);
+ return meta;
+}
+
+struct MetaData parse_meta_data(cJSON *md)
+{
+ struct MetaData result = { 0, {NULL}, CborInvalidType, false };
+ if (md == NULL || md->type != cJSON_Object)
+ return result;
+
+ for (md = md->child; md; md = md->next) {
+ if (strcmp(md->string, "tag") == 0) {
+ if (md->type != cJSON_String || sscanf(md->valuestring, "%" PRIu64, &result.tag) < 0)
+ fprintf(stderr, "json2cbor: could not parse tag: %s\n", md->valuestring);
+ else
+ result.tagged = true;
+ } else if (strcmp(md->string, "t") == 0) {
+ result.t = md->valueint;
+ } else if (strcmp(md->string, "v") == 0) {
+ if (md->type == cJSON_Number)
+ result.simpleType = md->valueint;
+ else
+ result.v = md->valuestring;
+ }
+ }
+ return result;
+}
+
+CborError decode_json(cJSON *json, CborEncoder *encoder);
+CborError decode_json_with_metadata(cJSON *item, CborEncoder *encoder, struct MetaData md)
+{
+ switch (md.t) {
+ case CborIntegerType: {
+ // integer that has more than 53 bits of precision
+ uint64_t v;
+ bool positive = *md.v++ == '+';
+ if (sscanf(md.v, "%" PRIx64, &v) < 0) {
+ fprintf(stderr, "json2cbor: could not parse number: %s\n", md.v);
+ break;
+ }
+ return positive ? cbor_encode_uint(encoder, v) : cbor_encode_negative_int(encoder, v);
+ }
+
+ case CborByteStringType: {
+ uint8_t *data;
+ size_t len;
+ if (md.tag == CborExpectedBase64Tag)
+ data = decode_base64(item->valuestring, &len);
+ else if (md.tag == CborExpectedBase16Tag)
+ data = decode_base16(item->valuestring, &len);
+ else if (md.tag == CborNegativeBignumTag)
+ data = decode_base64url(item->valuestring + 1, &len);
+ else
+ data = decode_base64url(item->valuestring, &len);
+
+ if (data != NULL) {
+ CborError err = cbor_encode_byte_string(encoder, data, len);
+ free(data);
+ return err;
+ }
+ fprintf(stderr, "json2cbor: could not decode encoded byte string: %s\n", item->valuestring);
+ break;
+ }
+
+ case CborSimpleType:
+ return cbor_encode_simple_value(encoder, md.simpleType);
+
+ case CborUndefinedType:
+ return cbor_encode_undefined(encoder);
+
+ case CborHalfFloatType:
+ case CborFloatType:
+ case CborDoubleType: {
+ unsigned short half;
+ double v;
+ if (!md.v) {
+ v = item->valuedouble;
+ } else if (strcmp(md.v, "nan") == 0) {
+ v = NAN;
+ } else if (strcmp(md.v, "-inf") == 0) {
+ v = -INFINITY;
+ } else if (strcmp(md.v, "inf") == 0) {
+ v = INFINITY;
+ } else {
+ fprintf(stderr, "json2cbor: invalid floating-point value: %s\n", md.v);
+ break;
+ }
+
+ // we can't get an OOM here because the metadata makes up for space
+ // (the smallest metadata is "$cbor":{"t":250} (17 bytes)
+ return (md.t == CborDoubleType) ? cbor_encode_double(encoder, v) :
+ (md.t == CborFloatType) ? cbor_encode_float(encoder, v) :
+ (half = encode_half(v), cbor_encode_half_float(encoder, &half));
+ }
+
+ default:
+ fprintf(stderr, "json2cbor: invalid CBOR type: %d\n", md.t);
+ case CborInvalidType:
+ break;
+ }
+
+ return decode_json(item, encoder);
+}
+
+CborError decode_json(cJSON *json, CborEncoder *encoder)
+{
+ CborEncoder container;
+ CborError err;
+ cJSON *item;
+
+ switch (json->type) {
+ case cJSON_False:
+ case cJSON_True:
+ return cbor_encode_boolean(encoder, json->type == cJSON_True);
+
+ case cJSON_NULL:
+ return cbor_encode_null(encoder);
+
+ case cJSON_Number:
+ if ((double)json->valueint == json->valuedouble)
+ return cbor_encode_int(encoder, json->valueint);
+encode_double:
+ // the only exception that JSON is larger: floating point numbers
+ container = *encoder; // save the state
+ err = cbor_encode_double(encoder, json->valuedouble);
+
+ if (err == CborErrorOutOfMemory) {
+ buffersize += 1024;
+ uint8_t *newbuffer = realloc(buffer, buffersize);
+ if (newbuffer == NULL)
+ return err;
+
+ *encoder = container; // restore state
+ encoder->ptr = newbuffer + (container.ptr - buffer);
+ encoder->end = newbuffer + buffersize;
+ buffer = newbuffer;
+ goto encode_double;
+ }
+ return err;
+
+ case cJSON_String:
+ return cbor_encode_text_stringz(encoder, json->valuestring);
+
+ default:
+ return CborErrorUnknownType;
+
+ case cJSON_Array:
+ err = cbor_encoder_create_array(encoder, &container, get_cjson_size_limited(json));
+ if (err)
+ return err;
+ for (item = json->child; item; item = item->next) {
+ err = decode_json(item, &container);
+ if (err)
+ return err;
+ }
+ return cbor_encoder_close_container_checked(encoder, &container);
+
+ case cJSON_Object:
+ err = cbor_encoder_create_map(encoder, &container,
+ usingMetaData ? CborIndefiniteLength : get_cjson_size_limited(json));
+ if (err)
+ return err;
+
+ for (item = json->child ; item; item = item->next) {
+ if (usingMetaData && strlen(item->string) > strlen(meta_data_marker)
+ && strcmp(item->string + strlen(item->string) - 5, meta_data_marker) == 0)
+ continue;
+
+ err = cbor_encode_text_stringz(&container, item->string);
+ if (err)
+ return err;
+
+ if (usingMetaData) {
+ cJSON *meta = get_meta_data(json, item);
+ struct MetaData md = parse_meta_data(meta);
+ if (md.tagged) {
+ err = cbor_encode_tag(&container, md.tag);
+ if (err)
+ return err;
+ }
+
+ err = decode_json_with_metadata(item, &container, md);
+ } else {
+ err = decode_json(item, &container);
+ }
+ if (err)
+ return err;
+ }
+
+ return cbor_encoder_close_container_checked(encoder, &container);
+ }
+}
+
+int main(int argc, char **argv)
+{
+ int c;
+ while ((c = getopt(argc, argv, "M")) != -1) {
+ switch (c) {
+ case 'M':
+ usingMetaData = true;
+ break;
+
+ case '?':
+ fprintf(stderr, "Unknown option -%c.\n", optopt);
+ // fall through
+ case 'h':
+ puts("Usage: json2cbor [OPTION]... [FILE]...\n"
+ "Reads JSON content from FILE and convert to CBOR.\n"
+ "\n"
+ "Options:\n"
+ " -M Interpret metadata added by cbordump tool\n"
+ "");
+ return c == '?' ? EXIT_FAILURE : EXIT_SUCCESS;
+ }
+ }
+
+ FILE *in;
+ const char *fname = argv[optind];
+ if (fname && strcmp(fname, "-") != 0) {
+ in = fopen(fname, "r");
+ if (!in) {
+ perror("open");
+ return EXIT_FAILURE;
+ }
+ } else {
+ in = stdin;
+ fname = "-";
+ }
+
+ /* 1. read the file */
+ off_t fsize;
+ if (fseeko(in, 0, SEEK_END) == 0 && (fsize = ftello(in)) >= 0) {
+ buffersize = fsize + 1;
+ buffer = malloc(buffersize);
+ if (buffer == NULL) {
+ perror("malloc");
+ return EXIT_FAILURE;
+ }
+
+ rewind(in);
+ fsize = fread(buffer, 1, fsize, in);
+ buffer[fsize] = '\0';
+ } else {
+ const unsigned chunk = 16384;
+ buffersize = 0;
+ buffer = NULL;
+ do { // it the hard way
+ buffer = realloc(buffer, buffersize + chunk);
+ if (buffer == NULL)
+ perror("malloc");
+
+ buffersize += fread(buffer + buffersize, 1, chunk, in);
+ } while (!feof(in) && !ferror(in));
+ buffer[buffersize] = '\0';
+ }
+
+ if (ferror(in)) {
+ perror("read");
+ return EXIT_FAILURE;
+ }
+ if (in != stdin)
+ fclose(in);
+
+ /* 2. parse as JSON */
+ cJSON *doc = cJSON_ParseWithOpts((char *)buffer, NULL, true);
+ if (doc == NULL) {
+ fprintf(stderr, "json2cbor: %s: could not parse.\n", fname);
+ return EXIT_FAILURE;
+ }
+
+ /* 3. encode as CBOR */
+ // We're going to reuse the buffer, as CBOR is usually shorter than the equivalent JSON
+ CborEncoder encoder;
+ cbor_encoder_init(&encoder, buffer, buffersize, 0);
+ CborError err = decode_json(doc, &encoder);
+
+ cJSON_Delete(doc);
+
+ if (err) {
+ fprintf(stderr, "json2cbor: %s: error encoding to CBOR: %s\n", fname,
+ cbor_error_string(err));
+ return EXIT_FAILURE;
+ }
+
+ fwrite(buffer, 1, encoder.ptr - buffer, stdout);
+ free(buffer);
+ return EXIT_SUCCESS;
+}
--- /dev/null
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG -= qt
+DESTDIR = ../../bin
+
+CBORDIR = $$PWD/../../src
+INCLUDEPATH += $$CBORDIR
+SOURCES += json2cbor.c
+LIBS += ../../lib/libtinycbor.a
+
+CJSONDIR = .
+!exists($$CJSONDIR/cJSON.h): CJSONDIR = $$CBORDIR/cjson
+exists($$CJSONDIR/cJSON.h) {
+ INCLUDEPATH += $$CJSONDIR
+ SOURCES += $$CJSONDIR/cJSON.c
+} else {
+ message("cJSON not found, not building json2cbor.")
+ TEMPLATE = aux
+}
projects / platform / upstream / iotivity.git / commitdiff