From: Philippe Coval Date: Thu, 1 Sep 2016 10:04:08 +0000 (+0200) Subject: tinycbor: Import v0.2.1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=81ac69eaaf891c6a3266d3a15c21cce10a1e2b44;p=contrib%2Fiotivity.git tinycbor: Import v0.2.1 Needed for Iotivity-1.1.1 and lower It is strongly recommended to rely on scons instead, if not possible, this change workaround this. For more details about building IoTivity please check: https://wiki.iotivity.org/build Bug: https://jira.iotivity.org/browse/IOT-820 Bug-Tizen: https://bugs.tizen.org/jira/browse/TINF-861 Change-Id: I0a622b8c7c47cfc4ea7afd8a3cf82720a50618bd Signed-off-by: Philippe Coval --- diff --git a/extlibs/tinycbor/tinycbor/.gitattributes b/extlibs/tinycbor/tinycbor/.gitattributes new file mode 100644 index 0000000..018cf2c --- /dev/null +++ b/extlibs/tinycbor/tinycbor/.gitattributes @@ -0,0 +1,3 @@ +.tag export-subst +.gitignore export-ignore +.gitattributes export-ignore diff --git a/extlibs/tinycbor/tinycbor/.gitignore b/extlibs/tinycbor/tinycbor/.gitignore new file mode 100644 index 0000000..5259302 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/.gitignore @@ -0,0 +1,77 @@ +# 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 diff --git a/extlibs/tinycbor/tinycbor/.tag b/extlibs/tinycbor/tinycbor/.tag new file mode 100644 index 0000000..6828f88 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/.tag @@ -0,0 +1 @@ +$Format:%H$ diff --git a/extlibs/tinycbor/tinycbor/.travis.yml b/extlibs/tinycbor/tinycbor/.travis.yml new file mode 100644 index 0000000..f7a5dec --- /dev/null +++ b/extlibs/tinycbor/tinycbor/.travis.yml @@ -0,0 +1,25 @@ +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` diff --git a/extlibs/tinycbor/tinycbor/LICENSE b/extlibs/tinycbor/tinycbor/LICENSE new file mode 100644 index 0000000..89de354 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/LICENSE @@ -0,0 +1,17 @@ +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. diff --git a/extlibs/tinycbor/tinycbor/Makefile b/extlibs/tinycbor/tinycbor/Makefile new file mode 100644 index 0000000..48c6c0e --- /dev/null +++ b/extlibs/tinycbor/tinycbor/Makefile @@ -0,0 +1,194 @@ +# 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 $@ $< + diff --git a/extlibs/tinycbor/tinycbor/Makefile.configure b/extlibs/tinycbor/tinycbor/Makefile.configure new file mode 100644 index 0000000..afb23c4 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/Makefile.configure @@ -0,0 +1,29 @@ +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 \n +PROGRAM-cjson += \#include \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 diff --git a/extlibs/tinycbor/tinycbor/Makefile.nmake b/extlibs/tinycbor/tinycbor/Makefile.nmake new file mode 100644 index 0000000..cf35bd5 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/Makefile.nmake @@ -0,0 +1,39 @@ +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$@ $< + diff --git a/extlibs/tinycbor/tinycbor/TODO b/extlibs/tinycbor/tinycbor/TODO new file mode 100644 index 0000000..e9103ee --- /dev/null +++ b/extlibs/tinycbor/tinycbor/TODO @@ -0,0 +1,25 @@ +==== 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 diff --git a/extlibs/tinycbor/tinycbor/VERSION b/extlibs/tinycbor/tinycbor/VERSION new file mode 100644 index 0000000..3b04cfb --- /dev/null +++ b/extlibs/tinycbor/tinycbor/VERSION @@ -0,0 +1 @@ +0.2 diff --git a/extlibs/tinycbor/tinycbor/examples/examples.pro b/extlibs/tinycbor/tinycbor/examples/examples.pro new file mode 100644 index 0000000..22071ac --- /dev/null +++ b/extlibs/tinycbor/tinycbor/examples/examples.pro @@ -0,0 +1,2 @@ +TEMPLATE = subdirs +SUBDIRS = simplereader.pro diff --git a/extlibs/tinycbor/tinycbor/examples/simplereader.c b/extlibs/tinycbor/tinycbor/examples/simplereader.c new file mode 100644 index 0000000..256191f --- /dev/null +++ b/extlibs/tinycbor/tinycbor/examples/simplereader.c @@ -0,0 +1,181 @@ +#include "../src/cbor.h" + +#include +#include +#include +#include +#include + +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 "); + 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; +} diff --git a/extlibs/tinycbor/tinycbor/examples/simplereader.pro b/extlibs/tinycbor/tinycbor/examples/simplereader.pro new file mode 100644 index 0000000..07fdc6a --- /dev/null +++ b/extlibs/tinycbor/tinycbor/examples/simplereader.pro @@ -0,0 +1,3 @@ +CONFIG -= qt +SOURCES = simplereader.c +include(../src/src.pri) diff --git a/extlibs/tinycbor/tinycbor/src/assert_p.h b/extlibs/tinycbor/tinycbor/src/assert_p.h new file mode 100644 index 0000000..994be06 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/assert_p.h @@ -0,0 +1,29 @@ +/**************************************************************************** +** +** 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 +#ifdef NDEBUG +# undef assert +# define assert(cond) do { if (!(cond)) unreachable(); } while (0) +#endif diff --git a/extlibs/tinycbor/tinycbor/src/cbor.h b/extlibs/tinycbor/tinycbor/src/cbor.h new file mode 100644 index 0000000..7f11475 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cbor.h @@ -0,0 +1,459 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#else +#include +#endif + +#ifndef SIZE_MAX +/* Some systems fail to define SIZE_MAX in , 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 + diff --git a/extlibs/tinycbor/tinycbor/src/cborconstants_p.h b/extlibs/tinycbor/tinycbor/src/cborconstants_p.h new file mode 100644 index 0000000..e8ab8b6 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborconstants_p.h @@ -0,0 +1,53 @@ +#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 + diff --git a/extlibs/tinycbor/tinycbor/src/cborencoder.c b/extlibs/tinycbor/tinycbor/src/cborencoder.c new file mode 100644 index 0000000..11d4e85 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborencoder.c @@ -0,0 +1,267 @@ +/**************************************************************************** +** +** 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 +#include +#include + +#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; +} diff --git a/extlibs/tinycbor/tinycbor/src/cborencoder_close_container_checked.c b/extlibs/tinycbor/tinycbor/src/cborencoder_close_container_checked.c new file mode 100644 index 0000000..aad2ebf --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborencoder_close_container_checked.c @@ -0,0 +1,55 @@ +/**************************************************************************** +** +** 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 + +#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; +} diff --git a/extlibs/tinycbor/tinycbor/src/cborerrorstrings.c b/extlibs/tinycbor/tinycbor/src/cborerrorstrings.c new file mode 100644 index 0000000..4f0cd50 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborerrorstrings.c @@ -0,0 +1,114 @@ +/**************************************************************************** +** +** 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); +} diff --git a/extlibs/tinycbor/tinycbor/src/cborjson.h b/extlibs/tinycbor/tinycbor/src/cborjson.h new file mode 100644 index 0000000..58c4cae --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborjson.h @@ -0,0 +1,62 @@ +/**************************************************************************** +** +** 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 + diff --git a/extlibs/tinycbor/tinycbor/src/cborparser.c b/extlibs/tinycbor/tinycbor/src/cborparser.c new file mode 100644 index 0000000..1880524 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborparser.c @@ -0,0 +1,738 @@ +/**************************************************************************** +** +** 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 +#include +#include + +#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; +} diff --git a/extlibs/tinycbor/tinycbor/src/cborpretty.c b/extlibs/tinycbor/tinycbor/src/cborpretty.c new file mode 100644 index 0000000..bd0b8ee --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cborpretty.c @@ -0,0 +1,371 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include +#include + +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); +} diff --git a/extlibs/tinycbor/tinycbor/src/cbortojson.c b/extlibs/tinycbor/tinycbor/src/cbortojson.c new file mode 100644 index 0000000..48ed8fa --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/cbortojson.c @@ -0,0 +1,531 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include +#include + +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); +} diff --git a/extlibs/tinycbor/tinycbor/src/compilersupport_p.h b/extlibs/tinycbor/tinycbor/src/compilersupport_p.h new file mode 100644 index 0000000..ea79851 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/compilersupport_p.h @@ -0,0 +1,214 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include + +#ifndef __cplusplus +# include +#endif + +#ifdef __F16C__ +# include +#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 +#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 +# define cbor_ntohs ntohs +# define cbor_htons htons +#endif +#ifndef cbor_ntohl +# include +# 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(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 + diff --git a/extlibs/tinycbor/tinycbor/src/extract_number_p.h b/extlibs/tinycbor/tinycbor/src/extract_number_p.h new file mode 100644 index 0000000..864ee7d --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/extract_number_p.h @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** 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 + +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; +} diff --git a/extlibs/tinycbor/tinycbor/src/math_support_p.h b/extlibs/tinycbor/tinycbor/src/math_support_p.h new file mode 100644 index 0000000..647ac91 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/math_support_p.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** 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 + +// 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 + diff --git a/extlibs/tinycbor/tinycbor/src/open_memstream.c b/extlibs/tinycbor/tinycbor/src/open_memstream.c new file mode 100644 index 0000000..aed5fe1 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/open_memstream.c @@ -0,0 +1,113 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include + +#if defined(__unix__) || defined(__APPLE__) +# include +#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 +} + diff --git a/extlibs/tinycbor/tinycbor/src/src.pri b/extlibs/tinycbor/tinycbor/src/src.pri new file mode 100644 index 0000000..fcf33c4 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/src.pri @@ -0,0 +1,11 @@ +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 diff --git a/extlibs/tinycbor/tinycbor/src/tinycbor.pro b/extlibs/tinycbor/tinycbor/src/tinycbor.pro new file mode 100644 index 0000000..22ba52e --- /dev/null +++ b/extlibs/tinycbor/tinycbor/src/tinycbor.pro @@ -0,0 +1,5 @@ +TEMPLATE = lib +CONFIG += static +DESTDIR = ../lib + +include(src.pri) diff --git a/extlibs/tinycbor/tinycbor/tests/.gitignore b/extlibs/tinycbor/tinycbor/tests/.gitignore new file mode 100644 index 0000000..8450623 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/.gitignore @@ -0,0 +1,4 @@ +Makefile +debug +release +target_wrapper.* diff --git a/extlibs/tinycbor/tinycbor/tests/cpp/cpp.pro b/extlibs/tinycbor/tinycbor/tests/cpp/cpp.pro new file mode 100644 index 0000000..5e9e608 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/cpp/cpp.pro @@ -0,0 +1,5 @@ +CONFIG += testcase parallel_test c++11 +QT = core testlib + +SOURCES = tst_cpp.cpp +INCLUDEPATH += ../../src diff --git a/extlibs/tinycbor/tinycbor/tests/cpp/tst_cpp.cpp b/extlibs/tinycbor/tinycbor/tests/cpp/tst_cpp.cpp new file mode 100644 index 0000000..48e017b --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/cpp/tst_cpp.cpp @@ -0,0 +1,40 @@ +/**************************************************************************** +** +** 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 + +// 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" diff --git a/extlibs/tinycbor/tinycbor/tests/encoder/encoder.pro b/extlibs/tinycbor/tinycbor/tests/encoder/encoder.pro new file mode 100644 index 0000000..62d9b7e --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/encoder/encoder.pro @@ -0,0 +1,9 @@ +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 diff --git a/extlibs/tinycbor/tinycbor/tests/encoder/tst_encoder.cpp b/extlibs/tinycbor/tinycbor/tests/encoder/tst_encoder.cpp new file mode 100644 index 0000000..54398f2 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/encoder/tst_encoder.cpp @@ -0,0 +1,644 @@ +/**************************************************************************** +** +** 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 +#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 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 +QVariant make_list(const Args &... args) +{ + return QVariantList{args...}; +} + +typedef QVector> Map; +Q_DECLARE_METATYPE(Map) +QVariant make_map(const std::initializer_list> &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 &list) +{ + return QVariant::fromValue(IndeterminateLengthArray(list)); +} + +QVariant make_ilmap(const std::initializer_list> &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(string.constData()), string.length()); + } + + default: + if (type == qMetaTypeId()) + return cbor_encode_simple_value(encoder, v.value().type); + if (type == qMetaTypeId()) + return cbor_encode_half_float(encoder, v.constData()); + if (type == qMetaTypeId()) { + CborError err = cbor_encode_tag(encoder, v.value().tag); + if (err && !isOomError(err)) + return err; + return static_cast(err | encodeVariant(encoder, v.value().tagged)); + } + if (type == QVariant::List || type == qMetaTypeId()) { + CborEncoder sub; + QVariantList list = v.toList(); + size_t len = list.length(); + if (type == qMetaTypeId()) { + len = CborIndefiniteLength; + list = v.value(); + } + CborError err = cbor_encoder_create_array(encoder, &sub, len); + if (err && !isOomError(err)) + return err; + foreach (const QVariant &v2, list) { + err = static_cast(err | encodeVariant(&sub, v2)); + if (err && !isOomError(err)) + return err; + } + return static_cast(err | cbor_encoder_close_container_checked(encoder, &sub)); + } + if (type == qMetaTypeId() || type == qMetaTypeId()) { + CborEncoder sub; + Map map = v.value(); + size_t len = map.length(); + if (type == qMetaTypeId()) { + len = CborIndefiniteLength; + map = v.value(); + } + CborError err = cbor_encoder_create_map(encoder, &sub, len); + if (err && !isOomError(err)) + return err; + for (auto pair : map) { + err = static_cast(err | encodeVariant(&sub, pair.first)); + if (err && !isOomError(err)) + return err; + err = static_cast(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(buffer.data()), buffer.length(), 0); + QCOMPARE(int(encodeVariant(&encoder, input)), int(CborNoError)); + buffer.resize(encoder.ptr - reinterpret_cast(buffer.constData())); + QCOMPARE(buffer, output); + QCOMPARE(encoder.added, size_t(1)); +} + +void addColumns() +{ + QTest::addColumn("output"); + QTest::addColumn("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::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::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(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(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(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(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(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(-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(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(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(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(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(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(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("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) diff --git a/extlibs/tinycbor/tinycbor/tests/parser/parser.pro b/extlibs/tinycbor/tinycbor/tests/parser/parser.pro new file mode 100644 index 0000000..a61291a --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/parser/parser.pro @@ -0,0 +1,10 @@ +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 diff --git a/extlibs/tinycbor/tinycbor/tests/parser/tst_parser.cpp b/extlibs/tinycbor/tinycbor/tests/parser/tst_parser.cpp new file mode 100644 index 0000000..a2de46d --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/parser/tst_parser.cpp @@ -0,0 +1,1281 @@ +/**************************************************************************** +** +** 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 +#include "cbor.h" +#include +#include + +#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(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 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("data"); + QTest::addColumn("expected"); + QTest::addColumn("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(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::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::min() + 1); + QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff") + << QString::number(std::numeric_limits::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::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::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("data"); + QTest::addColumn("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(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("data"); + QTest::addColumn("string"); + QTest::addColumn("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(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("data"); + QTest::addColumn("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(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("data"); + QTest::addColumn("flags"); // future + QTest::addColumn("expectedError"); + QTest::addColumn("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(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(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(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("data"); + QTest::addColumn("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(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(data.constBegin())), offset); +} + +void tst_Parser::recursionLimit_data() +{ + static const int recursions = CBOR_PARSER_MAX_RECURSIONS + 2; + QTest::addColumn("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(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" diff --git a/extlibs/tinycbor/tinycbor/tests/tests.pro b/extlibs/tinycbor/tinycbor/tests/tests.pro new file mode 100644 index 0000000..627ffbc --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/tests.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS = parser encoder cpp tojson +msvc: SUBDIRS -= tojson diff --git a/extlibs/tinycbor/tinycbor/tests/tojson/tojson.pro b/extlibs/tinycbor/tinycbor/tests/tojson/tojson.pro new file mode 100644 index 0000000..b422652 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/tojson/tojson.pro @@ -0,0 +1,8 @@ +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 diff --git a/extlibs/tinycbor/tinycbor/tests/tojson/tst_tojson.cpp b/extlibs/tinycbor/tinycbor/tests/tojson/tst_tojson.cpp new file mode 100644 index 0000000..e045cf3 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tests/tojson/tst_tojson.cpp @@ -0,0 +1,721 @@ +/**************************************************************************** +** +** 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 +#include "cbor.h" +#include "cborjson.h" +#include + +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 QByteArray raw(const char (&data)[N]) +{ + return QByteArray::fromRawData(data, N - 1); +} + +void addColumns() +{ + QTest::addColumn("data"); + QTest::addColumn("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(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::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::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::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(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("data"); + QTest::addColumn("base64url"); + QTest::addColumn("base64"); + QTest::addColumn("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(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) diff --git a/extlibs/tinycbor/tinycbor/tinycbor.pc.in b/extlibs/tinycbor/tinycbor/tinycbor.pc.in new file mode 100644 index 0000000..382779a --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tinycbor.pc.in @@ -0,0 +1,11 @@ +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 diff --git a/extlibs/tinycbor/tinycbor/tools/Makefile b/extlibs/tinycbor/tinycbor/tools/Makefile new file mode 100644 index 0000000..ddebd34 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tools/Makefile @@ -0,0 +1,12 @@ +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) $^ + diff --git a/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.c b/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.c new file mode 100644 index 0000000..8c8d7fd --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.c @@ -0,0 +1,158 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include +#include + +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; +} diff --git a/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.pro b/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.pro new file mode 100644 index 0000000..71ae6f7 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tools/cbordump/cbordump.pro @@ -0,0 +1,10 @@ +TEMPLATE = app +CONFIG += console +CONFIG -= app_bundle +CONFIG -= qt +DESTDIR = ../../bin + +CBORDIR = $$PWD/../../src +INCLUDEPATH += $$CBORDIR +SOURCES += cbordump.c +LIBS += ../../lib/libtinycbor.a diff --git a/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.c b/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.c new file mode 100644 index 0000000..fe7b389 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.c @@ -0,0 +1,489 @@ +/**************************************************************************** +** +** 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 + +#include +#include +#include +#include +#include +#include +#include + +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; +} diff --git a/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.pro b/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.pro new file mode 100644 index 0000000..fd6bcd0 --- /dev/null +++ b/extlibs/tinycbor/tinycbor/tools/json2cbor/json2cbor.pro @@ -0,0 +1,20 @@ +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 +}